From 267ef390f1dd38c7584c5bad37dce6725d58732e Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Tue, 6 Oct 2020 19:00:43 +0200 Subject: [PATCH 01/24] Migrate staking module --- x/genutil/legacy/v040/migrate.go | 18 ++++- x/staking/legacy/v038/types.go | 18 ++++- x/staking/legacy/v040/migrate.go | 116 +++++++++++++++++++++++++++++++ x/staking/legacy/v040/types.go | 6 ++ 4 files changed, 155 insertions(+), 3 deletions(-) create mode 100644 x/staking/legacy/v040/migrate.go create mode 100644 x/staking/legacy/v040/types.go diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 121c24b0c167..8c3b8ed5da52 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -14,6 +14,8 @@ import ( "github.com/cosmos/cosmos-sdk/x/genutil/types" v039slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v039" v040slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v040" + v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" + v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040" ) // Migrate migrates exported state from v0.39 to a v0.40 genesis state. @@ -82,7 +84,7 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { var slashingGenState v039slashing.GenesisState v039Codec.MustUnmarshalJSON(appState[v039slashing.ModuleName], &slashingGenState) - // delete deprecated x/evidence genesis state + // delete deprecated x/slashing genesis state delete(appState, v039slashing.ModuleName) // Migrate relative source genesis application state and marshal it into @@ -90,5 +92,19 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040slashing.ModuleName] = v040Codec.MustMarshalJSON(v040slashing.Migrate(slashingGenState)) } + // Migrate x/staking. + if appState[v038staking.ModuleName] != nil { + // unmarshal relative source genesis application state + var stakingGenState v038staking.GenesisState + v039Codec.MustUnmarshalJSON(appState[v038staking.ModuleName], &stakingGenState) + + // delete deprecated x/staking genesis state + delete(appState, v038staking.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040staking.ModuleName] = v040Codec.MustMarshalJSON(v040staking.Migrate(stakingGenState)) + } + return appState } diff --git a/x/staking/legacy/v038/types.go b/x/staking/legacy/v038/types.go index def28b31cbf8..3e6cb1d0a889 100644 --- a/x/staking/legacy/v038/types.go +++ b/x/staking/legacy/v038/types.go @@ -56,8 +56,16 @@ type ( Validators []Validator + Params struct { + UnbondingTime time.Duration `json:"unbonding_time" yaml:"unbonding_time"` // time duration of unbonding + MaxValidators uint16 `json:"max_validators" yaml:"max_validators"` // maximum number of validators (max uint16 = 65535) + MaxEntries uint16 `json:"max_entries" yaml:"max_entries"` // max entries for either unbonding delegation or redelegation (per pair/trio) + HistoricalEntries uint16 `json:"historical_entries" yaml:"historical_entries"` // number of historical entries to persist + BondDenom string `json:"bond_denom" yaml:"bond_denom"` // bondable coin denomination + } + GenesisState struct { - Params v034staking.Params `json:"params"` + Params Params `json:"params"` LastTotalPower sdk.Int `json:"last_total_power"` LastValidatorPowers []v034staking.LastValidatorPower `json:"last_validator_powers"` Validators Validators `json:"validators"` @@ -87,7 +95,13 @@ func NewGenesisState( ) GenesisState { return GenesisState{ - Params: params, + Params: Params{ + UnbondingTime: params.UnbondingTime, + MaxValidators: params.MaxValidators, + MaxEntries: params.MaxEntries, + BondDenom: params.BondDenom, + HistoricalEntries: 0, + }, LastTotalPower: lastTotalPower, LastValidatorPowers: lastValPowers, Validators: validators, diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go new file mode 100644 index 000000000000..c8de8d32dbbd --- /dev/null +++ b/x/staking/legacy/v040/migrate.go @@ -0,0 +1,116 @@ +package v040 + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" + v040staking "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// Migrate accepts exported v0.38 x/staking genesis state and migrates it to +// v0.40 x/staking genesis state. The migration includes: +// +// - Re-encode in v0.40 GenesisState +func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { + newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers)) + for i, oldLastValidatorPower := range stakingState.LastValidatorPowers { + newLastValidatorPowers[i] = v040staking.LastValidatorPower{ + Address: oldLastValidatorPower.Address.String(), + Power: oldLastValidatorPower.Power, + } + } + + newValidators := make([]v040staking.Validator, len(stakingState.Validators)) + for i, oldValidator := range stakingState.Validators { + newValidators[i] = v040staking.Validator{ + OperatorAddress: oldValidator.OperatorAddress.String(), + ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, oldValidator.ConsPubKey), + Jailed: oldValidator.Jailed, + Status: oldValidator.Status, + Tokens: oldValidator.Tokens, + DelegatorShares: oldValidator.DelegatorShares, + Description: v040staking.Description{ + Moniker: oldValidator.Description.Moniker, + Identity: oldValidator.Description.Identity, + Website: oldValidator.Description.Website, + SecurityContact: oldValidator.Description.SecurityContact, + Details: oldValidator.Description.Details, + }, + UnbondingHeight: oldValidator.UnbondingHeight, + UnbondingTime: oldValidator.UnbondingCompletionTime, + Commission: v040staking.Commission{ + CommissionRates: v040staking.CommissionRates{ + Rate: oldValidator.Commission.Rate, + MaxRate: oldValidator.Commission.MaxRate, + MaxChangeRate: oldValidator.Commission.MaxChangeRate, + }, + UpdateTime: oldValidator.Commission.UpdateTime, + }, + MinSelfDelegation: oldValidator.MinSelfDelegation, + } + } + + newDelegations := make([]v040staking.Delegation, len(stakingState.Delegations)) + for i, oldDelegation := range stakingState.Delegations { + newDelegations[i] = v040staking.Delegation{ + DelegatorAddress: oldDelegation.DelegatorAddress.String(), + ValidatorAddress: oldDelegation.ValidatorAddress.String(), + Shares: oldDelegation.Shares, + } + } + + newUnbondingDelegations := make([]v040staking.UnbondingDelegation, len(stakingState.UnbondingDelegations)) + for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations { + newEntries := make([]v040staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries)) + for j, oldEntry := range oldUnbondingDelegation.Entries { + newEntries[j] = v040staking.UnbondingDelegationEntry{ + CreationHeight: oldEntry.CreationHeight, + CompletionTime: oldEntry.CompletionTime, + InitialBalance: oldEntry.InitialBalance, + Balance: oldEntry.Balance, + } + } + + newUnbondingDelegations[i] = v040staking.UnbondingDelegation{ + DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(), + ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(), + Entries: newEntries, + } + } + + newRedelegations := make([]v040staking.Redelegation, len(stakingState.Redelegations)) + for i, oldRedelegation := range stakingState.Redelegations { + newEntries := make([]v040staking.RedelegationEntry, len(oldRedelegation.Entries)) + for j, oldEntry := range oldRedelegation.Entries { + newEntries[j] = v040staking.RedelegationEntry{ + CreationHeight: oldEntry.CreationHeight, + CompletionTime: oldEntry.CompletionTime, + InitialBalance: oldEntry.InitialBalance, + SharesDst: oldEntry.SharesDst, + } + } + + newRedelegations[i] = v040staking.Redelegation{ + DelegatorAddress: oldRedelegation.DelegatorAddress.String(), + ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(), + ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(), + Entries: newEntries, + } + } + + return &v040staking.GenesisState{ + Params: v040staking.Params{ + UnbondingTime: stakingState.Params.UnbondingTime, + MaxValidators: uint32(stakingState.Params.MaxValidators), + MaxEntries: uint32(stakingState.Params.MaxEntries), + HistoricalEntries: uint32(stakingState.Params.HistoricalEntries), + BondDenom: stakingState.Params.BondDenom, + }, + LastTotalPower: stakingState.LastTotalPower, + LastValidatorPowers: newLastValidatorPowers, + Validators: newValidators, + Delegations: newDelegations, + UnbondingDelegations: newUnbondingDelegations, + Redelegations: newRedelegations, + Exported: stakingState.Exported, + } +} diff --git a/x/staking/legacy/v040/types.go b/x/staking/legacy/v040/types.go new file mode 100644 index 000000000000..cff719fb8f66 --- /dev/null +++ b/x/staking/legacy/v040/types.go @@ -0,0 +1,6 @@ +package v040 + +// Default parameter values +const ( + ModuleName = "staking" +) From 075a4ef3f6ae7dfa42c5e227aeefa9b7375d7d55 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 13:43:53 +0200 Subject: [PATCH 02/24] Add gov legacy --- x/gov/legacy/v040/migrate.go | 116 +++++++++++++++++++++++++++++++++++ x/gov/legacy/v040/types.go | 6 ++ 2 files changed, 122 insertions(+) create mode 100644 x/gov/legacy/v040/migrate.go create mode 100644 x/gov/legacy/v040/types.go diff --git a/x/gov/legacy/v040/migrate.go b/x/gov/legacy/v040/migrate.go new file mode 100644 index 000000000000..e7a8f9c10154 --- /dev/null +++ b/x/gov/legacy/v040/migrate.go @@ -0,0 +1,116 @@ +package v040 + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" + v040gov "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +// Migrate accepts exported v0.36 x/gov genesis state and migrates it to +// v0.40 x/gov genesis state. The migration includes: +// +// - Re-encode in v0.40 GenesisState +func Migrate(govState v036gov.GenesisState) *v040gov.GenesisState { + newLastValidatorPowers := make([]v040gov.LastValidatorPower, len(govState.LastValidatorPowers)) + for i, oldLastValidatorPower := range govState.LastValidatorPowers { + newLastValidatorPowers[i] = v040gov.LastValidatorPower{ + Address: oldLastValidatorPower.Address.String(), + Power: oldLastValidatorPower.Power, + } + } + + newValidators := make([]v040gov.Validator, len(govState.Validators)) + for i, oldValidator := range govState.Validators { + newValidators[i] = v040gov.Validator{ + OperatorAddress: oldValidator.OperatorAddress.String(), + ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, oldValidator.ConsPubKey), + Jailed: oldValidator.Jailed, + Status: oldValidator.Status, + Tokens: oldValidator.Tokens, + DelegatorShares: oldValidator.DelegatorShares, + Description: v040gov.Description{ + Moniker: oldValidator.Description.Moniker, + Identity: oldValidator.Description.Identity, + Website: oldValidator.Description.Website, + SecurityContact: oldValidator.Description.SecurityContact, + Details: oldValidator.Description.Details, + }, + UnbondingHeight: oldValidator.UnbondingHeight, + UnbondingTime: oldValidator.UnbondingCompletionTime, + Commission: v040gov.Commission{ + CommissionRates: v040gov.CommissionRates{ + Rate: oldValidator.Commission.Rate, + MaxRate: oldValidator.Commission.MaxRate, + MaxChangeRate: oldValidator.Commission.MaxChangeRate, + }, + UpdateTime: oldValidator.Commission.UpdateTime, + }, + MinSelfDelegation: oldValidator.MinSelfDelegation, + } + } + + newDelegations := make([]v040gov.Delegation, len(govState.Delegations)) + for i, oldDelegation := range govState.Delegations { + newDelegations[i] = v040gov.Delegation{ + DelegatorAddress: oldDelegation.DelegatorAddress.String(), + ValidatorAddress: oldDelegation.ValidatorAddress.String(), + Shares: oldDelegation.Shares, + } + } + + newUnbondingDelegations := make([]v040gov.UnbondingDelegation, len(govState.UnbondingDelegations)) + for i, oldUnbondingDelegation := range govState.UnbondingDelegations { + newEntries := make([]v040gov.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries)) + for j, oldEntry := range oldUnbondingDelegation.Entries { + newEntries[j] = v040gov.UnbondingDelegationEntry{ + CreationHeight: oldEntry.CreationHeight, + CompletionTime: oldEntry.CompletionTime, + InitialBalance: oldEntry.InitialBalance, + Balance: oldEntry.Balance, + } + } + + newUnbondingDelegations[i] = v040gov.UnbondingDelegation{ + DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(), + ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(), + Entries: newEntries, + } + } + + newRedelegations := make([]v040gov.Redelegation, len(govState.Redelegations)) + for i, oldRedelegation := range govState.Redelegations { + newEntries := make([]v040gov.RedelegationEntry, len(oldRedelegation.Entries)) + for j, oldEntry := range oldRedelegation.Entries { + newEntries[j] = v040gov.RedelegationEntry{ + CreationHeight: oldEntry.CreationHeight, + CompletionTime: oldEntry.CompletionTime, + InitialBalance: oldEntry.InitialBalance, + SharesDst: oldEntry.SharesDst, + } + } + + newRedelegations[i] = v040gov.Redelegation{ + DelegatorAddress: oldRedelegation.DelegatorAddress.String(), + ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(), + ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(), + Entries: newEntries, + } + } + + return &v040gov.GenesisState{ + Params: v040gov.Params{ + UnbondingTime: govState.Params.UnbondingTime, + MaxValidators: uint32(govState.Params.MaxValidators), + MaxEntries: uint32(govState.Params.MaxEntries), + HistoricalEntries: uint32(govState.Params.HistoricalEntries), + BondDenom: govState.Params.BondDenom, + }, + LastTotalPower: govState.LastTotalPower, + LastValidatorPowers: newLastValidatorPowers, + Validators: newValidators, + Delegations: newDelegations, + UnbondingDelegations: newUnbondingDelegations, + Redelegations: newRedelegations, + Exported: govState.Exported, + } +} diff --git a/x/gov/legacy/v040/types.go b/x/gov/legacy/v040/types.go new file mode 100644 index 000000000000..27f668b2e1aa --- /dev/null +++ b/x/gov/legacy/v040/types.go @@ -0,0 +1,6 @@ +package v040 + +// Default parameter values +const ( + ModuleName = "gov" +) From e1521d53e4783a52f7ca2f9281385717cc2ea8f5 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 14:24:18 +0200 Subject: [PATCH 03/24] Add comments --- x/auth/legacy/v040/migrate.go | 1 + x/bank/legacy/v040/migrate.go | 1 + x/evidence/legacy/v040/migrate.go | 49 ++++---- x/gov/legacy/v040/migrate.go | 202 +++++++++++++++++------------- x/slashing/legacy/v040/migrate.go | 1 + x/staking/legacy/v040/migrate.go | 2 +- 6 files changed, 140 insertions(+), 116 deletions(-) diff --git a/x/auth/legacy/v040/migrate.go b/x/auth/legacy/v040/migrate.go index 4fe663a48d48..3d335804a50d 100644 --- a/x/auth/legacy/v040/migrate.go +++ b/x/auth/legacy/v040/migrate.go @@ -47,6 +47,7 @@ func convertBaseVestingAccount(old *v039auth.BaseVestingAccount) *v040vesting.Ba // it to v0.40 x/auth genesis state. The migration includes: // // - Removing coins from account encoding. +// - Re-encode in v0.40 GenesisState. func Migrate(authGenState v039auth.GenesisState) *v040auth.GenesisState { // Convert v0.39 accounts to v0.40 ones. var v040Accounts = make([]v040auth.GenesisAccount, len(authGenState.Accounts)) diff --git a/x/bank/legacy/v040/migrate.go b/x/bank/legacy/v040/migrate.go index ba617427648e..ab2e596f57c8 100644 --- a/x/bank/legacy/v040/migrate.go +++ b/x/bank/legacy/v040/migrate.go @@ -12,6 +12,7 @@ import ( // // - Moving balances from x/auth to x/bank genesis state. // - Moving supply from x/supply to x/bank genesis state. +// - Re-encode in v0.40 GenesisState. func Migrate( bankGenState v038bank.GenesisState, authGenState v039auth.GenesisState, diff --git a/x/evidence/legacy/v040/migrate.go b/x/evidence/legacy/v040/migrate.go index 7785cd12e791..cbcaa2ac7359 100644 --- a/x/evidence/legacy/v040/migrate.go +++ b/x/evidence/legacy/v040/migrate.go @@ -1,46 +1,43 @@ package v040 import ( + "fmt" + "github.com/cosmos/cosmos-sdk/client" codectypes "github.com/cosmos/cosmos-sdk/codec/types" v038evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v038" v040evidence "github.com/cosmos/cosmos-sdk/x/evidence/types" ) +func migrateEvidence(oldEvidence v038evidence.Evidence) *codectypes.Any { + switch oldEvidence := oldEvidence.(type) { + case *v040evidence.Equivocation: + { + any, err := codectypes.NewAnyWithValue(oldEvidence) + if err != nil { + panic(err) + } + + return any + } + default: + panic(fmt.Errorf("'%T' is not a valid evidence type", oldEvidence)) + } +} + // Migrate accepts exported v0.38 x/evidence genesis state and migrates it to // v0.40 x/evidence genesis state. The migration includes: // // - Removing the `Params` field. // - Converting Equivocations into Anys. +// - Re-encode in v0.40 GenesisState. func Migrate(evidenceState v038evidence.GenesisState, _ client.Context) *v040evidence.GenesisState { - var newEquivocations = make([]v040evidence.Equivocation, len(evidenceState.Evidence)) - for i, evidence := range evidenceState.Evidence { - equivocation, ok := evidence.(v038evidence.Equivocation) - if !ok { - // There's only equivocation in 0.38. - continue - } - - newEquivocations[i] = v040evidence.Equivocation{ - Height: equivocation.Height, - Time: equivocation.Time, - Power: equivocation.Power, - ConsensusAddress: equivocation.ConsensusAddress.String(), - } - } - - // Then convert the equivocations into Any. - newEvidence := make([]*codectypes.Any, len(newEquivocations)) - for i := range newEquivocations { - any, err := codectypes.NewAnyWithValue(&newEquivocations[i]) - if err != nil { - panic(err) - } - - newEvidence[i] = any + var newEvidences = make([]*codectypes.Any, len(evidenceState.Evidence)) + for i, oldEvidence := range evidenceState.Evidence { + newEvidences[i] = migrateEvidence(oldEvidence) } return &v040evidence.GenesisState{ - Evidence: newEvidence, + Evidence: newEvidences, } } diff --git a/x/gov/legacy/v040/migrate.go b/x/gov/legacy/v040/migrate.go index e7a8f9c10154..a46aa3f56950 100644 --- a/x/gov/legacy/v040/migrate.go +++ b/x/gov/legacy/v040/migrate.go @@ -1,116 +1,140 @@ package v040 import ( - sdk "github.com/cosmos/cosmos-sdk/types" + "fmt" + + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + v034gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v034" v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" v040gov "github.com/cosmos/cosmos-sdk/x/gov/types" ) -// Migrate accepts exported v0.36 x/gov genesis state and migrates it to -// v0.40 x/gov genesis state. The migration includes: -// -// - Re-encode in v0.40 GenesisState -func Migrate(govState v036gov.GenesisState) *v040gov.GenesisState { - newLastValidatorPowers := make([]v040gov.LastValidatorPower, len(govState.LastValidatorPowers)) - for i, oldLastValidatorPower := range govState.LastValidatorPowers { - newLastValidatorPowers[i] = v040gov.LastValidatorPower{ - Address: oldLastValidatorPower.Address.String(), - Power: oldLastValidatorPower.Power, - } - } +func migrateVoteOption(oldVoteOption v034gov.VoteOption) v040gov.VoteOption { + switch oldVoteOption { + case v034gov.OptionEmpty: + return v040gov.OptionEmpty - newValidators := make([]v040gov.Validator, len(govState.Validators)) - for i, oldValidator := range govState.Validators { - newValidators[i] = v040gov.Validator{ - OperatorAddress: oldValidator.OperatorAddress.String(), - ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, oldValidator.ConsPubKey), - Jailed: oldValidator.Jailed, - Status: oldValidator.Status, - Tokens: oldValidator.Tokens, - DelegatorShares: oldValidator.DelegatorShares, - Description: v040gov.Description{ - Moniker: oldValidator.Description.Moniker, - Identity: oldValidator.Description.Identity, - Website: oldValidator.Description.Website, - SecurityContact: oldValidator.Description.SecurityContact, - Details: oldValidator.Description.Details, - }, - UnbondingHeight: oldValidator.UnbondingHeight, - UnbondingTime: oldValidator.UnbondingCompletionTime, - Commission: v040gov.Commission{ - CommissionRates: v040gov.CommissionRates{ - Rate: oldValidator.Commission.Rate, - MaxRate: oldValidator.Commission.MaxRate, - MaxChangeRate: oldValidator.Commission.MaxChangeRate, - }, - UpdateTime: oldValidator.Commission.UpdateTime, - }, - MinSelfDelegation: oldValidator.MinSelfDelegation, - } + case v034gov.OptionYes: + return v040gov.OptionYes + + case v034gov.OptionAbstain: + return v040gov.OptionAbstain + + case v034gov.OptionNo: + return v040gov.OptionNo + + case v034gov.OptionNoWithVeto: + return v040gov.OptionNoWithVeto + + default: + panic(fmt.Errorf("'%s' is not a valid vote option", oldVoteOption)) } +} - newDelegations := make([]v040gov.Delegation, len(govState.Delegations)) - for i, oldDelegation := range govState.Delegations { - newDelegations[i] = v040gov.Delegation{ - DelegatorAddress: oldDelegation.DelegatorAddress.String(), - ValidatorAddress: oldDelegation.ValidatorAddress.String(), - Shares: oldDelegation.Shares, - } +func migrateProposalStatus(oldProposalStatus v034gov.ProposalStatus) v040gov.ProposalStatus { + switch oldProposalStatus { + + case v034gov.StatusNil: + return v040gov.StatusNil + + case v034gov.StatusDepositPeriod: + return v040gov.StatusDepositPeriod + + case v034gov.StatusVotingPeriod: + return v040gov.StatusVotingPeriod + + case v034gov.StatusPassed: + return v040gov.StatusPassed + + case v034gov.StatusRejected: + return v040gov.StatusRejected + + case v034gov.StatusFailed: + return v040gov.StatusFailed + + default: + panic(fmt.Errorf("'%s' is not a valid proposal status", oldProposalStatus)) } +} - newUnbondingDelegations := make([]v040gov.UnbondingDelegation, len(govState.UnbondingDelegations)) - for i, oldUnbondingDelegation := range govState.UnbondingDelegations { - newEntries := make([]v040gov.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries)) - for j, oldEntry := range oldUnbondingDelegation.Entries { - newEntries[j] = v040gov.UnbondingDelegationEntry{ - CreationHeight: oldEntry.CreationHeight, - CompletionTime: oldEntry.CompletionTime, - InitialBalance: oldEntry.InitialBalance, - Balance: oldEntry.Balance, +func migrateContent(oldContent v036gov.Content) *codectypes.Any { + switch oldContent := oldContent.(type) { + case *v040gov.TextProposal: + { + // Convert the content into Any. + contentAny, err := codectypes.NewAnyWithValue(oldContent) + if err != nil { + panic(err) } + + return contentAny } + default: + panic(fmt.Errorf("'%T' is not a valid proposal content type", oldContent)) + } +} - newUnbondingDelegations[i] = v040gov.UnbondingDelegation{ - DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(), - ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(), - Entries: newEntries, +// Migrate accepts exported v0.36 x/gov genesis state and migrates it to +// v0.40 x/gov genesis state. The migration includes: +// +// - Convert vote option & proposal status from byte to enum. +// - Migrate proposal content to Any. +// - Re-encode in v0.40 GenesisState. +func Migrate(oldGovState v036gov.GenesisState) *v040gov.GenesisState { + newDeposits := make([]v040gov.Deposit, len(oldGovState.Deposits)) + for i, oldDeposit := range oldGovState.Deposits { + newDeposits[i] = v040gov.Deposit{ + ProposalId: oldDeposit.ProposalID, + Depositor: oldDeposit.Depositor.String(), + Amount: oldDeposit.Amount, } } - newRedelegations := make([]v040gov.Redelegation, len(govState.Redelegations)) - for i, oldRedelegation := range govState.Redelegations { - newEntries := make([]v040gov.RedelegationEntry, len(oldRedelegation.Entries)) - for j, oldEntry := range oldRedelegation.Entries { - newEntries[j] = v040gov.RedelegationEntry{ - CreationHeight: oldEntry.CreationHeight, - CompletionTime: oldEntry.CompletionTime, - InitialBalance: oldEntry.InitialBalance, - SharesDst: oldEntry.SharesDst, - } + newVotes := make([]v040gov.Vote, len(oldGovState.Votes)) + for i, oldVote := range oldGovState.Votes { + newVotes[i] = v040gov.Vote{ + ProposalId: oldVote.ProposalID, + Voter: oldVote.Voter.String(), + Option: migrateVoteOption(oldVote.Option), } + } - newRedelegations[i] = v040gov.Redelegation{ - DelegatorAddress: oldRedelegation.DelegatorAddress.String(), - ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(), - ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(), - Entries: newEntries, + newProposals := make([]v040gov.Proposal, len(oldGovState.Proposals)) + for i, oldProposal := range oldGovState.Proposals { + newProposals[i] = v040gov.Proposal{ + ProposalId: oldProposal.ProposalID, + Content: migrateContent(oldProposal.Content), + Status: migrateProposalStatus(oldProposal.Status), + FinalTallyResult: v040gov.TallyResult{ + Yes: oldProposal.FinalTallyResult.Yes, + Abstain: oldProposal.FinalTallyResult.Abstain, + No: oldProposal.FinalTallyResult.No, + NoWithVeto: oldProposal.FinalTallyResult.NoWithVeto, + }, + SubmitTime: oldProposal.SubmitTime, + DepositEndTime: oldProposal.DepositEndTime, + TotalDeposit: oldProposal.TotalDeposit, + VotingStartTime: oldProposal.VotingStartTime, + VotingEndTime: oldProposal.VotingEndTime, } } return &v040gov.GenesisState{ - Params: v040gov.Params{ - UnbondingTime: govState.Params.UnbondingTime, - MaxValidators: uint32(govState.Params.MaxValidators), - MaxEntries: uint32(govState.Params.MaxEntries), - HistoricalEntries: uint32(govState.Params.HistoricalEntries), - BondDenom: govState.Params.BondDenom, + StartingProposalId: oldGovState.StartingProposalID, + Deposits: newDeposits, + Votes: newVotes, + Proposals: newProposals, + DepositParams: v040gov.DepositParams{ + MinDeposit: oldGovState.DepositParams.MinDeposit, + MaxDepositPeriod: oldGovState.DepositParams.MaxDepositPeriod, + }, + VotingParams: v040gov.VotingParams{ + VotingPeriod: oldGovState.VotingParams.VotingPeriod, + }, + TallyParams: v040gov.TallyParams{ + Quorum: oldGovState.TallyParams.Quorum, + Threshold: oldGovState.TallyParams.Threshold, + VetoThreshold: oldGovState.TallyParams.Veto, }, - LastTotalPower: govState.LastTotalPower, - LastValidatorPowers: newLastValidatorPowers, - Validators: newValidators, - Delegations: newDelegations, - UnbondingDelegations: newUnbondingDelegations, - Redelegations: newRedelegations, - Exported: govState.Exported, } } diff --git a/x/slashing/legacy/v040/migrate.go b/x/slashing/legacy/v040/migrate.go index 4f99af1446b0..c01fd501baaf 100644 --- a/x/slashing/legacy/v040/migrate.go +++ b/x/slashing/legacy/v040/migrate.go @@ -11,6 +11,7 @@ import ( // to v0.40 x/slashing genesis state. The migration includes: // // - Chaning SigningInfos and MissedBlocks from map to array. +// - Re-encode in v0.40 GenesisState. func Migrate(oldGenState v039slashing.GenesisState) *v040slashing.GenesisState { // Note that the two following `for` loop over a map's keys, so are not // deterministic. diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go index c8de8d32dbbd..ad0bd2c9c1df 100644 --- a/x/staking/legacy/v040/migrate.go +++ b/x/staking/legacy/v040/migrate.go @@ -9,7 +9,7 @@ import ( // Migrate accepts exported v0.38 x/staking genesis state and migrates it to // v0.40 x/staking genesis state. The migration includes: // -// - Re-encode in v0.40 GenesisState +// - Re-encode in v0.40 GenesisState. func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers)) for i, oldLastValidatorPower := range stakingState.LastValidatorPowers { From ef05dde86056010b81e000d3795db218cd55cc01 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 15:10:44 +0200 Subject: [PATCH 04/24] Add x/distrib --- x/distribution/legacy/v040/migrate.go | 108 +++++++++++++++++++++++++ x/distribution/legacy/v040/types.go | 6 ++ x/evidence/legacy/v040/migrate.go | 3 +- x/evidence/legacy/v040/migrate_test.go | 2 +- x/genutil/legacy/v040/migrate.go | 34 +++++++- x/gov/legacy/v040/migrate.go | 1 + x/slashing/legacy/v040/migrate.go | 1 + x/staking/legacy/v040/migrate.go | 1 + 8 files changed, 152 insertions(+), 4 deletions(-) create mode 100644 x/distribution/legacy/v040/migrate.go create mode 100644 x/distribution/legacy/v040/types.go diff --git a/x/distribution/legacy/v040/migrate.go b/x/distribution/legacy/v040/migrate.go new file mode 100644 index 000000000000..b0ba30bba861 --- /dev/null +++ b/x/distribution/legacy/v040/migrate.go @@ -0,0 +1,108 @@ +package v040 + +import ( + v038distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v038" + v040distribution "github.com/cosmos/cosmos-sdk/x/distribution/types" +) + +// Migrate accepts exported x/distribution genesis state from v0.38 and migrates it +// to v0.40 x/distribution genesis state. The migration includes: +// +// - Convert addresses from bytes to bech32 strings. +// - Re-encode in v0.40 GenesisState. +func Migrate(oldDistributionState v038distribution.GenesisState) *v040distribution.GenesisState { + newDelegatorWithdrawInfos := make([]v040distribution.DelegatorWithdrawInfo, len(oldDistributionState.DelegatorWithdrawInfos)) + for i, oldDelegatorWithdrawInfo := range oldDistributionState.DelegatorWithdrawInfos { + newDelegatorWithdrawInfos[i] = v040distribution.DelegatorWithdrawInfo{ + DelegatorAddress: oldDelegatorWithdrawInfo.DelegatorAddress.String(), + WithdrawAddress: oldDelegatorWithdrawInfo.WithdrawAddress.String(), + } + } + + newValidatorOutstandingRewards := make([]v040distribution.ValidatorOutstandingRewardsRecord, len(oldDistributionState.OutstandingRewards)) + for i, oldValidatorOutstandingReward := range oldDistributionState.OutstandingRewards { + newValidatorOutstandingRewards[i] = v040distribution.ValidatorOutstandingRewardsRecord{ + ValidatorAddress: oldValidatorOutstandingReward.ValidatorAddress.String(), + OutstandingRewards: oldValidatorOutstandingReward.OutstandingRewards, + } + } + + newValidatorAccumulatedCommissions := make([]v040distribution.ValidatorAccumulatedCommissionRecord, len(oldDistributionState.ValidatorAccumulatedCommissions)) + for i, oldValidatorAccumulatedCommission := range oldDistributionState.ValidatorAccumulatedCommissions { + newValidatorAccumulatedCommissions[i] = v040distribution.ValidatorAccumulatedCommissionRecord{ + ValidatorAddress: oldValidatorAccumulatedCommission.ValidatorAddress.String(), + Accumulated: v040distribution.ValidatorAccumulatedCommission{ + Commission: oldValidatorAccumulatedCommission.Accumulated, + }, + } + } + + newValidatorHistoricalRewards := make([]v040distribution.ValidatorHistoricalRewardsRecord, len(oldDistributionState.ValidatorHistoricalRewards)) + for i, oldValidatorHistoricalReward := range oldDistributionState.ValidatorHistoricalRewards { + newValidatorHistoricalRewards[i] = v040distribution.ValidatorHistoricalRewardsRecord{ + ValidatorAddress: oldValidatorHistoricalReward.ValidatorAddress.String(), + Period: oldValidatorHistoricalReward.Period, + Rewards: v040distribution.ValidatorHistoricalRewards{ + CumulativeRewardRatio: oldValidatorHistoricalReward.Rewards.CumulativeRewardRatio, + ReferenceCount: uint32(oldValidatorHistoricalReward.Rewards.ReferenceCount), + }, + } + } + + newValidatorCurrentRewards := make([]v040distribution.ValidatorCurrentRewardsRecord, len(oldDistributionState.ValidatorCurrentRewards)) + for i, oldValidatorCurrentReward := range oldDistributionState.ValidatorCurrentRewards { + newValidatorCurrentRewards[i] = v040distribution.ValidatorCurrentRewardsRecord{ + ValidatorAddress: oldValidatorCurrentReward.ValidatorAddress.String(), + Rewards: v040distribution.ValidatorCurrentRewards{ + Rewards: oldValidatorCurrentReward.Rewards.Rewards, + Period: oldValidatorCurrentReward.Rewards.Period, + }, + } + } + + newDelegatorStartingInfos := make([]v040distribution.DelegatorStartingInfoRecord, len(oldDistributionState.DelegatorStartingInfos)) + for i, oldDelegatorStartingInfo := range oldDistributionState.DelegatorStartingInfos { + newDelegatorStartingInfos[i] = v040distribution.DelegatorStartingInfoRecord{ + DelegatorAddress: oldDelegatorStartingInfo.DelegatorAddress.String(), + ValidatorAddress: oldDelegatorStartingInfo.ValidatorAddress.String(), + StartingInfo: v040distribution.DelegatorStartingInfo{ + PreviousPeriod: oldDelegatorStartingInfo.StartingInfo.PreviousPeriod, + Stake: oldDelegatorStartingInfo.StartingInfo.Stake, + Height: oldDelegatorStartingInfo.StartingInfo.Height, + }, + } + } + + newValidatorSlashEvents := make([]v040distribution.ValidatorSlashEventRecord, len(oldDistributionState.ValidatorSlashEvents)) + for i, oldValidatorSlashEvent := range oldDistributionState.ValidatorSlashEvents { + newValidatorSlashEvents[i] = v040distribution.ValidatorSlashEventRecord{ + ValidatorAddress: oldValidatorSlashEvent.ValidatorAddress.String(), + Height: oldValidatorSlashEvent.Height, + Period: oldValidatorSlashEvent.Period, + ValidatorSlashEvent: v040distribution.ValidatorSlashEvent{ + ValidatorPeriod: oldValidatorSlashEvent.Event.ValidatorPeriod, + Fraction: oldValidatorSlashEvent.Event.Fraction, + }, + } + } + + return &v040distribution.GenesisState{ + Params: v040distribution.Params{ + CommunityTax: oldDistributionState.Params.CommunityTax, + BaseProposerReward: oldDistributionState.Params.BaseProposerReward, + BonusProposerReward: oldDistributionState.Params.BonusProposerReward, + WithdrawAddrEnabled: oldDistributionState.Params.WithdrawAddrEnabled, + }, + FeePool: v040distribution.FeePool{ + CommunityPool: oldDistributionState.FeePool.CommunityPool, + }, + DelegatorWithdrawInfos: newDelegatorWithdrawInfos, + PreviousProposer: oldDistributionState.PreviousProposer.String(), + OutstandingRewards: newValidatorOutstandingRewards, + ValidatorAccumulatedCommissions: newValidatorAccumulatedCommissions, + ValidatorHistoricalRewards: newValidatorHistoricalRewards, + ValidatorCurrentRewards: newValidatorCurrentRewards, + DelegatorStartingInfos: newDelegatorStartingInfos, + ValidatorSlashEvents: newValidatorSlashEvents, + } +} diff --git a/x/distribution/legacy/v040/types.go b/x/distribution/legacy/v040/types.go new file mode 100644 index 000000000000..27f668b2e1aa --- /dev/null +++ b/x/distribution/legacy/v040/types.go @@ -0,0 +1,6 @@ +package v040 + +// Default parameter values +const ( + ModuleName = "gov" +) diff --git a/x/evidence/legacy/v040/migrate.go b/x/evidence/legacy/v040/migrate.go index cbcaa2ac7359..ec7178cb845c 100644 --- a/x/evidence/legacy/v040/migrate.go +++ b/x/evidence/legacy/v040/migrate.go @@ -3,7 +3,6 @@ package v040 import ( "fmt" - "github.com/cosmos/cosmos-sdk/client" codectypes "github.com/cosmos/cosmos-sdk/codec/types" v038evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v038" v040evidence "github.com/cosmos/cosmos-sdk/x/evidence/types" @@ -31,7 +30,7 @@ func migrateEvidence(oldEvidence v038evidence.Evidence) *codectypes.Any { // - Removing the `Params` field. // - Converting Equivocations into Anys. // - Re-encode in v0.40 GenesisState. -func Migrate(evidenceState v038evidence.GenesisState, _ client.Context) *v040evidence.GenesisState { +func Migrate(evidenceState v038evidence.GenesisState) *v040evidence.GenesisState { var newEvidences = make([]*codectypes.Any, len(evidenceState.Evidence)) for i, oldEvidence := range evidenceState.Evidence { newEvidences[i] = migrateEvidence(oldEvidence) diff --git a/x/evidence/legacy/v040/migrate_test.go b/x/evidence/legacy/v040/migrate_test.go index dcbe77e487ca..a9c23093f47f 100644 --- a/x/evidence/legacy/v040/migrate_test.go +++ b/x/evidence/legacy/v040/migrate_test.go @@ -31,7 +31,7 @@ func TestMigrate(t *testing.T) { }}, } - migrated := v040evidence.Migrate(evidenceGenState, clientCtx) + migrated := v040evidence.Migrate(evidenceGenState) expected := `{"evidence":[{"@type":"/cosmos.evidence.v1beta1.Equivocation","height":"20","time":"0001-01-01T00:00:00Z","power":"100","consensus_address":"cosmosvalcons1xxkueklal9vejv9unqu80w9vptyepfa99x2a3w"}]}` bz, err := clientCtx.JSONMarshaler.MarshalJSON(migrated) diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 8c3b8ed5da52..675e1072b28e 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -9,9 +9,13 @@ import ( v036supply "github.com/cosmos/cosmos-sdk/x/bank/legacy/v036" v038bank "github.com/cosmos/cosmos-sdk/x/bank/legacy/v038" v040bank "github.com/cosmos/cosmos-sdk/x/bank/legacy/v040" + v038distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v038" + v040distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v040" v038evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v038" v040evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v040" "github.com/cosmos/cosmos-sdk/x/genutil/types" + v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" + v040gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v040" v039slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v039" v040slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v040" v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" @@ -64,6 +68,20 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040auth.ModuleName] = v040Codec.MustMarshalJSON(v040auth.Migrate(authGenState)) } + // Migrate x/distribution. + if appState[v038distribution.ModuleName] != nil { + // unmarshal relative source genesis application state + var distributionGenState v038distribution.GenesisState + v039Codec.MustUnmarshalJSON(appState[v038distribution.ModuleName], &distributionGenState) + + // delete deprecated x/distribution genesis state + delete(appState, v038distribution.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040distribution.ModuleName] = v040Codec.MustMarshalJSON(v040distribution.Migrate(distributionGenState)) + } + // Migrate x/evidence. if appState[v038evidence.ModuleName] != nil { // unmarshal relative source genesis application state @@ -75,7 +93,21 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { // Migrate relative source genesis application state and marshal it into // the respective key. - appState[v040evidence.ModuleName] = v040Codec.MustMarshalJSON(v040evidence.Migrate(evidenceGenState, clientCtx)) + appState[v040evidence.ModuleName] = v040Codec.MustMarshalJSON(v040evidence.Migrate(evidenceGenState)) + } + + // Migrate x/gov. + if appState[v036gov.ModuleName] != nil { + // unmarshal relative source genesis application state + var govGenState v036gov.GenesisState + v039Codec.MustUnmarshalJSON(appState[v036gov.ModuleName], &govGenState) + + // delete deprecated x/gov genesis state + delete(appState, v036gov.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040gov.ModuleName] = v040Codec.MustMarshalJSON(v040gov.Migrate(govGenState)) } // Migrate x/slashing. diff --git a/x/gov/legacy/v040/migrate.go b/x/gov/legacy/v040/migrate.go index a46aa3f56950..73ee066dd60b 100644 --- a/x/gov/legacy/v040/migrate.go +++ b/x/gov/legacy/v040/migrate.go @@ -79,6 +79,7 @@ func migrateContent(oldContent v036gov.Content) *codectypes.Any { // // - Convert vote option & proposal status from byte to enum. // - Migrate proposal content to Any. +// - Convert addresses from bytes to bech32 strings. // - Re-encode in v0.40 GenesisState. func Migrate(oldGovState v036gov.GenesisState) *v040gov.GenesisState { newDeposits := make([]v040gov.Deposit, len(oldGovState.Deposits)) diff --git a/x/slashing/legacy/v040/migrate.go b/x/slashing/legacy/v040/migrate.go index c01fd501baaf..ba494dcad14a 100644 --- a/x/slashing/legacy/v040/migrate.go +++ b/x/slashing/legacy/v040/migrate.go @@ -11,6 +11,7 @@ import ( // to v0.40 x/slashing genesis state. The migration includes: // // - Chaning SigningInfos and MissedBlocks from map to array. +// - Convert addresses from bytes to bech32 strings. // - Re-encode in v0.40 GenesisState. func Migrate(oldGenState v039slashing.GenesisState) *v040slashing.GenesisState { // Note that the two following `for` loop over a map's keys, so are not diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go index ad0bd2c9c1df..07a4eba87a5f 100644 --- a/x/staking/legacy/v040/migrate.go +++ b/x/staking/legacy/v040/migrate.go @@ -9,6 +9,7 @@ import ( // Migrate accepts exported v0.38 x/staking genesis state and migrates it to // v0.40 x/staking genesis state. The migration includes: // +// - Convert addresses from bytes to bech32 strings. // - Re-encode in v0.40 GenesisState. func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers)) From e8488ae05de8a9829b87f434d45871f47504bc70 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 15:15:39 +0200 Subject: [PATCH 05/24] x/crisis --- x/crisis/legacy/v039/types.go | 13 +++++++++++++ x/crisis/legacy/v040/migrate.go | 16 ++++++++++++++++ x/crisis/legacy/v040/types.go | 5 +++++ x/distribution/legacy/v040/types.go | 2 +- x/genutil/legacy/v040/migrate.go | 16 ++++++++++++++++ x/staking/legacy/v040/types.go | 1 - 6 files changed, 51 insertions(+), 2 deletions(-) create mode 100644 x/crisis/legacy/v039/types.go create mode 100644 x/crisis/legacy/v040/migrate.go create mode 100644 x/crisis/legacy/v040/types.go diff --git a/x/crisis/legacy/v039/types.go b/x/crisis/legacy/v039/types.go new file mode 100644 index 000000000000..44903e349118 --- /dev/null +++ b/x/crisis/legacy/v039/types.go @@ -0,0 +1,13 @@ +package v039 + +import sdk "github.com/cosmos/cosmos-sdk/types" + +const ( + ModuleName = "crisis" +) + +type ( + GenesisState struct { + ConstantFee sdk.Coin `json:"constant_fee" yaml:"constant_fee"` + } +) diff --git a/x/crisis/legacy/v040/migrate.go b/x/crisis/legacy/v040/migrate.go new file mode 100644 index 000000000000..f3af6c6cd827 --- /dev/null +++ b/x/crisis/legacy/v040/migrate.go @@ -0,0 +1,16 @@ +package v040 + +import ( + v039crisis "github.com/cosmos/cosmos-sdk/x/crisis/legacy/v039" + v040crisis "github.com/cosmos/cosmos-sdk/x/crisis/types" +) + +// Migrate accepts exported v0.39 x/crisis enesis state and +// migrates it to v0.40 x/crisis genesis state. The migration includes: +// +// - Re-encode in v0.40 GenesisState. +func Migrate(crisisGenState v039crisis.GenesisState) *v040crisis.GenesisState { + return &v040crisis.GenesisState{ + ConstantFee: crisisGenState.ConstantFee, + } +} diff --git a/x/crisis/legacy/v040/types.go b/x/crisis/legacy/v040/types.go new file mode 100644 index 000000000000..04ac05f9fcd3 --- /dev/null +++ b/x/crisis/legacy/v040/types.go @@ -0,0 +1,5 @@ +package v040 + +const ( + ModuleName = "bank" +) diff --git a/x/distribution/legacy/v040/types.go b/x/distribution/legacy/v040/types.go index 27f668b2e1aa..aa502303803e 100644 --- a/x/distribution/legacy/v040/types.go +++ b/x/distribution/legacy/v040/types.go @@ -2,5 +2,5 @@ package v040 // Default parameter values const ( - ModuleName = "gov" + ModuleName = "distribution" ) diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 675e1072b28e..2d3a4d04d65a 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -9,6 +9,8 @@ import ( v036supply "github.com/cosmos/cosmos-sdk/x/bank/legacy/v036" v038bank "github.com/cosmos/cosmos-sdk/x/bank/legacy/v038" v040bank "github.com/cosmos/cosmos-sdk/x/bank/legacy/v040" + v039crisis "github.com/cosmos/cosmos-sdk/x/crisis/legacy/v039" + v040crisis "github.com/cosmos/cosmos-sdk/x/crisis/legacy/v040" v038distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v038" v040distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v040" v038evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v038" @@ -68,6 +70,20 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040auth.ModuleName] = v040Codec.MustMarshalJSON(v040auth.Migrate(authGenState)) } + // Migrate x/crisis. + if appState[v039crisis.ModuleName] != nil { + // unmarshal relative source genesis application state + var crisisGenState v039crisis.GenesisState + v039Codec.MustUnmarshalJSON(appState[v039crisis.ModuleName], &crisisGenState) + + // delete deprecated x/crisis genesis state + delete(appState, v039crisis.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040crisis.ModuleName] = v040Codec.MustMarshalJSON(v040crisis.Migrate(crisisGenState)) + } + // Migrate x/distribution. if appState[v038distribution.ModuleName] != nil { // unmarshal relative source genesis application state diff --git a/x/staking/legacy/v040/types.go b/x/staking/legacy/v040/types.go index cff719fb8f66..6ad280e277e5 100644 --- a/x/staking/legacy/v040/types.go +++ b/x/staking/legacy/v040/types.go @@ -1,6 +1,5 @@ package v040 -// Default parameter values const ( ModuleName = "staking" ) From ab59c836f4c51fed7c3259f75cc19e7d5bb0b218 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 15:21:18 +0200 Subject: [PATCH 06/24] x/mint --- x/crisis/legacy/v040/migrate.go | 2 +- x/crisis/legacy/v040/types.go | 2 +- x/genutil/legacy/v040/migrate.go | 16 ++++++++++++++++ x/mint/legacy/v039/types.go | 31 +++++++++++++++++++++++++++++++ x/mint/legacy/v040/migrate.go | 27 +++++++++++++++++++++++++++ x/mint/legacy/v040/types.go | 5 +++++ 6 files changed, 81 insertions(+), 2 deletions(-) create mode 100644 x/mint/legacy/v039/types.go create mode 100644 x/mint/legacy/v040/migrate.go create mode 100644 x/mint/legacy/v040/types.go diff --git a/x/crisis/legacy/v040/migrate.go b/x/crisis/legacy/v040/migrate.go index f3af6c6cd827..eb97ba9ee645 100644 --- a/x/crisis/legacy/v040/migrate.go +++ b/x/crisis/legacy/v040/migrate.go @@ -5,7 +5,7 @@ import ( v040crisis "github.com/cosmos/cosmos-sdk/x/crisis/types" ) -// Migrate accepts exported v0.39 x/crisis enesis state and +// Migrate accepts exported v0.39 x/crisis genesis state and // migrates it to v0.40 x/crisis genesis state. The migration includes: // // - Re-encode in v0.40 GenesisState. diff --git a/x/crisis/legacy/v040/types.go b/x/crisis/legacy/v040/types.go index 04ac05f9fcd3..68c25e93eec1 100644 --- a/x/crisis/legacy/v040/types.go +++ b/x/crisis/legacy/v040/types.go @@ -1,5 +1,5 @@ package v040 const ( - ModuleName = "bank" + ModuleName = "crisis" ) diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 2d3a4d04d65a..9b88d1474696 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -18,6 +18,8 @@ import ( "github.com/cosmos/cosmos-sdk/x/genutil/types" v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" v040gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v040" + v039mint "github.com/cosmos/cosmos-sdk/x/mint/legacy/v039" + v040mint "github.com/cosmos/cosmos-sdk/x/mint/legacy/v040" v039slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v039" v040slashing "github.com/cosmos/cosmos-sdk/x/slashing/legacy/v040" v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" @@ -126,6 +128,20 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040gov.ModuleName] = v040Codec.MustMarshalJSON(v040gov.Migrate(govGenState)) } + // Migrate x/mint. + if appState[v039mint.ModuleName] != nil { + // unmarshal relative source genesis application state + var mintGenState v039mint.GenesisState + v039Codec.MustUnmarshalJSON(appState[v039mint.ModuleName], &mintGenState) + + // delete deprecated x/mint genesis state + delete(appState, v039mint.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040mint.ModuleName] = v040Codec.MustMarshalJSON(v040mint.Migrate(mintGenState)) + } + // Migrate x/slashing. if appState[v039slashing.ModuleName] != nil { // unmarshal relative source genesis application state diff --git a/x/mint/legacy/v039/types.go b/x/mint/legacy/v039/types.go new file mode 100644 index 000000000000..10b351b7fb8f --- /dev/null +++ b/x/mint/legacy/v039/types.go @@ -0,0 +1,31 @@ +package v039 + +import sdk "github.com/cosmos/cosmos-sdk/types" + +const ( + ModuleName = "mint" +) + +type ( + // Minter represents the minting state. + Minter struct { + Inflation sdk.Dec `json:"inflation" yaml:"inflation"` // current annual inflation rate + AnnualProvisions sdk.Dec `json:"annual_provisions" yaml:"annual_provisions"` // current annual expected provisions + } + + // mint parameters + Params struct { + MintDenom string `json:"mint_denom" yaml:"mint_denom"` // type of coin to mint + InflationRateChange sdk.Dec `json:"inflation_rate_change" yaml:"inflation_rate_change"` // maximum annual change in inflation rate + InflationMax sdk.Dec `json:"inflation_max" yaml:"inflation_max"` // maximum inflation rate + InflationMin sdk.Dec `json:"inflation_min" yaml:"inflation_min"` // minimum inflation rate + GoalBonded sdk.Dec `json:"goal_bonded" yaml:"goal_bonded"` // goal of percent bonded atoms + BlocksPerYear uint64 `json:"blocks_per_year" yaml:"blocks_per_year"` // expected blocks per year + } + + // GenesisState - minter state + GenesisState struct { + Minter Minter `json:"minter" yaml:"minter"` // minter object + Params Params `json:"params" yaml:"params"` // inflation params + } +) diff --git a/x/mint/legacy/v040/migrate.go b/x/mint/legacy/v040/migrate.go new file mode 100644 index 000000000000..b417c6828951 --- /dev/null +++ b/x/mint/legacy/v040/migrate.go @@ -0,0 +1,27 @@ +package v040 + +import ( + v039mint "github.com/cosmos/cosmos-sdk/x/mint/legacy/v039" + v040mint "github.com/cosmos/cosmos-sdk/x/mint/types" +) + +// Migrate accepts exported v0.39 x/mint genesis state and +// migrates it to v0.40 x/mint genesis state. The migration includes: +// +// - Re-encode in v0.40 GenesisState. +func Migrate(mintGenState v039mint.GenesisState) *v040mint.GenesisState { + return &v040mint.GenesisState{ + Minter: v040mint.Minter{ + Inflation: mintGenState.Minter.Inflation, + AnnualProvisions: mintGenState.Minter.AnnualProvisions, + }, + Params: v040mint.Params{ + MintDenom: mintGenState.Params.MintDenom, + InflationRateChange: mintGenState.Params.InflationRateChange, + InflationMax: mintGenState.Params.InflationMax, + InflationMin: mintGenState.Params.InflationMin, + GoalBonded: mintGenState.Params.GoalBonded, + BlocksPerYear: mintGenState.Params.BlocksPerYear, + }, + } +} diff --git a/x/mint/legacy/v040/types.go b/x/mint/legacy/v040/types.go new file mode 100644 index 000000000000..d725b48c34fb --- /dev/null +++ b/x/mint/legacy/v040/types.go @@ -0,0 +1,5 @@ +package v040 + +const ( + ModuleName = "mint" +) From 777019604de5807498e6b672a0ba2e17a7b48d56 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Wed, 7 Oct 2020 15:41:02 +0200 Subject: [PATCH 07/24] Fix test --- x/evidence/legacy/v040/migrate.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/x/evidence/legacy/v040/migrate.go b/x/evidence/legacy/v040/migrate.go index ec7178cb845c..f848130f345c 100644 --- a/x/evidence/legacy/v040/migrate.go +++ b/x/evidence/legacy/v040/migrate.go @@ -10,9 +10,15 @@ import ( func migrateEvidence(oldEvidence v038evidence.Evidence) *codectypes.Any { switch oldEvidence := oldEvidence.(type) { - case *v040evidence.Equivocation: + case v038evidence.Equivocation: { - any, err := codectypes.NewAnyWithValue(oldEvidence) + newEquivocation := &v040evidence.Equivocation{ + Height: oldEvidence.Height, + Time: oldEvidence.Time, + Power: oldEvidence.Power, + ConsensusAddress: oldEvidence.ConsensusAddress.String(), + } + any, err := codectypes.NewAnyWithValue(newEquivocation) if err != nil { panic(err) } From f084fe1a08c23935aaa00871b079d27ba7b3fd68 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 11:17:58 +0200 Subject: [PATCH 08/24] migrate x/genutil --- x/genutil/legacy/v039/types.go | 12 ++++++++++++ x/genutil/legacy/v040/migrate.go | 22 ++++++++++++++++++++++ x/genutil/legacy/v040/types.go | 5 +++++ 3 files changed, 39 insertions(+) create mode 100644 x/genutil/legacy/v039/types.go create mode 100644 x/genutil/legacy/v040/types.go diff --git a/x/genutil/legacy/v039/types.go b/x/genutil/legacy/v039/types.go new file mode 100644 index 000000000000..12d082d1bc8a --- /dev/null +++ b/x/genutil/legacy/v039/types.go @@ -0,0 +1,12 @@ +package v039 + +import "encoding/json" + +const ( + ModuleName = "genutil" +) + +// GenesisState defines the raw genesis transaction in JSON +type GenesisState struct { + GenTxs []json.RawMessage `json:"gentxs" yaml:"gentxs"` +} diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 9b88d1474696..d91d9ae3b1bd 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -15,7 +15,9 @@ import ( v040distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v040" v038evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v038" v040evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v040" + v039genutil "github.com/cosmos/cosmos-sdk/x/genutil/legacy/v039" "github.com/cosmos/cosmos-sdk/x/genutil/types" + v040genutil "github.com/cosmos/cosmos-sdk/x/genutil/types" v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" v040gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v040" v039mint "github.com/cosmos/cosmos-sdk/x/mint/legacy/v039" @@ -26,6 +28,12 @@ import ( v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040" ) +func migrateGenutil(oldGenState v039genutil.GenesisState) *v040genutil.GenesisState { + return &v040genutil.GenesisState{ + GenTxs: oldGenState.GenTxs, + } +} + // Migrate migrates exported state from v0.39 to a v0.40 genesis state. func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { v039Codec := codec.NewLegacyAmino() @@ -170,5 +178,19 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040staking.ModuleName] = v040Codec.MustMarshalJSON(v040staking.Migrate(stakingGenState)) } + // Remove x/genutil + if appState[v039genutil.ModuleName] != nil { + // unmarshal relative source genesis application state + var genutilGenState v039genutil.GenesisState + v039Codec.MustUnmarshalJSON(appState[v039genutil.ModuleName], &genutilGenState) + + // delete deprecated x/staking genesis state + delete(appState, v039genutil.ModuleName) + + // Migrate relative source genesis application state and marshal it into + // the respective key. + appState[v040genutil.ModuleName] = v040Codec.MustMarshalJSON(migrateGenutil(genutilGenState)) + } + return appState } diff --git a/x/genutil/legacy/v040/types.go b/x/genutil/legacy/v040/types.go new file mode 100644 index 000000000000..f641dbff51e1 --- /dev/null +++ b/x/genutil/legacy/v040/types.go @@ -0,0 +1,5 @@ +package v040 + +const ( + ModuleName = "genutil" +) From eb0a7ab91d8a1136efcb77f15c044822202aed2e Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 11:37:56 +0200 Subject: [PATCH 09/24] Fix lint --- x/genutil/legacy/v040/migrate.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index d91d9ae3b1bd..0a8da3b306b7 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -17,7 +17,6 @@ import ( v040evidence "github.com/cosmos/cosmos-sdk/x/evidence/legacy/v040" v039genutil "github.com/cosmos/cosmos-sdk/x/genutil/legacy/v039" "github.com/cosmos/cosmos-sdk/x/genutil/types" - v040genutil "github.com/cosmos/cosmos-sdk/x/genutil/types" v036gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v036" v040gov "github.com/cosmos/cosmos-sdk/x/gov/legacy/v040" v039mint "github.com/cosmos/cosmos-sdk/x/mint/legacy/v039" @@ -28,8 +27,8 @@ import ( v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040" ) -func migrateGenutil(oldGenState v039genutil.GenesisState) *v040genutil.GenesisState { - return &v040genutil.GenesisState{ +func migrateGenutil(oldGenState v039genutil.GenesisState) *types.GenesisState { + return &types.GenesisState{ GenTxs: oldGenState.GenTxs, } } @@ -189,7 +188,7 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { // Migrate relative source genesis application state and marshal it into // the respective key. - appState[v040genutil.ModuleName] = v040Codec.MustMarshalJSON(migrateGenutil(genutilGenState)) + appState[ModuleName] = v040Codec.MustMarshalJSON(migrateGenutil(genutilGenState)) } return appState From 5d608ac1dfe8c18e370f7d27935a1de302b4c823 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 12:03:45 +0200 Subject: [PATCH 10/24] Fix staking constants --- types/staking.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/types/staking.go b/types/staking.go index 91c7601386d6..017af03c5738 100644 --- a/types/staking.go +++ b/types/staking.go @@ -40,9 +40,9 @@ type BondStatus int32 // staking constants const ( - Unbonded BondStatus = 1 - Unbonding BondStatus = 2 - Bonded BondStatus = 3 + Unbonded BondStatus = 0 + Unbonding BondStatus = 1 + Bonded BondStatus = 2 BondStatusUnbonded = "Unbonded" BondStatusUnbonding = "Unbonding" From 06cb04957f59f9578eee3fcbcd607f1611013048 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 12:12:50 +0200 Subject: [PATCH 11/24] Fix test --- types/staking_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/staking_test.go b/types/staking_test.go index 4ad06cc18b78..42dd3c3ed20a 100644 --- a/types/staking_test.go +++ b/types/staking_test.go @@ -24,7 +24,7 @@ func (s *stakingTestSuite) TestBondStatus() { s.Require().False(sdk.Unbonded.Equal(sdk.Bonded)) s.Require().False(sdk.Unbonded.Equal(sdk.Unbonding)) s.Require().False(sdk.Bonded.Equal(sdk.Unbonding)) - s.Require().Panicsf(func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet + s.Require().Panicsf(func() { sdk.BondStatus(3).String() }, "invalid bond status") // nolint:govet s.Require().Equal(sdk.BondStatusUnbonded, sdk.Unbonded.String()) s.Require().Equal(sdk.BondStatusBonded, sdk.Bonded.String()) s.Require().Equal(sdk.BondStatusUnbonding, sdk.Unbonding.String()) From b4d4289bb31bf34f1879f9ae02239637b6c2e6e2 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 13:02:58 +0200 Subject: [PATCH 12/24] Update x/genutil/legacy/v040/migrate.go Co-authored-by: Marie Gauthier --- x/genutil/legacy/v040/migrate.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/x/genutil/legacy/v040/migrate.go b/x/genutil/legacy/v040/migrate.go index 0a8da3b306b7..c07bcdb74243 100644 --- a/x/genutil/legacy/v040/migrate.go +++ b/x/genutil/legacy/v040/migrate.go @@ -177,7 +177,7 @@ func Migrate(appState types.AppMap, clientCtx client.Context) types.AppMap { appState[v040staking.ModuleName] = v040Codec.MustMarshalJSON(v040staking.Migrate(stakingGenState)) } - // Remove x/genutil + // Migrate x/genutil if appState[v039genutil.ModuleName] != nil { // unmarshal relative source genesis application state var genutilGenState v039genutil.GenesisState From b63535d8e9457cb93988fce29aa3bd6e96084ff4 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 13:44:54 +0200 Subject: [PATCH 13/24] Add migrate script instead of change BondStatus constants --- types/staking.go | 6 +- x/genaccounts/legacy/v036/migrate.go | 4 +- x/staking/legacy/v034/types.go | 18 ++++- x/staking/legacy/v036/types.go | 4 +- x/staking/legacy/v038/types.go | 4 +- x/staking/legacy/v040/migrate.go | 22 ++++++- x/staking/legacy/v040/migrate_test.go | 94 +++++++++++++++++++++++++++ 7 files changed, 140 insertions(+), 12 deletions(-) create mode 100644 x/staking/legacy/v040/migrate_test.go diff --git a/types/staking.go b/types/staking.go index 017af03c5738..91c7601386d6 100644 --- a/types/staking.go +++ b/types/staking.go @@ -40,9 +40,9 @@ type BondStatus int32 // staking constants const ( - Unbonded BondStatus = 0 - Unbonding BondStatus = 1 - Bonded BondStatus = 2 + Unbonded BondStatus = 1 + Unbonding BondStatus = 2 + Bonded BondStatus = 3 BondStatusUnbonded = "Unbonded" BondStatusUnbonding = "Unbonding" diff --git a/x/genaccounts/legacy/v036/migrate.go b/x/genaccounts/legacy/v036/migrate.go index 8dff3e454781..4da938aeaf79 100644 --- a/x/genaccounts/legacy/v036/migrate.go +++ b/x/genaccounts/legacy/v036/migrate.go @@ -90,10 +90,10 @@ func Migrate( // get staking module accounts coins for _, validator := range vals { switch validator.Status { - case sdk.Bonded: + case v034staking.Bonded: bondedAmt = bondedAmt.Add(validator.Tokens) - case sdk.Unbonding, sdk.Unbonded: + case v034staking.Unbonding, v034staking.Unbonded: notBondedAmt = notBondedAmt.Add(validator.Tokens) default: diff --git a/x/staking/legacy/v034/types.go b/x/staking/legacy/v034/types.go index f062ef2fa121..6e93b7986a52 100644 --- a/x/staking/legacy/v034/types.go +++ b/x/staking/legacy/v034/types.go @@ -15,7 +15,21 @@ const ( ModuleName = "staking" ) +// staking constants +const ( + Unbonded BondStatus = 0x00 + Unbonding BondStatus = 0x01 + Bonded BondStatus = 0x02 + + BondStatusUnbonded = "Unbonded" + BondStatusUnbonding = "Unbonding" + BondStatusBonded = "Bonded" +) + type ( + // BondStatus is the status of a validator + BondStatus byte + Pool struct { NotBondedTokens sdk.Int `json:"not_bonded_tokens"` BondedTokens sdk.Int `json:"bonded_tokens"` @@ -51,7 +65,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address"` // the bech32 address of the validator's operator ConsPubKey string `json:"consensus_pubkey"` // the bech32 consensus public key of the validator Jailed bool `json:"jailed"` // has the validator been jailed from bonded status? - Status sdk.BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded) + Status BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded) Tokens sdk.Int `json:"tokens"` // delegated tokens (incl. self-delegation) DelegatorShares sdk.Dec `json:"delegator_shares"` // total shares issued to a validator's delegators Description Description `json:"description"` // description terms for the validator @@ -65,7 +79,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address"` ConsPubKey crypto.PubKey `json:"consensus_pubkey"` Jailed bool `json:"jailed"` - Status sdk.BondStatus `json:"status"` + Status BondStatus `json:"status"` Tokens sdk.Int `json:"tokens"` DelegatorShares sdk.Dec `json:"delegator_shares"` Description Description `json:"description"` diff --git a/x/staking/legacy/v036/types.go b/x/staking/legacy/v036/types.go index 7adc446eb009..6c110bbe57dc 100644 --- a/x/staking/legacy/v036/types.go +++ b/x/staking/legacy/v036/types.go @@ -32,7 +32,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address" yaml:"operator_address"` ConsPubKey crypto.PubKey `json:"consensus_pubkey" yaml:"consensus_pubkey"` Jailed bool `json:"jailed" yaml:"jailed"` - Status sdk.BondStatus `json:"status" yaml:"status"` + Status v034staking.BondStatus `json:"status" yaml:"status"` Tokens sdk.Int `json:"tokens" yaml:"tokens"` DelegatorShares sdk.Dec `json:"delegator_shares" yaml:"delegator_shares"` Description v034staking.Description `json:"description" yaml:"description"` @@ -46,7 +46,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address" yaml:"operator_address"` ConsPubKey string `json:"consensus_pubkey" yaml:"consensus_pubkey"` Jailed bool `json:"jailed" yaml:"jailed"` - Status sdk.BondStatus `json:"status" yaml:"status"` + Status v034staking.BondStatus `json:"status" yaml:"status"` Tokens sdk.Int `json:"tokens" yaml:"tokens"` DelegatorShares sdk.Dec `json:"delegator_shares" yaml:"delegator_shares"` Description v034staking.Description `json:"description" yaml:"description"` diff --git a/x/staking/legacy/v038/types.go b/x/staking/legacy/v038/types.go index 3e6cb1d0a889..aff9a559d457 100644 --- a/x/staking/legacy/v038/types.go +++ b/x/staking/legacy/v038/types.go @@ -30,7 +30,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address" yaml:"operator_address"` ConsPubKey crypto.PubKey `json:"consensus_pubkey" yaml:"consensus_pubkey"` Jailed bool `json:"jailed" yaml:"jailed"` - Status sdk.BondStatus `json:"status" yaml:"status"` + Status v034staking.BondStatus `json:"status" yaml:"status"` Tokens sdk.Int `json:"tokens" yaml:"tokens"` DelegatorShares sdk.Dec `json:"delegator_shares" yaml:"delegator_shares"` Description Description `json:"description" yaml:"description"` @@ -44,7 +44,7 @@ type ( OperatorAddress sdk.ValAddress `json:"operator_address" yaml:"operator_address"` ConsPubKey string `json:"consensus_pubkey" yaml:"consensus_pubkey"` Jailed bool `json:"jailed" yaml:"jailed"` - Status sdk.BondStatus `json:"status" yaml:"status"` + Status v034staking.BondStatus `json:"status" yaml:"status"` Tokens sdk.Int `json:"tokens" yaml:"tokens"` DelegatorShares sdk.Dec `json:"delegator_shares" yaml:"delegator_shares"` Description Description `json:"description" yaml:"description"` diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go index 07a4eba87a5f..4cd55afa504a 100644 --- a/x/staking/legacy/v040/migrate.go +++ b/x/staking/legacy/v040/migrate.go @@ -1,15 +1,35 @@ package v040 import ( + "fmt" + sdk "github.com/cosmos/cosmos-sdk/types" + v034staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v034" v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" v040staking "github.com/cosmos/cosmos-sdk/x/staking/types" ) +func migrateBondStatus(oldStatus v034staking.BondStatus) sdk.BondStatus { + switch oldStatus { + case v034staking.Unbonded: + return sdk.Unbonded + + case v034staking.Unbonding: + return sdk.Unbonding + + case v034staking.Bonded: + return sdk.Bonded + + default: + panic(fmt.Errorf("invalid bond status %d", oldStatus)) + } +} + // Migrate accepts exported v0.38 x/staking genesis state and migrates it to // v0.40 x/staking genesis state. The migration includes: // // - Convert addresses from bytes to bech32 strings. +// - Update BondStatus staking constants. // - Re-encode in v0.40 GenesisState. func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers)) @@ -26,7 +46,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState { OperatorAddress: oldValidator.OperatorAddress.String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, oldValidator.ConsPubKey), Jailed: oldValidator.Jailed, - Status: oldValidator.Status, + Status: migrateBondStatus(oldValidator.Status), Tokens: oldValidator.Tokens, DelegatorShares: oldValidator.DelegatorShares, Description: v040staking.Description{ diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go new file mode 100644 index 000000000000..727428c8ce80 --- /dev/null +++ b/x/staking/legacy/v040/migrate_test.go @@ -0,0 +1,94 @@ +package v040_test + +import ( + "encoding/json" + "fmt" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" + "github.com/cosmos/cosmos-sdk/simapp" + v034staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v034" + v038staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v038" + v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040" +) + +func TestMigrate(t *testing.T) { + encodingConfig := simapp.MakeEncodingConfig() + clientCtx := client.Context{}. + WithInterfaceRegistry(encodingConfig.InterfaceRegistry). + WithTxConfig(encodingConfig.TxConfig). + WithLegacyAmino(encodingConfig.Amino). + WithJSONMarshaler(encodingConfig.Marshaler) + + consPubKey := ed25519.GenPrivKey().PubKey() + stakingGenState := v038staking.GenesisState{ + Validators: v038staking.Validators{v038staking.Validator{ + ConsPubKey: consPubKey, + Status: v034staking.Unbonded, + }},x + } + + migrated := v040staking.Migrate(stakingGenState) + + bz, err := clientCtx.JSONMarshaler.MarshalJSON(migrated) + require.NoError(t, err) + + // Indent the JSON bz correctly. + var jsonObj map[string]interface{} + err = json.Unmarshal(bz, &jsonObj) + require.NoError(t, err) + indentedBz, err := json.MarshalIndent(jsonObj, "", " ") + require.NoError(t, err) + + // Make sure about: + // - consensus_pubkey: should be bech32 pubkey + // - validator's status should be 1 (new unbonded) + expected := `{ + "delegations": [], + "exported": false, + "last_total_power": "0", + "last_validator_powers": [], + "params": { + "bond_denom": "", + "historical_entries": 0, + "max_entries": 0, + "max_validators": 0, + "unbonding_time": "0s" + }, + "redelegations": [], + "unbonding_delegations": [], + "validators": [ + { + "commission": { + "commission_rates": { + "max_change_rate": "0", + "max_rate": "0", + "rate": "0" + }, + "update_time": "0001-01-01T00:00:00Z" + }, + "consensus_pubkey": "cosmosvalconspub1zcjduepqtrz32re64nu80d3lagdry56ywym6yjrayrv2ycrvvm07f9tkve8s397nyf", + "delegator_shares": "0", + "description": { + "details": "", + "identity": "", + "moniker": "", + "security_contact": "", + "website": "" + }, + "jailed": false, + "min_self_delegation": "0", + "operator_address": "", + "status": 1, + "tokens": "0", + "unbonding_height": "0", + "unbonding_time": "0001-01-01T00:00:00Z" + } + ] +}` + + require.Equal(t, expected, string(indentedBz)) +} From 049ca8dab1a79bcd89c6931ceae3dd66ee424909 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 14:00:28 +0200 Subject: [PATCH 14/24] Change staking bondStatus to enum --- proto/cosmos/staking/v1beta1/staking.proto | 16 +- types/staking.go | 36 - x/slashing/keeper/keeper_test.go | 3 +- x/staking/exported/exported.go | 3 +- x/staking/keeper/delegation.go | 2 +- x/staking/keeper/querier_test.go | 2 +- x/staking/keeper/validator_test.go | 2 +- x/staking/legacy/v040/migrate.go | 8 +- x/staking/types/staking.pb.go | 1436 ++++++++++---------- x/staking/types/validator.go | 8 +- 10 files changed, 772 insertions(+), 744 deletions(-) diff --git a/proto/cosmos/staking/v1beta1/staking.proto b/proto/cosmos/staking/v1beta1/staking.proto index aee82dcb4285..51767a7f8898 100644 --- a/proto/cosmos/staking/v1beta1/staking.proto +++ b/proto/cosmos/staking/v1beta1/staking.proto @@ -75,7 +75,7 @@ message Validator { string operator_address = 1 [(gogoproto.moretags) = "yaml:\"operator_address\""]; string consensus_pubkey = 2 [(gogoproto.moretags) = "yaml:\"consensus_pubkey\""]; bool jailed = 3; - int32 status = 4 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.BondStatus"]; + BondStatus status = 4; string tokens = 5 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false]; string delegator_shares = 6 [ (gogoproto.moretags) = "yaml:\"delegator_shares\"", @@ -94,6 +94,20 @@ message Validator { ]; } +// BondStatus is the status of a validator. +enum BondStatus { + option (gogoproto.goproto_enum_prefix) = false; + + // UNSPECIFIED defines an invalid validator status. + UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unspecified"]; + // UNBONDED defines a validator that is not bonded. + UNBONDED = 1 [(gogoproto.enumvalue_customname) = "Unbonded"]; + // UNBONDING defines a validator that is unbonding. + UNBONDING = 2 [(gogoproto.enumvalue_customname) = "Unbonding"]; + // BONDED defines a validator that is bonded. + BONDED = 3 [(gogoproto.enumvalue_customname) = "Bonded"]; +} + // ValAddresses defines a repeated set of validator addresses. message ValAddresses { option (gogoproto.goproto_stringer) = false; diff --git a/types/staking.go b/types/staking.go index 91c7601386d6..0753d808b2e8 100644 --- a/types/staking.go +++ b/types/staking.go @@ -34,39 +34,3 @@ func TokensToConsensusPower(tokens Int) int64 { func TokensFromConsensusPower(power int64) Int { return NewInt(power).Mul(PowerReduction) } - -// BondStatus is the status of a validator -type BondStatus int32 - -// staking constants -const ( - Unbonded BondStatus = 1 - Unbonding BondStatus = 2 - Bonded BondStatus = 3 - - BondStatusUnbonded = "Unbonded" - BondStatusUnbonding = "Unbonding" - BondStatusBonded = "Bonded" -) - -// Equal compares two BondStatus instances -func (b BondStatus) Equal(b2 BondStatus) bool { - return byte(b) == byte(b2) -} - -// String implements the Stringer interface for BondStatus. -func (b BondStatus) String() string { - switch b { - case Unbonded: - return BondStatusUnbonded - - case Unbonding: - return BondStatusUnbonding - - case Bonded: - return BondStatusBonded - - default: - panic("invalid bond status") - } -} diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go index 5231edc79ae1..11ddb3ea6ea1 100644 --- a/x/slashing/keeper/keeper_test.go +++ b/x/slashing/keeper/keeper_test.go @@ -9,6 +9,7 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/capability/types" "github.com/cosmos/cosmos-sdk/x/slashing/keeper" "github.com/cosmos/cosmos-sdk/x/staking" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -54,7 +55,7 @@ func TestUnJailNotBonded(t *testing.T) { validator, ok := app.StakingKeeper.GetValidator(ctx, addr) require.True(t, ok) require.False(t, validator.Jailed) - require.Equal(t, sdk.BondStatusUnbonded, validator.GetStatus().String()) + require.Equal(t, types.BondStatusUnbonded, validator.GetStatus().String()) // unbond below minimum self-delegation msgUnbond := stakingtypes.NewMsgUndelegate(sdk.AccAddress(addr), addr, sdk.NewCoin(p.BondDenom, sdk.TokensFromConsensusPower(1))) diff --git a/x/staking/exported/exported.go b/x/staking/exported/exported.go index 7c8a257cd342..cd185d9eb8a0 100644 --- a/x/staking/exported/exported.go +++ b/x/staking/exported/exported.go @@ -4,6 +4,7 @@ import ( "github.com/tendermint/tendermint/crypto" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking/types" ) // DelegationI delegation bond for a delegated proof of stake system @@ -17,7 +18,7 @@ type DelegationI interface { type ValidatorI interface { IsJailed() bool // whether the validator is jailed GetMoniker() string // moniker of the validator - GetStatus() sdk.BondStatus // status of the validator + GetStatus() types.BondStatus // status of the validator IsBonded() bool // check if has a bonded status IsUnbonded() bool // check if has status unbonded IsUnbonding() bool // check if has status unbonding diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go index e2a4f64f1148..b62a26fdd850 100644 --- a/x/staking/keeper/delegation.go +++ b/x/staking/keeper/delegation.go @@ -545,7 +545,7 @@ func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time // Delegate performs a delegation, set/update everything necessary within the store. // tokenSrc indicates the bond status of the incoming funds. func (k Keeper) Delegate( - ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, tokenSrc sdk.BondStatus, + ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, tokenSrc types.BondStatus, validator types.Validator, subtractAccount bool, ) (newShares sdk.Dec, err error) { // In some situations, the exchange rate becomes invalid, e.g. if diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go index bdd796a1a78b..429d928d8f43 100644 --- a/x/staking/keeper/querier_test.go +++ b/x/staking/keeper/querier_test.go @@ -143,7 +143,7 @@ func TestQueryValidators(t *testing.T) { // Create Validators amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} - status := []sdk.BondStatus{sdk.Bonded, sdk.Unbonded, sdk.Unbonding} + status := []types.BondStatus{sdk.Bonded, sdk.Unbonded, sdk.Unbonding} var validators [3]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(addrs[i]), PKs[i], types.Description{}) diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go index 9fd77add737e..4da317a09026 100644 --- a/x/staking/keeper/validator_test.go +++ b/x/staking/keeper/validator_test.go @@ -175,7 +175,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec()) nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true) - expectedValStatus := map[int]sdk.BondStatus{ + expectedValStatus := map[int]types.BondStatus{ 9: sdk.Bonded, 8: sdk.Bonded, 7: sdk.Bonded, 5: sdk.Bonded, 4: sdk.Bonded, 0: sdk.Unbonding, 1: sdk.Unbonding, 2: sdk.Unbonding, 3: sdk.Unbonding, 6: sdk.Unbonding, } diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go index 4cd55afa504a..2749c99d9c37 100644 --- a/x/staking/legacy/v040/migrate.go +++ b/x/staking/legacy/v040/migrate.go @@ -9,16 +9,16 @@ import ( v040staking "github.com/cosmos/cosmos-sdk/x/staking/types" ) -func migrateBondStatus(oldStatus v034staking.BondStatus) sdk.BondStatus { +func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus { switch oldStatus { case v034staking.Unbonded: - return sdk.Unbonded + return v040staking.Unbonded case v034staking.Unbonding: - return sdk.Unbonding + return v040staking.Unbonding case v034staking.Bonded: - return sdk.Bonded + return v040staking.Bonded default: panic(fmt.Errorf("invalid bond status %d", oldStatus)) diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go index 9951a8174013..43ac3cda6638 100644 --- a/x/staking/types/staking.pb.go +++ b/x/staking/types/staking.pb.go @@ -38,6 +38,42 @@ var _ = time.Kitchen // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +// BondStatus is the status of a validator. +type BondStatus int32 + +const ( + // UNSPECIFIED defines an invalid validator status. + Unspecified BondStatus = 0 + // UNBONDED defines a validator that is not bonded. + Unbonded BondStatus = 1 + // UNBONDING defines a validator that is unbonding. + Unbonding BondStatus = 2 + // BONDED defines a validator that is bonded. + Bonded BondStatus = 3 +) + +var BondStatus_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "UNBONDED", + 2: "UNBONDING", + 3: "BONDED", +} + +var BondStatus_value = map[string]int32{ + "UNSPECIFIED": 0, + "UNBONDED": 1, + "UNBONDING": 2, + "BONDED": 3, +} + +func (x BondStatus) String() string { + return proto.EnumName(BondStatus_name, int32(x)) +} + +func (BondStatus) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_64c30c6cf92913c9, []int{0} +} + // HistoricalInfo contains header and validator information for a given block. // It is stored as part of staking module's state, which persists the `n` most // recent HistoricalInfo @@ -264,17 +300,17 @@ func (m *Description) GetDetails() string { // exchange rate. Voting power can be calculated as total bonded shares // multiplied by exchange rate. type Validator struct { - OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"` - ConsensusPubkey string `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty" yaml:"consensus_pubkey"` - Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"` - Status github_com_cosmos_cosmos_sdk_types.BondStatus `protobuf:"varint,4,opt,name=status,proto3,casttype=github.com/cosmos/cosmos-sdk/types.BondStatus" json:"status,omitempty"` - Tokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"` - DelegatorShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"delegator_shares" yaml:"delegator_shares"` - Description Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"` - UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty" yaml:"unbonding_height"` - UnbondingTime time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time" yaml:"unbonding_time"` - Commission Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"` - MinSelfDelegation github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_self_delegation" yaml:"min_self_delegation"` + OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"` + ConsensusPubkey string `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty" yaml:"consensus_pubkey"` + Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"` + Status BondStatus `protobuf:"varint,4,opt,name=status,proto3,enum=cosmos.staking.v1beta1.BondStatus" json:"status,omitempty"` + Tokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"` + DelegatorShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=delegator_shares,json=delegatorShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"delegator_shares" yaml:"delegator_shares"` + Description Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"` + UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty" yaml:"unbonding_height"` + UnbondingTime time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time" yaml:"unbonding_time"` + Commission Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"` + MinSelfDelegation github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=min_self_delegation,json=minSelfDelegation,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_self_delegation" yaml:"min_self_delegation"` } func (m *Validator) Reset() { *m = Validator{} } @@ -1028,6 +1064,7 @@ func (m *Pool) XXX_DiscardUnknown() { var xxx_messageInfo_Pool proto.InternalMessageInfo func init() { + proto.RegisterEnum("cosmos.staking.v1beta1.BondStatus", BondStatus_name, BondStatus_value) proto.RegisterType((*HistoricalInfo)(nil), "cosmos.staking.v1beta1.HistoricalInfo") proto.RegisterType((*CommissionRates)(nil), "cosmos.staking.v1beta1.CommissionRates") proto.RegisterType((*Commission)(nil), "cosmos.staking.v1beta1.Commission") @@ -1055,110 +1092,116 @@ func init() { } var fileDescriptor_64c30c6cf92913c9 = []byte{ - // 1641 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x1b, 0x5b, - 0x15, 0xf7, 0xd8, 0xae, 0x63, 0x1f, 0x27, 0x71, 0x7c, 0xdb, 0x06, 0x27, 0x04, 0x4f, 0x3a, 0x54, - 0x10, 0x24, 0xea, 0x90, 0x80, 0x8a, 0xc8, 0x06, 0xea, 0xb8, 0x55, 0x22, 0x0a, 0x0a, 0x93, 0x10, - 0x24, 0xa8, 0xb0, 0xae, 0x67, 0x6e, 0x9c, 0x21, 0x9e, 0x19, 0x33, 0xf7, 0xba, 0x24, 0x52, 0x17, - 0x2c, 0x41, 0x08, 0x51, 0x76, 0x5d, 0x46, 0x62, 0x8b, 0xc4, 0x9f, 0xc0, 0xb6, 0x88, 0x4d, 0xd9, - 0x21, 0x84, 0x0c, 0x6a, 0x37, 0x88, 0x15, 0xf2, 0x02, 0x21, 0x36, 0xef, 0xe9, 0x7e, 0xcc, 0x47, - 0xc6, 0x71, 0x1b, 0x47, 0x5d, 0x54, 0x7a, 0x6f, 0x93, 0xcc, 0x3d, 0x73, 0xce, 0xef, 0x7c, 0x9f, - 0x39, 0xd7, 0x70, 0xd7, 0xf2, 0xa9, 0xeb, 0xd3, 0x75, 0xca, 0xf0, 0x89, 0xe3, 0x75, 0xd7, 0x9f, - 0x6e, 0x74, 0x08, 0xc3, 0x1b, 0xe1, 0xb9, 0xd1, 0x0f, 0x7c, 0xe6, 0xa3, 0x45, 0xc9, 0xd5, 0x08, - 0xa9, 0x8a, 0x6b, 0xf9, 0x56, 0xd7, 0xef, 0xfa, 0x82, 0x65, 0x9d, 0x3f, 0x49, 0xee, 0xe5, 0x15, - 0x46, 0x3c, 0x9b, 0x04, 0xae, 0xe3, 0xb1, 0x75, 0x76, 0xd6, 0x27, 0x54, 0xfe, 0x55, 0x6f, 0xf5, - 0xae, 0xef, 0x77, 0x7b, 0x64, 0x5d, 0x9c, 0x3a, 0x83, 0xa3, 0x75, 0xe6, 0xb8, 0x84, 0x32, 0xec, - 0xf6, 0x15, 0x43, 0x3d, 0xcd, 0x60, 0x0f, 0x02, 0xcc, 0x1c, 0xdf, 0x0b, 0xdf, 0x2b, 0x93, 0x3b, - 0x98, 0x92, 0xc8, 0x5e, 0xcb, 0x77, 0xd4, 0x7b, 0xe3, 0x97, 0x1a, 0xcc, 0xef, 0x38, 0x94, 0xf9, - 0x81, 0x63, 0xe1, 0xde, 0xae, 0x77, 0xe4, 0xa3, 0xfb, 0x50, 0x38, 0x26, 0xd8, 0x26, 0x41, 0x4d, - 0x5b, 0xd5, 0xd6, 0xca, 0x9b, 0xb5, 0x46, 0x6c, 0x62, 0x43, 0x1a, 0xb7, 0x23, 0xde, 0x37, 0xf3, - 0x2f, 0x87, 0x7a, 0xc6, 0x54, 0xdc, 0xe8, 0x9b, 0x50, 0x78, 0x8a, 0x7b, 0x94, 0xb0, 0x5a, 0x76, - 0x35, 0xb7, 0x56, 0xde, 0xbc, 0xd3, 0xb8, 0x3c, 0x10, 0x8d, 0x43, 0xdc, 0x73, 0x6c, 0xcc, 0xfc, - 0x08, 0x40, 0x8a, 0x19, 0x7f, 0xc8, 0x42, 0x65, 0xdb, 0x77, 0x5d, 0x87, 0x52, 0xc7, 0xf7, 0x4c, - 0xcc, 0x08, 0x45, 0x4d, 0xc8, 0x07, 0x98, 0x11, 0x61, 0x4a, 0xa9, 0xd9, 0xe0, 0xfc, 0x7f, 0x1b, - 0xea, 0x5f, 0xe8, 0x3a, 0xec, 0x78, 0xd0, 0x69, 0x58, 0xbe, 0xbb, 0xae, 0x1c, 0x94, 0xff, 0xee, - 0x51, 0xfb, 0x44, 0x05, 0xb0, 0x45, 0x2c, 0x53, 0xc8, 0xa2, 0x27, 0x50, 0x74, 0xf1, 0x69, 0x5b, - 0xe0, 0x64, 0x05, 0xce, 0x83, 0xe9, 0x70, 0x46, 0x43, 0xbd, 0x72, 0x86, 0xdd, 0xde, 0x96, 0x11, - 0xe2, 0x18, 0xe6, 0x8c, 0x8b, 0x4f, 0xb9, 0x89, 0xa8, 0x0f, 0x15, 0x4e, 0xb5, 0x8e, 0xb1, 0xd7, - 0x25, 0x52, 0x49, 0x4e, 0x28, 0xd9, 0x99, 0x5a, 0xc9, 0x62, 0xac, 0x24, 0x01, 0x67, 0x98, 0x73, - 0x2e, 0x3e, 0xdd, 0x16, 0x04, 0xae, 0x71, 0xab, 0xf8, 0xe2, 0x5c, 0xcf, 0xfc, 0xeb, 0x5c, 0xd7, - 0x8c, 0xbf, 0x68, 0x00, 0x71, 0xc4, 0xd0, 0x13, 0x58, 0xb0, 0xa2, 0x93, 0x90, 0xa5, 0x2a, 0x87, - 0x5f, 0x9c, 0x94, 0x8b, 0x54, 0xbc, 0x9b, 0x45, 0x6e, 0xf4, 0xab, 0xa1, 0xae, 0x99, 0x15, 0x2b, - 0x95, 0x8a, 0x1f, 0x41, 0x79, 0xd0, 0xb7, 0x31, 0x23, 0x6d, 0x5e, 0x84, 0x22, 0x92, 0xe5, 0xcd, - 0xe5, 0x86, 0x2c, 0xc0, 0x46, 0x58, 0x80, 0x8d, 0x83, 0xb0, 0x42, 0x9b, 0x75, 0x8e, 0x35, 0x1a, - 0xea, 0x48, 0xba, 0x95, 0x10, 0x36, 0x9e, 0xff, 0x43, 0xd7, 0x4c, 0x90, 0x14, 0x2e, 0x90, 0xf0, - 0xe9, 0x4f, 0x1a, 0x94, 0x5b, 0x84, 0x5a, 0x81, 0xd3, 0xe7, 0x75, 0x8c, 0x6a, 0x30, 0xe3, 0xfa, - 0x9e, 0x73, 0xa2, 0xea, 0xb1, 0x64, 0x86, 0x47, 0xb4, 0x0c, 0x45, 0xc7, 0x26, 0x1e, 0x73, 0xd8, - 0x99, 0xcc, 0xab, 0x19, 0x9d, 0xb9, 0xd4, 0xcf, 0x48, 0x87, 0x3a, 0x61, 0x36, 0xcc, 0xf0, 0x88, - 0x1e, 0xc1, 0x02, 0x25, 0xd6, 0x20, 0x70, 0xd8, 0x59, 0xdb, 0xf2, 0x3d, 0x86, 0x2d, 0x56, 0xcb, - 0x8b, 0x84, 0x7d, 0x76, 0x34, 0xd4, 0x3f, 0x23, 0x6d, 0x4d, 0x73, 0x18, 0x66, 0x25, 0x24, 0x6d, - 0x4b, 0x0a, 0xd7, 0x60, 0x13, 0x86, 0x9d, 0x1e, 0xad, 0xdd, 0x90, 0x1a, 0xd4, 0x31, 0xe1, 0xcb, - 0xaf, 0x67, 0xa0, 0x14, 0x55, 0x3b, 0xd7, 0xec, 0xf7, 0x49, 0xc0, 0x9f, 0xdb, 0xd8, 0xb6, 0x03, - 0x42, 0xa9, 0xaa, 0xeb, 0x84, 0xe6, 0x34, 0x87, 0x61, 0x56, 0x42, 0xd2, 0x03, 0x49, 0xe1, 0x38, - 0x96, 0xef, 0x51, 0xe2, 0xd1, 0x01, 0x6d, 0xf7, 0x07, 0x9d, 0x13, 0xa2, 0xfc, 0x4f, 0xe2, 0xa4, - 0x39, 0x0c, 0x9e, 0x50, 0x45, 0xda, 0x13, 0x14, 0xb4, 0x08, 0x85, 0x9f, 0x60, 0xa7, 0x47, 0x6c, - 0x11, 0xa2, 0xa2, 0xa9, 0x4e, 0x68, 0x17, 0x0a, 0x94, 0x61, 0x36, 0xa0, 0x22, 0x2e, 0x37, 0x9a, - 0x1b, 0xff, 0x1f, 0xea, 0xf7, 0xae, 0x50, 0xc4, 0x4d, 0xdf, 0xb3, 0xf7, 0x85, 0xa0, 0xa9, 0x00, - 0xd0, 0x23, 0x28, 0x30, 0xff, 0x84, 0x78, 0x2a, 0x46, 0x53, 0x35, 0xf0, 0xae, 0xc7, 0x4c, 0x25, - 0x8d, 0x18, 0x2c, 0xd8, 0xa4, 0x47, 0xba, 0x22, 0x32, 0xf4, 0x18, 0x07, 0x84, 0xd6, 0x0a, 0x02, - 0x71, 0x77, 0xea, 0x2e, 0x53, 0x01, 0x4a, 0xe3, 0x19, 0x66, 0x25, 0x22, 0xed, 0x0b, 0x0a, 0xfa, - 0x36, 0x94, 0xed, 0xb8, 0x12, 0x6b, 0x33, 0xa2, 0xe2, 0x3f, 0x3f, 0xa9, 0x95, 0x12, 0x45, 0xab, - 0x06, 0x5b, 0x52, 0x9a, 0x67, 0x6d, 0xe0, 0x75, 0x7c, 0xcf, 0x76, 0xbc, 0x6e, 0xfb, 0x98, 0x38, - 0xdd, 0x63, 0x56, 0x2b, 0xae, 0x6a, 0x6b, 0xb9, 0x64, 0xd6, 0xd2, 0x1c, 0x86, 0x59, 0x89, 0x48, - 0x3b, 0x82, 0x82, 0x6c, 0x98, 0x8f, 0xb9, 0x44, 0x27, 0x96, 0xde, 0xd9, 0x89, 0x77, 0x54, 0x27, - 0xde, 0x4e, 0x6b, 0x89, 0x9b, 0x71, 0x2e, 0x22, 0x72, 0x31, 0xb4, 0x03, 0x10, 0xf7, 0x7f, 0x0d, - 0x84, 0x06, 0xe3, 0xdd, 0x43, 0x44, 0x39, 0x9e, 0x90, 0x45, 0xcf, 0xe0, 0xa6, 0xeb, 0x78, 0x6d, - 0x4a, 0x7a, 0x47, 0x6d, 0x15, 0x60, 0x0e, 0x59, 0x16, 0xd9, 0x7b, 0x3c, 0x5d, 0x3d, 0x8c, 0x86, - 0xfa, 0xb2, 0x9a, 0x91, 0xe3, 0x90, 0x86, 0x59, 0x75, 0x1d, 0x6f, 0x9f, 0xf4, 0x8e, 0x5a, 0x11, - 0x6d, 0x6b, 0xf6, 0x17, 0xe7, 0x7a, 0x46, 0xf5, 0x63, 0xc6, 0xb8, 0x0f, 0xb3, 0x87, 0xb8, 0xa7, - 0xfa, 0x88, 0x50, 0xb4, 0x02, 0x25, 0x1c, 0x1e, 0x6a, 0xda, 0x6a, 0x6e, 0xad, 0x64, 0xc6, 0x04, - 0xd9, 0xc7, 0x3f, 0xff, 0xfb, 0xaa, 0x66, 0xfc, 0x5e, 0x83, 0x42, 0xeb, 0x70, 0x0f, 0x3b, 0x01, - 0xda, 0x85, 0x6a, 0x5c, 0x39, 0x17, 0xbb, 0x78, 0x65, 0x34, 0xd4, 0x6b, 0xe9, 0xe2, 0x8a, 0xda, - 0x38, 0x2e, 0xe0, 0xb0, 0x8f, 0x77, 0xa1, 0xfa, 0x34, 0x1c, 0x0e, 0x11, 0x54, 0x36, 0x0d, 0x35, - 0xc6, 0x62, 0x98, 0x0b, 0x11, 0x4d, 0x41, 0xa5, 0xdc, 0x7c, 0x08, 0x33, 0xd2, 0x5a, 0x8a, 0xb6, - 0xe0, 0x46, 0x9f, 0x3f, 0x08, 0xef, 0xca, 0x9b, 0xf5, 0x89, 0xc5, 0x2b, 0xf8, 0x55, 0xfa, 0xa4, - 0x88, 0xf1, 0xdb, 0x2c, 0x40, 0xeb, 0xf0, 0xf0, 0x20, 0x70, 0xfa, 0x3d, 0xc2, 0xde, 0xa7, 0xe7, - 0x07, 0x70, 0x3b, 0x76, 0x8b, 0x06, 0x56, 0xca, 0xfb, 0xd5, 0xd1, 0x50, 0x5f, 0x49, 0x7b, 0x9f, - 0x60, 0x33, 0xcc, 0x9b, 0x11, 0x7d, 0x3f, 0xb0, 0x2e, 0x45, 0xb5, 0x29, 0x8b, 0x50, 0x73, 0x93, - 0x51, 0x13, 0x6c, 0x49, 0xd4, 0x16, 0x65, 0x97, 0x87, 0x76, 0x1f, 0xca, 0x71, 0x48, 0x28, 0x6a, - 0x41, 0x91, 0xa9, 0x67, 0x15, 0x61, 0x63, 0x72, 0x84, 0x43, 0x31, 0x15, 0xe5, 0x48, 0xd2, 0xf8, - 0x9f, 0x06, 0x10, 0xd7, 0xec, 0x87, 0x59, 0x62, 0x7c, 0x94, 0xab, 0xc1, 0x9b, 0xbb, 0xd6, 0x2e, - 0xa6, 0xa4, 0x53, 0xf1, 0xfc, 0x55, 0x16, 0x6e, 0x7e, 0x3f, 0x9c, 0x3c, 0x1f, 0x7c, 0x0c, 0xf6, - 0x60, 0x86, 0x78, 0x2c, 0x70, 0x44, 0x10, 0x78, 0xb6, 0xbf, 0x32, 0x29, 0xdb, 0x97, 0xf8, 0xf4, - 0xd0, 0x63, 0xc1, 0x99, 0xca, 0x7d, 0x08, 0x93, 0x8a, 0xc6, 0x6f, 0x72, 0x50, 0x9b, 0x24, 0x89, - 0xb6, 0xa1, 0x62, 0x05, 0x44, 0x10, 0xc2, 0xef, 0x87, 0x26, 0xbe, 0x1f, 0xcb, 0xf1, 0xea, 0x98, - 0x62, 0x30, 0xcc, 0xf9, 0x90, 0xa2, 0xbe, 0x1e, 0x5d, 0xe0, 0x7b, 0x1d, 0x2f, 0x3b, 0xce, 0x75, - 0xc5, 0x45, 0xce, 0x50, 0x9f, 0x8f, 0x50, 0xc9, 0x45, 0x00, 0xf9, 0xfd, 0x98, 0x8f, 0xa9, 0xe2, - 0x03, 0xf2, 0x53, 0xa8, 0x38, 0x9e, 0xc3, 0x1c, 0xdc, 0x6b, 0x77, 0x70, 0x0f, 0x7b, 0xd6, 0x75, - 0xd6, 0x62, 0x39, 0xf2, 0x95, 0xda, 0x14, 0x9c, 0x61, 0xce, 0x2b, 0x4a, 0x53, 0x12, 0xd0, 0x0e, - 0xcc, 0x84, 0xaa, 0xf2, 0xd7, 0xda, 0x36, 0x42, 0xf1, 0xe4, 0x06, 0x97, 0x83, 0xaa, 0x49, 0xec, - 0x4f, 0x53, 0x31, 0x5d, 0x2a, 0xbe, 0x03, 0x20, 0xdb, 0x9d, 0x0f, 0xd8, 0x6b, 0x64, 0x83, 0x0f, - 0x8c, 0x92, 0x44, 0x68, 0x51, 0x96, 0xc8, 0xc7, 0x30, 0x0b, 0xb3, 0xc9, 0x7c, 0x7c, 0x42, 0xbf, - 0x4a, 0x68, 0x37, 0x9e, 0x44, 0x79, 0x31, 0x89, 0xbe, 0x34, 0x69, 0x12, 0x8d, 0x55, 0xef, 0xdb, - 0x47, 0xd0, 0x7f, 0xb3, 0x50, 0xd8, 0xc3, 0x01, 0x76, 0x29, 0xb2, 0xc6, 0x36, 0x4d, 0x79, 0x99, - 0x5c, 0x1a, 0xab, 0xcf, 0x96, 0xfa, 0xd1, 0xe1, 0x1d, 0x8b, 0xe6, 0x8b, 0x4b, 0x16, 0xcd, 0x6f, - 0xc1, 0x3c, 0xbf, 0xef, 0x46, 0x3e, 0xca, 0x68, 0xcf, 0x35, 0x97, 0x62, 0x94, 0x8b, 0xef, 0xe5, - 0x75, 0x38, 0xba, 0x55, 0x51, 0xf4, 0x75, 0x28, 0x73, 0x8e, 0x78, 0x30, 0x73, 0xf1, 0xc5, 0xf8, - 0xde, 0x99, 0x78, 0x69, 0x98, 0xe0, 0xe2, 0xd3, 0x87, 0xf2, 0x80, 0x1e, 0x03, 0x3a, 0x8e, 0x7e, - 0xfa, 0x68, 0xc7, 0xe1, 0xe4, 0xf2, 0x9f, 0x1b, 0x0d, 0xf5, 0x25, 0x29, 0x3f, 0xce, 0x63, 0x98, - 0xd5, 0x98, 0x18, 0xa2, 0x7d, 0x0d, 0x80, 0xfb, 0xd5, 0xb6, 0x89, 0xe7, 0xbb, 0xea, 0xba, 0x73, - 0x7b, 0x34, 0xd4, 0xab, 0x12, 0x25, 0x7e, 0x67, 0x98, 0x25, 0x7e, 0x68, 0xf1, 0xe7, 0x44, 0x65, - 0xff, 0x4e, 0x03, 0x14, 0x8f, 0x7c, 0x93, 0xd0, 0x3e, 0xbf, 0xae, 0xf1, 0x45, 0x3c, 0xb1, 0x35, - 0x6b, 0x6f, 0x5f, 0xc4, 0x63, 0xf9, 0x70, 0x11, 0x4f, 0x74, 0xca, 0x37, 0xe2, 0xf1, 0x98, 0x55, - 0x79, 0x54, 0x30, 0x1d, 0x4c, 0x49, 0x62, 0x99, 0x77, 0x42, 0xe9, 0xb1, 0x79, 0x98, 0x31, 0xfe, - 0xac, 0xc1, 0xd2, 0x58, 0x45, 0x45, 0xc6, 0xfe, 0x18, 0x50, 0x90, 0x78, 0x29, 0xe2, 0x75, 0xa6, - 0x8c, 0x9e, 0xba, 0x40, 0xab, 0xc1, 0xd8, 0xdc, 0x7d, 0x7f, 0x13, 0x3e, 0x2f, 0x62, 0xfe, 0x47, - 0x0d, 0x6e, 0x25, 0xd5, 0x47, 0x8e, 0x7c, 0x17, 0x66, 0x93, 0xda, 0x95, 0x0b, 0x77, 0xaf, 0xe2, - 0x82, 0xb2, 0xfe, 0x82, 0x3c, 0xfa, 0x5e, 0xdc, 0xae, 0xf2, 0xc7, 0xb1, 0x8d, 0x2b, 0x47, 0x23, - 0xb4, 0x29, 0xdd, 0xb6, 0x79, 0x91, 0x8f, 0x8f, 0x34, 0xc8, 0xef, 0xf9, 0x7e, 0x0f, 0xf9, 0x50, - 0xf5, 0x7c, 0xd6, 0xe6, 0x95, 0x45, 0xec, 0xb6, 0xba, 0x74, 0xcb, 0x39, 0xb8, 0x3d, 0x5d, 0x90, - 0xfe, 0x3d, 0xd4, 0xc7, 0xa1, 0xcc, 0x8a, 0xe7, 0xb3, 0xa6, 0xa0, 0x1c, 0xc8, 0x2b, 0xf9, 0x33, - 0x98, 0xbb, 0xa8, 0x4c, 0x4e, 0xc9, 0x1f, 0x4c, 0xad, 0xec, 0x22, 0xcc, 0x68, 0xa8, 0xdf, 0x8a, - 0x3b, 0x26, 0x22, 0x1b, 0xe6, 0x6c, 0x27, 0xa1, 0x7d, 0xab, 0xc8, 0xf3, 0xf7, 0x9f, 0x73, 0x5d, - 0x6b, 0x3e, 0x7a, 0xf9, 0xba, 0xae, 0xbd, 0x7a, 0x5d, 0xd7, 0xfe, 0xf9, 0xba, 0xae, 0x3d, 0x7f, - 0x53, 0xcf, 0xbc, 0x7a, 0x53, 0xcf, 0xfc, 0xf5, 0x4d, 0x3d, 0xf3, 0xc3, 0x2f, 0xbf, 0xd5, 0x84, - 0xd3, 0xe8, 0x67, 0x5c, 0x61, 0x4c, 0xa7, 0x20, 0xa6, 0xd9, 0x57, 0x3f, 0x0e, 0x00, 0x00, 0xff, - 0xff, 0x24, 0x46, 0xec, 0x34, 0xe5, 0x15, 0x00, 0x00, + // 1740 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x23, 0x49, + 0x15, 0x77, 0xdb, 0x5e, 0xc7, 0x7e, 0x4e, 0xe2, 0xb8, 0x66, 0x26, 0x78, 0xcc, 0xe0, 0xf6, 0x36, + 0x2b, 0x18, 0x10, 0x38, 0x4c, 0x40, 0x8b, 0xc8, 0x05, 0xd6, 0x71, 0x86, 0x58, 0x2c, 0x21, 0x74, + 0x66, 0x82, 0x04, 0x2b, 0xac, 0x72, 0x77, 0xc5, 0x69, 0xe2, 0xee, 0x36, 0x5d, 0xe5, 0x21, 0x91, + 0xf6, 0xc0, 0x09, 0x2d, 0x83, 0x10, 0xcb, 0x6d, 0x2f, 0x91, 0x22, 0xed, 0x15, 0x89, 0x3f, 0x81, + 0xeb, 0x22, 0x2e, 0xc3, 0x0d, 0x21, 0x64, 0xd0, 0xcc, 0x05, 0x71, 0x42, 0x3e, 0x20, 0x4e, 0x80, + 0xea, 0xa3, 0x3f, 0xd2, 0x8e, 0x67, 0xc6, 0xd1, 0x1e, 0x56, 0x62, 0x2f, 0x89, 0xeb, 0xd5, 0x7b, + 0xbf, 0x57, 0xef, 0xb3, 0x5e, 0x35, 0xbc, 0x66, 0xf9, 0xd4, 0xf5, 0xe9, 0x06, 0x65, 0xf8, 0xc4, + 0xf1, 0x06, 0x1b, 0x8f, 0xee, 0xf5, 0x09, 0xc3, 0xf7, 0xc2, 0x75, 0x6b, 0x14, 0xf8, 0xcc, 0x47, + 0xeb, 0x92, 0xab, 0x15, 0x52, 0x15, 0x57, 0xfd, 0xe6, 0xc0, 0x1f, 0xf8, 0x82, 0x65, 0x83, 0xff, + 0x92, 0xdc, 0xf5, 0x3b, 0x8c, 0x78, 0x36, 0x09, 0x5c, 0xc7, 0x63, 0x1b, 0xec, 0x6c, 0x44, 0xa8, + 0xfc, 0xab, 0x76, 0xf5, 0x81, 0xef, 0x0f, 0x86, 0x64, 0x43, 0xac, 0xfa, 0xe3, 0xa3, 0x0d, 0xe6, + 0xb8, 0x84, 0x32, 0xec, 0x8e, 0x14, 0x43, 0x23, 0xcd, 0x60, 0x8f, 0x03, 0xcc, 0x1c, 0xdf, 0x0b, + 0xf7, 0xd5, 0x91, 0xfb, 0x98, 0x92, 0xe8, 0xbc, 0x96, 0xef, 0xa8, 0x7d, 0xe3, 0xe7, 0x1a, 0xac, + 0xee, 0x3a, 0x94, 0xf9, 0x81, 0x63, 0xe1, 0x61, 0xd7, 0x3b, 0xf2, 0xd1, 0xeb, 0x50, 0x38, 0x26, + 0xd8, 0x26, 0x41, 0x4d, 0x6b, 0x6a, 0x77, 0xcb, 0x9b, 0xb5, 0x56, 0x7c, 0xc4, 0x96, 0x3c, 0xdc, + 0xae, 0xd8, 0x6f, 0xe7, 0x3f, 0x98, 0xe8, 0x19, 0x53, 0x71, 0xa3, 0xaf, 0x43, 0xe1, 0x11, 0x1e, + 0x52, 0xc2, 0x6a, 0xd9, 0x66, 0xee, 0x6e, 0x79, 0xf3, 0xd5, 0xd6, 0xd5, 0x8e, 0x68, 0x1d, 0xe2, + 0xa1, 0x63, 0x63, 0xe6, 0x47, 0x00, 0x52, 0xcc, 0xf8, 0x6d, 0x16, 0x2a, 0xdb, 0xbe, 0xeb, 0x3a, + 0x94, 0x3a, 0xbe, 0x67, 0x62, 0x46, 0x28, 0x6a, 0x43, 0x3e, 0xc0, 0x8c, 0x88, 0xa3, 0x94, 0xda, + 0x2d, 0xce, 0xff, 0xe7, 0x89, 0xfe, 0x99, 0x81, 0xc3, 0x8e, 0xc7, 0xfd, 0x96, 0xe5, 0xbb, 0x1b, + 0xca, 0x40, 0xf9, 0xef, 0x8b, 0xd4, 0x3e, 0x51, 0x0e, 0xec, 0x10, 0xcb, 0x14, 0xb2, 0xe8, 0x2d, + 0x28, 0xba, 0xf8, 0xb4, 0x27, 0x70, 0xb2, 0x02, 0xe7, 0x8d, 0xc5, 0x70, 0xa6, 0x13, 0xbd, 0x72, + 0x86, 0xdd, 0xe1, 0x96, 0x11, 0xe2, 0x18, 0xe6, 0x92, 0x8b, 0x4f, 0xf9, 0x11, 0xd1, 0x08, 0x2a, + 0x9c, 0x6a, 0x1d, 0x63, 0x6f, 0x40, 0xa4, 0x92, 0x9c, 0x50, 0xb2, 0xbb, 0xb0, 0x92, 0xf5, 0x58, + 0x49, 0x02, 0xce, 0x30, 0x57, 0x5c, 0x7c, 0xba, 0x2d, 0x08, 0x5c, 0xe3, 0x56, 0xf1, 0xbd, 0x0b, + 0x3d, 0xf3, 0xf7, 0x0b, 0x5d, 0x33, 0xfe, 0xa8, 0x01, 0xc4, 0x1e, 0x43, 0x6f, 0xc1, 0x9a, 0x15, + 0xad, 0x84, 0x2c, 0x55, 0x31, 0xfc, 0xec, 0xbc, 0x58, 0xa4, 0xfc, 0xdd, 0x2e, 0xf2, 0x43, 0x3f, + 0x99, 0xe8, 0x9a, 0x59, 0xb1, 0x52, 0xa1, 0xf8, 0x01, 0x94, 0xc7, 0x23, 0x1b, 0x33, 0xd2, 0xe3, + 0x49, 0x28, 0x3c, 0x59, 0xde, 0xac, 0xb7, 0x64, 0x02, 0xb6, 0xc2, 0x04, 0x6c, 0x3d, 0x08, 0x33, + 0xb4, 0xdd, 0xe0, 0x58, 0xd3, 0x89, 0x8e, 0xa4, 0x59, 0x09, 0x61, 0xe3, 0xdd, 0xbf, 0xea, 0x9a, + 0x09, 0x92, 0xc2, 0x05, 0x12, 0x36, 0xfd, 0x5e, 0x83, 0x72, 0x87, 0x50, 0x2b, 0x70, 0x46, 0x3c, + 0x8f, 0x51, 0x0d, 0x96, 0x5c, 0xdf, 0x73, 0x4e, 0x54, 0x3e, 0x96, 0xcc, 0x70, 0x89, 0xea, 0x50, + 0x74, 0x6c, 0xe2, 0x31, 0x87, 0x9d, 0xc9, 0xb8, 0x9a, 0xd1, 0x9a, 0x4b, 0xfd, 0x84, 0xf4, 0xa9, + 0x13, 0x46, 0xc3, 0x0c, 0x97, 0xe8, 0x3e, 0xac, 0x51, 0x62, 0x8d, 0x03, 0x87, 0x9d, 0xf5, 0x2c, + 0xdf, 0x63, 0xd8, 0x62, 0xb5, 0xbc, 0x08, 0xd8, 0x27, 0xa7, 0x13, 0xfd, 0x13, 0xf2, 0xac, 0x69, + 0x0e, 0xc3, 0xac, 0x84, 0xa4, 0x6d, 0x49, 0xe1, 0x1a, 0x6c, 0xc2, 0xb0, 0x33, 0xa4, 0xb5, 0x57, + 0xa4, 0x06, 0xb5, 0x4c, 0xd8, 0xf2, 0x9f, 0x02, 0x94, 0xa2, 0x6c, 0xe7, 0x9a, 0xfd, 0x11, 0x09, + 0xf8, 0xef, 0x1e, 0xb6, 0xed, 0x80, 0x50, 0xaa, 0xf2, 0x3a, 0xa1, 0x39, 0xcd, 0x61, 0x98, 0x95, + 0x90, 0xf4, 0x86, 0xa4, 0x70, 0x1c, 0xcb, 0xf7, 0x28, 0xf1, 0xe8, 0x98, 0xf6, 0x46, 0xe3, 0xfe, + 0x09, 0x51, 0xf6, 0x27, 0x71, 0xd2, 0x1c, 0x06, 0x0f, 0xa8, 0x22, 0xed, 0x0b, 0x0a, 0x5a, 0x87, + 0xc2, 0x8f, 0xb0, 0x33, 0x24, 0xb6, 0x70, 0x51, 0xd1, 0x54, 0x2b, 0xb4, 0x05, 0x05, 0xca, 0x30, + 0x1b, 0x53, 0xe1, 0x97, 0xd5, 0x4d, 0x63, 0x5e, 0xf2, 0xb4, 0x7d, 0xcf, 0x3e, 0x10, 0x9c, 0xa6, + 0x92, 0x40, 0xf7, 0xa1, 0xc0, 0xfc, 0x13, 0xe2, 0x29, 0xa7, 0x2c, 0x54, 0xb1, 0x5d, 0x8f, 0x99, + 0x4a, 0x1a, 0x31, 0x58, 0xb3, 0xc9, 0x90, 0x0c, 0x84, 0x2b, 0xe8, 0x31, 0x0e, 0x08, 0xad, 0x15, + 0x04, 0x62, 0x77, 0xe1, 0xb2, 0x52, 0x1e, 0x49, 0xe3, 0x19, 0x66, 0x25, 0x22, 0x1d, 0x08, 0x0a, + 0xfa, 0x16, 0x94, 0xed, 0x38, 0xf5, 0x6a, 0x4b, 0x22, 0xc5, 0x3f, 0x3d, 0xcf, 0xfc, 0x44, 0x96, + 0xaa, 0x4e, 0x96, 0x94, 0xe6, 0x61, 0x1a, 0x7b, 0x7d, 0xdf, 0xb3, 0x1d, 0x6f, 0xd0, 0x3b, 0x26, + 0xce, 0xe0, 0x98, 0xd5, 0x8a, 0x4d, 0xed, 0x6e, 0x2e, 0x19, 0xa6, 0x34, 0x87, 0x61, 0x56, 0x22, + 0xd2, 0xae, 0xa0, 0x20, 0x1b, 0x56, 0x63, 0x2e, 0x51, 0x7a, 0xa5, 0x17, 0x96, 0xde, 0xab, 0xaa, + 0xf4, 0x6e, 0xa5, 0xb5, 0xc4, 0xd5, 0xb7, 0x12, 0x11, 0xb9, 0x18, 0xda, 0x05, 0x88, 0x0b, 0xbe, + 0x06, 0x42, 0x83, 0xf1, 0xe2, 0xae, 0xa1, 0x0c, 0x4f, 0xc8, 0xa2, 0xb7, 0xe1, 0x86, 0xeb, 0x78, + 0x3d, 0x4a, 0x86, 0x47, 0x3d, 0xe5, 0x60, 0x0e, 0x59, 0x16, 0xd1, 0x7b, 0x73, 0xb1, 0x7c, 0x98, + 0x4e, 0xf4, 0xba, 0x6a, 0x8a, 0xb3, 0x90, 0x86, 0x59, 0x75, 0x1d, 0xef, 0x80, 0x0c, 0x8f, 0x3a, + 0x11, 0x6d, 0x6b, 0xf9, 0x9d, 0x0b, 0x3d, 0xa3, 0x0a, 0x30, 0x63, 0xbc, 0x0e, 0xcb, 0x87, 0x78, + 0xa8, 0x0a, 0x87, 0x50, 0x74, 0x07, 0x4a, 0x38, 0x5c, 0xd4, 0xb4, 0x66, 0xee, 0x6e, 0xc9, 0x8c, + 0x09, 0xb2, 0x70, 0x7f, 0xfa, 0x97, 0xa6, 0x66, 0xfc, 0x46, 0x83, 0x42, 0xe7, 0x70, 0x1f, 0x3b, + 0x01, 0xea, 0x42, 0x35, 0xce, 0x9c, 0xcb, 0x65, 0x7b, 0x67, 0x3a, 0xd1, 0x6b, 0xe9, 0xe4, 0x8a, + 0xea, 0x36, 0x4e, 0xe0, 0xb0, 0x70, 0xbb, 0x50, 0x7d, 0x14, 0x76, 0x83, 0x08, 0x2a, 0x9b, 0x86, + 0x9a, 0x61, 0x31, 0xcc, 0xb5, 0x88, 0xa6, 0xa0, 0x52, 0x66, 0xee, 0xc0, 0x92, 0x3c, 0x2d, 0x45, + 0x5b, 0xf0, 0xca, 0x88, 0xff, 0x10, 0xd6, 0x95, 0x37, 0x1b, 0x73, 0x93, 0x57, 0xf0, 0xab, 0xf0, + 0x49, 0x11, 0xe3, 0xd7, 0x59, 0x80, 0xce, 0xe1, 0xe1, 0x83, 0xc0, 0x19, 0x0d, 0x09, 0xfb, 0x30, + 0x2d, 0x7f, 0x00, 0xb7, 0x62, 0xb3, 0x68, 0x60, 0xa5, 0xac, 0x6f, 0x4e, 0x27, 0xfa, 0x9d, 0xb4, + 0xf5, 0x09, 0x36, 0xc3, 0xbc, 0x11, 0xd1, 0x0f, 0x02, 0xeb, 0x4a, 0x54, 0x9b, 0xb2, 0x08, 0x35, + 0x37, 0x1f, 0x35, 0xc1, 0x96, 0x44, 0xed, 0x50, 0x76, 0xb5, 0x6b, 0x0f, 0xa0, 0x1c, 0xbb, 0x84, + 0xa2, 0x0e, 0x14, 0x99, 0xfa, 0xad, 0x3c, 0x6c, 0xcc, 0xf7, 0x70, 0x28, 0xa6, 0xbc, 0x1c, 0x49, + 0x1a, 0xff, 0xd6, 0x00, 0xe2, 0x9c, 0xfd, 0x68, 0xa6, 0x18, 0x6f, 0xe5, 0xaa, 0xf1, 0xe6, 0xae, + 0x35, 0x7c, 0x29, 0xe9, 0x94, 0x3f, 0x7f, 0x91, 0x85, 0x1b, 0x0f, 0xc3, 0xce, 0xf3, 0x91, 0xf7, + 0xc1, 0x3e, 0x2c, 0x11, 0x8f, 0x05, 0x8e, 0x70, 0x02, 0x8f, 0xf6, 0x97, 0xe6, 0x45, 0xfb, 0x0a, + 0x9b, 0x76, 0x3c, 0x16, 0x9c, 0xa9, 0xd8, 0x87, 0x30, 0x29, 0x6f, 0xfc, 0x2a, 0x07, 0xb5, 0x79, + 0x92, 0x68, 0x1b, 0x2a, 0x56, 0x40, 0x04, 0x21, 0xbc, 0x3f, 0x34, 0x71, 0x7f, 0xd4, 0xe3, 0x59, + 0x31, 0xc5, 0x60, 0x98, 0xab, 0x21, 0x45, 0xdd, 0x1e, 0x03, 0xe0, 0x83, 0x1c, 0x4f, 0x3b, 0xce, + 0xf5, 0x92, 0x93, 0x9b, 0xa1, 0xae, 0x8f, 0x50, 0xc9, 0x65, 0x00, 0x79, 0x7f, 0xac, 0xc6, 0x54, + 0x71, 0x81, 0xfc, 0x18, 0x2a, 0x8e, 0xe7, 0x30, 0x07, 0x0f, 0x7b, 0x7d, 0x3c, 0xc4, 0x9e, 0x75, + 0x9d, 0x39, 0x58, 0xb6, 0x7c, 0xa5, 0x36, 0x05, 0x67, 0x98, 0xab, 0x8a, 0xd2, 0x96, 0x04, 0xb4, + 0x0b, 0x4b, 0xa1, 0xaa, 0xfc, 0xb5, 0xa6, 0x8d, 0x50, 0x3c, 0x31, 0xb2, 0xfd, 0x32, 0x07, 0x55, + 0x93, 0xd8, 0x1f, 0x87, 0x62, 0xb1, 0x50, 0x7c, 0x1b, 0x40, 0x96, 0x3b, 0x6f, 0xb0, 0xd7, 0x88, + 0x06, 0x6f, 0x18, 0x25, 0x89, 0xd0, 0xa1, 0x2c, 0x11, 0x8f, 0x49, 0x16, 0x96, 0x93, 0xf1, 0xf8, + 0x3f, 0xbd, 0x95, 0x50, 0x37, 0xee, 0x44, 0x79, 0xd1, 0x89, 0x3e, 0x37, 0xaf, 0x13, 0xcd, 0x64, + 0xef, 0xf3, 0x5b, 0xd0, 0xbf, 0xb2, 0x50, 0xd8, 0xc7, 0x01, 0x76, 0x29, 0xb2, 0x66, 0x26, 0x4d, + 0xf9, 0x7a, 0xbc, 0x3d, 0x93, 0x9f, 0x1d, 0xf5, 0x95, 0xe1, 0x05, 0x83, 0xe6, 0x7b, 0x57, 0x0c, + 0x9a, 0xdf, 0x80, 0x55, 0xfe, 0xc0, 0x8d, 0x6c, 0x94, 0xde, 0x5e, 0x69, 0xdf, 0x8e, 0x51, 0x2e, + 0xef, 0xcb, 0xf7, 0x6f, 0xf4, 0x8c, 0xa2, 0xe8, 0xab, 0x50, 0xe6, 0x1c, 0x71, 0x63, 0xe6, 0xe2, + 0xeb, 0xf1, 0x43, 0x33, 0xb1, 0x69, 0x98, 0xe0, 0xe2, 0xd3, 0x1d, 0xb9, 0x40, 0x6f, 0x02, 0x3a, + 0x8e, 0xbe, 0x75, 0xf4, 0x62, 0x77, 0x72, 0xf9, 0x4f, 0x4d, 0x27, 0xfa, 0x6d, 0x29, 0x3f, 0xcb, + 0x63, 0x98, 0xd5, 0x98, 0x18, 0xa2, 0x7d, 0x05, 0x80, 0xdb, 0xd5, 0xb3, 0x89, 0xe7, 0xbb, 0xea, + 0xb9, 0x73, 0x6b, 0x3a, 0xd1, 0xab, 0x12, 0x25, 0xde, 0x33, 0xcc, 0x12, 0x5f, 0x74, 0xf8, 0xef, + 0x44, 0x66, 0xbf, 0xaf, 0x01, 0x8a, 0x5b, 0xbe, 0x49, 0xe8, 0x88, 0xbf, 0xcf, 0xf8, 0x20, 0x9e, + 0x98, 0x9a, 0xb5, 0xe7, 0x0f, 0xe2, 0xb1, 0x7c, 0x38, 0x88, 0x27, 0x2a, 0xe5, 0x6b, 0x71, 0x7b, + 0xcc, 0xaa, 0x38, 0x2a, 0x98, 0x3e, 0xa6, 0x24, 0x31, 0xcc, 0x3b, 0xa1, 0xf4, 0x4c, 0x3f, 0xcc, + 0x18, 0x7f, 0xd0, 0xe0, 0xf6, 0x4c, 0x46, 0x45, 0x87, 0xfd, 0x21, 0xa0, 0x20, 0xb1, 0x29, 0xfc, + 0x75, 0xa6, 0x0e, 0xbd, 0x70, 0x82, 0x56, 0x83, 0x99, 0xbe, 0xfb, 0xe1, 0x75, 0xf8, 0xbc, 0xf0, + 0xf9, 0xef, 0x34, 0xb8, 0x99, 0x54, 0x1f, 0x19, 0xb2, 0x07, 0xcb, 0x49, 0xed, 0xca, 0x84, 0xd7, + 0x5e, 0xc6, 0x04, 0x75, 0xfa, 0x4b, 0xf2, 0xe8, 0xbb, 0x71, 0xb9, 0xca, 0xaf, 0x61, 0xf7, 0x5e, + 0xda, 0x1b, 0xe1, 0x99, 0xd2, 0x65, 0x9b, 0x17, 0xf1, 0xf8, 0xaf, 0x06, 0xf9, 0x7d, 0xdf, 0x1f, + 0x22, 0x1f, 0xaa, 0x9e, 0xcf, 0x7a, 0x3c, 0xb3, 0x88, 0xdd, 0x53, 0x8f, 0x6e, 0xd9, 0x07, 0xb7, + 0x17, 0x73, 0xd2, 0x3f, 0x26, 0xfa, 0x2c, 0x94, 0x59, 0xf1, 0x7c, 0xd6, 0x16, 0x94, 0x07, 0xf2, + 0x49, 0xfe, 0x36, 0xac, 0x5c, 0x56, 0x26, 0xbb, 0xe4, 0xf7, 0x16, 0x56, 0x76, 0x19, 0x66, 0x3a, + 0xd1, 0x6f, 0xc6, 0x15, 0x13, 0x91, 0x0d, 0x73, 0xb9, 0x9f, 0xd0, 0xbe, 0x55, 0xe4, 0xf1, 0xfb, + 0xe7, 0x85, 0xae, 0x7d, 0xfe, 0x67, 0x1a, 0x40, 0xfc, 0xe5, 0x01, 0x35, 0xa1, 0xfc, 0x70, 0xef, + 0x60, 0x7f, 0x67, 0xbb, 0x7b, 0xbf, 0xbb, 0xd3, 0x59, 0xcb, 0xd4, 0x2b, 0x8f, 0xcf, 0x9b, 0xe5, + 0x87, 0x1e, 0x1d, 0x11, 0xcb, 0x39, 0x72, 0x88, 0x8d, 0xea, 0x50, 0x7c, 0xb8, 0xd7, 0xfe, 0xce, + 0x5e, 0x67, 0xa7, 0xb3, 0xa6, 0xd5, 0x97, 0x1f, 0x9f, 0x37, 0x8b, 0x72, 0xe6, 0x22, 0x36, 0x7f, + 0x10, 0xca, 0xbd, 0xee, 0xde, 0x37, 0xd7, 0xb2, 0xf5, 0x95, 0xc7, 0xe7, 0xcd, 0x52, 0x34, 0x90, + 0xa1, 0x75, 0x28, 0x28, 0xb9, 0x5c, 0x1d, 0x1e, 0x9f, 0x37, 0x0b, 0xd2, 0x21, 0xf5, 0xfc, 0x3b, + 0xef, 0x37, 0x32, 0xed, 0xfb, 0x1f, 0x3c, 0x6d, 0x68, 0x4f, 0x9e, 0x36, 0xb4, 0xbf, 0x3d, 0x6d, + 0x68, 0xef, 0x3e, 0x6b, 0x64, 0x9e, 0x3c, 0x6b, 0x64, 0xfe, 0xf4, 0xac, 0x91, 0xf9, 0xfe, 0x17, + 0x9e, 0xeb, 0x8b, 0xd3, 0xe8, 0x03, 0xb2, 0xf0, 0x4a, 0xbf, 0x20, 0xda, 0xea, 0x97, 0xff, 0x17, + 0x00, 0x00, 0xff, 0xff, 0xcb, 0x6b, 0x6c, 0xa9, 0x5f, 0x16, 0x00, 0x00, } func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { @@ -1167,584 +1210,589 @@ func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_ func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ - // 9223 bytes of a gzipped FileDescriptorSet - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x74, 0x1c, 0xd7, - 0x75, 0x18, 0x67, 0x3f, 0x80, 0xdd, 0xbb, 0xf8, 0x58, 0x3c, 0x80, 0xd0, 0x72, 0x49, 0x02, 0xd0, - 0x48, 0x96, 0x28, 0x4a, 0x5a, 0x48, 0x14, 0x49, 0x91, 0xcb, 0x58, 0x32, 0x16, 0x58, 0x82, 0x20, - 0xf1, 0xa5, 0x01, 0x48, 0xf9, 0x23, 0xe9, 0x9e, 0xc1, 0xee, 0xc3, 0x62, 0xc4, 0xdd, 0x99, 0xf1, - 0xcc, 0x2c, 0x09, 0xc8, 0xf6, 0x39, 0x4a, 0xec, 0xba, 0xb6, 0xd2, 0xd4, 0x76, 0x9d, 0x93, 0xda, - 0x8e, 0xe5, 0xca, 0x71, 0x5a, 0xa7, 0x4e, 0xda, 0x7c, 0x38, 0x4d, 0x9b, 0xb6, 0xe7, 0xd4, 0x6e, - 0x9b, 0xc6, 0x69, 0x4f, 0x73, 0xa4, 0xd3, 0x9c, 0xd3, 0x34, 0xa7, 0x61, 0x52, 0x59, 0x4d, 0x55, - 0xd7, 0x6d, 0x1d, 0x56, 0x4d, 0xd3, 0xfa, 0x47, 0x7b, 0xde, 0xd7, 0x7c, 0xed, 0x2e, 0x66, 0x17, - 0x22, 0x25, 0xa7, 0xe9, 0x2f, 0xec, 0xbb, 0xef, 0xde, 0xfb, 0xee, 0xbd, 0xef, 0xde, 0xfb, 0xee, - 0x7b, 0xf3, 0x66, 0x00, 0xff, 0xf4, 0x02, 0xcc, 0xd4, 0x0d, 0xa3, 0xde, 0xc0, 0xb3, 0xa6, 0x65, - 0x38, 0xc6, 0x56, 0x6b, 0x7b, 0xb6, 0x86, 0xed, 0xaa, 0xa5, 0x99, 0x8e, 0x61, 0x15, 0x28, 0x0c, - 0x8d, 0x32, 0x8c, 0x82, 0xc0, 0x90, 0x57, 0x60, 0xec, 0xa2, 0xd6, 0xc0, 0x0b, 0x2e, 0xe2, 0x06, - 0x76, 0xd0, 0x39, 0x48, 0x6c, 0x6b, 0x0d, 0x9c, 0x93, 0x66, 0xe2, 0x27, 0x32, 0xa7, 0xee, 0x2f, - 0x84, 0x88, 0x0a, 0x41, 0x8a, 0x75, 0x02, 0x56, 0x28, 0x85, 0xfc, 0x7a, 0x02, 0xc6, 0x3b, 0xf4, - 0x22, 0x04, 0x09, 0x5d, 0x6d, 0x12, 0x8e, 0xd2, 0x89, 0xb4, 0x42, 0x7f, 0xa3, 0x1c, 0x0c, 0x9a, - 0x6a, 0xf5, 0xba, 0x5a, 0xc7, 0xb9, 0x18, 0x05, 0x8b, 0x26, 0x9a, 0x02, 0xa8, 0x61, 0x13, 0xeb, - 0x35, 0xac, 0x57, 0xf7, 0x72, 0xf1, 0x99, 0xf8, 0x89, 0xb4, 0xe2, 0x83, 0xa0, 0x87, 0x61, 0xcc, - 0x6c, 0x6d, 0x35, 0xb4, 0x6a, 0xc5, 0x87, 0x06, 0x33, 0xf1, 0x13, 0x49, 0x25, 0xcb, 0x3a, 0x16, - 0x3c, 0xe4, 0x07, 0x61, 0xf4, 0x26, 0x56, 0xaf, 0xfb, 0x51, 0x33, 0x14, 0x75, 0x84, 0x80, 0x7d, - 0x88, 0xf3, 0x30, 0xd4, 0xc4, 0xb6, 0xad, 0xd6, 0x71, 0xc5, 0xd9, 0x33, 0x71, 0x2e, 0x41, 0xb5, - 0x9f, 0x69, 0xd3, 0x3e, 0xac, 0x79, 0x86, 0x53, 0x6d, 0xee, 0x99, 0x18, 0xcd, 0x41, 0x1a, 0xeb, - 0xad, 0x26, 0xe3, 0x90, 0xec, 0x62, 0xbf, 0xb2, 0xde, 0x6a, 0x86, 0xb9, 0xa4, 0x08, 0x19, 0x67, - 0x31, 0x68, 0x63, 0xeb, 0x86, 0x56, 0xc5, 0xb9, 0x01, 0xca, 0xe0, 0xc1, 0x36, 0x06, 0x1b, 0xac, - 0x3f, 0xcc, 0x43, 0xd0, 0xa1, 0x79, 0x48, 0xe3, 0x5d, 0x07, 0xeb, 0xb6, 0x66, 0xe8, 0xb9, 0x41, - 0xca, 0xe4, 0x5d, 0x1d, 0x66, 0x11, 0x37, 0x6a, 0x61, 0x16, 0x1e, 0x1d, 0x3a, 0x0b, 0x83, 0x86, - 0xe9, 0x68, 0x86, 0x6e, 0xe7, 0x52, 0x33, 0xd2, 0x89, 0xcc, 0xa9, 0x63, 0x1d, 0x1d, 0x61, 0x8d, - 0xe1, 0x28, 0x02, 0x19, 0x2d, 0x41, 0xd6, 0x36, 0x5a, 0x56, 0x15, 0x57, 0xaa, 0x46, 0x0d, 0x57, - 0x34, 0x7d, 0xdb, 0xc8, 0xa5, 0x29, 0x83, 0xe9, 0x76, 0x45, 0x28, 0xe2, 0xbc, 0x51, 0xc3, 0x4b, - 0xfa, 0xb6, 0xa1, 0x8c, 0xd8, 0x81, 0x36, 0x9a, 0x84, 0x01, 0x7b, 0x4f, 0x77, 0xd4, 0xdd, 0xdc, - 0x10, 0xf5, 0x10, 0xde, 0x92, 0x7f, 0x7d, 0x00, 0x46, 0x7b, 0x71, 0xb1, 0x0b, 0x90, 0xdc, 0x26, - 0x5a, 0xe6, 0x62, 0xfd, 0xd8, 0x80, 0xd1, 0x04, 0x8d, 0x38, 0x70, 0x40, 0x23, 0xce, 0x41, 0x46, - 0xc7, 0xb6, 0x83, 0x6b, 0xcc, 0x23, 0xe2, 0x3d, 0xfa, 0x14, 0x30, 0xa2, 0x76, 0x97, 0x4a, 0x1c, - 0xc8, 0xa5, 0xde, 0x0b, 0xa3, 0xae, 0x48, 0x15, 0x4b, 0xd5, 0xeb, 0xc2, 0x37, 0x67, 0xa3, 0x24, - 0x29, 0x94, 0x05, 0x9d, 0x42, 0xc8, 0x94, 0x11, 0x1c, 0x68, 0xa3, 0x05, 0x00, 0x43, 0xc7, 0xc6, - 0x76, 0xa5, 0x86, 0xab, 0x8d, 0x5c, 0xaa, 0x8b, 0x95, 0xd6, 0x08, 0x4a, 0x9b, 0x95, 0x0c, 0x06, - 0xad, 0x36, 0xd0, 0x79, 0xcf, 0xd5, 0x06, 0xbb, 0x78, 0xca, 0x0a, 0x0b, 0xb2, 0x36, 0x6f, 0xbb, - 0x0a, 0x23, 0x16, 0x26, 0x7e, 0x8f, 0x6b, 0x5c, 0xb3, 0x34, 0x15, 0xa2, 0x10, 0xa9, 0x99, 0xc2, - 0xc9, 0x98, 0x62, 0xc3, 0x96, 0xbf, 0x89, 0xee, 0x03, 0x17, 0x50, 0xa1, 0x6e, 0x05, 0x34, 0x0b, - 0x0d, 0x09, 0xe0, 0xaa, 0xda, 0xc4, 0xf9, 0xe7, 0x61, 0x24, 0x68, 0x1e, 0x34, 0x01, 0x49, 0xdb, - 0x51, 0x2d, 0x87, 0x7a, 0x61, 0x52, 0x61, 0x0d, 0x94, 0x85, 0x38, 0xd6, 0x6b, 0x34, 0xcb, 0x25, - 0x15, 0xf2, 0x13, 0xbd, 0xc7, 0x53, 0x38, 0x4e, 0x15, 0x7e, 0xa0, 0x7d, 0x46, 0x03, 0x9c, 0xc3, - 0x7a, 0xe7, 0x9f, 0x84, 0xe1, 0x80, 0x02, 0xbd, 0x0e, 0x2d, 0x7f, 0x18, 0x0e, 0x77, 0x64, 0x8d, - 0xde, 0x0b, 0x13, 0x2d, 0x5d, 0xd3, 0x1d, 0x6c, 0x99, 0x16, 0x26, 0x1e, 0xcb, 0x86, 0xca, 0xfd, - 0xc7, 0xc1, 0x2e, 0x3e, 0x77, 0xd5, 0x8f, 0xcd, 0xb8, 0x28, 0xe3, 0xad, 0x76, 0xe0, 0xc9, 0x74, - 0xea, 0x8d, 0xc1, 0xec, 0x0b, 0x2f, 0xbc, 0xf0, 0x42, 0x4c, 0xfe, 0xe6, 0x00, 0x4c, 0x74, 0x8a, - 0x99, 0x8e, 0xe1, 0x3b, 0x09, 0x03, 0x7a, 0xab, 0xb9, 0x85, 0x2d, 0x6a, 0xa4, 0xa4, 0xc2, 0x5b, - 0x68, 0x0e, 0x92, 0x0d, 0x75, 0x0b, 0x37, 0x72, 0x89, 0x19, 0xe9, 0xc4, 0xc8, 0xa9, 0x87, 0x7b, - 0x8a, 0xca, 0xc2, 0x32, 0x21, 0x51, 0x18, 0x25, 0x7a, 0x0a, 0x12, 0x3c, 0x45, 0x13, 0x0e, 0x27, - 0x7b, 0xe3, 0x40, 0x62, 0x49, 0xa1, 0x74, 0xe8, 0x28, 0xa4, 0xc9, 0x5f, 0xe6, 0x1b, 0x03, 0x54, - 0xe6, 0x14, 0x01, 0x10, 0xbf, 0x40, 0x79, 0x48, 0xd1, 0x30, 0xa9, 0x61, 0xb1, 0xb4, 0xb9, 0x6d, - 0xe2, 0x58, 0x35, 0xbc, 0xad, 0xb6, 0x1a, 0x4e, 0xe5, 0x86, 0xda, 0x68, 0x61, 0xea, 0xf0, 0x69, - 0x65, 0x88, 0x03, 0xaf, 0x11, 0x18, 0x9a, 0x86, 0x0c, 0x8b, 0x2a, 0x4d, 0xaf, 0xe1, 0x5d, 0x9a, - 0x3d, 0x93, 0x0a, 0x0b, 0xb4, 0x25, 0x02, 0x21, 0xc3, 0x3f, 0x67, 0x1b, 0xba, 0x70, 0x4d, 0x3a, - 0x04, 0x01, 0xd0, 0xe1, 0x9f, 0x0c, 0x27, 0xee, 0xe3, 0x9d, 0xd5, 0x6b, 0x8b, 0xa5, 0x07, 0x61, - 0x94, 0x62, 0x3c, 0xc1, 0xa7, 0x5e, 0x6d, 0xe4, 0xc6, 0x66, 0xa4, 0x13, 0x29, 0x65, 0x84, 0x81, - 0xd7, 0x38, 0x54, 0xfe, 0xb5, 0x18, 0x24, 0x68, 0x62, 0x19, 0x85, 0xcc, 0xe6, 0xfb, 0xd6, 0xcb, - 0x95, 0x85, 0xb5, 0xab, 0xa5, 0xe5, 0x72, 0x56, 0x42, 0x23, 0x00, 0x14, 0x70, 0x71, 0x79, 0x6d, - 0x6e, 0x33, 0x1b, 0x73, 0xdb, 0x4b, 0xab, 0x9b, 0x67, 0x4f, 0x67, 0xe3, 0x2e, 0xc1, 0x55, 0x06, - 0x48, 0xf8, 0x11, 0x9e, 0x38, 0x95, 0x4d, 0xa2, 0x2c, 0x0c, 0x31, 0x06, 0x4b, 0xef, 0x2d, 0x2f, - 0x9c, 0x3d, 0x9d, 0x1d, 0x08, 0x42, 0x9e, 0x38, 0x95, 0x1d, 0x44, 0xc3, 0x90, 0xa6, 0x90, 0xd2, - 0xda, 0xda, 0x72, 0x36, 0xe5, 0xf2, 0xdc, 0xd8, 0x54, 0x96, 0x56, 0x17, 0xb3, 0x69, 0x97, 0xe7, - 0xa2, 0xb2, 0x76, 0x75, 0x3d, 0x0b, 0x2e, 0x87, 0x95, 0xf2, 0xc6, 0xc6, 0xdc, 0x62, 0x39, 0x9b, - 0x71, 0x31, 0x4a, 0xef, 0xdb, 0x2c, 0x6f, 0x64, 0x87, 0x02, 0x62, 0x3d, 0x71, 0x2a, 0x3b, 0xec, - 0x0e, 0x51, 0x5e, 0xbd, 0xba, 0x92, 0x1d, 0x41, 0x63, 0x30, 0xcc, 0x86, 0x10, 0x42, 0x8c, 0x86, - 0x40, 0x67, 0x4f, 0x67, 0xb3, 0x9e, 0x20, 0x8c, 0xcb, 0x58, 0x00, 0x70, 0xf6, 0x74, 0x16, 0xc9, - 0xf3, 0x90, 0xa4, 0x6e, 0x88, 0x10, 0x8c, 0x2c, 0xcf, 0x95, 0xca, 0xcb, 0x95, 0xb5, 0xf5, 0xcd, - 0xa5, 0xb5, 0xd5, 0xb9, 0xe5, 0xac, 0xe4, 0xc1, 0x94, 0xf2, 0x33, 0x57, 0x97, 0x94, 0xf2, 0x42, - 0x36, 0xe6, 0x87, 0xad, 0x97, 0xe7, 0x36, 0xcb, 0x0b, 0xd9, 0xb8, 0x5c, 0x85, 0x89, 0x4e, 0x09, - 0xb5, 0x63, 0x08, 0xf9, 0x7c, 0x21, 0xd6, 0xc5, 0x17, 0x28, 0xaf, 0xb0, 0x2f, 0xc8, 0xdf, 0x8e, - 0xc1, 0x78, 0x87, 0x45, 0xa5, 0xe3, 0x20, 0x4f, 0x43, 0x92, 0xf9, 0x32, 0x5b, 0x66, 0x1f, 0xea, - 0xb8, 0x3a, 0x51, 0xcf, 0x6e, 0x5b, 0x6a, 0x29, 0x9d, 0xbf, 0xd4, 0x88, 0x77, 0x29, 0x35, 0x08, - 0x8b, 0x36, 0x87, 0xfd, 0x91, 0xb6, 0xe4, 0xcf, 0xd6, 0xc7, 0xb3, 0xbd, 0xac, 0x8f, 0x14, 0xd6, - 0xdf, 0x22, 0x90, 0xec, 0xb0, 0x08, 0x5c, 0x80, 0xb1, 0x36, 0x46, 0x3d, 0x27, 0xe3, 0x8f, 0x4a, - 0x90, 0xeb, 0x66, 0x9c, 0x88, 0x94, 0x18, 0x0b, 0xa4, 0xc4, 0x0b, 0x61, 0x0b, 0xde, 0xdb, 0x7d, - 0x12, 0xda, 0xe6, 0xfa, 0xab, 0x12, 0x4c, 0x76, 0x2e, 0x29, 0x3b, 0xca, 0xf0, 0x14, 0x0c, 0x34, - 0xb1, 0xb3, 0x63, 0x88, 0xb2, 0xea, 0x81, 0x0e, 0x8b, 0x35, 0xe9, 0x0e, 0x4f, 0x36, 0xa7, 0xf2, - 0xaf, 0xf6, 0xf1, 0x6e, 0x75, 0x21, 0x93, 0xa6, 0x4d, 0xd2, 0x4f, 0xc6, 0xe0, 0x70, 0x47, 0xe6, - 0x1d, 0x05, 0x3d, 0x0e, 0xa0, 0xe9, 0x66, 0xcb, 0x61, 0xa5, 0x13, 0xcb, 0xc4, 0x69, 0x0a, 0xa1, - 0xc9, 0x8b, 0x64, 0xd9, 0x96, 0xe3, 0xf6, 0xc7, 0x69, 0x3f, 0x30, 0x10, 0x45, 0x38, 0xe7, 0x09, - 0x9a, 0xa0, 0x82, 0x4e, 0x75, 0xd1, 0xb4, 0xcd, 0x31, 0x1f, 0x83, 0x6c, 0xb5, 0xa1, 0x61, 0xdd, - 0xa9, 0xd8, 0x8e, 0x85, 0xd5, 0xa6, 0xa6, 0xd7, 0xe9, 0x52, 0x93, 0x2a, 0x26, 0xb7, 0xd5, 0x86, - 0x8d, 0x95, 0x51, 0xd6, 0xbd, 0x21, 0x7a, 0x09, 0x05, 0x75, 0x20, 0xcb, 0x47, 0x31, 0x10, 0xa0, - 0x60, 0xdd, 0x2e, 0x85, 0xfc, 0x99, 0x34, 0x64, 0x7c, 0x05, 0x38, 0xba, 0x17, 0x86, 0x9e, 0x53, - 0x6f, 0xa8, 0x15, 0xb1, 0xa9, 0x62, 0x96, 0xc8, 0x10, 0xd8, 0x3a, 0xdf, 0x58, 0x3d, 0x06, 0x13, - 0x14, 0xc5, 0x68, 0x39, 0xd8, 0xaa, 0x54, 0x1b, 0xaa, 0x6d, 0x53, 0xa3, 0xa5, 0x28, 0x2a, 0x22, - 0x7d, 0x6b, 0xa4, 0x6b, 0x5e, 0xf4, 0xa0, 0x33, 0x30, 0x4e, 0x29, 0x9a, 0xad, 0x86, 0xa3, 0x99, - 0x0d, 0x5c, 0x21, 0xdb, 0x3c, 0x9b, 0x2e, 0x39, 0xae, 0x64, 0x63, 0x04, 0x63, 0x85, 0x23, 0x10, - 0x89, 0x6c, 0xb4, 0x00, 0xc7, 0x29, 0x59, 0x1d, 0xeb, 0xd8, 0x52, 0x1d, 0x5c, 0xc1, 0x1f, 0x6c, - 0xa9, 0x0d, 0xbb, 0xa2, 0xea, 0xb5, 0xca, 0x8e, 0x6a, 0xef, 0xe4, 0x26, 0x08, 0x83, 0x52, 0x2c, - 0x27, 0x29, 0x47, 0x08, 0xe2, 0x22, 0xc7, 0x2b, 0x53, 0xb4, 0x39, 0xbd, 0x76, 0x49, 0xb5, 0x77, - 0x50, 0x11, 0x26, 0x29, 0x17, 0xdb, 0xb1, 0x34, 0xbd, 0x5e, 0xa9, 0xee, 0xe0, 0xea, 0xf5, 0x4a, - 0xcb, 0xd9, 0x3e, 0x97, 0x3b, 0xea, 0x1f, 0x9f, 0x4a, 0xb8, 0x41, 0x71, 0xe6, 0x09, 0xca, 0x55, - 0x67, 0xfb, 0x1c, 0xda, 0x80, 0x21, 0x32, 0x19, 0x4d, 0xed, 0x79, 0x5c, 0xd9, 0x36, 0x2c, 0xba, - 0x86, 0x8e, 0x74, 0x48, 0x4d, 0x3e, 0x0b, 0x16, 0xd6, 0x38, 0xc1, 0x8a, 0x51, 0xc3, 0xc5, 0xe4, - 0xc6, 0x7a, 0xb9, 0xbc, 0xa0, 0x64, 0x04, 0x97, 0x8b, 0x86, 0x45, 0x1c, 0xaa, 0x6e, 0xb8, 0x06, - 0xce, 0x30, 0x87, 0xaa, 0x1b, 0xc2, 0xbc, 0x67, 0x60, 0xbc, 0x5a, 0x65, 0x3a, 0x6b, 0xd5, 0x0a, - 0xdf, 0x8c, 0xd9, 0xb9, 0x6c, 0xc0, 0x58, 0xd5, 0xea, 0x22, 0x43, 0xe0, 0x3e, 0x6e, 0xa3, 0xf3, - 0x70, 0xd8, 0x33, 0x96, 0x9f, 0x70, 0xac, 0x4d, 0xcb, 0x30, 0xe9, 0x19, 0x18, 0x37, 0xf7, 0xda, - 0x09, 0x51, 0x60, 0x44, 0x73, 0x2f, 0x4c, 0xf6, 0x24, 0x4c, 0x98, 0x3b, 0x66, 0x3b, 0xdd, 0x49, - 0x3f, 0x1d, 0x32, 0x77, 0xcc, 0x30, 0xe1, 0xbb, 0xe8, 0xce, 0xdc, 0xc2, 0x55, 0xd5, 0xc1, 0xb5, - 0xdc, 0x3d, 0x7e, 0x74, 0x5f, 0x07, 0x2a, 0x40, 0xb6, 0x5a, 0xad, 0x60, 0x5d, 0xdd, 0x6a, 0xe0, - 0x8a, 0x6a, 0x61, 0x5d, 0xb5, 0x73, 0xd3, 0x14, 0x39, 0xe1, 0x58, 0x2d, 0xac, 0x8c, 0x54, 0xab, - 0x65, 0xda, 0x39, 0x47, 0xfb, 0xd0, 0x49, 0x18, 0x33, 0xb6, 0x9e, 0xab, 0x32, 0x8f, 0xac, 0x98, - 0x16, 0xde, 0xd6, 0x76, 0x73, 0xf7, 0x53, 0xf3, 0x8e, 0x92, 0x0e, 0xea, 0x8f, 0xeb, 0x14, 0x8c, - 0x1e, 0x82, 0x6c, 0xd5, 0xde, 0x51, 0x2d, 0x93, 0xa6, 0x64, 0xdb, 0x54, 0xab, 0x38, 0xf7, 0x2e, - 0x86, 0xca, 0xe0, 0xab, 0x02, 0x4c, 0x22, 0xc2, 0xbe, 0xa9, 0x6d, 0x3b, 0x82, 0xe3, 0x83, 0x2c, - 0x22, 0x28, 0x8c, 0x73, 0x3b, 0x01, 0x59, 0x62, 0x89, 0xc0, 0xc0, 0x27, 0x28, 0xda, 0x88, 0xb9, - 0x63, 0xfa, 0xc7, 0xbd, 0x0f, 0x86, 0x09, 0xa6, 0x37, 0xe8, 0x43, 0xac, 0x70, 0x33, 0x77, 0x7c, - 0x23, 0x9e, 0x86, 0x49, 0x82, 0xd4, 0xc4, 0x8e, 0x5a, 0x53, 0x1d, 0xd5, 0x87, 0xfd, 0x08, 0xc5, - 0x26, 0x66, 0x5f, 0xe1, 0x9d, 0x01, 0x39, 0xad, 0xd6, 0xd6, 0x9e, 0xeb, 0x58, 0x8f, 0x32, 0x39, - 0x09, 0x4c, 0xb8, 0xd6, 0x5d, 0x2b, 0xce, 0xe5, 0x22, 0x0c, 0xf9, 0xfd, 0x1e, 0xa5, 0x81, 0x79, - 0x7e, 0x56, 0x22, 0x45, 0xd0, 0xfc, 0xda, 0x02, 0x29, 0x5f, 0xde, 0x5f, 0xce, 0xc6, 0x48, 0x19, - 0xb5, 0xbc, 0xb4, 0x59, 0xae, 0x28, 0x57, 0x57, 0x37, 0x97, 0x56, 0xca, 0xd9, 0xb8, 0xaf, 0xb0, - 0xbf, 0x9c, 0x48, 0x3d, 0x90, 0x7d, 0x50, 0x7e, 0x35, 0x06, 0x23, 0xc1, 0x9d, 0x1a, 0xfa, 0x21, - 0xb8, 0x47, 0x1c, 0xab, 0xd8, 0xd8, 0xa9, 0xdc, 0xd4, 0x2c, 0x1a, 0x90, 0x4d, 0x95, 0x2d, 0x8e, - 0xae, 0xff, 0x4c, 0x70, 0xac, 0x0d, 0xec, 0x3c, 0xab, 0x59, 0x24, 0xdc, 0x9a, 0xaa, 0x83, 0x96, - 0x61, 0x5a, 0x37, 0x2a, 0xb6, 0xa3, 0xea, 0x35, 0xd5, 0xaa, 0x55, 0xbc, 0x03, 0xad, 0x8a, 0x5a, - 0xad, 0x62, 0xdb, 0x36, 0xd8, 0x42, 0xe8, 0x72, 0x39, 0xa6, 0x1b, 0x1b, 0x1c, 0xd9, 0x5b, 0x21, - 0xe6, 0x38, 0x6a, 0xc8, 0x7d, 0xe3, 0xdd, 0xdc, 0xf7, 0x28, 0xa4, 0x9b, 0xaa, 0x59, 0xc1, 0xba, - 0x63, 0xed, 0xd1, 0xfa, 0x3c, 0xa5, 0xa4, 0x9a, 0xaa, 0x59, 0x26, 0xed, 0xb7, 0x65, 0x9b, 0x74, - 0x39, 0x91, 0x4a, 0x65, 0xd3, 0x97, 0x13, 0xa9, 0x74, 0x16, 0xe4, 0xd7, 0xe2, 0x30, 0xe4, 0xaf, - 0xd7, 0xc9, 0xf6, 0xa7, 0x4a, 0x57, 0x2c, 0x89, 0xe6, 0xb4, 0xfb, 0xf6, 0xad, 0xee, 0x0b, 0xf3, - 0x64, 0x29, 0x2b, 0x0e, 0xb0, 0xe2, 0x58, 0x61, 0x94, 0xa4, 0x8c, 0x20, 0xce, 0x86, 0x59, 0x31, - 0x92, 0x52, 0x78, 0x0b, 0x2d, 0xc2, 0xc0, 0x73, 0x36, 0xe5, 0x3d, 0x40, 0x79, 0xdf, 0xbf, 0x3f, - 0xef, 0xcb, 0x1b, 0x94, 0x79, 0xfa, 0xf2, 0x46, 0x65, 0x75, 0x4d, 0x59, 0x99, 0x5b, 0x56, 0x38, - 0x39, 0x3a, 0x02, 0x89, 0x86, 0xfa, 0xfc, 0x5e, 0x70, 0xd1, 0xa3, 0xa0, 0x5e, 0x27, 0xe1, 0x08, - 0x24, 0x6e, 0x62, 0xf5, 0x7a, 0x70, 0xa9, 0xa1, 0xa0, 0xbb, 0x18, 0x0c, 0xb3, 0x90, 0xa4, 0xf6, - 0x42, 0x00, 0xdc, 0x62, 0xd9, 0x43, 0x28, 0x05, 0x89, 0xf9, 0x35, 0x85, 0x04, 0x44, 0x16, 0x86, - 0x18, 0xb4, 0xb2, 0xbe, 0x54, 0x9e, 0x2f, 0x67, 0x63, 0xf2, 0x19, 0x18, 0x60, 0x46, 0x20, 0xc1, - 0xe2, 0x9a, 0x21, 0x7b, 0x88, 0x37, 0x39, 0x0f, 0x49, 0xf4, 0x5e, 0x5d, 0x29, 0x95, 0x95, 0x6c, - 0x2c, 0x38, 0xd5, 0x89, 0x6c, 0x52, 0xb6, 0x61, 0xc8, 0x5f, 0x87, 0xbf, 0x3d, 0x9b, 0xf1, 0x6f, - 0x48, 0x90, 0xf1, 0xd5, 0xd5, 0xa4, 0x20, 0x52, 0x1b, 0x0d, 0xe3, 0x66, 0x45, 0x6d, 0x68, 0xaa, - 0xcd, 0x5d, 0x03, 0x28, 0x68, 0x8e, 0x40, 0x7a, 0x9d, 0xba, 0xb7, 0x29, 0x44, 0x92, 0xd9, 0x01, - 0xf9, 0x4b, 0x12, 0x64, 0xc3, 0x85, 0x6d, 0x48, 0x4c, 0xe9, 0x9d, 0x14, 0x53, 0xfe, 0xa2, 0x04, - 0x23, 0xc1, 0x6a, 0x36, 0x24, 0xde, 0xbd, 0xef, 0xa8, 0x78, 0x7f, 0x18, 0x83, 0xe1, 0x40, 0x0d, - 0xdb, 0xab, 0x74, 0x1f, 0x84, 0x31, 0xad, 0x86, 0x9b, 0xa6, 0xe1, 0x60, 0xbd, 0xba, 0x57, 0x69, - 0xe0, 0x1b, 0xb8, 0x91, 0x93, 0x69, 0xd2, 0x98, 0xdd, 0xbf, 0x4a, 0x2e, 0x2c, 0x79, 0x74, 0xcb, - 0x84, 0xac, 0x38, 0xbe, 0xb4, 0x50, 0x5e, 0x59, 0x5f, 0xdb, 0x2c, 0xaf, 0xce, 0xbf, 0xaf, 0x72, - 0x75, 0xf5, 0xca, 0xea, 0xda, 0xb3, 0xab, 0x4a, 0x56, 0x0b, 0xa1, 0xdd, 0xc5, 0xb0, 0x5f, 0x87, - 0x6c, 0x58, 0x28, 0x74, 0x0f, 0x74, 0x12, 0x2b, 0x7b, 0x08, 0x8d, 0xc3, 0xe8, 0xea, 0x5a, 0x65, - 0x63, 0x69, 0xa1, 0x5c, 0x29, 0x5f, 0xbc, 0x58, 0x9e, 0xdf, 0xdc, 0x60, 0xe7, 0x1e, 0x2e, 0xf6, - 0x66, 0x20, 0xc0, 0xe5, 0x2f, 0xc4, 0x61, 0xbc, 0x83, 0x24, 0x68, 0x8e, 0xef, 0x58, 0xd8, 0x26, - 0xea, 0xd1, 0x5e, 0xa4, 0x2f, 0x90, 0x9a, 0x61, 0x5d, 0xb5, 0x1c, 0xbe, 0xc1, 0x79, 0x08, 0x88, - 0x95, 0x74, 0x47, 0xdb, 0xd6, 0xb0, 0xc5, 0xcf, 0x93, 0xd8, 0x36, 0x66, 0xd4, 0x83, 0xb3, 0x23, - 0xa5, 0x47, 0x00, 0x99, 0x86, 0xad, 0x39, 0xda, 0x0d, 0x5c, 0xd1, 0x74, 0x71, 0xf8, 0x44, 0xb6, - 0x35, 0x09, 0x25, 0x2b, 0x7a, 0x96, 0x74, 0xc7, 0xc5, 0xd6, 0x71, 0x5d, 0x0d, 0x61, 0x93, 0x64, - 0x1e, 0x57, 0xb2, 0xa2, 0xc7, 0xc5, 0xbe, 0x17, 0x86, 0x6a, 0x46, 0x8b, 0xd4, 0x7a, 0x0c, 0x8f, - 0xac, 0x1d, 0x92, 0x92, 0x61, 0x30, 0x17, 0x85, 0x57, 0xf1, 0xde, 0xa9, 0xd7, 0x90, 0x92, 0x61, - 0x30, 0x86, 0xf2, 0x20, 0x8c, 0xaa, 0xf5, 0xba, 0x45, 0x98, 0x0b, 0x46, 0x6c, 0x5f, 0x32, 0xe2, - 0x82, 0x29, 0x62, 0xfe, 0x32, 0xa4, 0x84, 0x1d, 0xc8, 0x52, 0x4d, 0x2c, 0x51, 0x31, 0xd9, 0x66, - 0x3b, 0x76, 0x22, 0xad, 0xa4, 0x74, 0xd1, 0x79, 0x2f, 0x0c, 0x69, 0x76, 0xc5, 0x3b, 0xc4, 0x8f, - 0xcd, 0xc4, 0x4e, 0xa4, 0x94, 0x8c, 0x66, 0xbb, 0x07, 0xa0, 0xf2, 0x57, 0x63, 0x30, 0x12, 0x7c, - 0x08, 0x81, 0x16, 0x20, 0xd5, 0x30, 0xaa, 0x2a, 0x75, 0x2d, 0xf6, 0x04, 0xec, 0x44, 0xc4, 0x73, - 0x8b, 0xc2, 0x32, 0xc7, 0x57, 0x5c, 0xca, 0xfc, 0x6f, 0x4b, 0x90, 0x12, 0x60, 0x34, 0x09, 0x09, - 0x53, 0x75, 0x76, 0x28, 0xbb, 0x64, 0x29, 0x96, 0x95, 0x14, 0xda, 0x26, 0x70, 0xdb, 0x54, 0x75, - 0xea, 0x02, 0x1c, 0x4e, 0xda, 0x64, 0x5e, 0x1b, 0x58, 0xad, 0xd1, 0x4d, 0x8f, 0xd1, 0x6c, 0x62, - 0xdd, 0xb1, 0xc5, 0xbc, 0x72, 0xf8, 0x3c, 0x07, 0xa3, 0x87, 0x61, 0xcc, 0xb1, 0x54, 0xad, 0x11, - 0xc0, 0x4d, 0x50, 0xdc, 0xac, 0xe8, 0x70, 0x91, 0x8b, 0x70, 0x44, 0xf0, 0xad, 0x61, 0x47, 0xad, - 0xee, 0xe0, 0x9a, 0x47, 0x34, 0x40, 0x0f, 0x37, 0xee, 0xe1, 0x08, 0x0b, 0xbc, 0x5f, 0xd0, 0xca, - 0xaf, 0x4a, 0x30, 0x26, 0xb6, 0x69, 0x35, 0xd7, 0x58, 0x2b, 0x00, 0xaa, 0xae, 0x1b, 0x8e, 0xdf, - 0x5c, 0xed, 0xae, 0xdc, 0x46, 0x57, 0x98, 0x73, 0x89, 0x14, 0x1f, 0x83, 0x7c, 0x13, 0xc0, 0xeb, - 0xe9, 0x6a, 0xb6, 0x69, 0xc8, 0xf0, 0x27, 0x4c, 0xf4, 0x31, 0x25, 0xdb, 0xd8, 0x03, 0x03, 0x91, - 0xfd, 0x1c, 0x9a, 0x80, 0xe4, 0x16, 0xae, 0x6b, 0x3a, 0x3f, 0x37, 0x66, 0x0d, 0x71, 0xfc, 0x92, - 0x70, 0x8f, 0x5f, 0x4a, 0x9f, 0x92, 0x60, 0xbc, 0x6a, 0x34, 0xc3, 0xf2, 0x96, 0xb2, 0xa1, 0xd3, - 0x05, 0xfb, 0x92, 0xf4, 0xfe, 0xa7, 0xea, 0x9a, 0xb3, 0xd3, 0xda, 0x2a, 0x54, 0x8d, 0xe6, 0x6c, - 0xdd, 0x68, 0xa8, 0x7a, 0xdd, 0x7b, 0xce, 0x4a, 0x7f, 0x54, 0x1f, 0xad, 0x63, 0xfd, 0xd1, 0xba, - 0xe1, 0x7b, 0xea, 0x7a, 0xc1, 0xfb, 0xf9, 0xa7, 0x92, 0xf4, 0x33, 0xb1, 0xf8, 0xe2, 0x7a, 0xe9, - 0x6b, 0xb1, 0xfc, 0x22, 0x1b, 0x6e, 0x5d, 0x98, 0x47, 0xc1, 0xdb, 0x0d, 0x5c, 0x25, 0x2a, 0xc3, - 0x77, 0x1e, 0x86, 0x89, 0xba, 0x51, 0x37, 0x28, 0xc7, 0x59, 0xf2, 0x8b, 0x3f, 0xb9, 0x4d, 0xbb, - 0xd0, 0x7c, 0xe4, 0x63, 0xde, 0xe2, 0x2a, 0x8c, 0x73, 0xe4, 0x0a, 0x7d, 0x74, 0xc4, 0x36, 0x36, - 0x68, 0xdf, 0x53, 0xb5, 0xdc, 0x2f, 0xbf, 0x4e, 0x17, 0x74, 0x65, 0x8c, 0x93, 0x92, 0x3e, 0xb6, - 0xf7, 0x29, 0x2a, 0x70, 0x38, 0xc0, 0x8f, 0x85, 0x2d, 0xb6, 0x22, 0x38, 0xfe, 0x06, 0xe7, 0x38, - 0xee, 0xe3, 0xb8, 0xc1, 0x49, 0x8b, 0xf3, 0x30, 0xdc, 0x0f, 0xaf, 0x7f, 0xce, 0x79, 0x0d, 0x61, - 0x3f, 0x93, 0x45, 0x18, 0xa5, 0x4c, 0xaa, 0x2d, 0xdb, 0x31, 0x9a, 0x34, 0x27, 0xee, 0xcf, 0xe6, - 0x37, 0x5f, 0x67, 0x71, 0x34, 0x42, 0xc8, 0xe6, 0x5d, 0xaa, 0x62, 0x11, 0xe8, 0xd3, 0xb2, 0x1a, - 0xae, 0x36, 0x22, 0x38, 0x7c, 0x8b, 0x0b, 0xe2, 0xe2, 0x17, 0xaf, 0xc1, 0x04, 0xf9, 0x4d, 0x53, - 0x96, 0x5f, 0x92, 0xe8, 0x23, 0xb8, 0xdc, 0xab, 0x1f, 0x65, 0xa1, 0x3a, 0xee, 0x32, 0xf0, 0xc9, - 0xe4, 0x9b, 0xc5, 0x3a, 0x76, 0x1c, 0x6c, 0xd9, 0x15, 0xb5, 0xd1, 0x49, 0x3c, 0xdf, 0x19, 0x46, - 0xee, 0xf3, 0xdf, 0x0d, 0xce, 0xe2, 0x22, 0xa3, 0x9c, 0x6b, 0x34, 0x8a, 0x57, 0xe1, 0x9e, 0x0e, - 0x5e, 0xd1, 0x03, 0xcf, 0x2f, 0x70, 0x9e, 0x13, 0x6d, 0x9e, 0x41, 0xd8, 0xae, 0x83, 0x80, 0xbb, - 0x73, 0xd9, 0x03, 0xcf, 0x9f, 0xe6, 0x3c, 0x11, 0xa7, 0x15, 0x53, 0x4a, 0x38, 0x5e, 0x86, 0xb1, - 0x1b, 0xd8, 0xda, 0x32, 0x6c, 0x7e, 0x6e, 0xd4, 0x03, 0xbb, 0x2f, 0x72, 0x76, 0xa3, 0x9c, 0x90, - 0x1e, 0x24, 0x11, 0x5e, 0xe7, 0x21, 0xb5, 0xad, 0x56, 0x71, 0x0f, 0x2c, 0x5e, 0xe2, 0x2c, 0x06, - 0x09, 0x3e, 0x21, 0x9d, 0x83, 0xa1, 0xba, 0xc1, 0x57, 0xad, 0x68, 0xf2, 0x2f, 0x71, 0xf2, 0x8c, - 0xa0, 0xe1, 0x2c, 0x4c, 0xc3, 0x6c, 0x35, 0xc8, 0x92, 0x16, 0xcd, 0xe2, 0xaf, 0x0b, 0x16, 0x82, - 0x86, 0xb3, 0xe8, 0xc3, 0xac, 0x2f, 0x0b, 0x16, 0xb6, 0xcf, 0x9e, 0x4f, 0x43, 0xc6, 0xd0, 0x1b, - 0x7b, 0x86, 0xde, 0x8b, 0x10, 0x5f, 0xe6, 0x1c, 0x80, 0x93, 0x10, 0x06, 0x17, 0x20, 0xdd, 0xeb, - 0x44, 0xfc, 0x8d, 0xef, 0x8a, 0xf0, 0x10, 0x33, 0xb0, 0x08, 0xa3, 0x22, 0x41, 0x69, 0x86, 0xde, - 0x03, 0x8b, 0xbf, 0xc9, 0x59, 0x8c, 0xf8, 0xc8, 0xb8, 0x1a, 0x0e, 0xb6, 0x9d, 0x3a, 0xee, 0x85, - 0xc9, 0x57, 0x85, 0x1a, 0x9c, 0x84, 0x9b, 0x72, 0x0b, 0xeb, 0xd5, 0x9d, 0xde, 0x38, 0xfc, 0x9c, - 0x30, 0xa5, 0xa0, 0x21, 0x2c, 0xe6, 0x61, 0xb8, 0xa9, 0x5a, 0xf6, 0x8e, 0xda, 0xe8, 0x69, 0x3a, - 0xfe, 0x16, 0xe7, 0x31, 0xe4, 0x12, 0x71, 0x8b, 0xb4, 0xf4, 0x7e, 0xd8, 0x7c, 0x4d, 0x58, 0xc4, - 0x47, 0xc6, 0x43, 0xcf, 0x76, 0xe8, 0x21, 0x5b, 0x3f, 0xdc, 0x7e, 0x5e, 0x84, 0x1e, 0xa3, 0x5d, - 0xf1, 0x73, 0xbc, 0x00, 0x69, 0x5b, 0x7b, 0xbe, 0x27, 0x36, 0xbf, 0x20, 0x66, 0x9a, 0x12, 0x10, - 0xe2, 0xf7, 0xc1, 0x91, 0x8e, 0xcb, 0x44, 0x0f, 0xcc, 0xfe, 0x36, 0x67, 0x36, 0xd9, 0x61, 0xa9, - 0xe0, 0x29, 0xa1, 0x5f, 0x96, 0x7f, 0x47, 0xa4, 0x04, 0x1c, 0xe2, 0xb5, 0x4e, 0xf6, 0x11, 0xb6, - 0xba, 0xdd, 0x9f, 0xd5, 0x7e, 0x51, 0x58, 0x8d, 0xd1, 0x06, 0xac, 0xb6, 0x09, 0x93, 0x9c, 0x63, - 0x7f, 0xf3, 0xfa, 0x4b, 0x22, 0xb1, 0x32, 0xea, 0xab, 0xc1, 0xd9, 0xfd, 0x00, 0xe4, 0x5d, 0x73, - 0x8a, 0x82, 0xd5, 0xae, 0x34, 0x55, 0xb3, 0x07, 0xce, 0xbf, 0xcc, 0x39, 0x8b, 0x8c, 0xef, 0x56, - 0xbc, 0xf6, 0x8a, 0x6a, 0x12, 0xe6, 0xef, 0x85, 0x9c, 0x60, 0xde, 0xd2, 0x2d, 0x5c, 0x35, 0xea, - 0xba, 0xf6, 0x3c, 0xae, 0xf5, 0xc0, 0xfa, 0x57, 0x42, 0x53, 0x75, 0xd5, 0x47, 0x4e, 0x38, 0x2f, - 0x41, 0xd6, 0xad, 0x55, 0x2a, 0x5a, 0xd3, 0x34, 0x2c, 0x27, 0x82, 0xe3, 0xd7, 0xc5, 0x4c, 0xb9, - 0x74, 0x4b, 0x94, 0xac, 0x58, 0x06, 0xf6, 0xe4, 0xb9, 0x57, 0x97, 0xfc, 0x55, 0xce, 0x68, 0xd8, - 0xa3, 0xe2, 0x89, 0xa3, 0x6a, 0x34, 0x4d, 0xd5, 0xea, 0x25, 0xff, 0xfd, 0x5d, 0x91, 0x38, 0x38, - 0x09, 0x4f, 0x1c, 0xce, 0x9e, 0x89, 0xc9, 0x6a, 0xdf, 0x03, 0x87, 0x5f, 0x13, 0x89, 0x43, 0xd0, - 0x70, 0x16, 0xa2, 0x60, 0xe8, 0x81, 0xc5, 0xdf, 0x13, 0x2c, 0x04, 0x0d, 0x61, 0xf1, 0x8c, 0xb7, - 0xd0, 0x5a, 0xb8, 0xae, 0xd9, 0x8e, 0xc5, 0xca, 0xe4, 0xfd, 0x59, 0xfd, 0xfd, 0xef, 0x06, 0x8b, - 0x30, 0xc5, 0x47, 0x4a, 0x32, 0x11, 0x3f, 0x76, 0xa5, 0xbb, 0xa8, 0x68, 0xc1, 0x7e, 0x5d, 0x64, - 0x22, 0x1f, 0x19, 0x91, 0xcd, 0x57, 0x21, 0x12, 0xb3, 0x57, 0xc9, 0xde, 0xa1, 0x07, 0x76, 0xff, - 0x20, 0x24, 0xdc, 0x86, 0xa0, 0x25, 0x3c, 0x7d, 0xf5, 0x4f, 0x4b, 0xbf, 0x8e, 0xf7, 0x7a, 0xf2, - 0xce, 0x7f, 0x18, 0xaa, 0x7f, 0xae, 0x32, 0x4a, 0x96, 0x43, 0x46, 0x43, 0xf5, 0x14, 0x8a, 0xba, - 0x67, 0x94, 0xfb, 0xd1, 0x37, 0xb9, 0xbe, 0xc1, 0x72, 0xaa, 0xb8, 0x4c, 0x9c, 0x3c, 0x58, 0xf4, - 0x44, 0x33, 0xfb, 0xe8, 0x9b, 0xae, 0x9f, 0x07, 0x6a, 0x9e, 0xe2, 0x45, 0x18, 0x0e, 0x14, 0x3c, - 0xd1, 0xac, 0x3e, 0xc6, 0x59, 0x0d, 0xf9, 0xeb, 0x9d, 0xe2, 0x19, 0x48, 0x90, 0xe2, 0x25, 0x9a, - 0xfc, 0x2f, 0x72, 0x72, 0x8a, 0x5e, 0x7c, 0x37, 0xa4, 0x44, 0xd1, 0x12, 0x4d, 0xfa, 0x71, 0x4e, - 0xea, 0x92, 0x10, 0x72, 0x51, 0xb0, 0x44, 0x93, 0xff, 0x25, 0x41, 0x2e, 0x48, 0x08, 0x79, 0xef, - 0x26, 0xfc, 0xc6, 0x8f, 0x27, 0xf8, 0xa2, 0x23, 0x6c, 0x77, 0x01, 0x06, 0x79, 0xa5, 0x12, 0x4d, - 0xfd, 0x49, 0x3e, 0xb8, 0xa0, 0x28, 0x3e, 0x09, 0xc9, 0x1e, 0x0d, 0xfe, 0x13, 0x9c, 0x94, 0xe1, - 0x17, 0xe7, 0x21, 0xe3, 0xab, 0x4e, 0xa2, 0xc9, 0xff, 0x0a, 0x27, 0xf7, 0x53, 0x11, 0xd1, 0x79, - 0x75, 0x12, 0xcd, 0xe0, 0x53, 0x42, 0x74, 0x4e, 0x41, 0xcc, 0x26, 0x0a, 0x93, 0x68, 0xea, 0x4f, - 0x0b, 0xab, 0x0b, 0x92, 0xe2, 0xd3, 0x90, 0x76, 0x17, 0x9b, 0x68, 0xfa, 0xcf, 0x70, 0x7a, 0x8f, - 0x86, 0x58, 0xc0, 0xb7, 0xd8, 0x45, 0xb3, 0xf8, 0xab, 0xc2, 0x02, 0x3e, 0x2a, 0x12, 0x46, 0xe1, - 0x02, 0x26, 0x9a, 0xd3, 0x67, 0x45, 0x18, 0x85, 0xea, 0x17, 0x32, 0x9b, 0x34, 0xe7, 0x47, 0xb3, - 0xf8, 0x49, 0x31, 0x9b, 0x14, 0x9f, 0x88, 0x11, 0xae, 0x08, 0xa2, 0x79, 0xfc, 0x35, 0x21, 0x46, - 0xa8, 0x20, 0x28, 0xae, 0x03, 0x6a, 0xaf, 0x06, 0xa2, 0xf9, 0x7d, 0x8e, 0xf3, 0x1b, 0x6b, 0x2b, - 0x06, 0x8a, 0xcf, 0xc2, 0x64, 0xe7, 0x4a, 0x20, 0x9a, 0xeb, 0xe7, 0xdf, 0x0c, 0xed, 0xdd, 0xfc, - 0x85, 0x40, 0x71, 0xd3, 0x5b, 0x52, 0xfc, 0x55, 0x40, 0x34, 0xdb, 0x2f, 0xbc, 0x19, 0x4c, 0xdc, - 0xfe, 0x22, 0xa0, 0x38, 0x07, 0xe0, 0x2d, 0xc0, 0xd1, 0xbc, 0xbe, 0xc8, 0x79, 0xf9, 0x88, 0x48, - 0x68, 0xf0, 0xf5, 0x37, 0x9a, 0xfe, 0x25, 0x11, 0x1a, 0x9c, 0x82, 0x84, 0x86, 0x58, 0x7a, 0xa3, - 0xa9, 0xbf, 0x24, 0x42, 0x43, 0x90, 0x10, 0xcf, 0xf6, 0xad, 0x6e, 0xd1, 0x1c, 0xbe, 0x2c, 0x3c, - 0xdb, 0x47, 0x55, 0x5c, 0x85, 0xb1, 0xb6, 0x05, 0x31, 0x9a, 0xd5, 0xcf, 0x70, 0x56, 0xd9, 0xf0, - 0x7a, 0xe8, 0x5f, 0xbc, 0xf8, 0x62, 0x18, 0xcd, 0xed, 0x2b, 0xa1, 0xc5, 0x8b, 0xaf, 0x85, 0xc5, - 0x0b, 0x90, 0xd2, 0x5b, 0x8d, 0x06, 0x09, 0x1e, 0xb4, 0xff, 0xdd, 0xc0, 0xdc, 0x7f, 0xfa, 0x3e, - 0xb7, 0x8e, 0x20, 0x28, 0x9e, 0x81, 0x24, 0x6e, 0x6e, 0xe1, 0x5a, 0x14, 0xe5, 0x77, 0xbe, 0x2f, - 0x12, 0x26, 0xc1, 0x2e, 0x3e, 0x0d, 0xc0, 0x8e, 0x46, 0xe8, 0xe3, 0xc1, 0x08, 0xda, 0xff, 0xfc, - 0x7d, 0x7e, 0x19, 0xc7, 0x23, 0xf1, 0x18, 0xb0, 0xab, 0x3d, 0xfb, 0x33, 0xf8, 0x6e, 0x90, 0x01, - 0x9d, 0x91, 0xf3, 0x30, 0xf8, 0x9c, 0x6d, 0xe8, 0x8e, 0x5a, 0x8f, 0xa2, 0xfe, 0x2f, 0x9c, 0x5a, - 0xe0, 0x13, 0x83, 0x35, 0x0d, 0x0b, 0x3b, 0x6a, 0xdd, 0x8e, 0xa2, 0xfd, 0xaf, 0x9c, 0xd6, 0x25, - 0x20, 0xc4, 0x55, 0xd5, 0x76, 0x7a, 0xd1, 0xfb, 0xbf, 0x09, 0x62, 0x41, 0x40, 0x84, 0x26, 0xbf, - 0xaf, 0xe3, 0xbd, 0x28, 0xda, 0xef, 0x09, 0xa1, 0x39, 0x7e, 0xf1, 0xdd, 0x90, 0x26, 0x3f, 0xd9, - 0x0d, 0xbb, 0x08, 0xe2, 0x3f, 0xe6, 0xc4, 0x1e, 0x05, 0x19, 0xd9, 0x76, 0x6a, 0x8e, 0x16, 0x6d, - 0xec, 0xdb, 0x7c, 0xa6, 0x05, 0x7e, 0x71, 0x0e, 0x32, 0xb6, 0x53, 0xab, 0xb5, 0x78, 0x7d, 0x1a, - 0x41, 0xfe, 0xdf, 0xbf, 0xef, 0x1e, 0x59, 0xb8, 0x34, 0x64, 0xb6, 0x6f, 0x5e, 0x77, 0x4c, 0x83, - 0x3e, 0x02, 0x89, 0xe2, 0xf0, 0x26, 0xe7, 0xe0, 0x23, 0x29, 0xce, 0xc3, 0x10, 0xd1, 0xc5, 0xc2, - 0x26, 0xa6, 0xcf, 0xab, 0x22, 0x58, 0xfc, 0x0f, 0x6e, 0x80, 0x00, 0x51, 0xe9, 0x47, 0xbe, 0xf5, - 0xda, 0x94, 0xf4, 0xca, 0x6b, 0x53, 0xd2, 0x1f, 0xbe, 0x36, 0x25, 0x7d, 0xfa, 0xdb, 0x53, 0x87, - 0x5e, 0xf9, 0xf6, 0xd4, 0xa1, 0xdf, 0xfd, 0xf6, 0xd4, 0xa1, 0xce, 0xc7, 0xc6, 0xb0, 0x68, 0x2c, - 0x1a, 0xec, 0xc0, 0xf8, 0xfd, 0x72, 0xe0, 0xb8, 0xb8, 0x6e, 0x78, 0xa7, 0xb5, 0xee, 0x26, 0x07, - 0x3e, 0x16, 0x87, 0xa9, 0xaa, 0x61, 0x37, 0x0d, 0x7b, 0x76, 0x4b, 0xb5, 0xf1, 0xec, 0x8d, 0xc7, - 0xb7, 0xb0, 0xa3, 0x3e, 0x3e, 0x5b, 0x35, 0x34, 0x9d, 0x1f, 0xfb, 0x8e, 0xb3, 0xfe, 0x02, 0xe9, - 0x2f, 0xf0, 0xfe, 0x7c, 0xc7, 0x13, 0x62, 0x79, 0x11, 0x12, 0xf3, 0x86, 0xa6, 0xa3, 0x09, 0x48, - 0xd6, 0xb0, 0x6e, 0x34, 0xf9, 0x05, 0x30, 0xd6, 0x40, 0xf7, 0xc1, 0x80, 0xda, 0x34, 0x5a, 0xba, - 0xc3, 0x8e, 0xcb, 0x4b, 0x99, 0x6f, 0xdd, 0x9a, 0x3e, 0xf4, 0x7b, 0xb7, 0xa6, 0xe3, 0x4b, 0xba, - 0xa3, 0xf0, 0xae, 0x62, 0xe2, 0x8d, 0x97, 0xa7, 0x25, 0xf9, 0x32, 0x0c, 0x2e, 0xe0, 0xea, 0x41, - 0x78, 0x2d, 0xe0, 0x6a, 0x88, 0xd7, 0x43, 0x90, 0x5a, 0xd2, 0x1d, 0x76, 0x45, 0xef, 0x38, 0xc4, - 0x35, 0x9d, 0xdd, 0xfa, 0x08, 0x8d, 0x4f, 0xe0, 0x04, 0x75, 0x01, 0x57, 0x5d, 0xd4, 0x1a, 0xae, - 0x86, 0x51, 0x09, 0x7b, 0x02, 0x2f, 0x2d, 0xfc, 0xee, 0xbf, 0x9f, 0x3a, 0xf4, 0xc2, 0x6b, 0x53, - 0x87, 0xba, 0xcd, 0x4f, 0xc0, 0xfc, 0xdc, 0xc4, 0xec, 0xcf, 0xa3, 0x76, 0xed, 0xfa, 0x2c, 0x09, - 0x2d, 0x7b, 0x6b, 0x80, 0xdd, 0x6a, 0x86, 0x4f, 0xc7, 0x60, 0x3a, 0x7c, 0xa4, 0x4e, 0xfc, 0xd8, - 0x76, 0xd4, 0xa6, 0xd9, 0xed, 0xc5, 0xa9, 0x0b, 0x90, 0xde, 0x14, 0x38, 0x28, 0x07, 0x83, 0x36, - 0xae, 0x1a, 0x7a, 0xcd, 0xa6, 0x22, 0xc7, 0x15, 0xd1, 0x24, 0x06, 0xd4, 0x55, 0xdd, 0xb0, 0xf9, - 0x75, 0x4d, 0xd6, 0x28, 0xfd, 0x94, 0xd4, 0x9f, 0x63, 0x8d, 0xb8, 0x43, 0x51, 0xf3, 0xac, 0x4b, - 0xef, 0x7f, 0x78, 0xbf, 0xa7, 0x11, 0x54, 0x3d, 0x4f, 0x05, 0xdf, 0xa3, 0x87, 0xa9, 0xf0, 0xa3, - 0x87, 0x67, 0x71, 0xa3, 0x71, 0x45, 0x37, 0x6e, 0xea, 0x9b, 0x01, 0x93, 0xfc, 0x2b, 0x09, 0x66, - 0xe8, 0x85, 0x75, 0xab, 0xa9, 0xe9, 0xce, 0x6c, 0x43, 0xdb, 0xb2, 0x67, 0xb7, 0x34, 0xc7, 0x66, - 0x96, 0xe3, 0x36, 0x99, 0xf0, 0x30, 0x0a, 0x04, 0xa3, 0x40, 0x30, 0xe4, 0xd3, 0x90, 0x2a, 0x69, - 0xce, 0x9c, 0x65, 0xa9, 0x7b, 0x08, 0x41, 0x82, 0xc0, 0xb8, 0x51, 0xe8, 0x6f, 0x62, 0x11, 0xdc, - 0xc0, 0x4d, 0x9b, 0x3e, 0xf4, 0x4a, 0x28, 0xac, 0x51, 0xba, 0xda, 0x75, 0x26, 0x2f, 0xf8, 0x34, - 0xf5, 0x89, 0xe4, 0xfb, 0xc9, 0x22, 0xa1, 0x93, 0xb8, 0xae, 0x3e, 0x5f, 0x4b, 0xc0, 0x71, 0x1f, - 0x42, 0xd5, 0xda, 0x33, 0x1d, 0x1a, 0x92, 0xc6, 0x36, 0x57, 0x66, 0xcc, 0xa7, 0x0c, 0xeb, 0xee, - 0x12, 0x66, 0xdb, 0x90, 0x5c, 0x27, 0x74, 0x44, 0x11, 0xc7, 0x70, 0xd4, 0x06, 0xd7, 0x8e, 0x35, - 0x08, 0x94, 0x5d, 0xda, 0x8f, 0x31, 0xa8, 0x26, 0xee, 0xeb, 0x37, 0xb0, 0xba, 0xcd, 0xee, 0x3e, - 0xc6, 0xe9, 0xb3, 0xcf, 0x14, 0x01, 0xd0, 0x6b, 0x8e, 0x13, 0x90, 0x54, 0x5b, 0xec, 0xb1, 0x5d, - 0xfc, 0xc4, 0x90, 0xc2, 0x1a, 0xf2, 0x15, 0x18, 0xe4, 0x8f, 0x0a, 0x50, 0x16, 0xe2, 0xd7, 0xf1, - 0x1e, 0x1d, 0x67, 0x48, 0x21, 0x3f, 0x51, 0x01, 0x92, 0x54, 0x78, 0x7e, 0xa9, 0x3b, 0x57, 0x68, - 0x93, 0xbe, 0x40, 0x85, 0x54, 0x18, 0x9a, 0x7c, 0x19, 0x52, 0x0b, 0x46, 0x53, 0xd3, 0x8d, 0x20, - 0xb7, 0x34, 0xe3, 0x46, 0x65, 0x36, 0x5b, 0x3c, 0x9c, 0x15, 0xd6, 0x40, 0x93, 0x30, 0xc0, 0xee, - 0xc2, 0xf2, 0x47, 0x8f, 0xbc, 0x25, 0xcf, 0xc3, 0x20, 0xe5, 0xbd, 0x66, 0x92, 0xf9, 0x75, 0x2f, - 0x22, 0xa5, 0xf9, 0x9b, 0x11, 0x9c, 0x7d, 0xcc, 0x13, 0x16, 0x41, 0xa2, 0xa6, 0x3a, 0x2a, 0xd7, - 0x9b, 0xfe, 0x96, 0x9f, 0x82, 0x14, 0x67, 0x62, 0xa3, 0x53, 0x10, 0x37, 0x4c, 0x9b, 0x3f, 0x3c, - 0xcc, 0x77, 0x53, 0x65, 0xcd, 0x2c, 0x25, 0x48, 0x22, 0x50, 0x08, 0x72, 0x49, 0xe9, 0xea, 0x2f, - 0xe7, 0xfa, 0xf7, 0x17, 0x36, 0x8c, 0xeb, 0x2c, 0x5f, 0x8e, 0xc1, 0x94, 0xaf, 0xf7, 0x06, 0xb6, - 0x48, 0xbd, 0x1c, 0x70, 0x7d, 0xe4, 0x13, 0x92, 0xf7, 0x77, 0x71, 0x97, 0x77, 0x43, 0x7c, 0xce, - 0x34, 0x51, 0x1e, 0x52, 0xec, 0x21, 0xa1, 0xc1, 0xfc, 0x25, 0xa1, 0xb8, 0x6d, 0xd2, 0x67, 0x1b, - 0xdb, 0xce, 0x4d, 0xd5, 0x72, 0x5f, 0x17, 0x11, 0x6d, 0xf9, 0x3c, 0xa4, 0xe7, 0x0d, 0xdd, 0xc6, - 0xba, 0xdd, 0xa2, 0xa1, 0xb3, 0xd5, 0x30, 0xaa, 0xd7, 0x39, 0x07, 0xd6, 0x20, 0x06, 0x57, 0x4d, - 0x93, 0x52, 0x26, 0x14, 0xf2, 0x93, 0xa5, 0xde, 0xd2, 0x46, 0x57, 0x13, 0x9d, 0xef, 0xdf, 0x44, - 0x5c, 0x49, 0xd7, 0x46, 0xbf, 0x2f, 0xc1, 0xb1, 0xf6, 0x80, 0xba, 0x8e, 0xf7, 0xec, 0x7e, 0xe3, - 0xe9, 0x1c, 0xa4, 0xd7, 0xe9, 0x3b, 0x9b, 0x57, 0xf0, 0x1e, 0xca, 0xc3, 0x20, 0xae, 0x9d, 0x3a, - 0x73, 0xe6, 0xf1, 0xf3, 0xcc, 0xdb, 0x2f, 0x1d, 0x52, 0x04, 0xa0, 0x98, 0x22, 0x5a, 0xbd, 0xf1, - 0xe5, 0x69, 0xa9, 0x94, 0x84, 0xb8, 0xdd, 0x6a, 0xde, 0x55, 0x1f, 0xf8, 0x42, 0x32, 0x90, 0x00, - 0x59, 0x46, 0xbd, 0xa1, 0x36, 0xb4, 0x9a, 0xea, 0xbd, 0x4d, 0x9b, 0xf5, 0xe9, 0x48, 0x31, 0x3a, - 0xab, 0x98, 0xdf, 0xd7, 0x52, 0xf2, 0xaf, 0x48, 0x30, 0x74, 0x4d, 0x70, 0xde, 0xc0, 0x0e, 0xba, - 0x00, 0xe0, 0x8e, 0x24, 0xc2, 0xe2, 0x68, 0x21, 0x3c, 0x56, 0xc1, 0xa5, 0x51, 0x7c, 0xe8, 0xe8, - 0x49, 0xea, 0x68, 0xa6, 0x61, 0xf3, 0x57, 0x04, 0x22, 0x48, 0x5d, 0x64, 0xf4, 0x08, 0x20, 0x9a, - 0xc1, 0x2a, 0x37, 0x0c, 0x47, 0xd3, 0xeb, 0x15, 0xd3, 0xb8, 0xc9, 0x5f, 0xbc, 0x8a, 0x2b, 0x59, - 0xda, 0x73, 0x8d, 0x76, 0xac, 0x13, 0x38, 0x11, 0x3a, 0xed, 0x72, 0x21, 0xeb, 0x9f, 0x5a, 0xab, - 0x59, 0xd8, 0xb6, 0x79, 0x92, 0x12, 0x4d, 0x74, 0x01, 0x06, 0xcd, 0xd6, 0x56, 0x45, 0x64, 0x84, - 0xcc, 0xa9, 0x63, 0x9d, 0xe2, 0x5b, 0xcc, 0x3f, 0x8f, 0xf0, 0x01, 0xb3, 0xb5, 0x45, 0xbc, 0xe1, - 0x5e, 0x18, 0xea, 0x20, 0x4c, 0xe6, 0x86, 0x27, 0x07, 0x7d, 0x15, 0x98, 0x6b, 0x50, 0x31, 0x2d, - 0xcd, 0xb0, 0x34, 0x67, 0x8f, 0x3e, 0xe1, 0x8f, 0x2b, 0x59, 0xd1, 0xb1, 0xce, 0xe1, 0xf2, 0x75, - 0x18, 0xdd, 0xd0, 0x9a, 0x26, 0xbd, 0x93, 0xc2, 0x25, 0x3f, 0xe3, 0xc9, 0x27, 0x45, 0xcb, 0xd7, - 0x55, 0xb2, 0x58, 0x9b, 0x64, 0xa5, 0x67, 0xba, 0x7a, 0xe7, 0x93, 0xfd, 0x7b, 0x67, 0xb0, 0x60, - 0xf9, 0x93, 0x7c, 0x20, 0xf8, 0xf8, 0x72, 0xef, 0x4b, 0x4f, 0xbd, 0x3a, 0x66, 0x54, 0xd9, 0x93, - 0x8f, 0x2c, 0x02, 0xf2, 0xfb, 0x2f, 0xab, 0xf9, 0x88, 0x44, 0x9a, 0x8f, 0x0c, 0x32, 0xf9, 0x3c, - 0x0c, 0xaf, 0xab, 0x96, 0xb3, 0x81, 0x9d, 0x4b, 0x58, 0xad, 0x61, 0x2b, 0xb8, 0xee, 0x0e, 0x8b, - 0x75, 0x17, 0x41, 0x82, 0x2e, 0xae, 0x6c, 0xdd, 0xa1, 0xbf, 0xe5, 0x1d, 0x48, 0xd0, 0x7b, 0x40, - 0xee, 0x9a, 0xcc, 0x29, 0xd8, 0x9a, 0x4c, 0xb2, 0xe9, 0x9e, 0x83, 0x6d, 0x4e, 0xc2, 0x1a, 0xe8, - 0xb4, 0x58, 0x59, 0xe3, 0xfb, 0xaf, 0xac, 0xdc, 0x55, 0xf9, 0xfa, 0xda, 0x80, 0xc1, 0x12, 0x49, - 0xc6, 0x4b, 0x0b, 0xae, 0x20, 0x92, 0x27, 0x08, 0x5a, 0x81, 0x51, 0x53, 0xb5, 0x1c, 0x7a, 0x01, - 0x7a, 0x87, 0x6a, 0xc1, 0xa3, 0x61, 0xba, 0x3d, 0x36, 0x03, 0xca, 0xf2, 0x51, 0x86, 0x4d, 0x3f, - 0x50, 0xfe, 0xa3, 0x04, 0x0c, 0x70, 0x63, 0xbc, 0x1b, 0x06, 0xb9, 0x59, 0xb9, 0xff, 0x1e, 0x2f, - 0xb4, 0x2f, 0x4d, 0x05, 0x77, 0x09, 0xe1, 0xfc, 0x04, 0x0d, 0x7a, 0x00, 0x52, 0xd5, 0x1d, 0x55, - 0xd3, 0x2b, 0x5a, 0x4d, 0xd4, 0xf2, 0xaf, 0xdd, 0x9a, 0x1e, 0x9c, 0x27, 0xb0, 0xa5, 0x05, 0x65, - 0x90, 0x76, 0x2e, 0xd5, 0x48, 0x2d, 0xb0, 0x83, 0xb5, 0xfa, 0x8e, 0xc3, 0x63, 0x90, 0xb7, 0xd0, - 0x39, 0x48, 0x10, 0x97, 0xe1, 0xaf, 0xc7, 0xe4, 0xdb, 0xf6, 0x58, 0x6e, 0xdd, 0x5a, 0x4a, 0x91, - 0x81, 0x3f, 0xfd, 0x07, 0xd3, 0x92, 0x42, 0x29, 0xd0, 0x3c, 0x0c, 0x37, 0x54, 0xdb, 0xa9, 0xd0, - 0x35, 0x8c, 0x0c, 0x9f, 0xa4, 0x2c, 0x8e, 0xb4, 0x1b, 0x84, 0x1b, 0x96, 0x8b, 0x9e, 0x21, 0x54, - 0x0c, 0x54, 0x43, 0x27, 0x20, 0x4b, 0x99, 0x54, 0x8d, 0x66, 0x53, 0x73, 0x58, 0x75, 0x35, 0x40, - 0xed, 0x3e, 0x42, 0xe0, 0xf3, 0x14, 0x4c, 0x6b, 0xac, 0xa3, 0x90, 0xa6, 0x17, 0xf2, 0x29, 0x0a, - 0xbb, 0x7c, 0x96, 0x22, 0x00, 0xda, 0xf9, 0x20, 0x8c, 0x7a, 0x19, 0x94, 0xa1, 0xa4, 0x18, 0x17, - 0x0f, 0x4c, 0x11, 0x1f, 0x83, 0x09, 0x1d, 0xef, 0xd2, 0xeb, 0x70, 0x01, 0xec, 0x34, 0xc5, 0x46, - 0xa4, 0xef, 0x5a, 0x90, 0xe2, 0x5d, 0x30, 0x52, 0x15, 0xc6, 0x67, 0xb8, 0x40, 0x71, 0x87, 0x5d, - 0x28, 0x45, 0x3b, 0x02, 0x29, 0xd5, 0x34, 0x19, 0x42, 0x86, 0x67, 0x50, 0xd3, 0xa4, 0x5d, 0x27, - 0x61, 0x8c, 0xea, 0x68, 0x61, 0xbb, 0xd5, 0x70, 0x38, 0x93, 0x21, 0x8a, 0x33, 0x4a, 0x3a, 0x14, - 0x06, 0xa7, 0xb8, 0xf7, 0xc1, 0x30, 0xbe, 0xa1, 0xd5, 0xb0, 0x5e, 0xc5, 0x0c, 0x6f, 0x98, 0xe2, - 0x0d, 0x09, 0x20, 0x45, 0x7a, 0x08, 0xdc, 0xcc, 0x58, 0x11, 0x59, 0x7b, 0x84, 0xf1, 0x13, 0xf0, - 0x39, 0x06, 0x96, 0x1f, 0x81, 0xc4, 0x82, 0xea, 0xa8, 0xa4, 0xc4, 0x70, 0x76, 0xd9, 0x52, 0x34, - 0xa4, 0x90, 0x9f, 0x1d, 0xc3, 0xed, 0x8d, 0x18, 0x24, 0xae, 0x19, 0x0e, 0x46, 0x4f, 0xf8, 0xca, - 0xc2, 0x91, 0x4e, 0x3e, 0xbe, 0xa1, 0xd5, 0x75, 0x5c, 0x5b, 0xb1, 0xeb, 0xbe, 0x37, 0x6a, 0x3d, - 0x17, 0x8b, 0x05, 0x5c, 0x6c, 0x02, 0x92, 0x96, 0xd1, 0xd2, 0x6b, 0xe2, 0x2e, 0x17, 0x6d, 0xa0, - 0x32, 0xa4, 0x5c, 0xcf, 0x49, 0x44, 0x79, 0xce, 0x28, 0xf1, 0x1c, 0xe2, 0xd7, 0x1c, 0xa0, 0x0c, - 0x6e, 0x71, 0x07, 0x2a, 0x41, 0xda, 0x4d, 0x79, 0xdc, 0x03, 0x7b, 0x73, 0x62, 0x8f, 0x8c, 0x2c, - 0x41, 0xae, 0x3f, 0xb8, 0x06, 0x65, 0x5e, 0x98, 0x75, 0x3b, 0xb8, 0x45, 0x03, 0xae, 0xc6, 0xdf, - 0xee, 0x1d, 0xa4, 0x7a, 0x79, 0xae, 0xc6, 0xde, 0xf0, 0x3d, 0x06, 0x69, 0x5b, 0xab, 0xeb, 0xaa, - 0xd3, 0xb2, 0x30, 0xf7, 0x46, 0x0f, 0x20, 0x7f, 0x26, 0x06, 0x03, 0xcc, 0xbb, 0x7d, 0x76, 0x93, - 0x3a, 0xdb, 0x2d, 0xd6, 0xcd, 0x6e, 0xf1, 0x83, 0xdb, 0x6d, 0x0e, 0xc0, 0x15, 0xc6, 0xe6, 0x2f, - 0x5d, 0x76, 0xa8, 0x33, 0x98, 0x88, 0x1b, 0x5a, 0x9d, 0x07, 0xaf, 0x8f, 0xc8, 0xf5, 0xa0, 0xa4, - 0x2f, 0x4f, 0x5e, 0x80, 0xf4, 0x96, 0xe6, 0x54, 0x54, 0xb2, 0x79, 0xa4, 0x26, 0xcc, 0x9c, 0x9a, - 0x2a, 0x74, 0xda, 0x65, 0x16, 0xc4, 0x16, 0x53, 0x49, 0x6d, 0xf1, 0x5f, 0xf2, 0xef, 0x4b, 0xa4, - 0x56, 0xe6, 0x03, 0xa2, 0x39, 0x18, 0x16, 0x8a, 0x56, 0xb6, 0x1b, 0x6a, 0x9d, 0x3b, 0xe3, 0xf1, - 0xae, 0xda, 0x5e, 0x6c, 0xa8, 0x75, 0x25, 0xc3, 0x15, 0x24, 0x8d, 0xce, 0x13, 0x1b, 0xeb, 0x32, - 0xb1, 0x01, 0x4f, 0x8a, 0x1f, 0xcc, 0x93, 0x02, 0x73, 0x9e, 0x08, 0xcf, 0xf9, 0xd7, 0x63, 0x74, - 0xcf, 0x64, 0x1a, 0xb6, 0xda, 0x78, 0x3b, 0x42, 0xec, 0x28, 0xa4, 0x4d, 0xa3, 0x51, 0x61, 0x3d, - 0xec, 0xd2, 0x64, 0xca, 0x34, 0x1a, 0x4a, 0x9b, 0x1f, 0x25, 0xef, 0x50, 0xfc, 0x0d, 0xdc, 0x01, - 0xab, 0x0d, 0x86, 0xad, 0x66, 0xc1, 0x10, 0x33, 0x05, 0x5f, 0x30, 0x1f, 0x23, 0x36, 0xa0, 0x2b, - 0xb0, 0xd4, 0xbe, 0xc0, 0x33, 0xb1, 0x19, 0xa6, 0xc2, 0xf1, 0x08, 0x05, 0x5b, 0x5f, 0x3a, 0x6d, - 0xb6, 0xfd, 0x7e, 0xae, 0x70, 0x3c, 0xf9, 0xa7, 0x24, 0x80, 0x65, 0x62, 0x59, 0xaa, 0x2f, 0x59, - 0xea, 0x6c, 0x2a, 0x42, 0x25, 0x30, 0xf2, 0x54, 0xb7, 0x49, 0xe3, 0xe3, 0x0f, 0xd9, 0x7e, 0xb9, - 0xe7, 0x61, 0xd8, 0x73, 0x46, 0x1b, 0x0b, 0x61, 0xa6, 0xf6, 0x29, 0xee, 0x37, 0xb0, 0xa3, 0x0c, - 0xdd, 0xf0, 0xb5, 0xe4, 0x7f, 0x22, 0x41, 0x9a, 0xca, 0xb4, 0x82, 0x1d, 0x35, 0x30, 0x87, 0xd2, - 0xc1, 0xe7, 0xf0, 0x38, 0x00, 0x63, 0x63, 0x6b, 0xcf, 0x63, 0xee, 0x59, 0x69, 0x0a, 0xd9, 0xd0, - 0x9e, 0xc7, 0xe8, 0xac, 0x6b, 0xf0, 0xf8, 0xfe, 0x06, 0x17, 0xc5, 0x3f, 0x37, 0xfb, 0x3d, 0x30, - 0x48, 0xbf, 0x7a, 0xb2, 0x6b, 0xf3, 0x7a, 0x7e, 0x40, 0x6f, 0x35, 0x37, 0x77, 0x6d, 0xf9, 0x39, - 0x18, 0xdc, 0xdc, 0x65, 0x47, 0x30, 0x47, 0x21, 0x6d, 0x19, 0x06, 0x5f, 0xf8, 0x59, 0xc1, 0x95, - 0x22, 0x00, 0xba, 0xce, 0x89, 0x63, 0x87, 0x98, 0x77, 0xec, 0xe0, 0x9d, 0x9b, 0xc4, 0x7b, 0x3a, - 0x37, 0x39, 0xf9, 0x6f, 0x24, 0xc8, 0xf8, 0xf2, 0x03, 0x7a, 0x1c, 0x0e, 0x97, 0x96, 0xd7, 0xe6, - 0xaf, 0x54, 0x96, 0x16, 0x2a, 0x17, 0x97, 0xe7, 0x16, 0xbd, 0xd7, 0x02, 0xf2, 0x93, 0x2f, 0xbe, - 0x34, 0x83, 0x7c, 0xb8, 0x57, 0xf5, 0xeb, 0xba, 0x71, 0x53, 0x47, 0xb3, 0x30, 0x11, 0x24, 0x99, - 0x2b, 0x6d, 0x94, 0x57, 0x37, 0xb3, 0x52, 0xfe, 0xf0, 0x8b, 0x2f, 0xcd, 0x8c, 0xf9, 0x28, 0xe6, - 0xb6, 0x6c, 0xac, 0x3b, 0xed, 0x04, 0xf3, 0x6b, 0x2b, 0x2b, 0x4b, 0x9b, 0xd9, 0x58, 0x1b, 0x01, - 0x5f, 0x01, 0x1e, 0x82, 0xb1, 0x20, 0xc1, 0xea, 0xd2, 0x72, 0x36, 0x9e, 0x47, 0x2f, 0xbe, 0x34, - 0x33, 0xe2, 0xc3, 0x5e, 0xd5, 0x1a, 0xf9, 0xd4, 0x27, 0xbe, 0x32, 0x75, 0xe8, 0xe7, 0x7e, 0x76, - 0x4a, 0x22, 0x9a, 0x0d, 0x07, 0x72, 0x04, 0x7a, 0x04, 0xee, 0xd9, 0x58, 0x5a, 0x5c, 0x2d, 0x2f, - 0x54, 0x56, 0x36, 0x16, 0x2b, 0xec, 0x73, 0x08, 0xae, 0x76, 0xa3, 0x2f, 0xbe, 0x34, 0x93, 0xe1, - 0x2a, 0x75, 0xc3, 0x5e, 0x57, 0xca, 0xd7, 0xd6, 0x36, 0xcb, 0x59, 0x89, 0x61, 0xaf, 0x5b, 0xf8, - 0x86, 0xe1, 0xb0, 0xcf, 0x22, 0x3d, 0x06, 0x47, 0x3a, 0x60, 0xbb, 0x8a, 0x8d, 0xbd, 0xf8, 0xd2, - 0xcc, 0xf0, 0xba, 0x85, 0x59, 0xfc, 0x50, 0x8a, 0x02, 0xe4, 0xda, 0x29, 0xd6, 0xd6, 0xd7, 0x36, - 0xe6, 0x96, 0xb3, 0x33, 0xf9, 0xec, 0x8b, 0x2f, 0xcd, 0x0c, 0x89, 0x64, 0x48, 0xf0, 0x3d, 0xcd, - 0xee, 0xe6, 0xc6, 0xeb, 0x2f, 0xc7, 0x60, 0xaa, 0xed, 0xf2, 0x35, 0x7f, 0x64, 0xd1, 0xed, 0xa0, - 0xb8, 0x08, 0xa9, 0x05, 0xf1, 0x24, 0xa4, 0xdf, 0x73, 0xe2, 0x9f, 0xec, 0xf3, 0x9c, 0x78, 0x58, - 0x8c, 0x24, 0x8e, 0x89, 0x4f, 0x46, 0x1f, 0x13, 0x0b, 0xf9, 0x0f, 0x70, 0x4a, 0xfc, 0x1f, 0x1e, - 0x86, 0xfb, 0xf9, 0xe1, 0xba, 0xed, 0xa8, 0xd7, 0x35, 0xbd, 0xee, 0x3e, 0xc2, 0xe0, 0x6d, 0x6e, - 0x94, 0x49, 0xfe, 0x14, 0x43, 0x40, 0xf7, 0x7d, 0x90, 0x91, 0xdf, 0x77, 0x6f, 0x1b, 0xbd, 0x67, - 0x8d, 0x98, 0xa1, 0x7c, 0xc4, 0x23, 0x17, 0xf9, 0x93, 0x12, 0x8c, 0x5c, 0xd2, 0x6c, 0xc7, 0xb0, - 0xb4, 0xaa, 0xda, 0xa0, 0x6f, 0x39, 0x9c, 0xed, 0x75, 0xd1, 0x08, 0xe5, 0xb0, 0xa7, 0x61, 0xe0, - 0x86, 0xda, 0x60, 0xd9, 0x3a, 0x4e, 0x3f, 0xca, 0xd0, 0xd9, 0x10, 0x5e, 0xce, 0x16, 0x0c, 0x18, - 0x99, 0xfc, 0x8b, 0x31, 0x18, 0xa5, 0x51, 0x6e, 0xb3, 0xcf, 0xf5, 0x90, 0x1d, 0x6a, 0x09, 0x12, - 0x96, 0xea, 0xf0, 0x43, 0xd7, 0x52, 0x81, 0x3f, 0x1c, 0x79, 0x20, 0xfa, 0x81, 0x47, 0x61, 0x01, - 0x57, 0x15, 0x4a, 0x8b, 0x7e, 0x18, 0x52, 0x4d, 0x75, 0xb7, 0x42, 0xf9, 0xb0, 0x7d, 0xdf, 0x5c, - 0x7f, 0x7c, 0x6e, 0xdf, 0x9a, 0x1e, 0xdd, 0x53, 0x9b, 0x8d, 0xa2, 0x2c, 0xf8, 0xc8, 0xca, 0x60, - 0x53, 0xdd, 0x25, 0x22, 0x22, 0x13, 0x46, 0x09, 0xb4, 0xba, 0xa3, 0xea, 0x75, 0xcc, 0x06, 0xa1, - 0x47, 0xc8, 0xa5, 0x4b, 0x7d, 0x0f, 0x32, 0xe9, 0x0d, 0xe2, 0x63, 0x27, 0x2b, 0xc3, 0x4d, 0x75, - 0x77, 0x9e, 0x02, 0xc8, 0x88, 0xc5, 0xd4, 0xe7, 0x5e, 0x9e, 0x3e, 0x44, 0x1f, 0x38, 0xbd, 0x2a, - 0x01, 0x78, 0x16, 0x43, 0x3f, 0x0c, 0xd9, 0xaa, 0xdb, 0xa2, 0xb4, 0x36, 0x9f, 0xc3, 0x07, 0xbb, - 0xcd, 0x45, 0xc8, 0xde, 0xac, 0xe8, 0x78, 0xe5, 0xd6, 0xb4, 0xa4, 0x8c, 0x56, 0x43, 0x53, 0xf1, - 0x01, 0xc8, 0xb4, 0xcc, 0x9a, 0xea, 0xe0, 0x0a, 0xdd, 0x05, 0xc7, 0x22, 0x0b, 0x98, 0x29, 0xc2, - 0xeb, 0xf6, 0xad, 0x69, 0xc4, 0xd4, 0xf2, 0x11, 0xcb, 0xb4, 0xac, 0x01, 0x06, 0x21, 0x04, 0x3e, - 0x9d, 0x7e, 0x4b, 0x82, 0xcc, 0x82, 0xef, 0xb6, 0x51, 0x0e, 0x06, 0x9b, 0x86, 0xae, 0x5d, 0xe7, - 0xfe, 0x98, 0x56, 0x44, 0x13, 0xe5, 0x21, 0xc5, 0x5e, 0xfc, 0x72, 0xf6, 0xc4, 0x51, 0xb2, 0x68, - 0x13, 0xaa, 0x9b, 0x78, 0xcb, 0xd6, 0xc4, 0x6c, 0x28, 0xa2, 0x89, 0x2e, 0x42, 0xd6, 0xc6, 0xd5, - 0x96, 0xa5, 0x39, 0x7b, 0x95, 0xaa, 0xa1, 0x3b, 0x6a, 0xd5, 0x61, 0xaf, 0x10, 0x95, 0x8e, 0xde, - 0xbe, 0x35, 0x7d, 0x0f, 0x93, 0x35, 0x8c, 0x21, 0x2b, 0xa3, 0x02, 0x34, 0xcf, 0x20, 0x64, 0x84, - 0x1a, 0x76, 0x54, 0xad, 0x61, 0xd3, 0x9a, 0x30, 0xad, 0x88, 0xa6, 0x4f, 0x97, 0x9f, 0x18, 0xf4, - 0x1f, 0x1c, 0x5e, 0x84, 0xac, 0x61, 0x62, 0x2b, 0x50, 0x61, 0x4b, 0xe1, 0x91, 0xc3, 0x18, 0xb2, - 0x32, 0x2a, 0x40, 0xa2, 0xfa, 0xbe, 0x48, 0xa6, 0x59, 0x6c, 0xb3, 0xcd, 0xd6, 0x96, 0x38, 0x6f, - 0x0c, 0xf0, 0x09, 0x63, 0xc8, 0x64, 0x42, 0x39, 0x68, 0x9d, 0x42, 0x48, 0x85, 0xfc, 0x9c, 0xaa, - 0x35, 0xc4, 0xcb, 0xad, 0x0a, 0x6f, 0xa1, 0x25, 0x18, 0xb0, 0x1d, 0xd5, 0x69, 0xb1, 0x5a, 0x24, - 0x59, 0x7a, 0xfc, 0x7f, 0xdf, 0x9a, 0x7e, 0xb4, 0x07, 0x27, 0x2e, 0x19, 0x7a, 0x6d, 0x83, 0x12, - 0x2a, 0x9c, 0x01, 0xba, 0x08, 0x03, 0x8e, 0x71, 0x1d, 0xeb, 0xdc, 0x46, 0x7d, 0x05, 0x30, 0x7d, - 0x56, 0xcb, 0xa8, 0x91, 0x03, 0xd9, 0x1a, 0x6e, 0xe0, 0x3a, 0x2b, 0x08, 0x77, 0x54, 0xb2, 0x11, - 0xa3, 0x1f, 0xa2, 0x2a, 0x2d, 0xf5, 0x1d, 0x65, 0xdc, 0x40, 0x61, 0x7e, 0xb2, 0x32, 0xea, 0x82, - 0x36, 0x28, 0x04, 0x5d, 0x09, 0xdc, 0x7b, 0xe3, 0x5f, 0x6b, 0xbb, 0xaf, 0x5b, 0x28, 0xf9, 0x9c, - 0x56, 0x1c, 0xdf, 0xf8, 0x6f, 0xcd, 0x5d, 0x84, 0x6c, 0x4b, 0xdf, 0x32, 0x74, 0xfa, 0x42, 0x1a, - 0xdf, 0x99, 0x90, 0xad, 0x6e, 0xdc, 0x3f, 0x6b, 0x61, 0x0c, 0x59, 0x19, 0x75, 0x41, 0x97, 0xd8, - 0xfe, 0xa5, 0x06, 0x23, 0x1e, 0x16, 0x8d, 0xc4, 0x74, 0x64, 0x24, 0xde, 0xcb, 0x23, 0xf1, 0x70, - 0x78, 0x14, 0x2f, 0x18, 0x87, 0x5d, 0x20, 0x21, 0x43, 0x97, 0x00, 0xbc, 0xf8, 0xa7, 0xc7, 0x38, - 0x99, 0x53, 0x72, 0x74, 0x12, 0x11, 0x5b, 0x5f, 0x8f, 0x16, 0x7d, 0x18, 0xc6, 0x9b, 0x9a, 0x5e, - 0xb1, 0x71, 0x63, 0xbb, 0xc2, 0x0d, 0x4c, 0x58, 0xd2, 0xef, 0x89, 0x94, 0x96, 0xfb, 0xf3, 0x87, - 0xdb, 0xb7, 0xa6, 0xf3, 0x3c, 0x47, 0xb6, 0xb3, 0x94, 0x95, 0xb1, 0xa6, 0xa6, 0x6f, 0xe0, 0xc6, - 0xf6, 0x82, 0x0b, 0x2b, 0x0e, 0x7d, 0xe2, 0xe5, 0xe9, 0x43, 0x3c, 0x1e, 0x0f, 0xc9, 0x67, 0xe9, - 0xc3, 0x07, 0x1e, 0x47, 0xd8, 0x26, 0xbb, 0x29, 0x55, 0x34, 0xe8, 0x81, 0x4f, 0x5a, 0xf1, 0x00, - 0x2c, 0x8e, 0x5f, 0xf8, 0x77, 0x33, 0x92, 0xfc, 0x0b, 0x12, 0x0c, 0x2c, 0x5c, 0x5b, 0x57, 0x35, - 0x0b, 0x2d, 0xc1, 0x98, 0xe7, 0x39, 0xc1, 0x28, 0x3e, 0x76, 0xfb, 0xd6, 0x74, 0x2e, 0xec, 0x5c, - 0x6e, 0x18, 0x7b, 0x0e, 0x2c, 0xe2, 0x78, 0xa9, 0xdb, 0x96, 0x3b, 0xc0, 0xaa, 0x0d, 0x45, 0x6e, - 0xdf, 0x90, 0x87, 0xd4, 0x2c, 0xc3, 0x20, 0x93, 0xd6, 0x46, 0x45, 0x48, 0x9a, 0xe4, 0x07, 0x7f, - 0xb2, 0x32, 0xd5, 0xd5, 0x79, 0x29, 0xbe, 0x7b, 0xce, 0x4b, 0x48, 0xe4, 0xcf, 0xc4, 0x00, 0x16, - 0xae, 0x5d, 0xdb, 0xb4, 0x34, 0xb3, 0x81, 0x9d, 0x3b, 0xa9, 0xf9, 0x26, 0x1c, 0xf6, 0xed, 0xef, - 0xac, 0x6a, 0x48, 0xfb, 0x99, 0xdb, 0xb7, 0xa6, 0x8f, 0x85, 0xb5, 0xf7, 0xa1, 0xc9, 0xca, 0xb8, - 0xb7, 0xd3, 0xb3, 0xaa, 0x1d, 0xb9, 0xd6, 0x6c, 0xc7, 0xe5, 0x1a, 0xef, 0xce, 0xd5, 0x87, 0xe6, - 0xe7, 0xba, 0x60, 0x3b, 0x9d, 0x4d, 0xbb, 0x01, 0x19, 0xcf, 0x24, 0x36, 0x5a, 0x80, 0x94, 0xc3, - 0x7f, 0x73, 0x0b, 0xcb, 0xdd, 0x2d, 0x2c, 0xc8, 0xb8, 0x95, 0x5d, 0x4a, 0xf9, 0x4f, 0x25, 0x00, - 0xcf, 0x67, 0x7f, 0x30, 0x5d, 0x8c, 0xa4, 0x72, 0x9e, 0x78, 0xe3, 0x07, 0xaa, 0xc5, 0x38, 0x75, - 0xc8, 0x9e, 0x3f, 0x1e, 0x83, 0xf1, 0xab, 0x22, 0xf3, 0xfc, 0xc0, 0xdb, 0x60, 0x1d, 0x06, 0xb1, - 0xee, 0x58, 0x1a, 0x35, 0x02, 0x99, 0xed, 0xc7, 0xba, 0xcd, 0x76, 0x07, 0x9d, 0xe8, 0x17, 0x55, - 0xc4, 0x33, 0x09, 0xce, 0x26, 0x64, 0x8d, 0x4f, 0xc5, 0x21, 0xd7, 0x8d, 0x12, 0xcd, 0xc3, 0x68, - 0xd5, 0xc2, 0x14, 0x50, 0xf1, 0x1f, 0x82, 0x96, 0xf2, 0x5e, 0xe9, 0x18, 0x42, 0x90, 0x95, 0x11, - 0x01, 0xe1, 0xab, 0x47, 0x1d, 0x48, 0x5d, 0x47, 0xdc, 0x8e, 0x60, 0xf5, 0x58, 0xc8, 0xc9, 0x7c, - 0xf9, 0x10, 0x83, 0x04, 0x19, 0xb0, 0xf5, 0x63, 0xc4, 0x83, 0xd2, 0x05, 0xe4, 0x83, 0x30, 0xaa, - 0xe9, 0x9a, 0xa3, 0xa9, 0x8d, 0xca, 0x96, 0xda, 0x50, 0xf5, 0xea, 0x41, 0xca, 0x62, 0x96, 0xf2, - 0xf9, 0xb0, 0x21, 0x76, 0xb2, 0x32, 0xc2, 0x21, 0x25, 0x06, 0x40, 0x97, 0x60, 0x50, 0x0c, 0x95, - 0x38, 0x50, 0xb5, 0x21, 0xc8, 0xfd, 0x15, 0x5c, 0x1c, 0xc6, 0x14, 0x5c, 0xfb, 0xff, 0x53, 0xd1, - 0xdf, 0x54, 0xac, 0x00, 0xb0, 0x70, 0x27, 0x09, 0xf6, 0x00, 0xb3, 0x41, 0x12, 0x46, 0x9a, 0x71, - 0x58, 0xb0, 0x1d, 0xdf, 0x7c, 0xdc, 0x8a, 0xc1, 0x90, 0x7f, 0x3e, 0xfe, 0x9c, 0xae, 0x4a, 0x68, - 0xc9, 0xcb, 0x44, 0x09, 0xfe, 0x1d, 0xca, 0x2e, 0x99, 0xa8, 0xcd, 0x7b, 0xf7, 0x4f, 0x41, 0x7f, - 0x12, 0x83, 0x81, 0x75, 0xd5, 0x52, 0x9b, 0x36, 0xaa, 0xb6, 0x55, 0x9a, 0xe2, 0xe0, 0xb4, 0xed, - 0x6b, 0xc3, 0xfc, 0xd0, 0x21, 0xa2, 0xd0, 0xfc, 0x5c, 0x87, 0x42, 0xf3, 0x3d, 0x30, 0x42, 0xf6, - 0xbb, 0xbe, 0x3b, 0x20, 0xc4, 0xda, 0xc3, 0xa5, 0x23, 0x1e, 0x97, 0x60, 0x3f, 0xdb, 0x0e, 0x5f, - 0xf3, 0x5f, 0x02, 0xc9, 0x10, 0x0c, 0x2f, 0x31, 0x13, 0xf2, 0x49, 0x6f, 0xdf, 0xe9, 0xeb, 0x94, - 0x15, 0x68, 0xaa, 0xbb, 0x65, 0xd6, 0x40, 0xcb, 0x80, 0x76, 0xdc, 0xa3, 0x8f, 0x8a, 0x67, 0x4e, - 0x42, 0x7f, 0xfc, 0xf6, 0xad, 0xe9, 0x23, 0x8c, 0xbe, 0x1d, 0x47, 0x56, 0xc6, 0x3c, 0xa0, 0xe0, - 0x76, 0x1a, 0x80, 0xe8, 0x55, 0x61, 0x57, 0x48, 0xd9, 0x76, 0xe7, 0xf0, 0xed, 0x5b, 0xd3, 0x63, - 0x8c, 0x8b, 0xd7, 0x27, 0x2b, 0x69, 0xd2, 0x58, 0x20, 0xbf, 0x7d, 0x9e, 0xfd, 0x15, 0x09, 0x90, - 0x97, 0xf2, 0x15, 0x6c, 0x9b, 0x64, 0xbb, 0x46, 0x0a, 0x71, 0x5f, 0xd5, 0x2c, 0xed, 0x5f, 0x88, - 0x7b, 0xf4, 0xa2, 0x10, 0xf7, 0x45, 0xca, 0x79, 0x2f, 0x3d, 0xc6, 0xf8, 0x3c, 0x76, 0xb8, 0x6f, - 0x5b, 0x98, 0x37, 0x34, 0x41, 0xdd, 0x96, 0x0f, 0x0f, 0xc9, 0xff, 0x52, 0x82, 0x23, 0x6d, 0x1e, - 0xe5, 0x0a, 0xfb, 0x17, 0x00, 0x59, 0xbe, 0x4e, 0xfe, 0x51, 0x31, 0x26, 0x74, 0xdf, 0x0e, 0x3a, - 0x66, 0xb5, 0xe5, 0xdd, 0x3b, 0x97, 0xe1, 0xd9, 0x85, 0xdd, 0x7f, 0x2c, 0xc1, 0x84, 0x7f, 0x78, - 0x57, 0x91, 0x55, 0x18, 0xf2, 0x8f, 0xce, 0x55, 0xb8, 0xbf, 0x17, 0x15, 0xb8, 0xf4, 0x01, 0x7a, - 0xf4, 0x8c, 0x17, 0xae, 0xec, 0x70, 0xec, 0xf1, 0x9e, 0xad, 0x21, 0x64, 0x0a, 0x87, 0x6d, 0x82, - 0xce, 0xc7, 0xff, 0x91, 0x20, 0xb1, 0x6e, 0x18, 0x0d, 0x64, 0xc0, 0x98, 0x6e, 0x38, 0x15, 0xe2, - 0x59, 0xb8, 0x56, 0xe1, 0x9b, 0x6e, 0x96, 0x07, 0xe7, 0xfb, 0x33, 0xd2, 0x77, 0x6e, 0x4d, 0xb7, - 0xb3, 0x52, 0x46, 0x75, 0xc3, 0x29, 0x51, 0xc8, 0x26, 0xdb, 0x92, 0x7f, 0x18, 0x86, 0x83, 0x83, - 0xb1, 0x2c, 0xf9, 0x6c, 0xdf, 0x83, 0x05, 0xd9, 0xdc, 0xbe, 0x35, 0x3d, 0xe1, 0x45, 0x8c, 0x0b, - 0x96, 0x95, 0xa1, 0x2d, 0xdf, 0xe8, 0xec, 0x7e, 0xdc, 0xf7, 0x5e, 0x9e, 0x96, 0x4a, 0x17, 0xbb, - 0x9e, 0x80, 0x3f, 0xb2, 0xaf, 0x08, 0xbb, 0xee, 0x31, 0x6e, 0xf0, 0xd8, 0xfb, 0x1b, 0xa3, 0x30, - 0xdd, 0xe5, 0x9c, 0xd7, 0xd9, 0x3d, 0xd0, 0x11, 0x6f, 0xc4, 0x19, 0x6c, 0xbe, 0xa7, 0x63, 0x65, - 0xf9, 0xa5, 0x04, 0xa0, 0x15, 0xbb, 0x3e, 0x4f, 0x8a, 0x08, 0xdf, 0x9d, 0xae, 0xd0, 0x19, 0x85, - 0xf4, 0x96, 0xce, 0x28, 0x56, 0x02, 0xbb, 0xfe, 0x58, 0x7f, 0x47, 0x87, 0x3d, 0x6f, 0xfd, 0xe3, - 0x6f, 0xcb, 0xd6, 0xbf, 0x73, 0x65, 0x90, 0xb8, 0x73, 0x5b, 0x88, 0xe4, 0x81, 0xb6, 0x10, 0x93, - 0x30, 0xc0, 0x8f, 0xec, 0xd8, 0x87, 0xd4, 0x79, 0x0b, 0x9d, 0x11, 0x9f, 0x95, 0x1e, 0xec, 0x2d, - 0x37, 0x33, 0xec, 0x62, 0xea, 0x13, 0x22, 0x33, 0x7f, 0x36, 0x0e, 0xd9, 0x15, 0xbb, 0x5e, 0xae, - 0x69, 0xce, 0x5d, 0xf2, 0x8e, 0xa7, 0xbb, 0x6f, 0xa4, 0xd0, 0xed, 0x5b, 0xd3, 0x23, 0xcc, 0x0a, - 0xfb, 0xe8, 0xde, 0x84, 0xd1, 0xd0, 0xf9, 0x34, 0xf7, 0x85, 0x85, 0x83, 0x1c, 0x93, 0x87, 0x58, - 0xc9, 0xb4, 0xee, 0xf5, 0x79, 0x24, 0xda, 0xed, 0xec, 0x7e, 0xcc, 0x05, 0x2e, 0xdd, 0xcd, 0x53, - 0x27, 0x6f, 0x56, 0xfe, 0x48, 0x82, 0xcc, 0x8a, 0x2d, 0xf6, 0x72, 0xf8, 0x07, 0x74, 0x5f, 0xfb, - 0xa4, 0xfb, 0x8e, 0x4b, 0xbc, 0x37, 0xef, 0x13, 0xef, 0xbd, 0x78, 0x8a, 0xfe, 0x76, 0x8c, 0xa6, - 0xa7, 0x12, 0xae, 0x6b, 0xba, 0xbb, 0x86, 0xe1, 0x3f, 0xaf, 0xe5, 0xb9, 0x67, 0xd0, 0xc4, 0x41, - 0x0d, 0xfa, 0x86, 0x04, 0xc3, 0x2b, 0x76, 0xfd, 0xaa, 0x5e, 0xfb, 0x7f, 0xdd, 0x77, 0xee, 0xf8, - 0x12, 0xfe, 0xcf, 0x62, 0x70, 0xd2, 0xbf, 0xe6, 0x7e, 0xb0, 0x85, 0xad, 0x3d, 0x77, 0x59, 0x35, - 0xd5, 0xba, 0xa6, 0xfb, 0x9f, 0x62, 0x1f, 0xf1, 0x0b, 0x4c, 0x71, 0x85, 0xd8, 0xb2, 0x0e, 0x99, - 0x75, 0xb5, 0x8e, 0x15, 0xfc, 0xc1, 0x16, 0xb6, 0x9d, 0x0e, 0xef, 0xa6, 0x4c, 0xc2, 0x80, 0xb1, - 0xbd, 0x2d, 0xae, 0xa8, 0x24, 0x14, 0xde, 0x42, 0x13, 0x90, 0x6c, 0x68, 0x4d, 0x8d, 0x19, 0x25, - 0xa1, 0xb0, 0x06, 0x9a, 0x86, 0x4c, 0x95, 0xe8, 0x5e, 0x61, 0x77, 0x7a, 0x13, 0xe2, 0xdb, 0x1b, - 0x2d, 0xdd, 0xd9, 0x24, 0x10, 0xf9, 0x69, 0x18, 0x62, 0xe3, 0xf1, 0x3a, 0xf4, 0x08, 0xa4, 0xe8, - 0x1d, 0x4c, 0x6f, 0xd4, 0x41, 0xd2, 0xbe, 0xc2, 0xde, 0x63, 0x61, 0x5c, 0xd8, 0xc0, 0xac, 0x51, - 0x2a, 0x75, 0x35, 0xe5, 0x89, 0xe8, 0x64, 0xc7, 0x0c, 0xe5, 0x9a, 0xf1, 0x37, 0x92, 0x70, 0x98, - 0x3f, 0x5e, 0x56, 0x4d, 0x6d, 0x76, 0xc7, 0x71, 0xc4, 0x0b, 0x62, 0xc0, 0x37, 0x80, 0xaa, 0xa9, - 0xc9, 0x7b, 0x90, 0xb8, 0xe4, 0x38, 0x26, 0x3a, 0x09, 0x49, 0xab, 0xd5, 0xc0, 0xe2, 0x1c, 0x74, - 0xa2, 0xe0, 0xe1, 0x14, 0x08, 0x82, 0xd2, 0x6a, 0x60, 0x85, 0xa1, 0xa0, 0x32, 0x4c, 0x6f, 0xb7, - 0x1a, 0x8d, 0xbd, 0x4a, 0x0d, 0xd3, 0x7f, 0x9b, 0xe4, 0xfe, 0xe3, 0x01, 0xbc, 0x6b, 0xaa, 0xba, - 0x5b, 0x7c, 0xa4, 0x94, 0x63, 0x14, 0x6d, 0x81, 0x62, 0x89, 0x7f, 0x3a, 0x50, 0x16, 0x38, 0xf2, - 0xef, 0xc5, 0x20, 0x25, 0x58, 0xd3, 0x17, 0x4b, 0x70, 0x03, 0x57, 0x1d, 0x43, 0x3c, 0x28, 0x74, - 0xdb, 0x08, 0x41, 0xbc, 0xce, 0xa7, 0x28, 0x7d, 0xe9, 0x90, 0x42, 0x1a, 0x04, 0xe6, 0xbe, 0xee, - 0x43, 0x60, 0x66, 0x8b, 0xcc, 0x5a, 0xc2, 0x34, 0xc4, 0x81, 0xc5, 0xa5, 0x43, 0x0a, 0x6d, 0xa1, - 0x1c, 0x0c, 0x90, 0x00, 0x72, 0xd8, 0x37, 0x21, 0x09, 0x9c, 0xb7, 0xd1, 0x24, 0x24, 0x4d, 0xd5, - 0xa9, 0xb2, 0x7b, 0xb8, 0xa4, 0x83, 0x35, 0x49, 0x4c, 0xb0, 0x77, 0x71, 0xc3, 0xff, 0x93, 0x84, - 0x18, 0x83, 0x7d, 0xf4, 0x8c, 0xc8, 0xbd, 0xae, 0x3a, 0x0e, 0xb6, 0x74, 0xc2, 0x90, 0xa1, 0xd3, - 0x77, 0xc8, 0x8c, 0xda, 0x1e, 0xff, 0x3f, 0x29, 0xf4, 0x37, 0xff, 0xc7, 0x0c, 0xd4, 0x1f, 0x2a, - 0xb4, 0x93, 0xfd, 0x7b, 0xa8, 0x21, 0x01, 0x2c, 0x11, 0xa4, 0x32, 0x8c, 0xab, 0xb5, 0x9a, 0xc6, - 0xfe, 0x65, 0x49, 0x65, 0x4b, 0xa3, 0x1b, 0x6c, 0x9b, 0xfe, 0xf3, 0xaf, 0x6e, 0x73, 0x81, 0x3c, - 0x82, 0x12, 0xc7, 0x2f, 0xa5, 0x61, 0xd0, 0x64, 0x42, 0xc9, 0x17, 0x60, 0xac, 0x4d, 0x52, 0x22, - 0xdf, 0x75, 0x4d, 0xaf, 0x89, 0x77, 0xa0, 0xc8, 0x6f, 0x02, 0xa3, 0x1f, 0x2e, 0x64, 0x8f, 0x60, - 0xe9, 0xef, 0xd2, 0x8f, 0x75, 0xbf, 0xcb, 0x31, 0xe2, 0xbb, 0xcb, 0xa1, 0x9a, 0x5a, 0x29, 0x4d, - 0xf9, 0xf3, 0x2b, 0x1c, 0x73, 0xbc, 0x83, 0x5d, 0xdf, 0x28, 0x18, 0x56, 0x7d, 0xb6, 0x8e, 0x75, - 0x51, 0x51, 0x93, 0x2e, 0xd5, 0xd4, 0x6c, 0xea, 0x8e, 0xde, 0x87, 0x14, 0xed, 0x0b, 0xbe, 0xdf, - 0xf4, 0x66, 0x47, 0x62, 0x71, 0x6e, 0x7d, 0xc9, 0xf5, 0xe3, 0x6f, 0xc6, 0xe0, 0x98, 0xcf, 0x8f, - 0x7d, 0xc8, 0xed, 0xee, 0x9c, 0xef, 0xec, 0xf1, 0x3d, 0x7c, 0x86, 0xf0, 0x0a, 0x24, 0x08, 0x3e, - 0x8a, 0xf8, 0xb7, 0x09, 0xb9, 0x5f, 0xfa, 0x17, 0xff, 0x48, 0xa6, 0x4e, 0xd1, 0x79, 0x56, 0x28, - 0x93, 0xd2, 0xc7, 0x7b, 0xb7, 0x5f, 0xd6, 0xfb, 0x86, 0xa4, 0x7d, 0xe7, 0xcc, 0x18, 0xb6, 0xe1, - 0xeb, 0x67, 0x40, 0xee, 0xb2, 0x4d, 0x61, 0x19, 0x73, 0xff, 0x8d, 0x51, 0x1f, 0xe9, 0xb8, 0xdb, - 0x3d, 0x99, 0xfd, 0x66, 0xb0, 0xc7, 0x2d, 0xd4, 0x2e, 0x4c, 0x3e, 0x43, 0xc6, 0xf6, 0x0e, 0x8f, - 0x44, 0x62, 0x9f, 0x74, 0x1f, 0x79, 0x4b, 0xfc, 0x7f, 0xaf, 0x89, 0xe7, 0xd7, 0xe0, 0xc9, 0xc7, - 0x37, 0x44, 0x0f, 0x14, 0xba, 0xae, 0x17, 0x05, 0xdf, 0x62, 0xa1, 0xf8, 0x28, 0xe5, 0x9f, 0x97, - 0xe0, 0x9e, 0xb6, 0xa1, 0x79, 0x8e, 0x5f, 0xec, 0xf0, 0x06, 0x54, 0xcf, 0x77, 0x67, 0xfc, 0x6f, - 0x43, 0x2d, 0x76, 0x10, 0xf6, 0xc1, 0x48, 0x61, 0x99, 0x14, 0x01, 0x69, 0x9f, 0x82, 0xc3, 0x41, - 0x61, 0x85, 0x99, 0xde, 0x05, 0x23, 0xc1, 0x9a, 0x80, 0x9b, 0x6b, 0x38, 0x50, 0x15, 0xc8, 0x95, - 0xb0, 0x9d, 0x5d, 0x5d, 0xcb, 0x90, 0x76, 0x51, 0xf9, 0x6e, 0xa4, 0x67, 0x55, 0x3d, 0x4a, 0xf9, - 0x33, 0x12, 0xcc, 0x04, 0x47, 0xf0, 0x8a, 0x6f, 0xbb, 0x3f, 0x61, 0xef, 0xd8, 0x14, 0xbf, 0x21, - 0xc1, 0xbd, 0xfb, 0xc8, 0xc4, 0x0d, 0xf0, 0x3c, 0x4c, 0xf8, 0xce, 0xc7, 0x44, 0x0a, 0x17, 0xd3, - 0x7e, 0x32, 0xfa, 0x60, 0xcf, 0x3d, 0x0e, 0x3a, 0x4a, 0x8c, 0xf2, 0xb5, 0x3f, 0x98, 0x1e, 0x6f, - 0xef, 0xb3, 0x95, 0xf1, 0xf6, 0x33, 0xad, 0x3b, 0xe8, 0x1f, 0x5f, 0x90, 0xe0, 0xa1, 0xa0, 0xaa, - 0x1d, 0x1e, 0x5a, 0xbd, 0x53, 0xf3, 0xf0, 0x6f, 0x25, 0x38, 0xd9, 0x8b, 0x70, 0x7c, 0x42, 0xb6, - 0x60, 0xdc, 0x3b, 0xa5, 0x0e, 0xcf, 0xc7, 0xc3, 0x7d, 0x3c, 0xde, 0xe3, 0x5e, 0x8a, 0x5c, 0x6e, - 0x77, 0xc1, 0xf0, 0x26, 0x0f, 0x2c, 0xff, 0x94, 0xbb, 0x46, 0x0e, 0x16, 0xfe, 0xc2, 0xc8, 0x81, - 0xd2, 0xbf, 0xc3, 0x5c, 0xc4, 0x3a, 0xcc, 0x85, 0x6f, 0x17, 0x72, 0x83, 0xe7, 0xad, 0x0e, 0x27, - 0xd3, 0x1f, 0x80, 0xf1, 0x0e, 0xae, 0xcc, 0xa3, 0xba, 0x0f, 0x4f, 0x56, 0x50, 0xbb, 0xb3, 0xca, - 0x7b, 0x30, 0x4d, 0xc7, 0xed, 0x60, 0xe8, 0xbb, 0xad, 0x72, 0x93, 0xe7, 0x96, 0x8e, 0x43, 0x73, - 0xdd, 0x97, 0x60, 0x80, 0xcd, 0x33, 0x57, 0xf7, 0x00, 0x8e, 0xc2, 0x19, 0xc8, 0x3f, 0x2d, 0x72, - 0xd9, 0x82, 0x10, 0xbb, 0x73, 0x0c, 0xf5, 0xa2, 0xeb, 0x1d, 0x8a, 0x21, 0x9f, 0x31, 0x5e, 0x15, - 0x59, 0xad, 0xb3, 0x74, 0xdc, 0x1c, 0xd5, 0x3b, 0x96, 0xd5, 0x98, 0x6d, 0xee, 0x6e, 0xfa, 0xfa, - 0x59, 0x91, 0xbe, 0x5c, 0x9d, 0x22, 0xd2, 0xd7, 0x3b, 0x63, 0x7a, 0x37, 0x91, 0x45, 0x88, 0xf9, - 0x67, 0x31, 0x91, 0x7d, 0x4f, 0x82, 0x23, 0x54, 0x37, 0xff, 0xe3, 0x8e, 0x7e, 0x4d, 0xfe, 0x08, - 0x20, 0xdb, 0xaa, 0x56, 0x3a, 0x46, 0x77, 0xd6, 0xb6, 0xaa, 0xd7, 0x02, 0xeb, 0xcb, 0x23, 0x80, - 0x6a, 0xb6, 0x13, 0xc6, 0x66, 0x97, 0x43, 0xb3, 0x35, 0xdb, 0xb9, 0xb6, 0xcf, 0x6a, 0x94, 0xb8, - 0x03, 0xd3, 0xf9, 0x8a, 0x04, 0xf9, 0x4e, 0x2a, 0xf3, 0xe9, 0xd3, 0x60, 0x32, 0xf0, 0xe8, 0x2c, - 0x3c, 0x83, 0x8f, 0xf4, 0xf2, 0xc0, 0x28, 0x14, 0x46, 0x87, 0x2d, 0x7c, 0xb7, 0xeb, 0x80, 0xe9, - 0xa0, 0x87, 0xb6, 0x57, 0xd6, 0xef, 0x58, 0xf8, 0xfc, 0x6a, 0x5b, 0x5e, 0xfd, 0x33, 0x51, 0x7b, - 0xef, 0xc2, 0x54, 0x17, 0xa9, 0xef, 0xf6, 0xba, 0xb7, 0xd3, 0x75, 0x32, 0xef, 0x74, 0xf9, 0x7e, - 0x9a, 0x47, 0x42, 0xf0, 0xc5, 0x03, 0xdf, 0x5e, 0xac, 0xd3, 0x3b, 0x9e, 0xf2, 0xfb, 0xe0, 0x68, - 0x47, 0x2a, 0x2e, 0x5b, 0x11, 0x12, 0x3b, 0x9a, 0xed, 0x70, 0xb1, 0x1e, 0xe8, 0x26, 0x56, 0x88, - 0x9a, 0xd2, 0xc8, 0x08, 0xb2, 0x94, 0xf5, 0xba, 0x61, 0x34, 0xb8, 0x18, 0xf2, 0x15, 0x18, 0xf3, - 0xc1, 0xf8, 0x20, 0x67, 0x21, 0x61, 0x1a, 0xfc, 0xab, 0x26, 0x99, 0x53, 0xc7, 0xba, 0x0d, 0x42, - 0x68, 0xb8, 0xda, 0x14, 0x5f, 0x9e, 0x00, 0xc4, 0x98, 0xd1, 0x9b, 0x15, 0x62, 0x88, 0x0d, 0x18, - 0x0f, 0x40, 0xf9, 0x20, 0x3f, 0x04, 0x03, 0x26, 0x85, 0xb8, 0xef, 0xce, 0x75, 0x1b, 0x86, 0x62, - 0xb9, 0xdf, 0x91, 0xa0, 0xad, 0x53, 0xdf, 0x39, 0x0c, 0x49, 0xca, 0x15, 0x7d, 0x5e, 0x02, 0xf0, - 0xdd, 0x93, 0x28, 0x74, 0x63, 0xd3, 0x79, 0x4f, 0x9c, 0x9f, 0xed, 0x19, 0x9f, 0xd7, 0x6c, 0x27, - 0x7f, 0xec, 0x5f, 0xbf, 0xfe, 0xd9, 0xd8, 0xfd, 0x48, 0x9e, 0xed, 0xb2, 0x1b, 0xf7, 0xc5, 0xcb, - 0x57, 0x03, 0x9f, 0xd4, 0x78, 0xb4, 0xb7, 0xa1, 0x84, 0x64, 0x85, 0x5e, 0xd1, 0xb9, 0x60, 0x17, - 0xa8, 0x60, 0x67, 0xd0, 0x13, 0xd1, 0x82, 0xcd, 0x7e, 0x28, 0x18, 0x34, 0x1f, 0x41, 0xbf, 0x23, - 0xc1, 0x44, 0xa7, 0x2d, 0x1d, 0x3a, 0xd7, 0x9b, 0x14, 0xed, 0x25, 0x45, 0xfe, 0xfc, 0x01, 0x28, - 0xb9, 0x2a, 0x8b, 0x54, 0x95, 0x39, 0xf4, 0xf4, 0x01, 0x54, 0x99, 0xf5, 0xad, 0x3b, 0xe8, 0x7f, - 0x49, 0x70, 0x7c, 0xdf, 0x1d, 0x12, 0x9a, 0xeb, 0x4d, 0xca, 0x7d, 0x6a, 0xa7, 0x7c, 0xe9, 0xad, - 0xb0, 0xe0, 0x1a, 0x3f, 0x43, 0x35, 0xbe, 0x82, 0x96, 0x0e, 0xa2, 0xb1, 0x57, 0x11, 0xf9, 0x75, - 0xff, 0xcd, 0xe0, 0x7d, 0xdb, 0xfd, 0xdd, 0xa9, 0x6d, 0xe3, 0x11, 0x11, 0x18, 0xed, 0x45, 0xad, - 0xfc, 0x5e, 0xaa, 0x82, 0x82, 0xd6, 0xdf, 0xe2, 0xa4, 0xcd, 0x7e, 0x28, 0x98, 0xf8, 0x3f, 0x82, - 0xfe, 0xa7, 0xd4, 0xf9, 0xfa, 0xec, 0x93, 0xfb, 0x8a, 0xd8, 0x7d, 0x53, 0x95, 0x3f, 0xd7, 0x3f, - 0x21, 0x57, 0xb2, 0x49, 0x95, 0xac, 0x23, 0x7c, 0xa7, 0x95, 0xec, 0x38, 0x89, 0xe8, 0xb7, 0x24, - 0x98, 0xe8, 0xb4, 0x27, 0x89, 0x08, 0xcb, 0x7d, 0x36, 0x59, 0x11, 0x61, 0xb9, 0xdf, 0x06, 0x48, - 0xfe, 0x21, 0xaa, 0xfc, 0x59, 0x74, 0xba, 0x9b, 0xf2, 0xfb, 0xce, 0x22, 0x89, 0xc5, 0x7d, 0x8b, - 0xfc, 0x88, 0x58, 0xec, 0x65, 0x1f, 0x13, 0x11, 0x8b, 0x3d, 0xed, 0x31, 0xa2, 0x63, 0xd1, 0xd5, - 0xac, 0xc7, 0x69, 0xb4, 0xd1, 0x37, 0x25, 0x18, 0x0e, 0x54, 0xc4, 0xe8, 0xf1, 0x7d, 0x05, 0xed, - 0xb4, 0x61, 0xc8, 0x9f, 0xea, 0x87, 0x84, 0xeb, 0xb2, 0x44, 0x75, 0x99, 0x47, 0x73, 0x07, 0xd1, - 0xc5, 0x0a, 0x48, 0xfc, 0x8a, 0x04, 0xe3, 0x1d, 0xaa, 0xcc, 0x88, 0x28, 0xec, 0x5e, 0x34, 0xe7, - 0xcf, 0xf5, 0x4f, 0xc8, 0xb5, 0xba, 0x48, 0xb5, 0x7a, 0x0f, 0x7a, 0xea, 0x20, 0x5a, 0xf9, 0xd6, - 0xe7, 0x5b, 0xde, 0x6d, 0x44, 0xdf, 0x38, 0xe8, 0x6c, 0x9f, 0x82, 0x09, 0x85, 0x9e, 0xec, 0x9b, - 0x8e, 0xeb, 0xf3, 0x2c, 0xd5, 0xe7, 0x19, 0xb4, 0xf6, 0xd6, 0xf4, 0x69, 0x5f, 0xd6, 0xbf, 0xde, - 0xfe, 0xe2, 0xeb, 0xfe, 0x5e, 0xd4, 0xb1, 0x58, 0xcd, 0x3f, 0xd1, 0x17, 0x0d, 0x57, 0xea, 0x1c, - 0x55, 0xea, 0x14, 0x7a, 0xac, 0x9b, 0x52, 0xbe, 0x2b, 0xa7, 0x9a, 0xbe, 0x6d, 0xcc, 0x7e, 0x88, - 0x95, 0xc0, 0x1f, 0x41, 0x3f, 0x2a, 0xae, 0xfb, 0x9d, 0xd8, 0x77, 0x5c, 0x5f, 0x1d, 0x9b, 0x7f, - 0xa8, 0x07, 0x4c, 0x2e, 0xd7, 0xfd, 0x54, 0xae, 0x29, 0x74, 0xac, 0x9b, 0x5c, 0xa4, 0x96, 0x45, - 0x9f, 0x94, 0xdc, 0x1b, 0xc2, 0x27, 0xf7, 0xe7, 0xed, 0x2f, 0x76, 0xf3, 0x0f, 0xf7, 0x84, 0xcb, - 0x25, 0x79, 0x80, 0x4a, 0x32, 0x83, 0xa6, 0xba, 0x4a, 0xc2, 0x4a, 0xdf, 0x3b, 0x7d, 0x73, 0xe0, - 0x8f, 0x07, 0xbb, 0xbe, 0xe4, 0x5d, 0xc7, 0x3a, 0xb6, 0x35, 0xfb, 0x40, 0x37, 0x00, 0x7b, 0x7b, - 0x3c, 0xf5, 0x3b, 0x49, 0x18, 0x5a, 0x64, 0xa3, 0x6c, 0x38, 0xaa, 0xf3, 0x16, 0x37, 0x02, 0xc8, - 0xe6, 0xdf, 0x8b, 0x62, 0x1f, 0xba, 0xf3, 0x3e, 0xdd, 0x36, 0xd4, 0xd7, 0x3b, 0x93, 0xec, 0xfe, - 0x13, 0x7f, 0x3d, 0x31, 0xcc, 0x4f, 0x66, 0x9f, 0x9e, 0xa2, 0x77, 0x17, 0xd8, 0x27, 0xea, 0x3e, - 0x26, 0xc1, 0x61, 0x8a, 0xe5, 0xc5, 0x1b, 0xc5, 0x14, 0x2f, 0xcc, 0x74, 0xf5, 0x98, 0x65, 0xd5, - 0x77, 0x04, 0xc3, 0x3e, 0x2a, 0x77, 0x3f, 0xbf, 0x4c, 0x7e, 0xcc, 0x37, 0x78, 0x98, 0xad, 0xac, - 0x8c, 0x37, 0xda, 0x28, 0xed, 0xd0, 0xbe, 0x3e, 0x71, 0xf0, 0x7d, 0xfd, 0x65, 0xc8, 0xf8, 0x32, - 0x7d, 0x2e, 0x19, 0xf1, 0x8e, 0x57, 0xf8, 0x10, 0xcd, 0x4f, 0x8c, 0x3e, 0x2e, 0xc1, 0xe1, 0x8e, - 0x8b, 0x20, 0xfd, 0x6f, 0x84, 0x7d, 0x1e, 0xd2, 0x85, 0x8c, 0xd3, 0x91, 0xaf, 0xac, 0x4c, 0xb4, - 0x3a, 0x55, 0x13, 0xeb, 0x30, 0x1c, 0x58, 0xc0, 0x72, 0xe2, 0x7f, 0x8a, 0xf6, 0x7e, 0xbd, 0x39, - 0xc8, 0x00, 0xe5, 0x21, 0x85, 0x77, 0x4d, 0xc3, 0x72, 0x70, 0x8d, 0x5e, 0x79, 0x48, 0x29, 0x6e, - 0x5b, 0x5e, 0x05, 0xd4, 0x3e, 0xb9, 0xe1, 0xaf, 0x28, 0xa6, 0xbd, 0xaf, 0x28, 0x4e, 0x40, 0xd2, - 0xff, 0x9d, 0x41, 0xd6, 0xb8, 0x7b, 0xb7, 0x85, 0xfe, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x99, - 0x63, 0xc7, 0x34, 0x4c, 0x8e, 0x00, 0x00, + // 9310 bytes of a gzipped FileDescriptorSet + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x5c, 0xd7, + 0x75, 0x18, 0xdf, 0x7e, 0x00, 0xbb, 0x67, 0x17, 0xc0, 0xe2, 0x02, 0x84, 0x96, 0x4b, 0x12, 0x80, + 0x9e, 0x64, 0x89, 0xa2, 0x28, 0x40, 0xa2, 0x48, 0x8a, 0x5c, 0xda, 0x92, 0xb1, 0xd8, 0x25, 0x08, + 0x12, 0x5f, 0x7a, 0x00, 0x28, 0x7f, 0x24, 0xdd, 0x79, 0xd8, 0xbd, 0x58, 0x3c, 0x71, 0xf7, 0xbd, + 0xe7, 0xf7, 0xde, 0x92, 0x80, 0x6c, 0xcf, 0x28, 0xb1, 0xeb, 0xda, 0x4a, 0x53, 0xdb, 0x75, 0x26, + 0xb5, 0x1d, 0xd3, 0xb5, 0xe3, 0xb4, 0x4e, 0x9d, 0xb4, 0xf9, 0x70, 0x9a, 0x36, 0x6d, 0x67, 0x6a, + 0xb7, 0x4d, 0xe3, 0xb4, 0xd3, 0x8c, 0x34, 0xcd, 0x4c, 0xd3, 0x4c, 0x43, 0xa7, 0xb2, 0x26, 0x55, + 0x5d, 0xb7, 0x75, 0x58, 0x35, 0x4d, 0xc7, 0x33, 0x6d, 0xe7, 0x7e, 0xbd, 0xaf, 0xdd, 0xc5, 0xee, + 0x42, 0xa4, 0xe4, 0x34, 0xf9, 0x85, 0xbd, 0xe7, 0x9e, 0x73, 0xee, 0x39, 0xe7, 0x9e, 0x73, 0xee, + 0xb9, 0xf7, 0xdd, 0xf7, 0x00, 0xff, 0xfc, 0x22, 0x4c, 0xd7, 0x0c, 0xa3, 0x56, 0xc7, 0xb3, 0xa6, + 0x65, 0x38, 0xc6, 0x56, 0x73, 0x7b, 0xb6, 0x8a, 0xed, 0x8a, 0xa5, 0x99, 0x8e, 0x61, 0xcd, 0x50, + 0x18, 0x1a, 0x61, 0x18, 0x33, 0x02, 0x43, 0x5e, 0x86, 0xd1, 0x4b, 0x5a, 0x1d, 0x17, 0x5d, 0xc4, + 0x75, 0xec, 0xa0, 0xf3, 0x10, 0xdb, 0xd6, 0xea, 0x38, 0x2b, 0x4d, 0x47, 0x4f, 0xa4, 0x4e, 0x3f, + 0x38, 0x13, 0x22, 0x9a, 0x09, 0x52, 0xac, 0x11, 0xb0, 0x42, 0x29, 0xe4, 0xd7, 0x62, 0x30, 0xd6, + 0xa6, 0x17, 0x21, 0x88, 0xe9, 0x6a, 0x83, 0x70, 0x94, 0x4e, 0x24, 0x15, 0xfa, 0x1b, 0x65, 0x61, + 0xd0, 0x54, 0x2b, 0xd7, 0xd5, 0x1a, 0xce, 0x46, 0x28, 0x58, 0x34, 0xd1, 0x24, 0x40, 0x15, 0x9b, + 0x58, 0xaf, 0x62, 0xbd, 0xb2, 0x97, 0x8d, 0x4e, 0x47, 0x4f, 0x24, 0x15, 0x1f, 0x04, 0x3d, 0x0a, + 0xa3, 0x66, 0x73, 0xab, 0xae, 0x55, 0xca, 0x3e, 0x34, 0x98, 0x8e, 0x9e, 0x88, 0x2b, 0x19, 0xd6, + 0x51, 0xf4, 0x90, 0x1f, 0x86, 0x91, 0x9b, 0x58, 0xbd, 0xee, 0x47, 0x4d, 0x51, 0xd4, 0x61, 0x02, + 0xf6, 0x21, 0xce, 0x43, 0xba, 0x81, 0x6d, 0x5b, 0xad, 0xe1, 0xb2, 0xb3, 0x67, 0xe2, 0x6c, 0x8c, + 0x6a, 0x3f, 0xdd, 0xa2, 0x7d, 0x58, 0xf3, 0x14, 0xa7, 0xda, 0xd8, 0x33, 0x31, 0x9a, 0x83, 0x24, + 0xd6, 0x9b, 0x0d, 0xc6, 0x21, 0xde, 0xc1, 0x7e, 0x25, 0xbd, 0xd9, 0x08, 0x73, 0x49, 0x10, 0x32, + 0xce, 0x62, 0xd0, 0xc6, 0xd6, 0x0d, 0xad, 0x82, 0xb3, 0x03, 0x94, 0xc1, 0xc3, 0x2d, 0x0c, 0xd6, + 0x59, 0x7f, 0x98, 0x87, 0xa0, 0x43, 0xf3, 0x90, 0xc4, 0xbb, 0x0e, 0xd6, 0x6d, 0xcd, 0xd0, 0xb3, + 0x83, 0x94, 0xc9, 0x3b, 0xda, 0xcc, 0x22, 0xae, 0x57, 0xc3, 0x2c, 0x3c, 0x3a, 0x74, 0x0e, 0x06, + 0x0d, 0xd3, 0xd1, 0x0c, 0xdd, 0xce, 0x26, 0xa6, 0xa5, 0x13, 0xa9, 0xd3, 0xc7, 0xda, 0x3a, 0xc2, + 0x2a, 0xc3, 0x51, 0x04, 0x32, 0x5a, 0x84, 0x8c, 0x6d, 0x34, 0xad, 0x0a, 0x2e, 0x57, 0x8c, 0x2a, + 0x2e, 0x6b, 0xfa, 0xb6, 0x91, 0x4d, 0x52, 0x06, 0x53, 0xad, 0x8a, 0x50, 0xc4, 0x79, 0xa3, 0x8a, + 0x17, 0xf5, 0x6d, 0x43, 0x19, 0xb6, 0x03, 0x6d, 0x34, 0x01, 0x03, 0xf6, 0x9e, 0xee, 0xa8, 0xbb, + 0xd9, 0x34, 0xf5, 0x10, 0xde, 0x92, 0x7f, 0x63, 0x00, 0x46, 0x7a, 0x71, 0xb1, 0x8b, 0x10, 0xdf, + 0x26, 0x5a, 0x66, 0x23, 0xfd, 0xd8, 0x80, 0xd1, 0x04, 0x8d, 0x38, 0x70, 0x40, 0x23, 0xce, 0x41, + 0x4a, 0xc7, 0xb6, 0x83, 0xab, 0xcc, 0x23, 0xa2, 0x3d, 0xfa, 0x14, 0x30, 0xa2, 0x56, 0x97, 0x8a, + 0x1d, 0xc8, 0xa5, 0xde, 0x03, 0x23, 0xae, 0x48, 0x65, 0x4b, 0xd5, 0x6b, 0xc2, 0x37, 0x67, 0xbb, + 0x49, 0x32, 0x53, 0x12, 0x74, 0x0a, 0x21, 0x53, 0x86, 0x71, 0xa0, 0x8d, 0x8a, 0x00, 0x86, 0x8e, + 0x8d, 0xed, 0x72, 0x15, 0x57, 0xea, 0xd9, 0x44, 0x07, 0x2b, 0xad, 0x12, 0x94, 0x16, 0x2b, 0x19, + 0x0c, 0x5a, 0xa9, 0xa3, 0x0b, 0x9e, 0xab, 0x0d, 0x76, 0xf0, 0x94, 0x65, 0x16, 0x64, 0x2d, 0xde, + 0xb6, 0x09, 0xc3, 0x16, 0x26, 0x7e, 0x8f, 0xab, 0x5c, 0xb3, 0x24, 0x15, 0x62, 0xa6, 0xab, 0x66, + 0x0a, 0x27, 0x63, 0x8a, 0x0d, 0x59, 0xfe, 0x26, 0x7a, 0x00, 0x5c, 0x40, 0x99, 0xba, 0x15, 0xd0, + 0x2c, 0x94, 0x16, 0xc0, 0x15, 0xb5, 0x81, 0x73, 0x2f, 0xc0, 0x70, 0xd0, 0x3c, 0x68, 0x1c, 0xe2, + 0xb6, 0xa3, 0x5a, 0x0e, 0xf5, 0xc2, 0xb8, 0xc2, 0x1a, 0x28, 0x03, 0x51, 0xac, 0x57, 0x69, 0x96, + 0x8b, 0x2b, 0xe4, 0x27, 0x7a, 0xb7, 0xa7, 0x70, 0x94, 0x2a, 0xfc, 0x50, 0xeb, 0x8c, 0x06, 0x38, + 0x87, 0xf5, 0xce, 0x3d, 0x05, 0x43, 0x01, 0x05, 0x7a, 0x1d, 0x5a, 0xfe, 0x10, 0x1c, 0x6e, 0xcb, + 0x1a, 0xbd, 0x07, 0xc6, 0x9b, 0xba, 0xa6, 0x3b, 0xd8, 0x32, 0x2d, 0x4c, 0x3c, 0x96, 0x0d, 0x95, + 0xfd, 0x4f, 0x83, 0x1d, 0x7c, 0x6e, 0xd3, 0x8f, 0xcd, 0xb8, 0x28, 0x63, 0xcd, 0x56, 0xe0, 0xc9, + 0x64, 0xe2, 0xf5, 0xc1, 0xcc, 0x8b, 0x2f, 0xbe, 0xf8, 0x62, 0x44, 0xfe, 0xe6, 0x00, 0x8c, 0xb7, + 0x8b, 0x99, 0xb6, 0xe1, 0x3b, 0x01, 0x03, 0x7a, 0xb3, 0xb1, 0x85, 0x2d, 0x6a, 0xa4, 0xb8, 0xc2, + 0x5b, 0x68, 0x0e, 0xe2, 0x75, 0x75, 0x0b, 0xd7, 0xb3, 0xb1, 0x69, 0xe9, 0xc4, 0xf0, 0xe9, 0x47, + 0x7b, 0x8a, 0xca, 0x99, 0x25, 0x42, 0xa2, 0x30, 0x4a, 0xf4, 0x34, 0xc4, 0x78, 0x8a, 0x26, 0x1c, + 0x4e, 0xf6, 0xc6, 0x81, 0xc4, 0x92, 0x42, 0xe9, 0xd0, 0x51, 0x48, 0x92, 0xbf, 0xcc, 0x37, 0x06, + 0xa8, 0xcc, 0x09, 0x02, 0x20, 0x7e, 0x81, 0x72, 0x90, 0xa0, 0x61, 0x52, 0xc5, 0x62, 0x69, 0x73, + 0xdb, 0xc4, 0xb1, 0xaa, 0x78, 0x5b, 0x6d, 0xd6, 0x9d, 0xf2, 0x0d, 0xb5, 0xde, 0xc4, 0xd4, 0xe1, + 0x93, 0x4a, 0x9a, 0x03, 0xaf, 0x11, 0x18, 0x9a, 0x82, 0x14, 0x8b, 0x2a, 0x4d, 0xaf, 0xe2, 0x5d, + 0x9a, 0x3d, 0xe3, 0x0a, 0x0b, 0xb4, 0x45, 0x02, 0x21, 0xc3, 0x3f, 0x6f, 0x1b, 0xba, 0x70, 0x4d, + 0x3a, 0x04, 0x01, 0xd0, 0xe1, 0x9f, 0x0a, 0x27, 0xee, 0xe3, 0xed, 0xd5, 0x6b, 0x89, 0xa5, 0x87, + 0x61, 0x84, 0x62, 0x3c, 0xc9, 0xa7, 0x5e, 0xad, 0x67, 0x47, 0xa7, 0xa5, 0x13, 0x09, 0x65, 0x98, + 0x81, 0x57, 0x39, 0x54, 0xfe, 0xf5, 0x08, 0xc4, 0x68, 0x62, 0x19, 0x81, 0xd4, 0xc6, 0x7b, 0xd7, + 0x4a, 0xe5, 0xe2, 0xea, 0x66, 0x61, 0xa9, 0x94, 0x91, 0xd0, 0x30, 0x00, 0x05, 0x5c, 0x5a, 0x5a, + 0x9d, 0xdb, 0xc8, 0x44, 0xdc, 0xf6, 0xe2, 0xca, 0xc6, 0xb9, 0x33, 0x99, 0xa8, 0x4b, 0xb0, 0xc9, + 0x00, 0x31, 0x3f, 0xc2, 0x93, 0xa7, 0x33, 0x71, 0x94, 0x81, 0x34, 0x63, 0xb0, 0xf8, 0x9e, 0x52, + 0xf1, 0xdc, 0x99, 0xcc, 0x40, 0x10, 0xf2, 0xe4, 0xe9, 0xcc, 0x20, 0x1a, 0x82, 0x24, 0x85, 0x14, + 0x56, 0x57, 0x97, 0x32, 0x09, 0x97, 0xe7, 0xfa, 0x86, 0xb2, 0xb8, 0xb2, 0x90, 0x49, 0xba, 0x3c, + 0x17, 0x94, 0xd5, 0xcd, 0xb5, 0x0c, 0xb8, 0x1c, 0x96, 0x4b, 0xeb, 0xeb, 0x73, 0x0b, 0xa5, 0x4c, + 0xca, 0xc5, 0x28, 0xbc, 0x77, 0xa3, 0xb4, 0x9e, 0x49, 0x07, 0xc4, 0x7a, 0xf2, 0x74, 0x66, 0xc8, + 0x1d, 0xa2, 0xb4, 0xb2, 0xb9, 0x9c, 0x19, 0x46, 0xa3, 0x30, 0xc4, 0x86, 0x10, 0x42, 0x8c, 0x84, + 0x40, 0xe7, 0xce, 0x64, 0x32, 0x9e, 0x20, 0x8c, 0xcb, 0x68, 0x00, 0x70, 0xee, 0x4c, 0x06, 0xc9, + 0xf3, 0x10, 0xa7, 0x6e, 0x88, 0x10, 0x0c, 0x2f, 0xcd, 0x15, 0x4a, 0x4b, 0xe5, 0xd5, 0xb5, 0x8d, + 0xc5, 0xd5, 0x95, 0xb9, 0xa5, 0x8c, 0xe4, 0xc1, 0x94, 0xd2, 0xb3, 0x9b, 0x8b, 0x4a, 0xa9, 0x98, + 0x89, 0xf8, 0x61, 0x6b, 0xa5, 0xb9, 0x8d, 0x52, 0x31, 0x13, 0x95, 0x2b, 0x30, 0xde, 0x2e, 0xa1, + 0xb6, 0x0d, 0x21, 0x9f, 0x2f, 0x44, 0x3a, 0xf8, 0x02, 0xe5, 0x15, 0xf6, 0x05, 0xf9, 0x3b, 0x11, + 0x18, 0x6b, 0xb3, 0xa8, 0xb4, 0x1d, 0xe4, 0x19, 0x88, 0x33, 0x5f, 0x66, 0xcb, 0xec, 0x23, 0x6d, + 0x57, 0x27, 0xea, 0xd9, 0x2d, 0x4b, 0x2d, 0xa5, 0xf3, 0x97, 0x1a, 0xd1, 0x0e, 0xa5, 0x06, 0x61, + 0xd1, 0xe2, 0xb0, 0x3f, 0xda, 0x92, 0xfc, 0xd9, 0xfa, 0x78, 0xae, 0x97, 0xf5, 0x91, 0xc2, 0xfa, + 0x5b, 0x04, 0xe2, 0x6d, 0x16, 0x81, 0x8b, 0x30, 0xda, 0xc2, 0xa8, 0xe7, 0x64, 0xfc, 0x11, 0x09, + 0xb2, 0x9d, 0x8c, 0xd3, 0x25, 0x25, 0x46, 0x02, 0x29, 0xf1, 0x62, 0xd8, 0x82, 0xf7, 0x77, 0x9e, + 0x84, 0x96, 0xb9, 0xfe, 0xaa, 0x04, 0x13, 0xed, 0x4b, 0xca, 0xb6, 0x32, 0x3c, 0x0d, 0x03, 0x0d, + 0xec, 0xec, 0x18, 0xa2, 0xac, 0x7a, 0xa8, 0xcd, 0x62, 0x4d, 0xba, 0xc3, 0x93, 0xcd, 0xa9, 0xfc, + 0xab, 0x7d, 0xb4, 0x53, 0x5d, 0xc8, 0xa4, 0x69, 0x91, 0xf4, 0x13, 0x11, 0x38, 0xdc, 0x96, 0x79, + 0x5b, 0x41, 0x8f, 0x03, 0x68, 0xba, 0xd9, 0x74, 0x58, 0xe9, 0xc4, 0x32, 0x71, 0x92, 0x42, 0x68, + 0xf2, 0x22, 0x59, 0xb6, 0xe9, 0xb8, 0xfd, 0x51, 0xda, 0x0f, 0x0c, 0x44, 0x11, 0xce, 0x7b, 0x82, + 0xc6, 0xa8, 0xa0, 0x93, 0x1d, 0x34, 0x6d, 0x71, 0xcc, 0xc7, 0x21, 0x53, 0xa9, 0x6b, 0x58, 0x77, + 0xca, 0xb6, 0x63, 0x61, 0xb5, 0xa1, 0xe9, 0x35, 0xba, 0xd4, 0x24, 0xf2, 0xf1, 0x6d, 0xb5, 0x6e, + 0x63, 0x65, 0x84, 0x75, 0xaf, 0x8b, 0x5e, 0x42, 0x41, 0x1d, 0xc8, 0xf2, 0x51, 0x0c, 0x04, 0x28, + 0x58, 0xb7, 0x4b, 0x21, 0x7f, 0x3a, 0x09, 0x29, 0x5f, 0x01, 0x8e, 0xee, 0x87, 0xf4, 0xf3, 0xea, + 0x0d, 0xb5, 0x2c, 0x36, 0x55, 0xcc, 0x12, 0x29, 0x02, 0x5b, 0xe3, 0x1b, 0xab, 0xc7, 0x61, 0x9c, + 0xa2, 0x18, 0x4d, 0x07, 0x5b, 0xe5, 0x4a, 0x5d, 0xb5, 0x6d, 0x6a, 0xb4, 0x04, 0x45, 0x45, 0xa4, + 0x6f, 0x95, 0x74, 0xcd, 0x8b, 0x1e, 0x74, 0x16, 0xc6, 0x28, 0x45, 0xa3, 0x59, 0x77, 0x34, 0xb3, + 0x8e, 0xcb, 0x64, 0x9b, 0x67, 0xd3, 0x25, 0xc7, 0x95, 0x6c, 0x94, 0x60, 0x2c, 0x73, 0x04, 0x22, + 0x91, 0x8d, 0x8a, 0x70, 0x9c, 0x92, 0xd5, 0xb0, 0x8e, 0x2d, 0xd5, 0xc1, 0x65, 0xfc, 0x81, 0xa6, + 0x5a, 0xb7, 0xcb, 0xaa, 0x5e, 0x2d, 0xef, 0xa8, 0xf6, 0x4e, 0x76, 0x9c, 0x30, 0x28, 0x44, 0xb2, + 0x92, 0x72, 0x84, 0x20, 0x2e, 0x70, 0xbc, 0x12, 0x45, 0x9b, 0xd3, 0xab, 0x97, 0x55, 0x7b, 0x07, + 0xe5, 0x61, 0x82, 0x72, 0xb1, 0x1d, 0x4b, 0xd3, 0x6b, 0xe5, 0xca, 0x0e, 0xae, 0x5c, 0x2f, 0x37, + 0x9d, 0xed, 0xf3, 0xd9, 0xa3, 0xfe, 0xf1, 0xa9, 0x84, 0xeb, 0x14, 0x67, 0x9e, 0xa0, 0x6c, 0x3a, + 0xdb, 0xe7, 0xd1, 0x3a, 0xa4, 0xc9, 0x64, 0x34, 0xb4, 0x17, 0x70, 0x79, 0xdb, 0xb0, 0xe8, 0x1a, + 0x3a, 0xdc, 0x26, 0x35, 0xf9, 0x2c, 0x38, 0xb3, 0xca, 0x09, 0x96, 0x8d, 0x2a, 0xce, 0xc7, 0xd7, + 0xd7, 0x4a, 0xa5, 0xa2, 0x92, 0x12, 0x5c, 0x2e, 0x19, 0x16, 0x71, 0xa8, 0x9a, 0xe1, 0x1a, 0x38, + 0xc5, 0x1c, 0xaa, 0x66, 0x08, 0xf3, 0x9e, 0x85, 0xb1, 0x4a, 0x85, 0xe9, 0xac, 0x55, 0xca, 0x7c, + 0x33, 0x66, 0x67, 0x33, 0x01, 0x63, 0x55, 0x2a, 0x0b, 0x0c, 0x81, 0xfb, 0xb8, 0x8d, 0x2e, 0xc0, + 0x61, 0xcf, 0x58, 0x7e, 0xc2, 0xd1, 0x16, 0x2d, 0xc3, 0xa4, 0x67, 0x61, 0xcc, 0xdc, 0x6b, 0x25, + 0x44, 0x81, 0x11, 0xcd, 0xbd, 0x30, 0xd9, 0x53, 0x30, 0x6e, 0xee, 0x98, 0xad, 0x74, 0x27, 0xfd, + 0x74, 0xc8, 0xdc, 0x31, 0xc3, 0x84, 0xef, 0xa0, 0x3b, 0x73, 0x0b, 0x57, 0x54, 0x07, 0x57, 0xb3, + 0xf7, 0xf9, 0xd1, 0x7d, 0x1d, 0x68, 0x06, 0x32, 0x95, 0x4a, 0x19, 0xeb, 0xea, 0x56, 0x1d, 0x97, + 0x55, 0x0b, 0xeb, 0xaa, 0x9d, 0x9d, 0xa2, 0xc8, 0x31, 0xc7, 0x6a, 0x62, 0x65, 0xb8, 0x52, 0x29, + 0xd1, 0xce, 0x39, 0xda, 0x87, 0x4e, 0xc2, 0xa8, 0xb1, 0xf5, 0x7c, 0x85, 0x79, 0x64, 0xd9, 0xb4, + 0xf0, 0xb6, 0xb6, 0x9b, 0x7d, 0x90, 0x9a, 0x77, 0x84, 0x74, 0x50, 0x7f, 0x5c, 0xa3, 0x60, 0xf4, + 0x08, 0x64, 0x2a, 0xf6, 0x8e, 0x6a, 0x99, 0x34, 0x25, 0xdb, 0xa6, 0x5a, 0xc1, 0xd9, 0x77, 0x30, + 0x54, 0x06, 0x5f, 0x11, 0x60, 0x12, 0x11, 0xf6, 0x4d, 0x6d, 0xdb, 0x11, 0x1c, 0x1f, 0x66, 0x11, + 0x41, 0x61, 0x9c, 0xdb, 0x09, 0xc8, 0x10, 0x4b, 0x04, 0x06, 0x3e, 0x41, 0xd1, 0x86, 0xcd, 0x1d, + 0xd3, 0x3f, 0xee, 0x03, 0x30, 0x44, 0x30, 0xbd, 0x41, 0x1f, 0x61, 0x85, 0x9b, 0xb9, 0xe3, 0x1b, + 0xf1, 0x0c, 0x4c, 0x10, 0xa4, 0x06, 0x76, 0xd4, 0xaa, 0xea, 0xa8, 0x3e, 0xec, 0x53, 0x14, 0x9b, + 0x98, 0x7d, 0x99, 0x77, 0x06, 0xe4, 0xb4, 0x9a, 0x5b, 0x7b, 0xae, 0x63, 0x3d, 0xc6, 0xe4, 0x24, + 0x30, 0xe1, 0x5a, 0xf7, 0xac, 0x38, 0x97, 0xf3, 0x90, 0xf6, 0xfb, 0x3d, 0x4a, 0x02, 0xf3, 0xfc, + 0x8c, 0x44, 0x8a, 0xa0, 0xf9, 0xd5, 0x22, 0x29, 0x5f, 0xde, 0x57, 0xca, 0x44, 0x48, 0x19, 0xb5, + 0xb4, 0xb8, 0x51, 0x2a, 0x2b, 0x9b, 0x2b, 0x1b, 0x8b, 0xcb, 0xa5, 0x4c, 0xd4, 0x57, 0xd8, 0x5f, + 0x89, 0x25, 0x1e, 0xca, 0x3c, 0x2c, 0xbf, 0x12, 0x81, 0xe1, 0xe0, 0x4e, 0x0d, 0xbd, 0x13, 0xee, + 0x13, 0xc7, 0x2a, 0x36, 0x76, 0xca, 0x37, 0x35, 0x8b, 0x06, 0x64, 0x43, 0x65, 0x8b, 0xa3, 0xeb, + 0x3f, 0xe3, 0x1c, 0x6b, 0x1d, 0x3b, 0xcf, 0x69, 0x16, 0x09, 0xb7, 0x86, 0xea, 0xa0, 0x25, 0x98, + 0xd2, 0x8d, 0xb2, 0xed, 0xa8, 0x7a, 0x55, 0xb5, 0xaa, 0x65, 0xef, 0x40, 0xab, 0xac, 0x56, 0x2a, + 0xd8, 0xb6, 0x0d, 0xb6, 0x10, 0xba, 0x5c, 0x8e, 0xe9, 0xc6, 0x3a, 0x47, 0xf6, 0x56, 0x88, 0x39, + 0x8e, 0x1a, 0x72, 0xdf, 0x68, 0x27, 0xf7, 0x3d, 0x0a, 0xc9, 0x86, 0x6a, 0x96, 0xb1, 0xee, 0x58, + 0x7b, 0xb4, 0x3e, 0x4f, 0x28, 0x89, 0x86, 0x6a, 0x96, 0x48, 0xfb, 0x2d, 0xd9, 0x26, 0x5d, 0x89, + 0x25, 0x12, 0x99, 0xe4, 0x95, 0x58, 0x22, 0x99, 0x01, 0xf9, 0xd5, 0x28, 0xa4, 0xfd, 0xf5, 0x3a, + 0xd9, 0xfe, 0x54, 0xe8, 0x8a, 0x25, 0xd1, 0x9c, 0xf6, 0xc0, 0xbe, 0xd5, 0xfd, 0xcc, 0x3c, 0x59, + 0xca, 0xf2, 0x03, 0xac, 0x38, 0x56, 0x18, 0x25, 0x29, 0x23, 0x88, 0xb3, 0x61, 0x56, 0x8c, 0x24, + 0x14, 0xde, 0x42, 0x0b, 0x30, 0xf0, 0xbc, 0x4d, 0x79, 0x0f, 0x50, 0xde, 0x0f, 0xee, 0xcf, 0xfb, + 0xca, 0x3a, 0x65, 0x9e, 0xbc, 0xb2, 0x5e, 0x5e, 0x59, 0x55, 0x96, 0xe7, 0x96, 0x14, 0x4e, 0x8e, + 0x8e, 0x40, 0xac, 0xae, 0xbe, 0xb0, 0x17, 0x5c, 0xf4, 0x28, 0xa8, 0xd7, 0x49, 0x38, 0x02, 0xb1, + 0x9b, 0x58, 0xbd, 0x1e, 0x5c, 0x6a, 0x28, 0xe8, 0x1e, 0x06, 0xc3, 0x2c, 0xc4, 0xa9, 0xbd, 0x10, + 0x00, 0xb7, 0x58, 0xe6, 0x10, 0x4a, 0x40, 0x6c, 0x7e, 0x55, 0x21, 0x01, 0x91, 0x81, 0x34, 0x83, + 0x96, 0xd7, 0x16, 0x4b, 0xf3, 0xa5, 0x4c, 0x44, 0x3e, 0x0b, 0x03, 0xcc, 0x08, 0x24, 0x58, 0x5c, + 0x33, 0x64, 0x0e, 0xf1, 0x26, 0xe7, 0x21, 0x89, 0xde, 0xcd, 0xe5, 0x42, 0x49, 0xc9, 0x44, 0x82, + 0x53, 0x1d, 0xcb, 0xc4, 0x65, 0x1b, 0xd2, 0xfe, 0x3a, 0xfc, 0xad, 0xd9, 0x8c, 0x7f, 0x43, 0x82, + 0x94, 0xaf, 0xae, 0x26, 0x05, 0x91, 0x5a, 0xaf, 0x1b, 0x37, 0xcb, 0x6a, 0x5d, 0x53, 0x6d, 0xee, + 0x1a, 0x40, 0x41, 0x73, 0x04, 0xd2, 0xeb, 0xd4, 0xbd, 0x45, 0x21, 0x12, 0xcf, 0x0c, 0xc8, 0x5f, + 0x94, 0x20, 0x13, 0x2e, 0x6c, 0x43, 0x62, 0x4a, 0x6f, 0xa7, 0x98, 0xf2, 0x17, 0x24, 0x18, 0x0e, + 0x56, 0xb3, 0x21, 0xf1, 0xee, 0x7f, 0x5b, 0xc5, 0xfb, 0xc3, 0x08, 0x0c, 0x05, 0x6a, 0xd8, 0x5e, + 0xa5, 0xfb, 0x00, 0x8c, 0x6a, 0x55, 0xdc, 0x30, 0x0d, 0x07, 0xeb, 0x95, 0xbd, 0x72, 0x1d, 0xdf, + 0xc0, 0xf5, 0xac, 0x4c, 0x93, 0xc6, 0xec, 0xfe, 0x55, 0xf2, 0xcc, 0xa2, 0x47, 0xb7, 0x44, 0xc8, + 0xf2, 0x63, 0x8b, 0xc5, 0xd2, 0xf2, 0xda, 0xea, 0x46, 0x69, 0x65, 0xfe, 0xbd, 0xe5, 0xcd, 0x95, + 0xab, 0x2b, 0xab, 0xcf, 0xad, 0x28, 0x19, 0x2d, 0x84, 0x76, 0x0f, 0xc3, 0x7e, 0x0d, 0x32, 0x61, + 0xa1, 0xd0, 0x7d, 0xd0, 0x4e, 0xac, 0xcc, 0x21, 0x34, 0x06, 0x23, 0x2b, 0xab, 0xe5, 0xf5, 0xc5, + 0x62, 0xa9, 0x5c, 0xba, 0x74, 0xa9, 0x34, 0xbf, 0xb1, 0xce, 0xce, 0x3d, 0x5c, 0xec, 0x8d, 0x40, + 0x80, 0xcb, 0x9f, 0x8f, 0xc2, 0x58, 0x1b, 0x49, 0xd0, 0x1c, 0xdf, 0xb1, 0xb0, 0x4d, 0xd4, 0x63, + 0xbd, 0x48, 0x3f, 0x43, 0x6a, 0x86, 0x35, 0xd5, 0x72, 0xf8, 0x06, 0xe7, 0x11, 0x20, 0x56, 0xd2, + 0x1d, 0x6d, 0x5b, 0xc3, 0x16, 0x3f, 0x4f, 0x62, 0xdb, 0x98, 0x11, 0x0f, 0xce, 0x8e, 0x94, 0x4e, + 0x01, 0x32, 0x0d, 0x5b, 0x73, 0xb4, 0x1b, 0xb8, 0xac, 0xe9, 0xe2, 0xf0, 0x89, 0x6c, 0x6b, 0x62, + 0x4a, 0x46, 0xf4, 0x2c, 0xea, 0x8e, 0x8b, 0xad, 0xe3, 0x9a, 0x1a, 0xc2, 0x26, 0xc9, 0x3c, 0xaa, + 0x64, 0x44, 0x8f, 0x8b, 0x7d, 0x3f, 0xa4, 0xab, 0x46, 0x93, 0xd4, 0x7a, 0x0c, 0x8f, 0xac, 0x1d, + 0x92, 0x92, 0x62, 0x30, 0x17, 0x85, 0x57, 0xf1, 0xde, 0xa9, 0x57, 0x5a, 0x49, 0x31, 0x18, 0x43, + 0x79, 0x18, 0x46, 0xd4, 0x5a, 0xcd, 0x22, 0xcc, 0x05, 0x23, 0xb6, 0x2f, 0x19, 0x76, 0xc1, 0x14, + 0x31, 0x77, 0x05, 0x12, 0xc2, 0x0e, 0x64, 0xa9, 0x26, 0x96, 0x28, 0x9b, 0x6c, 0xb3, 0x1d, 0x39, + 0x91, 0x54, 0x12, 0xba, 0xe8, 0xbc, 0x1f, 0xd2, 0x9a, 0x5d, 0xf6, 0x0e, 0xf1, 0x23, 0xd3, 0x91, + 0x13, 0x09, 0x25, 0xa5, 0xd9, 0xee, 0x01, 0xa8, 0xfc, 0xd5, 0x08, 0x0c, 0x07, 0x1f, 0x42, 0xa0, + 0x22, 0x24, 0xea, 0x46, 0x45, 0xa5, 0xae, 0xc5, 0x9e, 0x80, 0x9d, 0xe8, 0xf2, 0xdc, 0x62, 0x66, + 0x89, 0xe3, 0x2b, 0x2e, 0x65, 0xee, 0x77, 0x24, 0x48, 0x08, 0x30, 0x9a, 0x80, 0x98, 0xa9, 0x3a, + 0x3b, 0x94, 0x5d, 0xbc, 0x10, 0xc9, 0x48, 0x0a, 0x6d, 0x13, 0xb8, 0x6d, 0xaa, 0x3a, 0x75, 0x01, + 0x0e, 0x27, 0x6d, 0x32, 0xaf, 0x75, 0xac, 0x56, 0xe9, 0xa6, 0xc7, 0x68, 0x34, 0xb0, 0xee, 0xd8, + 0x62, 0x5e, 0x39, 0x7c, 0x9e, 0x83, 0xd1, 0xa3, 0x30, 0xea, 0x58, 0xaa, 0x56, 0x0f, 0xe0, 0xc6, + 0x28, 0x6e, 0x46, 0x74, 0xb8, 0xc8, 0x79, 0x38, 0x22, 0xf8, 0x56, 0xb1, 0xa3, 0x56, 0x76, 0x70, + 0xd5, 0x23, 0x1a, 0xa0, 0x87, 0x1b, 0xf7, 0x71, 0x84, 0x22, 0xef, 0x17, 0xb4, 0xf2, 0x2b, 0x12, + 0x8c, 0x8a, 0x6d, 0x5a, 0xd5, 0x35, 0xd6, 0x32, 0x80, 0xaa, 0xeb, 0x86, 0xe3, 0x37, 0x57, 0xab, + 0x2b, 0xb7, 0xd0, 0xcd, 0xcc, 0xb9, 0x44, 0x8a, 0x8f, 0x41, 0xae, 0x01, 0xe0, 0xf5, 0x74, 0x34, + 0xdb, 0x14, 0xa4, 0xf8, 0x13, 0x26, 0xfa, 0x98, 0x92, 0x6d, 0xec, 0x81, 0x81, 0xc8, 0x7e, 0x0e, + 0x8d, 0x43, 0x7c, 0x0b, 0xd7, 0x34, 0x9d, 0x9f, 0x1b, 0xb3, 0x86, 0x38, 0x7e, 0x89, 0xb9, 0xc7, + 0x2f, 0x85, 0x4f, 0x4a, 0x30, 0x56, 0x31, 0x1a, 0x61, 0x79, 0x0b, 0x99, 0xd0, 0xe9, 0x82, 0x7d, + 0x59, 0x7a, 0xdf, 0xd3, 0x35, 0xcd, 0xd9, 0x69, 0x6e, 0xcd, 0x54, 0x8c, 0xc6, 0x6c, 0xcd, 0xa8, + 0xab, 0x7a, 0xcd, 0x7b, 0xce, 0x4a, 0x7f, 0x54, 0x1e, 0xab, 0x61, 0xfd, 0xb1, 0x9a, 0xe1, 0x7b, + 0xea, 0x7a, 0xd1, 0xfb, 0xf9, 0xa7, 0x92, 0xf4, 0xb3, 0x91, 0xe8, 0xc2, 0x5a, 0xe1, 0x6b, 0x91, + 0xdc, 0x02, 0x1b, 0x6e, 0x4d, 0x98, 0x47, 0xc1, 0xdb, 0x75, 0x5c, 0x21, 0x2a, 0xc3, 0x77, 0x1f, + 0x85, 0xf1, 0x9a, 0x51, 0x33, 0x28, 0xc7, 0x59, 0xf2, 0x8b, 0x3f, 0xb9, 0x4d, 0xba, 0xd0, 0x5c, + 0xd7, 0xc7, 0xbc, 0xf9, 0x15, 0x18, 0xe3, 0xc8, 0x65, 0xfa, 0xe8, 0x88, 0x6d, 0x6c, 0xd0, 0xbe, + 0xa7, 0x6a, 0xd9, 0x5f, 0x79, 0x8d, 0x2e, 0xe8, 0xca, 0x28, 0x27, 0x25, 0x7d, 0x6c, 0xef, 0x93, + 0x57, 0xe0, 0x70, 0x80, 0x1f, 0x0b, 0x5b, 0x6c, 0x75, 0xe1, 0xf8, 0x9b, 0x9c, 0xe3, 0x98, 0x8f, + 0xe3, 0x3a, 0x27, 0xcd, 0xcf, 0xc3, 0x50, 0x3f, 0xbc, 0xfe, 0x25, 0xe7, 0x95, 0xc6, 0x7e, 0x26, + 0x0b, 0x30, 0x42, 0x99, 0x54, 0x9a, 0xb6, 0x63, 0x34, 0x68, 0x4e, 0xdc, 0x9f, 0xcd, 0x6f, 0xbd, + 0xc6, 0xe2, 0x68, 0x98, 0x90, 0xcd, 0xbb, 0x54, 0xf9, 0x3c, 0xd0, 0xa7, 0x65, 0x55, 0x5c, 0xa9, + 0x77, 0xe1, 0xf0, 0x2d, 0x2e, 0x88, 0x8b, 0x9f, 0xbf, 0x06, 0xe3, 0xe4, 0x37, 0x4d, 0x59, 0x7e, + 0x49, 0xba, 0x1f, 0xc1, 0x65, 0x5f, 0xf9, 0x08, 0x0b, 0xd5, 0x31, 0x97, 0x81, 0x4f, 0x26, 0xdf, + 0x2c, 0xd6, 0xb0, 0xe3, 0x60, 0xcb, 0x2e, 0xab, 0xf5, 0x76, 0xe2, 0xf9, 0xce, 0x30, 0xb2, 0x9f, + 0xfb, 0x5e, 0x70, 0x16, 0x17, 0x18, 0xe5, 0x5c, 0xbd, 0x9e, 0xdf, 0x84, 0xfb, 0xda, 0x78, 0x45, + 0x0f, 0x3c, 0x3f, 0xcf, 0x79, 0x8e, 0xb7, 0x78, 0x06, 0x61, 0xbb, 0x06, 0x02, 0xee, 0xce, 0x65, + 0x0f, 0x3c, 0x7f, 0x86, 0xf3, 0x44, 0x9c, 0x56, 0x4c, 0x29, 0xe1, 0x78, 0x05, 0x46, 0x6f, 0x60, + 0x6b, 0xcb, 0xb0, 0xf9, 0xb9, 0x51, 0x0f, 0xec, 0xbe, 0xc0, 0xd9, 0x8d, 0x70, 0x42, 0x7a, 0x90, + 0x44, 0x78, 0x5d, 0x80, 0xc4, 0xb6, 0x5a, 0xc1, 0x3d, 0xb0, 0xb8, 0xc5, 0x59, 0x0c, 0x12, 0x7c, + 0x42, 0x3a, 0x07, 0xe9, 0x9a, 0xc1, 0x57, 0xad, 0xee, 0xe4, 0x5f, 0xe4, 0xe4, 0x29, 0x41, 0xc3, + 0x59, 0x98, 0x86, 0xd9, 0xac, 0x93, 0x25, 0xad, 0x3b, 0x8b, 0xbf, 0x29, 0x58, 0x08, 0x1a, 0xce, + 0xa2, 0x0f, 0xb3, 0x7e, 0x49, 0xb0, 0xb0, 0x7d, 0xf6, 0x7c, 0x06, 0x52, 0x86, 0x5e, 0xdf, 0x33, + 0xf4, 0x5e, 0x84, 0xf8, 0x32, 0xe7, 0x00, 0x9c, 0x84, 0x30, 0xb8, 0x08, 0xc9, 0x5e, 0x27, 0xe2, + 0x6f, 0x7d, 0x4f, 0x84, 0x87, 0x98, 0x81, 0x05, 0x18, 0x11, 0x09, 0x4a, 0x33, 0xf4, 0x1e, 0x58, + 0xfc, 0x6d, 0xce, 0x62, 0xd8, 0x47, 0xc6, 0xd5, 0x70, 0xb0, 0xed, 0xd4, 0x70, 0x2f, 0x4c, 0xbe, + 0x2a, 0xd4, 0xe0, 0x24, 0xdc, 0x94, 0x5b, 0x58, 0xaf, 0xec, 0xf4, 0xc6, 0xe1, 0xe7, 0x85, 0x29, + 0x05, 0x0d, 0x61, 0x31, 0x0f, 0x43, 0x0d, 0xd5, 0xb2, 0x77, 0xd4, 0x7a, 0x4f, 0xd3, 0xf1, 0x77, + 0x38, 0x8f, 0xb4, 0x4b, 0xc4, 0x2d, 0xd2, 0xd4, 0xfb, 0x61, 0xf3, 0x35, 0x61, 0x11, 0x1f, 0x19, + 0x0f, 0x3d, 0xdb, 0xa1, 0x87, 0x6c, 0xfd, 0x70, 0xfb, 0x05, 0x11, 0x7a, 0x8c, 0x76, 0xd9, 0xcf, + 0xf1, 0x22, 0x24, 0x6d, 0xed, 0x85, 0x9e, 0xd8, 0xfc, 0xa2, 0x98, 0x69, 0x4a, 0x40, 0x88, 0xdf, + 0x0b, 0x47, 0xda, 0x2e, 0x13, 0x3d, 0x30, 0xfb, 0xbb, 0x9c, 0xd9, 0x44, 0x9b, 0xa5, 0x82, 0xa7, + 0x84, 0x7e, 0x59, 0xfe, 0x3d, 0x91, 0x12, 0x70, 0x88, 0xd7, 0x1a, 0xd9, 0x47, 0xd8, 0xea, 0x76, + 0x7f, 0x56, 0xfb, 0x25, 0x61, 0x35, 0x46, 0x1b, 0xb0, 0xda, 0x06, 0x4c, 0x70, 0x8e, 0xfd, 0xcd, + 0xeb, 0x2f, 0x8b, 0xc4, 0xca, 0xa8, 0x37, 0x83, 0xb3, 0xfb, 0x7e, 0xc8, 0xb9, 0xe6, 0x14, 0x05, + 0xab, 0x5d, 0x6e, 0xa8, 0x66, 0x0f, 0x9c, 0x7f, 0x85, 0x73, 0x16, 0x19, 0xdf, 0xad, 0x78, 0xed, + 0x65, 0xd5, 0x24, 0xcc, 0xdf, 0x03, 0x59, 0xc1, 0xbc, 0xa9, 0x5b, 0xb8, 0x62, 0xd4, 0x74, 0xed, + 0x05, 0x5c, 0xed, 0x81, 0xf5, 0xaf, 0x86, 0xa6, 0x6a, 0xd3, 0x47, 0x4e, 0x38, 0x2f, 0x42, 0xc6, + 0xad, 0x55, 0xca, 0x5a, 0xc3, 0x34, 0x2c, 0xa7, 0x0b, 0xc7, 0xaf, 0x8b, 0x99, 0x72, 0xe9, 0x16, + 0x29, 0x59, 0xbe, 0x04, 0xec, 0xc9, 0x73, 0xaf, 0x2e, 0xf9, 0x6b, 0x9c, 0xd1, 0x90, 0x47, 0xc5, + 0x13, 0x47, 0xc5, 0x68, 0x98, 0xaa, 0xd5, 0x4b, 0xfe, 0xfb, 0xfb, 0x22, 0x71, 0x70, 0x12, 0x9e, + 0x38, 0x9c, 0x3d, 0x13, 0x93, 0xd5, 0xbe, 0x07, 0x0e, 0xbf, 0x2e, 0x12, 0x87, 0xa0, 0xe1, 0x2c, + 0x44, 0xc1, 0xd0, 0x03, 0x8b, 0x7f, 0x20, 0x58, 0x08, 0x1a, 0xc2, 0xe2, 0x59, 0x6f, 0xa1, 0xb5, + 0x70, 0x4d, 0xb3, 0x1d, 0x8b, 0x95, 0xc9, 0xfb, 0xb3, 0xfa, 0x87, 0xdf, 0x0b, 0x16, 0x61, 0x8a, + 0x8f, 0x94, 0x64, 0x22, 0x7e, 0xec, 0x4a, 0x77, 0x51, 0xdd, 0x05, 0xfb, 0x0d, 0x91, 0x89, 0x7c, + 0x64, 0x44, 0x36, 0x5f, 0x85, 0x48, 0xcc, 0x5e, 0x21, 0x7b, 0x87, 0x1e, 0xd8, 0xfd, 0xa3, 0x90, + 0x70, 0xeb, 0x82, 0x96, 0xf0, 0xf4, 0xd5, 0x3f, 0x4d, 0xfd, 0x3a, 0xde, 0xeb, 0xc9, 0x3b, 0xff, + 0x71, 0xa8, 0xfe, 0xd9, 0x64, 0x94, 0x2c, 0x87, 0x8c, 0x84, 0xea, 0x29, 0xd4, 0xed, 0x9e, 0x51, + 0xf6, 0xc7, 0xde, 0xe0, 0xfa, 0x06, 0xcb, 0xa9, 0xfc, 0x12, 0x71, 0xf2, 0x60, 0xd1, 0xd3, 0x9d, + 0xd9, 0x47, 0xde, 0x70, 0xfd, 0x3c, 0x50, 0xf3, 0xe4, 0x2f, 0xc1, 0x50, 0xa0, 0xe0, 0xe9, 0xce, + 0xea, 0xa3, 0x9c, 0x55, 0xda, 0x5f, 0xef, 0xe4, 0xcf, 0x42, 0x8c, 0x14, 0x2f, 0xdd, 0xc9, 0xff, + 0x32, 0x27, 0xa7, 0xe8, 0xf9, 0x77, 0x41, 0x42, 0x14, 0x2d, 0xdd, 0x49, 0x3f, 0xc6, 0x49, 0x5d, + 0x12, 0x42, 0x2e, 0x0a, 0x96, 0xee, 0xe4, 0x7f, 0x45, 0x90, 0x0b, 0x12, 0x42, 0xde, 0xbb, 0x09, + 0xbf, 0xf1, 0x13, 0x31, 0xbe, 0xe8, 0x08, 0xdb, 0x5d, 0x84, 0x41, 0x5e, 0xa9, 0x74, 0xa7, 0xfe, + 0x04, 0x1f, 0x5c, 0x50, 0xe4, 0x9f, 0x82, 0x78, 0x8f, 0x06, 0xff, 0x49, 0x4e, 0xca, 0xf0, 0xf3, + 0xf3, 0x90, 0xf2, 0x55, 0x27, 0xdd, 0xc9, 0xff, 0x1a, 0x27, 0xf7, 0x53, 0x11, 0xd1, 0x79, 0x75, + 0xd2, 0x9d, 0xc1, 0x27, 0x85, 0xe8, 0x9c, 0x82, 0x98, 0x4d, 0x14, 0x26, 0xdd, 0xa9, 0x3f, 0x25, + 0xac, 0x2e, 0x48, 0xf2, 0xcf, 0x40, 0xd2, 0x5d, 0x6c, 0xba, 0xd3, 0x7f, 0x9a, 0xd3, 0x7b, 0x34, + 0xc4, 0x02, 0xbe, 0xc5, 0xae, 0x3b, 0x8b, 0xbf, 0x2e, 0x2c, 0xe0, 0xa3, 0x22, 0x61, 0x14, 0x2e, + 0x60, 0xba, 0x73, 0xfa, 0x8c, 0x08, 0xa3, 0x50, 0xfd, 0x42, 0x66, 0x93, 0xe6, 0xfc, 0xee, 0x2c, + 0x7e, 0x4a, 0xcc, 0x26, 0xc5, 0x27, 0x62, 0x84, 0x2b, 0x82, 0xee, 0x3c, 0xfe, 0x86, 0x10, 0x23, + 0x54, 0x10, 0xe4, 0xd7, 0x00, 0xb5, 0x56, 0x03, 0xdd, 0xf9, 0x7d, 0x96, 0xf3, 0x1b, 0x6d, 0x29, + 0x06, 0xf2, 0xcf, 0xc1, 0x44, 0xfb, 0x4a, 0xa0, 0x3b, 0xd7, 0xcf, 0xbd, 0x11, 0xda, 0xbb, 0xf9, + 0x0b, 0x81, 0xfc, 0x86, 0xb7, 0xa4, 0xf8, 0xab, 0x80, 0xee, 0x6c, 0x3f, 0xff, 0x46, 0x30, 0x71, + 0xfb, 0x8b, 0x80, 0xfc, 0x1c, 0x80, 0xb7, 0x00, 0x77, 0xe7, 0xf5, 0x05, 0xce, 0xcb, 0x47, 0x44, + 0x42, 0x83, 0xaf, 0xbf, 0xdd, 0xe9, 0x6f, 0x89, 0xd0, 0xe0, 0x14, 0x24, 0x34, 0xc4, 0xd2, 0xdb, + 0x9d, 0xfa, 0x8b, 0x22, 0x34, 0x04, 0x09, 0xf1, 0x6c, 0xdf, 0xea, 0xd6, 0x9d, 0xc3, 0x97, 0x85, + 0x67, 0xfb, 0xa8, 0xf2, 0x2b, 0x30, 0xda, 0xb2, 0x20, 0x76, 0x67, 0xf5, 0xb3, 0x9c, 0x55, 0x26, + 0xbc, 0x1e, 0xfa, 0x17, 0x2f, 0xbe, 0x18, 0x76, 0xe7, 0xf6, 0x95, 0xd0, 0xe2, 0xc5, 0xd7, 0xc2, + 0xfc, 0x45, 0x48, 0xe8, 0xcd, 0x7a, 0x9d, 0x04, 0x0f, 0xda, 0xff, 0x6e, 0x60, 0xf6, 0x3f, 0xff, + 0x80, 0x5b, 0x47, 0x10, 0xe4, 0xcf, 0x42, 0x1c, 0x37, 0xb6, 0x70, 0xb5, 0x1b, 0xe5, 0x77, 0x7f, + 0x20, 0x12, 0x26, 0xc1, 0xce, 0x3f, 0x03, 0xc0, 0x8e, 0x46, 0xe8, 0xe3, 0xc1, 0x2e, 0xb4, 0xff, + 0xe5, 0x07, 0xfc, 0x32, 0x8e, 0x47, 0xe2, 0x31, 0x60, 0x57, 0x7b, 0xf6, 0x67, 0xf0, 0xbd, 0x20, + 0x03, 0x3a, 0x23, 0x17, 0x60, 0xf0, 0x79, 0xdb, 0xd0, 0x1d, 0xb5, 0xd6, 0x8d, 0xfa, 0xbf, 0x72, + 0x6a, 0x81, 0x4f, 0x0c, 0xd6, 0x30, 0x2c, 0xec, 0xa8, 0x35, 0xbb, 0x1b, 0xed, 0x7f, 0xe3, 0xb4, + 0x2e, 0x01, 0x21, 0xae, 0xa8, 0xb6, 0xd3, 0x8b, 0xde, 0xff, 0x5d, 0x10, 0x0b, 0x02, 0x22, 0x34, + 0xf9, 0x7d, 0x1d, 0xef, 0x75, 0xa3, 0xfd, 0xbe, 0x10, 0x9a, 0xe3, 0xe7, 0xdf, 0x05, 0x49, 0xf2, + 0x93, 0xdd, 0xb0, 0xeb, 0x42, 0xfc, 0xc7, 0x9c, 0xd8, 0xa3, 0x20, 0x23, 0xdb, 0x4e, 0xd5, 0xd1, + 0xba, 0x1b, 0xfb, 0x0e, 0x9f, 0x69, 0x81, 0x9f, 0x9f, 0x83, 0x94, 0xed, 0x54, 0xab, 0x4d, 0x5e, + 0x9f, 0x76, 0x21, 0xff, 0x1f, 0x3f, 0x70, 0x8f, 0x2c, 0x5c, 0x1a, 0x32, 0xdb, 0x37, 0xaf, 0x3b, + 0xa6, 0x41, 0x1f, 0x81, 0x74, 0xe3, 0xf0, 0x06, 0xe7, 0xe0, 0x23, 0xc9, 0xcf, 0x43, 0x9a, 0xe8, + 0x62, 0x61, 0x13, 0xd3, 0xe7, 0x55, 0x5d, 0x58, 0xfc, 0x4f, 0x6e, 0x80, 0x00, 0x51, 0xe1, 0x47, + 0xbf, 0xf5, 0xea, 0xa4, 0xf4, 0xf2, 0xab, 0x93, 0xd2, 0x1f, 0xbe, 0x3a, 0x29, 0x7d, 0xea, 0x3b, + 0x93, 0x87, 0x5e, 0xfe, 0xce, 0xe4, 0xa1, 0xdf, 0xfb, 0xce, 0xe4, 0xa1, 0xf6, 0xc7, 0xc6, 0xb0, + 0x60, 0x2c, 0x18, 0xec, 0xc0, 0xf8, 0x7d, 0x72, 0xe0, 0xb8, 0xb8, 0x66, 0x78, 0xa7, 0xb5, 0xee, + 0x26, 0x07, 0x3e, 0x1a, 0x85, 0xc9, 0x8a, 0x61, 0x37, 0x0c, 0x7b, 0x76, 0x4b, 0xb5, 0xf1, 0xec, + 0x8d, 0x27, 0xb6, 0xb0, 0xa3, 0x3e, 0x31, 0x5b, 0x31, 0x34, 0x9d, 0x1f, 0xfb, 0x8e, 0xb1, 0xfe, + 0x19, 0xd2, 0x3f, 0xc3, 0xfb, 0x73, 0x6d, 0x4f, 0x88, 0xe5, 0x05, 0x88, 0xcd, 0x1b, 0x9a, 0x8e, + 0xc6, 0x21, 0x5e, 0xc5, 0xba, 0xd1, 0xe0, 0x17, 0xc0, 0x58, 0x03, 0x3d, 0x00, 0x03, 0x6a, 0xc3, + 0x68, 0xea, 0x0e, 0x3b, 0x2e, 0x2f, 0xa4, 0xbe, 0x75, 0x7b, 0xea, 0xd0, 0xef, 0xdf, 0x9e, 0x8a, + 0x2e, 0xea, 0x8e, 0xc2, 0xbb, 0xf2, 0xb1, 0xd7, 0xbf, 0x34, 0x25, 0xc9, 0x57, 0x60, 0xb0, 0x88, + 0x2b, 0x07, 0xe1, 0x55, 0xc4, 0x95, 0x10, 0xaf, 0x47, 0x20, 0xb1, 0xa8, 0x3b, 0xec, 0x8a, 0xde, + 0x71, 0x88, 0x6a, 0x3a, 0xbb, 0xf5, 0x11, 0x1a, 0x9f, 0xc0, 0x09, 0x6a, 0x11, 0x57, 0x5c, 0xd4, + 0x2a, 0xae, 0x84, 0x51, 0x09, 0x7b, 0x02, 0x2f, 0x14, 0x7f, 0xef, 0x3f, 0x4e, 0x1e, 0x7a, 0xf1, + 0xd5, 0xc9, 0x43, 0x9d, 0xe6, 0x27, 0x60, 0x7e, 0x6e, 0x62, 0xf6, 0xe7, 0x31, 0xbb, 0x7a, 0x7d, + 0x96, 0x84, 0x96, 0xbd, 0x35, 0xc0, 0x6e, 0x35, 0xc3, 0xa7, 0x22, 0x30, 0x15, 0x3e, 0x52, 0x27, + 0x7e, 0x6c, 0x3b, 0x6a, 0xc3, 0xec, 0xf4, 0xe2, 0xd4, 0x45, 0x48, 0x6e, 0x08, 0x1c, 0x94, 0x85, + 0x41, 0x1b, 0x57, 0x0c, 0xbd, 0x6a, 0x53, 0x91, 0xa3, 0x8a, 0x68, 0x12, 0x03, 0xea, 0xaa, 0x6e, + 0xd8, 0xfc, 0xba, 0x26, 0x6b, 0x14, 0x7e, 0x5a, 0xea, 0xcf, 0xb1, 0x86, 0xdd, 0xa1, 0xa8, 0x79, + 0xd6, 0xa4, 0xf7, 0x3d, 0xba, 0xdf, 0xd3, 0x08, 0xaa, 0x9e, 0xa7, 0x82, 0xef, 0xd1, 0xc3, 0x64, + 0xf8, 0xd1, 0xc3, 0x73, 0xb8, 0x5e, 0xbf, 0xaa, 0x1b, 0x37, 0xf5, 0x8d, 0x80, 0x49, 0xfe, 0x8d, + 0x04, 0xd3, 0xf4, 0xc2, 0xba, 0xd5, 0xd0, 0x74, 0x67, 0xb6, 0xae, 0x6d, 0xd9, 0xb3, 0x5b, 0x9a, + 0x63, 0x33, 0xcb, 0x71, 0x9b, 0x8c, 0x7b, 0x18, 0x33, 0x04, 0x63, 0x86, 0x60, 0xc8, 0x67, 0x20, + 0x51, 0xd0, 0x9c, 0x39, 0xcb, 0x52, 0xf7, 0x10, 0x82, 0x18, 0x81, 0x71, 0xa3, 0xd0, 0xdf, 0xc4, + 0x22, 0xb8, 0x8e, 0x1b, 0x36, 0x7d, 0xe8, 0x15, 0x53, 0x58, 0xa3, 0xb0, 0xd9, 0x71, 0x26, 0x2f, + 0xfa, 0x34, 0xf5, 0x89, 0xe4, 0xfb, 0xc9, 0x22, 0xa1, 0x9d, 0xb8, 0xae, 0x3e, 0x5f, 0x8b, 0xc1, + 0x71, 0x1f, 0x42, 0xc5, 0xda, 0x33, 0x1d, 0x1a, 0x92, 0xc6, 0x36, 0x57, 0x66, 0xd4, 0xa7, 0x0c, + 0xeb, 0xee, 0x10, 0x66, 0xdb, 0x10, 0x5f, 0x23, 0x74, 0x44, 0x11, 0xc7, 0x70, 0xd4, 0x3a, 0xd7, + 0x8e, 0x35, 0x08, 0x94, 0x5d, 0xda, 0x8f, 0x30, 0xa8, 0x26, 0xee, 0xeb, 0xd7, 0xb1, 0xba, 0xcd, + 0xee, 0x3e, 0x46, 0xe9, 0xb3, 0xcf, 0x04, 0x01, 0xd0, 0x6b, 0x8e, 0xe3, 0x10, 0x57, 0x9b, 0xec, + 0xb1, 0x5d, 0xf4, 0x44, 0x5a, 0x61, 0x0d, 0xf9, 0x2a, 0x0c, 0xf2, 0x47, 0x05, 0x28, 0x03, 0xd1, + 0xeb, 0x78, 0x8f, 0x8e, 0x93, 0x56, 0xc8, 0x4f, 0x34, 0x03, 0x71, 0x2a, 0x3c, 0xbf, 0xd4, 0x9d, + 0x9d, 0x69, 0x91, 0x7e, 0x86, 0x0a, 0xa9, 0x30, 0x34, 0xf9, 0x0a, 0x24, 0x8a, 0x46, 0x43, 0xd3, + 0x8d, 0x20, 0xb7, 0x24, 0xe3, 0x46, 0x65, 0x36, 0x9b, 0x3c, 0x9c, 0x15, 0xd6, 0x40, 0x13, 0x30, + 0xc0, 0xee, 0xc2, 0xf2, 0x47, 0x8f, 0xbc, 0x25, 0xcf, 0xc3, 0x20, 0xe5, 0xbd, 0x6a, 0x92, 0xf9, + 0x75, 0x2f, 0x22, 0x25, 0xf9, 0x9b, 0x11, 0x9c, 0x7d, 0xc4, 0x13, 0x16, 0x41, 0xac, 0xaa, 0x3a, + 0x2a, 0xd7, 0x9b, 0xfe, 0x96, 0x9f, 0x86, 0x04, 0x67, 0x62, 0xa3, 0xd3, 0x10, 0x35, 0x4c, 0x9b, + 0x3f, 0x3c, 0xcc, 0x75, 0x52, 0x65, 0xd5, 0x2c, 0xc4, 0x48, 0x22, 0x50, 0x08, 0x72, 0x41, 0xe9, + 0xe8, 0x2f, 0xe7, 0xfb, 0xf7, 0x17, 0x36, 0x8c, 0xeb, 0x2c, 0x5f, 0x8e, 0xc0, 0xa4, 0xaf, 0xf7, + 0x06, 0xb6, 0x48, 0xbd, 0x1c, 0x70, 0x7d, 0xe4, 0x13, 0x92, 0xf7, 0x77, 0x70, 0x97, 0x77, 0x41, + 0x74, 0xce, 0x34, 0x51, 0x0e, 0x12, 0xec, 0x21, 0xa1, 0xc1, 0xfc, 0x25, 0xa6, 0xb8, 0x6d, 0xd2, + 0x67, 0x1b, 0xdb, 0xce, 0x4d, 0xd5, 0x72, 0x5f, 0x17, 0x11, 0x6d, 0xf9, 0x02, 0x24, 0xe7, 0x0d, + 0xdd, 0xc6, 0xba, 0xdd, 0xa4, 0xa1, 0xb3, 0x55, 0x37, 0x2a, 0xd7, 0x39, 0x07, 0xd6, 0x20, 0x06, + 0x57, 0x4d, 0x93, 0x52, 0xc6, 0x14, 0xf2, 0x93, 0xa5, 0xde, 0xc2, 0x7a, 0x47, 0x13, 0x5d, 0xe8, + 0xdf, 0x44, 0x5c, 0x49, 0xd7, 0x46, 0x7f, 0x20, 0xc1, 0xb1, 0xd6, 0x80, 0xba, 0x8e, 0xf7, 0xec, + 0x7e, 0xe3, 0xe9, 0x3c, 0x24, 0xd7, 0xe8, 0x3b, 0x9b, 0x57, 0xf1, 0x1e, 0xca, 0xc1, 0x20, 0xae, + 0x9e, 0x3e, 0x7b, 0xf6, 0x89, 0x0b, 0xcc, 0xdb, 0x2f, 0x1f, 0x52, 0x04, 0x20, 0x9f, 0x20, 0x5a, + 0xbd, 0xfe, 0xe5, 0x29, 0xa9, 0x10, 0x87, 0xa8, 0xdd, 0x6c, 0xdc, 0x53, 0x1f, 0xf8, 0x7c, 0x3c, + 0x90, 0x00, 0x59, 0x46, 0xbd, 0xa1, 0xd6, 0xb5, 0xaa, 0xea, 0xbd, 0x4d, 0x9b, 0xf1, 0xe9, 0x48, + 0x31, 0xda, 0xab, 0x98, 0xdb, 0xd7, 0x52, 0xf2, 0xaf, 0x4a, 0x90, 0xbe, 0x26, 0x38, 0xaf, 0x63, + 0x07, 0x5d, 0x04, 0x70, 0x47, 0x12, 0x61, 0x71, 0x74, 0x26, 0x3c, 0xd6, 0x8c, 0x4b, 0xa3, 0xf8, + 0xd0, 0xd1, 0x53, 0xd4, 0xd1, 0x4c, 0xc3, 0xe6, 0xaf, 0x08, 0x74, 0x21, 0x75, 0x91, 0xd1, 0x29, + 0x40, 0x34, 0x83, 0x95, 0x6f, 0x18, 0x8e, 0xa6, 0xd7, 0xca, 0xa6, 0x71, 0x93, 0xbf, 0x78, 0x15, + 0x55, 0x32, 0xb4, 0xe7, 0x1a, 0xed, 0x58, 0x23, 0x70, 0x22, 0x74, 0xd2, 0xe5, 0x42, 0xd6, 0x3f, + 0xb5, 0x5a, 0xb5, 0xb0, 0x6d, 0xf3, 0x24, 0x25, 0x9a, 0xe8, 0x22, 0x0c, 0x9a, 0xcd, 0xad, 0xb2, + 0xc8, 0x08, 0xa9, 0xd3, 0xc7, 0xda, 0xc5, 0xb7, 0x98, 0x7f, 0x1e, 0xe1, 0x03, 0x66, 0x73, 0x8b, + 0x78, 0xc3, 0xfd, 0x90, 0x6e, 0x23, 0x4c, 0xea, 0x86, 0x27, 0x07, 0x7d, 0x15, 0x98, 0x6b, 0x50, + 0x36, 0x2d, 0xcd, 0xb0, 0x34, 0x67, 0x8f, 0x3e, 0xe1, 0x8f, 0x2a, 0x19, 0xd1, 0xb1, 0xc6, 0xe1, + 0xf2, 0x75, 0x18, 0x59, 0xd7, 0x1a, 0x26, 0xbd, 0x93, 0xc2, 0x25, 0x3f, 0xeb, 0xc9, 0x27, 0x75, + 0x97, 0xaf, 0xa3, 0x64, 0x91, 0x16, 0xc9, 0x0a, 0xcf, 0x76, 0xf4, 0xce, 0xa7, 0xfa, 0xf7, 0xce, + 0x60, 0xc1, 0xf2, 0x27, 0xb9, 0x40, 0xf0, 0xf1, 0xe5, 0xde, 0x97, 0x9e, 0x7a, 0x75, 0xcc, 0x6e, + 0x65, 0x4f, 0xae, 0x6b, 0x11, 0x90, 0xdb, 0x7f, 0x59, 0xcd, 0x75, 0x49, 0xa4, 0xb9, 0xae, 0x41, + 0x26, 0x5f, 0x80, 0xa1, 0x35, 0xd5, 0x72, 0xd6, 0xb1, 0x73, 0x19, 0xab, 0x55, 0x6c, 0x05, 0xd7, + 0xdd, 0x21, 0xb1, 0xee, 0x22, 0x88, 0xd1, 0xc5, 0x95, 0xad, 0x3b, 0xf4, 0xb7, 0xbc, 0x03, 0x31, + 0x7a, 0x0f, 0xc8, 0x5d, 0x93, 0x39, 0x05, 0x5b, 0x93, 0x49, 0x36, 0xdd, 0x73, 0xb0, 0xcd, 0x49, + 0x58, 0x03, 0x9d, 0x11, 0x2b, 0x6b, 0x74, 0xff, 0x95, 0x95, 0xbb, 0x2a, 0x5f, 0x5f, 0xeb, 0x30, + 0x58, 0x20, 0xc9, 0x78, 0xb1, 0xe8, 0x0a, 0x22, 0x79, 0x82, 0xa0, 0x65, 0x18, 0x31, 0x55, 0xcb, + 0xa1, 0x17, 0xa0, 0x77, 0xa8, 0x16, 0x3c, 0x1a, 0xa6, 0x5a, 0x63, 0x33, 0xa0, 0x2c, 0x1f, 0x65, + 0xc8, 0xf4, 0x03, 0xe5, 0x3f, 0x8a, 0xc1, 0x00, 0x37, 0xc6, 0xbb, 0x60, 0x90, 0x9b, 0x95, 0xfb, + 0xef, 0xf1, 0x99, 0xd6, 0xa5, 0x69, 0xc6, 0x5d, 0x42, 0x38, 0x3f, 0x41, 0x83, 0x1e, 0x82, 0x44, + 0x65, 0x47, 0xd5, 0xf4, 0xb2, 0x56, 0x15, 0xb5, 0xfc, 0xab, 0xb7, 0xa7, 0x06, 0xe7, 0x09, 0x6c, + 0xb1, 0xa8, 0x0c, 0xd2, 0xce, 0xc5, 0x2a, 0xa9, 0x05, 0x76, 0xb0, 0x56, 0xdb, 0x71, 0x78, 0x0c, + 0xf2, 0x16, 0x3a, 0x0f, 0x31, 0xe2, 0x32, 0xfc, 0xf5, 0x98, 0x5c, 0xcb, 0x1e, 0xcb, 0xad, 0x5b, + 0x0b, 0x09, 0x32, 0xf0, 0xa7, 0xbe, 0x3d, 0x25, 0x29, 0x94, 0x02, 0xcd, 0xc3, 0x50, 0x5d, 0xb5, + 0x9d, 0x32, 0x5d, 0xc3, 0xc8, 0xf0, 0x71, 0xca, 0xe2, 0x48, 0xab, 0x41, 0xb8, 0x61, 0xb9, 0xe8, + 0x29, 0x42, 0xc5, 0x40, 0x55, 0x74, 0x02, 0x32, 0x94, 0x49, 0xc5, 0x68, 0x34, 0x34, 0x87, 0x55, + 0x57, 0x03, 0xd4, 0xee, 0xc3, 0x04, 0x3e, 0x4f, 0xc1, 0xb4, 0xc6, 0x3a, 0x0a, 0x49, 0x7a, 0x21, + 0x9f, 0xa2, 0xb0, 0xcb, 0x67, 0x09, 0x02, 0xa0, 0x9d, 0x0f, 0xc3, 0x88, 0x97, 0x41, 0x19, 0x4a, + 0x82, 0x71, 0xf1, 0xc0, 0x14, 0xf1, 0x71, 0x18, 0xd7, 0xf1, 0x2e, 0xbd, 0x0e, 0x17, 0xc0, 0x4e, + 0x52, 0x6c, 0x44, 0xfa, 0xae, 0x05, 0x29, 0xde, 0x01, 0xc3, 0x15, 0x61, 0x7c, 0x86, 0x0b, 0x14, + 0x77, 0xc8, 0x85, 0x52, 0xb4, 0x23, 0x90, 0x50, 0x4d, 0x93, 0x21, 0xa4, 0x78, 0x06, 0x35, 0x4d, + 0xda, 0x75, 0x12, 0x46, 0xa9, 0x8e, 0x16, 0xb6, 0x9b, 0x75, 0x87, 0x33, 0x49, 0x53, 0x9c, 0x11, + 0xd2, 0xa1, 0x30, 0x38, 0xc5, 0x7d, 0x00, 0x86, 0xf0, 0x0d, 0xad, 0x8a, 0xf5, 0x0a, 0x66, 0x78, + 0x43, 0x14, 0x2f, 0x2d, 0x80, 0x14, 0xe9, 0x11, 0x70, 0x33, 0x63, 0x59, 0x64, 0xed, 0x61, 0xc6, + 0x4f, 0xc0, 0xe7, 0x18, 0x58, 0x3e, 0x05, 0xb1, 0xa2, 0xea, 0xa8, 0xa4, 0xc4, 0x70, 0x76, 0xd9, + 0x52, 0x94, 0x56, 0xc8, 0xcf, 0xb6, 0xe1, 0xf6, 0x7a, 0x04, 0x62, 0xd7, 0x0c, 0x07, 0xa3, 0x27, + 0x7d, 0x65, 0xe1, 0x70, 0x3b, 0x1f, 0x5f, 0xd7, 0x6a, 0x3a, 0xae, 0x2e, 0xdb, 0x35, 0xdf, 0x1b, + 0xb5, 0x9e, 0x8b, 0x45, 0x02, 0x2e, 0x36, 0x0e, 0x71, 0xcb, 0x68, 0xea, 0x55, 0x71, 0x97, 0x8b, + 0x36, 0x50, 0x09, 0x12, 0xae, 0xe7, 0xc4, 0xba, 0x79, 0xce, 0x08, 0xf1, 0x1c, 0xe2, 0xd7, 0x1c, + 0xa0, 0x0c, 0x6e, 0x71, 0x07, 0x2a, 0x40, 0xd2, 0x4d, 0x79, 0xdc, 0x03, 0x7b, 0x73, 0x62, 0x8f, + 0x8c, 0x2c, 0x41, 0xae, 0x3f, 0xb8, 0x06, 0x65, 0x5e, 0x98, 0x71, 0x3b, 0xb8, 0x45, 0x03, 0xae, + 0xc6, 0xdf, 0xee, 0x1d, 0xa4, 0x7a, 0x79, 0xae, 0xc6, 0xde, 0xf0, 0x3d, 0x06, 0x49, 0x5b, 0xab, + 0xe9, 0xaa, 0xd3, 0xb4, 0x30, 0xf7, 0x46, 0x0f, 0x20, 0x7f, 0x3a, 0x02, 0x03, 0xcc, 0xbb, 0x7d, + 0x76, 0x93, 0xda, 0xdb, 0x2d, 0xd2, 0xc9, 0x6e, 0xd1, 0x83, 0xdb, 0x6d, 0x0e, 0xc0, 0x15, 0xc6, + 0xe6, 0x2f, 0x5d, 0xb6, 0xa9, 0x33, 0x98, 0x88, 0xeb, 0x5a, 0x8d, 0x07, 0xaf, 0x8f, 0xc8, 0xf5, + 0xa0, 0xb8, 0x2f, 0x4f, 0x5e, 0x84, 0xe4, 0x96, 0xe6, 0x94, 0x55, 0xb2, 0x79, 0xa4, 0x26, 0x4c, + 0x9d, 0x9e, 0x9c, 0x69, 0xb7, 0xcb, 0x9c, 0x11, 0x5b, 0x4c, 0x25, 0xb1, 0xc5, 0x7f, 0xc9, 0x7f, + 0x20, 0x91, 0x5a, 0x99, 0x0f, 0x88, 0xe6, 0x60, 0x48, 0x28, 0x5a, 0xde, 0xae, 0xab, 0x35, 0xee, + 0x8c, 0xc7, 0x3b, 0x6a, 0x7b, 0xa9, 0xae, 0xd6, 0x94, 0x14, 0x57, 0x90, 0x34, 0xda, 0x4f, 0x6c, + 0xa4, 0xc3, 0xc4, 0x06, 0x3c, 0x29, 0x7a, 0x30, 0x4f, 0x0a, 0xcc, 0x79, 0x2c, 0x3c, 0xe7, 0x5f, + 0x8f, 0xd0, 0x3d, 0x93, 0x69, 0xd8, 0x6a, 0xfd, 0xad, 0x08, 0xb1, 0xa3, 0x90, 0x34, 0x8d, 0x7a, + 0x99, 0xf5, 0xb0, 0x4b, 0x93, 0x09, 0xd3, 0xa8, 0x2b, 0x2d, 0x7e, 0x14, 0xbf, 0x4b, 0xf1, 0x37, + 0x70, 0x17, 0xac, 0x36, 0x18, 0xb6, 0x9a, 0x05, 0x69, 0x66, 0x0a, 0xbe, 0x60, 0x3e, 0x4e, 0x6c, + 0x40, 0x57, 0x60, 0xa9, 0x75, 0x81, 0x67, 0x62, 0x33, 0x4c, 0x85, 0xe3, 0x11, 0x0a, 0xb6, 0xbe, + 0xb4, 0xdb, 0x6c, 0xfb, 0xfd, 0x5c, 0xe1, 0x78, 0xf2, 0x4f, 0x4b, 0x00, 0x4b, 0xc4, 0xb2, 0x54, + 0x5f, 0xb2, 0xd4, 0xd9, 0x54, 0x84, 0x72, 0x60, 0xe4, 0xc9, 0x4e, 0x93, 0xc6, 0xc7, 0x4f, 0xdb, + 0x7e, 0xb9, 0xe7, 0x61, 0xc8, 0x73, 0x46, 0x1b, 0x0b, 0x61, 0x26, 0xf7, 0x29, 0xee, 0xd7, 0xb1, + 0xa3, 0xa4, 0x6f, 0xf8, 0x5a, 0xf2, 0x3f, 0x93, 0x20, 0x49, 0x65, 0x5a, 0xc6, 0x8e, 0x1a, 0x98, + 0x43, 0xe9, 0xe0, 0x73, 0x78, 0x1c, 0x80, 0xb1, 0xb1, 0xb5, 0x17, 0x30, 0xf7, 0xac, 0x24, 0x85, + 0xac, 0x6b, 0x2f, 0x60, 0x74, 0xce, 0x35, 0x78, 0x74, 0x7f, 0x83, 0x8b, 0xe2, 0x9f, 0x9b, 0xfd, + 0x3e, 0x18, 0xa4, 0x5f, 0x3d, 0xd9, 0xb5, 0x79, 0x3d, 0x3f, 0xa0, 0x37, 0x1b, 0x1b, 0xbb, 0xb6, + 0xfc, 0x3c, 0x0c, 0x6e, 0xec, 0xb2, 0x23, 0x98, 0xa3, 0x90, 0xb4, 0x0c, 0x83, 0x2f, 0xfc, 0xac, + 0xe0, 0x4a, 0x10, 0x00, 0x5d, 0xe7, 0xc4, 0xb1, 0x43, 0xc4, 0x3b, 0x76, 0xf0, 0xce, 0x4d, 0xa2, + 0x3d, 0x9d, 0x9b, 0x9c, 0xfc, 0x77, 0x12, 0xa4, 0x7c, 0xf9, 0x01, 0x3d, 0x01, 0x87, 0x0b, 0x4b, + 0xab, 0xf3, 0x57, 0xcb, 0x8b, 0xc5, 0xf2, 0xa5, 0xa5, 0xb9, 0x05, 0xef, 0xb5, 0x80, 0xdc, 0xc4, + 0x4b, 0xb7, 0xa6, 0x91, 0x0f, 0x77, 0x53, 0xbf, 0xae, 0x1b, 0x37, 0x75, 0x34, 0x0b, 0xe3, 0x41, + 0x92, 0xb9, 0xc2, 0x7a, 0x69, 0x65, 0x23, 0x23, 0xe5, 0x0e, 0xbf, 0x74, 0x6b, 0x7a, 0xd4, 0x47, + 0x31, 0xb7, 0x65, 0x63, 0xdd, 0x69, 0x25, 0x98, 0x5f, 0x5d, 0x5e, 0x5e, 0xdc, 0xc8, 0x44, 0x5a, + 0x08, 0xf8, 0x0a, 0xf0, 0x08, 0x8c, 0x06, 0x09, 0x56, 0x16, 0x97, 0x32, 0xd1, 0x1c, 0x7a, 0xe9, + 0xd6, 0xf4, 0xb0, 0x0f, 0x7b, 0x45, 0xab, 0xe7, 0x12, 0x1f, 0xff, 0xca, 0xe4, 0xa1, 0x9f, 0xff, + 0xb9, 0x49, 0x89, 0x68, 0x36, 0x14, 0xc8, 0x11, 0xe8, 0x14, 0xdc, 0xb7, 0xbe, 0xb8, 0xb0, 0x52, + 0x2a, 0x96, 0x97, 0xd7, 0x17, 0xca, 0xec, 0x73, 0x08, 0xae, 0x76, 0x23, 0x2f, 0xdd, 0x9a, 0x4e, + 0x71, 0x95, 0x3a, 0x61, 0xaf, 0x29, 0xa5, 0x6b, 0xab, 0x1b, 0xa5, 0x8c, 0xc4, 0xb0, 0xd7, 0x2c, + 0x7c, 0xc3, 0x70, 0xd8, 0x67, 0x91, 0x1e, 0x87, 0x23, 0x6d, 0xb0, 0x5d, 0xc5, 0x46, 0x5f, 0xba, + 0x35, 0x3d, 0xb4, 0x66, 0x61, 0x16, 0x3f, 0x94, 0x62, 0x06, 0xb2, 0xad, 0x14, 0xab, 0x6b, 0xab, + 0xeb, 0x73, 0x4b, 0x99, 0xe9, 0x5c, 0xe6, 0xa5, 0x5b, 0xd3, 0x69, 0x91, 0x0c, 0x09, 0xbe, 0xa7, + 0xd9, 0xbd, 0xdc, 0x78, 0xfd, 0xd5, 0x08, 0x4c, 0xb6, 0x5c, 0xbe, 0xe6, 0x8f, 0x2c, 0x3a, 0x1d, + 0x14, 0xe7, 0x21, 0x51, 0x14, 0x4f, 0x42, 0xfa, 0x3d, 0x27, 0xfe, 0xa9, 0x3e, 0xcf, 0x89, 0x87, + 0xc4, 0x48, 0xe2, 0x98, 0xf8, 0x64, 0xf7, 0x63, 0x62, 0x21, 0xff, 0x01, 0x4e, 0x89, 0xbf, 0x7d, + 0x0a, 0x1e, 0xe4, 0x87, 0xeb, 0xb6, 0xa3, 0x5e, 0xd7, 0xf4, 0x9a, 0xfb, 0x08, 0x83, 0xb7, 0xb9, + 0x51, 0x26, 0xf8, 0x53, 0x0c, 0x01, 0xdd, 0xf7, 0x41, 0x46, 0x6e, 0xdf, 0xbd, 0x6d, 0xf7, 0x3d, + 0x6b, 0x97, 0x19, 0xca, 0x75, 0x79, 0xe4, 0x22, 0x7f, 0x42, 0x82, 0xe1, 0xcb, 0x9a, 0xed, 0x18, + 0x96, 0x56, 0x51, 0xeb, 0xf4, 0x2d, 0x87, 0x73, 0xbd, 0x2e, 0x1a, 0xa1, 0x1c, 0xf6, 0x0c, 0x0c, + 0xdc, 0x50, 0xeb, 0x2c, 0x5b, 0x47, 0xe9, 0x47, 0x19, 0xda, 0x1b, 0xc2, 0xcb, 0xd9, 0x82, 0x01, + 0x23, 0x93, 0x7f, 0x29, 0x02, 0x23, 0x34, 0xca, 0x6d, 0xf6, 0xb9, 0x1e, 0xb2, 0x43, 0x2d, 0x40, + 0xcc, 0x52, 0x1d, 0x7e, 0xe8, 0x5a, 0x98, 0xe1, 0x0f, 0x47, 0x1e, 0xea, 0xfe, 0xc0, 0x63, 0xa6, + 0x88, 0x2b, 0x0a, 0xa5, 0x45, 0x3f, 0x02, 0x89, 0x86, 0xba, 0x5b, 0xa6, 0x7c, 0xd8, 0xbe, 0x6f, + 0xae, 0x3f, 0x3e, 0x77, 0x6e, 0x4f, 0x8d, 0xec, 0xa9, 0x8d, 0x7a, 0x5e, 0x16, 0x7c, 0x64, 0x65, + 0xb0, 0xa1, 0xee, 0x12, 0x11, 0x91, 0x09, 0x23, 0x04, 0x5a, 0xd9, 0x51, 0xf5, 0x1a, 0x66, 0x83, + 0xd0, 0x23, 0xe4, 0xc2, 0xe5, 0xbe, 0x07, 0x99, 0xf0, 0x06, 0xf1, 0xb1, 0x93, 0x95, 0xa1, 0x86, + 0xba, 0x3b, 0x4f, 0x01, 0x64, 0xc4, 0x7c, 0xe2, 0xb3, 0x5f, 0x9a, 0x3a, 0x44, 0x1f, 0x38, 0xbd, + 0x22, 0x01, 0x78, 0x16, 0x43, 0x3f, 0x02, 0x99, 0x8a, 0xdb, 0xa2, 0xb4, 0x36, 0x9f, 0xc3, 0x87, + 0x3b, 0xcd, 0x45, 0xc8, 0xde, 0xac, 0xe8, 0x78, 0xf9, 0xf6, 0x94, 0xa4, 0x8c, 0x54, 0x42, 0x53, + 0xf1, 0x7e, 0x48, 0x35, 0xcd, 0xaa, 0xea, 0xe0, 0x32, 0xdd, 0x05, 0x47, 0xba, 0x16, 0x30, 0x93, + 0x84, 0xd7, 0x9d, 0xdb, 0x53, 0x88, 0xa9, 0xe5, 0x23, 0x96, 0x69, 0x59, 0x03, 0x0c, 0x42, 0x08, + 0x7c, 0x3a, 0xfd, 0xb6, 0x04, 0xa9, 0xa2, 0xef, 0xb6, 0x51, 0x16, 0x06, 0x1b, 0x86, 0xae, 0x5d, + 0xe7, 0xfe, 0x98, 0x54, 0x44, 0x13, 0xe5, 0x20, 0xc1, 0x5e, 0xfc, 0x72, 0xf6, 0xc4, 0x51, 0xb2, + 0x68, 0x13, 0xaa, 0x9b, 0x78, 0xcb, 0xd6, 0xc4, 0x6c, 0x28, 0xa2, 0x89, 0x2e, 0x41, 0xc6, 0xc6, + 0x95, 0xa6, 0xa5, 0x39, 0x7b, 0xe5, 0x8a, 0xa1, 0x3b, 0x6a, 0xc5, 0x61, 0xaf, 0x10, 0x15, 0x8e, + 0xde, 0xb9, 0x3d, 0x75, 0x1f, 0x93, 0x35, 0x8c, 0x21, 0x2b, 0x23, 0x02, 0x34, 0xcf, 0x20, 0x64, + 0x84, 0x2a, 0x76, 0x54, 0xad, 0x6e, 0xd3, 0x9a, 0x30, 0xa9, 0x88, 0xa6, 0x4f, 0x97, 0xff, 0x33, + 0xe0, 0x3f, 0x38, 0xbc, 0x04, 0x19, 0xc3, 0xc4, 0x56, 0xa0, 0xc2, 0x96, 0xc2, 0x23, 0x87, 0x31, + 0x64, 0x65, 0x44, 0x80, 0x44, 0xf5, 0x7d, 0x89, 0x4c, 0xb3, 0xd8, 0x66, 0x9b, 0xcd, 0x2d, 0x71, + 0xde, 0x18, 0xe0, 0x13, 0xc6, 0x90, 0xc9, 0x84, 0x72, 0xd0, 0x1a, 0x85, 0x90, 0x0a, 0xf9, 0x79, + 0x55, 0xab, 0x8b, 0x97, 0x5b, 0x15, 0xde, 0x42, 0x79, 0x18, 0xb0, 0x1d, 0xd5, 0x69, 0xda, 0xfc, + 0x93, 0x53, 0x72, 0x27, 0xe7, 0x29, 0x18, 0x7a, 0x75, 0x9d, 0x62, 0x2a, 0x9c, 0x02, 0x5d, 0x82, + 0x01, 0xc7, 0xb8, 0x8e, 0x75, 0x6e, 0x94, 0xbe, 0x22, 0x96, 0x3e, 0x9c, 0x65, 0xd4, 0xc8, 0x81, + 0x4c, 0x15, 0xd7, 0x71, 0x8d, 0x55, 0x80, 0x3b, 0x2a, 0xd9, 0x79, 0xd1, 0x2f, 0x4f, 0x15, 0x16, + 0xfb, 0x0e, 0x2b, 0x6e, 0x91, 0x30, 0x3f, 0x59, 0x19, 0x71, 0x41, 0xeb, 0x14, 0x82, 0xae, 0x06, + 0x2e, 0xba, 0xf1, 0xcf, 0xb3, 0x3d, 0xd0, 0x49, 0x7d, 0x9f, 0x97, 0x8a, 0xf3, 0x1a, 0xff, 0x35, + 0xb9, 0x4b, 0x90, 0x69, 0xea, 0x5b, 0x86, 0x4e, 0xdf, 0x40, 0xe3, 0x5b, 0x11, 0xb2, 0xb7, 0x8d, + 0xfa, 0xa7, 0x29, 0x8c, 0x21, 0x2b, 0x23, 0x2e, 0xe8, 0x32, 0xdb, 0xb0, 0x54, 0x61, 0xd8, 0xc3, + 0xa2, 0xa1, 0x97, 0xec, 0x1a, 0x7a, 0xf7, 0xf3, 0xd0, 0x3b, 0x1c, 0x1e, 0xc5, 0x8b, 0xbe, 0x21, + 0x17, 0x48, 0xc8, 0xd0, 0x65, 0x00, 0x2f, 0xe0, 0xe9, 0xb9, 0x4d, 0xaa, 0xf3, 0xc4, 0x7b, 0x59, + 0x43, 0xec, 0x75, 0x3d, 0x5a, 0xf4, 0x21, 0x18, 0x6b, 0x68, 0x7a, 0xd9, 0xc6, 0xf5, 0xed, 0x32, + 0x37, 0x30, 0x61, 0x49, 0x3f, 0x20, 0x52, 0x58, 0xea, 0xcf, 0x1f, 0xee, 0xdc, 0x9e, 0xca, 0xf1, + 0xa4, 0xd8, 0xca, 0x52, 0x56, 0x46, 0x1b, 0x9a, 0xbe, 0x8e, 0xeb, 0xdb, 0x45, 0x17, 0x96, 0x4f, + 0x7f, 0xfc, 0x4b, 0x53, 0x87, 0x78, 0x00, 0x1e, 0x92, 0xcf, 0xd1, 0xa7, 0x0d, 0x3c, 0x70, 0xb0, + 0x4d, 0xb6, 0x4f, 0xaa, 0x68, 0xd0, 0x13, 0x9e, 0xa4, 0xe2, 0x01, 0x58, 0xe0, 0xbe, 0xf8, 0x1f, + 0xa6, 0x25, 0xf9, 0x17, 0x25, 0x18, 0x28, 0x5e, 0x5b, 0x53, 0x35, 0x0b, 0x2d, 0xc2, 0xa8, 0xe7, + 0x39, 0xc1, 0xb0, 0x3d, 0x76, 0xe7, 0xf6, 0x54, 0x36, 0xec, 0x5c, 0x6e, 0xdc, 0x7a, 0x0e, 0x2c, + 0x02, 0x77, 0xb1, 0xd3, 0x1e, 0x3b, 0xc0, 0xaa, 0x05, 0x45, 0x6e, 0xdd, 0x81, 0x87, 0xd4, 0x2c, + 0xc1, 0x20, 0x93, 0xd6, 0x46, 0x79, 0x88, 0x9b, 0xe4, 0x07, 0x7f, 0x94, 0x32, 0xd9, 0xd1, 0x79, + 0x29, 0xbe, 0x7b, 0xb0, 0x4b, 0x48, 0xe4, 0x4f, 0x47, 0x00, 0x8a, 0xd7, 0xae, 0x6d, 0x58, 0x9a, + 0x59, 0xc7, 0xce, 0xdd, 0xd4, 0x7c, 0x03, 0x0e, 0xfb, 0x36, 0x74, 0x56, 0x25, 0xa4, 0xfd, 0xf4, + 0x9d, 0xdb, 0x53, 0xc7, 0xc2, 0xda, 0xfb, 0xd0, 0x64, 0x65, 0xcc, 0xdb, 0xda, 0x59, 0x95, 0xb6, + 0x5c, 0xab, 0xb6, 0xe3, 0x72, 0x8d, 0x76, 0xe6, 0xea, 0x43, 0xf3, 0x73, 0x2d, 0xda, 0x4e, 0x7b, + 0xd3, 0xae, 0x43, 0xca, 0x33, 0x89, 0x8d, 0x8a, 0x90, 0x70, 0xf8, 0x6f, 0x6e, 0x61, 0xb9, 0xb3, + 0x85, 0x05, 0x19, 0xb7, 0xb2, 0x4b, 0x29, 0xff, 0xa9, 0x04, 0xe0, 0xf9, 0xec, 0x0f, 0xa7, 0x8b, + 0x91, 0x54, 0xce, 0x13, 0x6f, 0xf4, 0x40, 0xc5, 0x17, 0xa7, 0x0e, 0xd9, 0xf3, 0x27, 0x22, 0x30, + 0xb6, 0x29, 0x32, 0xcf, 0x0f, 0xbd, 0x0d, 0xd6, 0x60, 0x10, 0xeb, 0x8e, 0xa5, 0x51, 0x23, 0x90, + 0xd9, 0x7e, 0xbc, 0xd3, 0x6c, 0xb7, 0xd1, 0x89, 0x7e, 0x42, 0x45, 0x3c, 0x84, 0xe0, 0x6c, 0x42, + 0xd6, 0xf8, 0x64, 0x14, 0xb2, 0x9d, 0x28, 0xd1, 0x3c, 0x8c, 0x54, 0x2c, 0x4c, 0x01, 0x65, 0xff, + 0xa9, 0x67, 0x21, 0xe7, 0xd5, 0x8a, 0x21, 0x04, 0x59, 0x19, 0x16, 0x10, 0xbe, 0x7a, 0xd4, 0x80, + 0x14, 0x72, 0xc4, 0xed, 0x08, 0x56, 0x8f, 0x95, 0x9b, 0xcc, 0x97, 0x0f, 0x31, 0x48, 0x90, 0x01, + 0x5b, 0x3f, 0x86, 0x3d, 0x28, 0x5d, 0x40, 0x3e, 0x00, 0x23, 0x9a, 0xae, 0x39, 0x9a, 0x5a, 0x2f, + 0x6f, 0xa9, 0x75, 0x55, 0xaf, 0x1c, 0xa4, 0x0e, 0x66, 0x29, 0x9f, 0x0f, 0x1b, 0x62, 0x27, 0x2b, + 0xc3, 0x1c, 0x52, 0x60, 0x00, 0x74, 0x19, 0x06, 0xc5, 0x50, 0xb1, 0x03, 0x55, 0x1b, 0x82, 0xdc, + 0x57, 0xb2, 0xfd, 0x64, 0x14, 0x46, 0x15, 0x5c, 0xfd, 0x8b, 0xa9, 0xe8, 0x6f, 0x2a, 0x96, 0x01, + 0x58, 0xb8, 0x93, 0x04, 0x7b, 0x80, 0xd9, 0x20, 0x09, 0x23, 0xc9, 0x38, 0x14, 0x6d, 0xc7, 0x37, + 0x1f, 0xb7, 0x23, 0x90, 0xf6, 0xcf, 0xc7, 0x9f, 0xd3, 0x55, 0x09, 0x2d, 0x7a, 0x99, 0x28, 0xc6, + 0x3f, 0x3c, 0xd9, 0x21, 0x13, 0xb5, 0x78, 0xef, 0xfe, 0x29, 0xe8, 0x4f, 0x22, 0x30, 0xb0, 0xa6, + 0x5a, 0x6a, 0xc3, 0x46, 0x95, 0x96, 0x4a, 0x53, 0x9c, 0x94, 0xb6, 0x7c, 0x5e, 0x98, 0x9f, 0x32, + 0x74, 0x29, 0x34, 0x3f, 0xdb, 0xa6, 0xd0, 0x7c, 0x37, 0x0c, 0x93, 0x0d, 0xae, 0xef, 0xd2, 0x07, + 0xb1, 0xf6, 0x50, 0xe1, 0x88, 0xc7, 0x25, 0xd8, 0xcf, 0xf6, 0xbf, 0xd7, 0xfc, 0xb7, 0x3e, 0x52, + 0x04, 0xc3, 0x4b, 0xcc, 0x84, 0x7c, 0xc2, 0xdb, 0x68, 0xfa, 0x3a, 0x65, 0x05, 0x1a, 0xea, 0x6e, + 0x89, 0x35, 0xd0, 0x12, 0xa0, 0x1d, 0xf7, 0xac, 0xa3, 0xec, 0x99, 0x93, 0xd0, 0x1f, 0xbf, 0x73, + 0x7b, 0xea, 0x08, 0xa3, 0x6f, 0xc5, 0x91, 0x95, 0x51, 0x0f, 0x28, 0xb8, 0x9d, 0x01, 0x20, 0x7a, + 0x95, 0xd9, 0x9d, 0x51, 0xb6, 0xdd, 0x39, 0x7c, 0xe7, 0xf6, 0xd4, 0x28, 0xe3, 0xe2, 0xf5, 0xc9, + 0x4a, 0x92, 0x34, 0x8a, 0xe4, 0xb7, 0xcf, 0xb3, 0xbf, 0x22, 0x01, 0xf2, 0x52, 0xbe, 0x82, 0x6d, + 0x93, 0xec, 0xcf, 0x48, 0x21, 0xee, 0xab, 0x9a, 0xa5, 0xfd, 0x0b, 0x71, 0x8f, 0x5e, 0x14, 0xe2, + 0xbe, 0x48, 0xb9, 0xe0, 0xa5, 0xc7, 0x08, 0x9f, 0xc7, 0x36, 0x17, 0x6c, 0x67, 0xe6, 0x0d, 0x4d, + 0x50, 0xb7, 0xe4, 0xc3, 0x43, 0xf2, 0xbf, 0x96, 0xe0, 0x48, 0x8b, 0x47, 0xb9, 0xc2, 0xfe, 0x25, + 0x40, 0x96, 0xaf, 0x93, 0x7f, 0x45, 0x8c, 0x09, 0xdd, 0xb7, 0x83, 0x8e, 0x5a, 0x2d, 0x79, 0xf7, + 0xee, 0x65, 0x78, 0x76, 0x43, 0xf7, 0x9f, 0x4a, 0x30, 0xee, 0x1f, 0xde, 0x55, 0x64, 0x05, 0xd2, + 0xfe, 0xd1, 0xb9, 0x0a, 0x0f, 0xf6, 0xa2, 0x02, 0x97, 0x3e, 0x40, 0x8f, 0x9e, 0xf5, 0xc2, 0x95, + 0x9d, 0x86, 0x3d, 0xd1, 0xb3, 0x35, 0x84, 0x4c, 0xe1, 0xb0, 0x8d, 0xd1, 0xf9, 0xf8, 0xbf, 0x12, + 0xc4, 0xd6, 0x0c, 0xa3, 0x8e, 0x0c, 0x18, 0xd5, 0x0d, 0xa7, 0x4c, 0x3c, 0x0b, 0x57, 0xcb, 0x7c, + 0xd3, 0xcd, 0xf2, 0xe0, 0x7c, 0x7f, 0x46, 0xfa, 0xee, 0xed, 0xa9, 0x56, 0x56, 0xca, 0x88, 0x6e, + 0x38, 0x05, 0x0a, 0xd9, 0x60, 0x5b, 0xf2, 0x0f, 0xc1, 0x50, 0x70, 0x30, 0x96, 0x25, 0x9f, 0xeb, + 0x7b, 0xb0, 0x20, 0x9b, 0x3b, 0xb7, 0xa7, 0xc6, 0xbd, 0x88, 0x71, 0xc1, 0xb2, 0x92, 0xde, 0xf2, + 0x8d, 0xce, 0x2e, 0xc4, 0x7d, 0xff, 0x4b, 0x53, 0xd2, 0xc9, 0x8f, 0x49, 0x00, 0xde, 0xc9, 0x03, + 0x9a, 0x86, 0xd4, 0xe6, 0xca, 0xfa, 0x5a, 0x69, 0x7e, 0xf1, 0xd2, 0x62, 0xa9, 0xe8, 0x9d, 0xde, + 0xdb, 0x26, 0xae, 0x68, 0xdb, 0x1a, 0xae, 0xa2, 0x1c, 0x24, 0x36, 0x57, 0x0a, 0xab, 0x2b, 0xc5, + 0x52, 0x31, 0x23, 0xe5, 0xd2, 0x2f, 0xdd, 0x9a, 0x4e, 0xb0, 0x9a, 0x0b, 0x57, 0xc9, 0x86, 0x90, + 0xf5, 0x2d, 0xae, 0x2c, 0x64, 0x22, 0xb9, 0xa1, 0x97, 0x6e, 0x4d, 0x27, 0xdd, 0x82, 0x0c, 0x4d, + 0xc0, 0x00, 0xa7, 0x8b, 0xe6, 0xe0, 0xa5, 0x5b, 0xd3, 0x03, 0xcc, 0x20, 0xb9, 0xd8, 0xc7, 0xbf, + 0x32, 0x79, 0xa8, 0x70, 0xa9, 0xe3, 0xd9, 0xfb, 0xa9, 0x7d, 0x6d, 0xb1, 0xeb, 0x1e, 0x20, 0x07, + 0x0f, 0xdc, 0xbf, 0x31, 0x02, 0x53, 0x1d, 0x4e, 0x98, 0x9d, 0xdd, 0x03, 0x1d, 0x2e, 0x77, 0x39, + 0xfd, 0xcd, 0xf5, 0x74, 0xa0, 0x2d, 0xdf, 0x8a, 0x01, 0x5a, 0xb6, 0x6b, 0xf3, 0xa4, 0x9a, 0xf1, + 0xdd, 0x26, 0x0b, 0x1d, 0x96, 0x48, 0x6f, 0xea, 0xb0, 0x64, 0x39, 0x70, 0xfc, 0x10, 0xe9, 0xef, + 0xd0, 0xb2, 0xe7, 0x33, 0x88, 0xe8, 0x5b, 0x72, 0x06, 0xd1, 0xbe, 0x44, 0x89, 0xdd, 0xbd, 0xbd, + 0x4c, 0xfc, 0x40, 0x7b, 0x99, 0x09, 0x18, 0xe0, 0x87, 0x85, 0xec, 0x13, 0xee, 0xbc, 0x85, 0xce, + 0x8a, 0x0f, 0x5a, 0x0f, 0xf6, 0xb6, 0x48, 0x30, 0xec, 0x7c, 0xe2, 0xe3, 0x62, 0x89, 0xf8, 0x4c, + 0x14, 0x32, 0xcb, 0x76, 0xad, 0x54, 0xd5, 0x9c, 0x7b, 0xe4, 0x1d, 0xcf, 0x74, 0xde, 0xd1, 0xa1, + 0x3b, 0xb7, 0xa7, 0x86, 0x99, 0x15, 0xf6, 0xd1, 0xbd, 0x01, 0x23, 0xa1, 0x93, 0x71, 0xee, 0x0b, + 0xc5, 0x83, 0x1c, 0xd0, 0x87, 0x58, 0xc9, 0xb4, 0x00, 0xf7, 0x79, 0x24, 0xda, 0x6d, 0xef, 0x7e, + 0xcc, 0x05, 0x2e, 0xdf, 0xcb, 0xe3, 0x2f, 0x6f, 0x56, 0xfe, 0x48, 0x82, 0xd4, 0xb2, 0x2d, 0x36, + 0x95, 0xf8, 0x87, 0x74, 0x83, 0xfd, 0x94, 0xfb, 0x76, 0x4d, 0xb4, 0x37, 0xef, 0x13, 0x6f, 0xdc, + 0x78, 0x8a, 0xfe, 0x4e, 0x84, 0xa6, 0xa7, 0x02, 0xae, 0x69, 0xba, 0xbb, 0x98, 0xe2, 0x3f, 0xaf, + 0xfb, 0x04, 0xcf, 0xa0, 0xb1, 0x83, 0x1a, 0xf4, 0x75, 0x09, 0x86, 0x96, 0xed, 0xda, 0xa6, 0x5e, + 0xfd, 0xff, 0xdd, 0x77, 0xee, 0xfa, 0x12, 0xfe, 0x2f, 0x22, 0x70, 0xd2, 0xbf, 0xe6, 0x7e, 0xa0, + 0x89, 0xad, 0x3d, 0x77, 0x59, 0x35, 0xd5, 0x9a, 0xa6, 0xfb, 0x9f, 0x9f, 0x1f, 0xf1, 0x0b, 0x4c, + 0x71, 0x85, 0xd8, 0xb2, 0x0e, 0xa9, 0x35, 0xb5, 0x86, 0x15, 0xfc, 0x81, 0x26, 0xb6, 0x9d, 0x36, + 0x6f, 0xc5, 0x4c, 0xc0, 0x80, 0xb1, 0xbd, 0x2d, 0x2e, 0xc7, 0xc4, 0x14, 0xde, 0x42, 0xe3, 0x10, + 0xaf, 0x6b, 0x0d, 0x8d, 0x19, 0x25, 0xa6, 0xb0, 0x06, 0x9a, 0x82, 0x54, 0x85, 0xe8, 0x5e, 0x66, + 0xb7, 0x89, 0x63, 0xe2, 0xab, 0x1f, 0x4d, 0xdd, 0xd9, 0x20, 0x10, 0xf9, 0x19, 0x48, 0xb3, 0xf1, + 0x78, 0x41, 0x7c, 0x04, 0x12, 0xf4, 0xf6, 0xa7, 0x37, 0xea, 0x20, 0x69, 0x5f, 0x65, 0x6f, 0xd0, + 0x30, 0x2e, 0x6c, 0x60, 0xd6, 0x28, 0x14, 0x3a, 0x9a, 0xf2, 0x44, 0xf7, 0x64, 0xc7, 0x0c, 0xe5, + 0x9a, 0xf1, 0x37, 0xe3, 0x70, 0x98, 0x3f, 0xd8, 0x56, 0x4d, 0x6d, 0x76, 0xc7, 0x71, 0xc4, 0xab, + 0x69, 0xc0, 0x77, 0xa2, 0xaa, 0xa9, 0xc9, 0x7b, 0x10, 0xbb, 0xec, 0x38, 0x26, 0x3a, 0x09, 0x71, + 0xab, 0x59, 0xc7, 0xe2, 0x40, 0x76, 0x7c, 0xc6, 0xc3, 0x99, 0x21, 0x08, 0x4a, 0xb3, 0x8e, 0x15, + 0x86, 0x82, 0x4a, 0x30, 0xb5, 0xdd, 0xac, 0xd7, 0xf7, 0xca, 0x55, 0x4c, 0xff, 0x61, 0x93, 0xfb, + 0x2f, 0x0f, 0xf0, 0xae, 0xa9, 0xea, 0x6e, 0xf1, 0x91, 0x50, 0x8e, 0x51, 0xb4, 0x22, 0xc5, 0x12, + 0xff, 0xee, 0xa0, 0x24, 0x70, 0xe4, 0xdf, 0x8f, 0x40, 0x42, 0xb0, 0xa6, 0xaf, 0xb4, 0xe0, 0x3a, + 0xae, 0x38, 0x86, 0x78, 0x44, 0xe9, 0xb6, 0x11, 0x82, 0x68, 0x8d, 0x4f, 0x51, 0xf2, 0xf2, 0x21, + 0x85, 0x34, 0x08, 0xcc, 0x7d, 0xd1, 0x88, 0xc0, 0xcc, 0x26, 0x99, 0xb5, 0x98, 0x69, 0x88, 0x93, + 0x93, 0xcb, 0x87, 0x14, 0xda, 0x42, 0x59, 0x18, 0x20, 0x01, 0xe4, 0xb0, 0xaf, 0x51, 0x12, 0x38, + 0x6f, 0xa3, 0x09, 0x88, 0x9b, 0xaa, 0x53, 0x61, 0x37, 0x80, 0x49, 0x07, 0x6b, 0x92, 0x98, 0x60, + 0x6f, 0x01, 0x87, 0xff, 0x1b, 0x0a, 0x31, 0x06, 0xfb, 0xdc, 0x1a, 0x91, 0x7b, 0x4d, 0x75, 0x1c, + 0x6c, 0xe9, 0x84, 0x21, 0x43, 0xa7, 0x6f, 0xaf, 0x19, 0xd5, 0x3d, 0xfe, 0x1f, 0x5a, 0xe8, 0x6f, + 0xfe, 0x2f, 0x21, 0xa8, 0x3f, 0x94, 0x69, 0x27, 0xfb, 0xc7, 0x54, 0x69, 0x01, 0x2c, 0x10, 0xa4, + 0x12, 0x8c, 0xa9, 0xd5, 0xaa, 0xc6, 0xfe, 0x59, 0x4a, 0x79, 0x4b, 0xa3, 0x95, 0xb3, 0x4d, 0xff, + 0xed, 0x58, 0xa7, 0xb9, 0x40, 0x1e, 0x41, 0x81, 0xe3, 0x17, 0x92, 0x30, 0x68, 0x32, 0xa1, 0xe4, + 0x8b, 0x30, 0xda, 0x22, 0x29, 0x91, 0xef, 0xba, 0xa6, 0x57, 0xc5, 0xdb, 0x57, 0xe4, 0x37, 0x81, + 0xd1, 0x4f, 0x26, 0xb2, 0x87, 0xbf, 0xf4, 0x77, 0xe1, 0xc7, 0x3b, 0xdf, 0x22, 0x19, 0xf6, 0xdd, + 0x22, 0x51, 0x4d, 0xad, 0x90, 0xa4, 0xfc, 0xf9, 0xe5, 0x91, 0x39, 0xde, 0xc1, 0x2e, 0x8e, 0xcc, + 0x18, 0x56, 0x6d, 0xb6, 0x86, 0x75, 0x51, 0x51, 0x93, 0x2e, 0xd5, 0xd4, 0x6c, 0xea, 0x8e, 0xde, + 0x27, 0x1c, 0xed, 0x8b, 0xbe, 0xdf, 0xf4, 0x4e, 0x49, 0x6c, 0x61, 0x6e, 0x6d, 0xd1, 0xf5, 0xe3, + 0x6f, 0x46, 0xe0, 0x98, 0xcf, 0x8f, 0x7d, 0xc8, 0xad, 0xee, 0x9c, 0x6b, 0xef, 0xf1, 0x3d, 0x7c, + 0x00, 0xf1, 0x2a, 0xc4, 0x08, 0x3e, 0xea, 0xf2, 0x0f, 0x1b, 0xb2, 0xbf, 0xfc, 0xaf, 0xfe, 0x89, + 0x4c, 0x9d, 0xa2, 0xfd, 0xac, 0x50, 0x26, 0x85, 0x8f, 0xf5, 0x6e, 0xbf, 0x8c, 0xf7, 0xf5, 0x4a, + 0xfb, 0xee, 0x99, 0x31, 0x6c, 0xc3, 0xd7, 0xce, 0x82, 0xdc, 0x61, 0x9b, 0xc2, 0x32, 0xe6, 0xfe, + 0x1b, 0xa3, 0x3e, 0xd2, 0x71, 0xa7, 0x1b, 0x3a, 0xfb, 0xcd, 0x60, 0x8f, 0x5b, 0xa8, 0x5d, 0x98, + 0x78, 0x96, 0x8c, 0xed, 0x9d, 0x62, 0x89, 0xc4, 0x3e, 0xe1, 0x3e, 0x6c, 0x97, 0xf8, 0x7f, 0x7d, + 0x13, 0x0f, 0xd2, 0xc1, 0x93, 0x8f, 0x6f, 0x88, 0x1e, 0x9a, 0xe9, 0xb8, 0x5e, 0xcc, 0xf8, 0x16, + 0x0b, 0xc5, 0x47, 0x29, 0xff, 0x82, 0x04, 0xf7, 0xb5, 0x0c, 0xcd, 0x73, 0xfc, 0x42, 0x9b, 0x77, + 0xaf, 0x7a, 0xbe, 0xb5, 0xe3, 0x7f, 0x0f, 0x6b, 0xa1, 0x8d, 0xb0, 0x0f, 0x77, 0x15, 0x96, 0x49, + 0x11, 0x90, 0xf6, 0x69, 0x38, 0x1c, 0x14, 0x56, 0x98, 0xe9, 0x1d, 0x30, 0x1c, 0xac, 0x09, 0xb8, + 0xb9, 0x86, 0x02, 0x55, 0x81, 0x5c, 0x0e, 0xdb, 0xd9, 0xd5, 0xb5, 0x04, 0x49, 0x17, 0x95, 0xef, + 0x46, 0x7a, 0x56, 0xd5, 0xa3, 0x94, 0x3f, 0x2d, 0xc1, 0x74, 0x70, 0x04, 0xaf, 0xf8, 0xb6, 0xfb, + 0x13, 0xf6, 0xae, 0x4d, 0xf1, 0xeb, 0x12, 0xdc, 0xbf, 0x8f, 0x4c, 0xdc, 0x00, 0x2f, 0xc0, 0xb8, + 0xef, 0xa0, 0x4e, 0xa4, 0x70, 0x31, 0xed, 0x27, 0xbb, 0x9f, 0x30, 0xba, 0xe7, 0x52, 0x47, 0x89, + 0x51, 0xbe, 0xf6, 0xed, 0xa9, 0xb1, 0xd6, 0x3e, 0x5b, 0x19, 0x6b, 0x3d, 0x5c, 0xbb, 0x8b, 0xfe, + 0xf1, 0x79, 0x09, 0x1e, 0x09, 0xaa, 0xda, 0xe6, 0xe9, 0xd9, 0xdb, 0x35, 0x0f, 0xff, 0x5e, 0x82, + 0x93, 0xbd, 0x08, 0xc7, 0x27, 0x64, 0x0b, 0xc6, 0xbc, 0xe3, 0xf2, 0xf0, 0x7c, 0x3c, 0xda, 0xc7, + 0x73, 0x46, 0xee, 0xa5, 0xc8, 0xe5, 0x76, 0x0f, 0x0c, 0x6f, 0xf2, 0xc0, 0xf2, 0x4f, 0xb9, 0x6b, + 0xe4, 0x60, 0xe1, 0x2f, 0x8c, 0x1c, 0x28, 0xfd, 0xdb, 0xcc, 0x45, 0xa4, 0xcd, 0x5c, 0xf8, 0x76, + 0x21, 0x37, 0x78, 0xde, 0x6a, 0x73, 0x44, 0xfe, 0x7e, 0x18, 0x6b, 0xe3, 0xca, 0x3c, 0xaa, 0xfb, + 0xf0, 0x64, 0x05, 0xb5, 0x3a, 0xab, 0xbc, 0x07, 0x53, 0x74, 0xdc, 0x36, 0x86, 0xbe, 0xd7, 0x2a, + 0x37, 0x78, 0x6e, 0x69, 0x3b, 0x34, 0xd7, 0x7d, 0x11, 0x06, 0xd8, 0x3c, 0x73, 0x75, 0x0f, 0xe0, + 0x28, 0x9c, 0x81, 0xfc, 0x33, 0x22, 0x97, 0x15, 0x85, 0xd8, 0xed, 0x63, 0xa8, 0x17, 0x5d, 0xef, + 0x52, 0x0c, 0xf9, 0x8c, 0xf1, 0x8a, 0xc8, 0x6a, 0xed, 0xa5, 0xe3, 0xe6, 0xa8, 0xdc, 0xb5, 0xac, + 0xc6, 0x6c, 0x73, 0x6f, 0xd3, 0xd7, 0xcf, 0x89, 0xf4, 0xe5, 0xea, 0xd4, 0x25, 0x7d, 0xbd, 0x3d, + 0xa6, 0x77, 0x13, 0x59, 0x17, 0x31, 0xff, 0x2c, 0x26, 0xb2, 0xef, 0x4b, 0x70, 0x84, 0xea, 0xe6, + 0x7f, 0xee, 0xd2, 0xaf, 0xc9, 0x4f, 0x01, 0xb2, 0xad, 0x4a, 0xb9, 0x6d, 0x74, 0x67, 0x6c, 0xab, + 0x72, 0x2d, 0xb0, 0xbe, 0x9c, 0x02, 0x54, 0xb5, 0x9d, 0x30, 0x36, 0xbb, 0x96, 0x9a, 0xa9, 0xda, + 0xce, 0xb5, 0x7d, 0x56, 0xa3, 0xd8, 0x5d, 0x98, 0xce, 0x97, 0x25, 0xc8, 0xb5, 0x53, 0x99, 0x4f, + 0x9f, 0x06, 0x13, 0x81, 0x67, 0x78, 0xe1, 0x19, 0x3c, 0xd5, 0xcb, 0x93, 0xab, 0x50, 0x18, 0x1d, + 0xb6, 0xf0, 0xbd, 0xae, 0x03, 0xa6, 0x82, 0x1e, 0xda, 0x5a, 0x59, 0xbf, 0x6d, 0xe1, 0xf3, 0x6b, + 0x2d, 0x79, 0xf5, 0xcf, 0x44, 0xed, 0xbd, 0x0b, 0x93, 0x1d, 0xa4, 0xbe, 0xd7, 0xeb, 0xde, 0x4e, + 0xc7, 0xc9, 0xbc, 0xdb, 0xe5, 0xfb, 0x19, 0x1e, 0x09, 0xc1, 0x57, 0x1e, 0x7c, 0x7b, 0xb1, 0x76, + 0x6f, 0x97, 0xca, 0xef, 0x85, 0xa3, 0x6d, 0xa9, 0xb8, 0x6c, 0x79, 0x88, 0xed, 0x68, 0xb6, 0xc3, + 0xc5, 0x7a, 0xa8, 0x93, 0x58, 0x21, 0x6a, 0x4a, 0x23, 0x23, 0xc8, 0x50, 0xd6, 0x6b, 0x86, 0x51, + 0xe7, 0x62, 0xc8, 0x57, 0x61, 0xd4, 0x07, 0xe3, 0x83, 0x9c, 0x83, 0x98, 0x69, 0xf0, 0xef, 0xa9, + 0xa4, 0x4e, 0x1f, 0xeb, 0x34, 0x08, 0xa1, 0xe1, 0x6a, 0x53, 0x7c, 0x79, 0x1c, 0x10, 0x63, 0x46, + 0xaf, 0x78, 0x88, 0x21, 0xd6, 0x61, 0x2c, 0x00, 0xe5, 0x83, 0xbc, 0x13, 0x06, 0x4c, 0x0a, 0x71, + 0xdf, 0xda, 0xeb, 0x34, 0x0c, 0xc5, 0x72, 0xbf, 0x60, 0x41, 0x5b, 0xa7, 0xbf, 0x7b, 0x18, 0xe2, + 0x94, 0x2b, 0xfa, 0x9c, 0x04, 0xe0, 0xbb, 0xb0, 0x31, 0xd3, 0x89, 0x4d, 0xfb, 0x3d, 0x71, 0x6e, + 0xb6, 0x67, 0x7c, 0x5e, 0xb3, 0x9d, 0xfc, 0xf1, 0x7f, 0xfb, 0xda, 0x67, 0x22, 0x0f, 0x22, 0x79, + 0xb6, 0xc3, 0x6e, 0xdc, 0x17, 0x2f, 0x5f, 0x0d, 0x7c, 0xcc, 0xe3, 0xb1, 0xde, 0x86, 0x12, 0x92, + 0xcd, 0xf4, 0x8a, 0xce, 0x05, 0xbb, 0x48, 0x05, 0x3b, 0x8b, 0x9e, 0xec, 0x2e, 0xd8, 0xec, 0x07, + 0x83, 0x41, 0xf3, 0x61, 0xf4, 0xbb, 0x12, 0x8c, 0xb7, 0xdb, 0xd2, 0xa1, 0xf3, 0xbd, 0x49, 0xd1, + 0x5a, 0x52, 0xe4, 0x2e, 0x1c, 0x80, 0x92, 0xab, 0xb2, 0x40, 0x55, 0x99, 0x43, 0xcf, 0x1c, 0x40, + 0x95, 0x59, 0xdf, 0xba, 0x83, 0xfe, 0xb7, 0x04, 0xc7, 0xf7, 0xdd, 0x21, 0xa1, 0xb9, 0xde, 0xa4, + 0xdc, 0xa7, 0x76, 0xca, 0x15, 0xde, 0x0c, 0x0b, 0xae, 0xf1, 0xb3, 0x54, 0xe3, 0xab, 0x68, 0xf1, + 0x20, 0x1a, 0x7b, 0x15, 0x91, 0x5f, 0xf7, 0xdf, 0x0a, 0x5e, 0xfc, 0xdd, 0xdf, 0x9d, 0x5a, 0x36, + 0x1e, 0x5d, 0x02, 0xa3, 0xb5, 0xa8, 0x95, 0xdf, 0x43, 0x55, 0x50, 0xd0, 0xda, 0x9b, 0x9c, 0xb4, + 0xd9, 0x0f, 0x06, 0x13, 0xff, 0x87, 0xd1, 0xff, 0x92, 0xda, 0xdf, 0xe3, 0x7d, 0x6a, 0x5f, 0x11, + 0x3b, 0x6f, 0xaa, 0x72, 0xe7, 0xfb, 0x27, 0xe4, 0x4a, 0x36, 0xa8, 0x92, 0x35, 0x84, 0xef, 0xb6, + 0x92, 0x6d, 0x27, 0x11, 0xfd, 0xb6, 0x04, 0xe3, 0xed, 0xf6, 0x24, 0x5d, 0xc2, 0x72, 0x9f, 0x4d, + 0x56, 0x97, 0xb0, 0xdc, 0x6f, 0x03, 0x24, 0xbf, 0x93, 0x2a, 0x7f, 0x0e, 0x9d, 0xe9, 0xa4, 0xfc, + 0xbe, 0xb3, 0x48, 0x62, 0x71, 0xdf, 0x22, 0xbf, 0x4b, 0x2c, 0xf6, 0xb2, 0x8f, 0xe9, 0x12, 0x8b, + 0x3d, 0xed, 0x31, 0xba, 0xc7, 0xa2, 0xab, 0x59, 0x8f, 0xd3, 0x68, 0xa3, 0x6f, 0x4a, 0x30, 0x14, + 0xa8, 0x88, 0xd1, 0x13, 0xfb, 0x0a, 0xda, 0x6e, 0xc3, 0x90, 0x3b, 0xdd, 0x0f, 0x09, 0xd7, 0x65, + 0x91, 0xea, 0x32, 0x8f, 0xe6, 0x0e, 0xa2, 0x8b, 0x15, 0x90, 0xf8, 0x65, 0x09, 0xc6, 0xda, 0x54, + 0x99, 0x5d, 0xa2, 0xb0, 0x73, 0xd1, 0x9c, 0x3b, 0xdf, 0x3f, 0x21, 0xd7, 0xea, 0x12, 0xd5, 0xea, + 0xdd, 0xe8, 0xe9, 0x83, 0x68, 0xe5, 0x5b, 0x9f, 0x6f, 0x7b, 0xd7, 0x22, 0x7d, 0xe3, 0xa0, 0x73, + 0x7d, 0x0a, 0x26, 0x14, 0x7a, 0xaa, 0x6f, 0x3a, 0xae, 0xcf, 0x73, 0x54, 0x9f, 0x67, 0xd1, 0xea, + 0x9b, 0xd3, 0xa7, 0x75, 0x59, 0xff, 0x7a, 0xeb, 0x2b, 0xb7, 0xfb, 0x7b, 0x51, 0xdb, 0x62, 0x35, + 0xf7, 0x64, 0x5f, 0x34, 0x5c, 0xa9, 0xf3, 0x54, 0xa9, 0xd3, 0xe8, 0xf1, 0x4e, 0x4a, 0xf9, 0xee, + 0xbe, 0x6a, 0xfa, 0xb6, 0x31, 0xfb, 0x41, 0x56, 0x02, 0x7f, 0x18, 0xfd, 0x98, 0xb8, 0x77, 0x78, + 0x62, 0xdf, 0x71, 0x7d, 0x75, 0x6c, 0xee, 0x91, 0x1e, 0x30, 0xb9, 0x5c, 0x0f, 0x52, 0xb9, 0x26, + 0xd1, 0xb1, 0x4e, 0x72, 0x91, 0x5a, 0x16, 0x7d, 0x42, 0x72, 0xaf, 0x2a, 0x9f, 0xdc, 0x9f, 0xb7, + 0xbf, 0xd8, 0xcd, 0x3d, 0xda, 0x13, 0x2e, 0x97, 0xe4, 0x21, 0x2a, 0xc9, 0x34, 0x9a, 0xec, 0x28, + 0x09, 0x2b, 0x7d, 0xef, 0xf6, 0xcd, 0x81, 0x3f, 0x1e, 0xec, 0xf8, 0x7a, 0x79, 0x0d, 0xeb, 0xd8, + 0xd6, 0xec, 0x03, 0xdd, 0x00, 0xec, 0xed, 0xf1, 0xd4, 0xef, 0xc6, 0x21, 0xbd, 0xc0, 0x46, 0x59, + 0x77, 0x54, 0xe7, 0x4d, 0x6e, 0x04, 0x90, 0xcd, 0xbf, 0x54, 0xc5, 0x3e, 0xb1, 0xe7, 0x7d, 0x34, + 0x2e, 0xdd, 0xd7, 0xcb, 0x9b, 0xec, 0xfe, 0x13, 0x7f, 0x4f, 0x32, 0xcc, 0x4f, 0x66, 0x1f, 0xbd, + 0xa2, 0x77, 0x17, 0xd8, 0xc7, 0xf1, 0x3e, 0x2a, 0xc1, 0x61, 0x8a, 0xe5, 0xc5, 0x1b, 0xc5, 0x14, + 0x6f, 0xee, 0x74, 0xf4, 0x98, 0x25, 0xd5, 0x77, 0x04, 0xc3, 0x3e, 0x67, 0xf7, 0x20, 0xbf, 0xd5, + 0x7e, 0xcc, 0x37, 0x78, 0x98, 0xad, 0xac, 0x8c, 0xd5, 0x5b, 0x28, 0xed, 0xd0, 0xbe, 0x3e, 0x76, + 0xf0, 0x7d, 0xfd, 0x15, 0x48, 0xf9, 0x32, 0x7d, 0x36, 0xde, 0xe5, 0x65, 0xb3, 0xf0, 0x21, 0x9a, + 0x9f, 0x18, 0x7d, 0x4c, 0x82, 0xc3, 0x6d, 0x17, 0x41, 0xfa, 0x7f, 0x10, 0xfb, 0x3c, 0xa4, 0x0b, + 0x19, 0xa7, 0x2d, 0x5f, 0x59, 0x19, 0x6f, 0xb6, 0xab, 0x26, 0xd6, 0x60, 0x28, 0xb0, 0x80, 0x65, + 0xc5, 0x7f, 0x33, 0xed, 0xfd, 0x9e, 0x75, 0x90, 0x01, 0xca, 0x41, 0x02, 0xef, 0x9a, 0x86, 0xe5, + 0xe0, 0x2a, 0xbd, 0xf2, 0x90, 0x50, 0xdc, 0xb6, 0xbc, 0x02, 0xa8, 0x75, 0x72, 0xc3, 0xdf, 0x6f, + 0x4c, 0x7a, 0xdf, 0x6f, 0x1c, 0x87, 0xb8, 0xff, 0x0b, 0x87, 0xac, 0x71, 0xef, 0x6e, 0x0b, 0xfd, + 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xa9, 0xa8, 0x2a, 0xc6, 0x8e, 0x00, 0x00, } r := bytes.NewReader(gzipped) gzipr, err := compress_gzip.NewReader(r) @@ -4156,7 +4204,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Status |= github_com_cosmos_cosmos_sdk_types.BondStatus(b&0x7F) << shift + m.Status |= BondStatus(b&0x7F) << shift if b < 0x80 { break } diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index aa042c307e84..532fe56a834c 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -338,7 +338,7 @@ func (v Validator) PotentialConsensusPower() int64 { // UpdateStatus updates the location of the shares within a validator // to reflect the new status -func (v Validator) UpdateStatus(newStatus sdk.BondStatus) Validator { +func (v Validator) UpdateStatus(newStatus BondStatus) Validator { v.Status = newStatus return v } @@ -419,9 +419,9 @@ func (v Validator) MinEqual(other Validator) bool { v.Commission.Equal(other.Commission) } -func (v Validator) IsJailed() bool { return v.Jailed } -func (v Validator) GetMoniker() string { return v.Description.Moniker } -func (v Validator) GetStatus() sdk.BondStatus { return v.Status } +func (v Validator) IsJailed() bool { return v.Jailed } +func (v Validator) GetMoniker() string { return v.Description.Moniker } +func (v Validator) GetStatus() BondStatus { return v.Status } func (v Validator) GetOperator() sdk.ValAddress { if v.OperatorAddress == "" { return nil From 6fcc16338cee7edec6cda56261f3361aa1edf40c Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 14:16:22 +0200 Subject: [PATCH 15/24] Fix test --- types/staking_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/staking_test.go b/types/staking_test.go index 42dd3c3ed20a..4ad06cc18b78 100644 --- a/types/staking_test.go +++ b/types/staking_test.go @@ -24,7 +24,7 @@ func (s *stakingTestSuite) TestBondStatus() { s.Require().False(sdk.Unbonded.Equal(sdk.Bonded)) s.Require().False(sdk.Unbonded.Equal(sdk.Unbonding)) s.Require().False(sdk.Bonded.Equal(sdk.Unbonding)) - s.Require().Panicsf(func() { sdk.BondStatus(3).String() }, "invalid bond status") // nolint:govet + s.Require().Panicsf(func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet s.Require().Equal(sdk.BondStatusUnbonded, sdk.Unbonded.String()) s.Require().Equal(sdk.BondStatusBonded, sdk.Bonded.String()) s.Require().Equal(sdk.BondStatusUnbonding, sdk.Unbonding.String()) From 2bc7a87da17f7edbc4cbbf1087d53064f8531bdf Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 14:27:59 +0200 Subject: [PATCH 16/24] Fix another test --- x/staking/legacy/v040/migrate_test.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go index 727428c8ce80..1d593a6fc98a 100644 --- a/x/staking/legacy/v040/migrate_test.go +++ b/x/staking/legacy/v040/migrate_test.go @@ -2,7 +2,6 @@ package v040_test import ( "encoding/json" - "fmt" "testing" "github.com/stretchr/testify/require" @@ -23,12 +22,12 @@ func TestMigrate(t *testing.T) { WithLegacyAmino(encodingConfig.Amino). WithJSONMarshaler(encodingConfig.Marshaler) - consPubKey := ed25519.GenPrivKey().PubKey() + consPubKey := ed25519.GenPrivKeyFromSecret([]byte("val0")).PubKey() stakingGenState := v038staking.GenesisState{ Validators: v038staking.Validators{v038staking.Validator{ ConsPubKey: consPubKey, Status: v034staking.Unbonded, - }},x + }}, } migrated := v040staking.Migrate(stakingGenState) @@ -70,7 +69,7 @@ func TestMigrate(t *testing.T) { }, "update_time": "0001-01-01T00:00:00Z" }, - "consensus_pubkey": "cosmosvalconspub1zcjduepqtrz32re64nu80d3lagdry56ywym6yjrayrv2ycrvvm07f9tkve8s397nyf", + "consensus_pubkey": "cosmosvalconspub1zcjduepq9ymett3nlv6fytn7lqxzd3q3ckvd79eqlcf3wkhgamcl4rzghesq83ecpx", "delegator_shares": "0", "description": { "details": "", From f0cd71051b120bdb7ad293ce1e1de3d1e2d06018 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 17:20:11 +0200 Subject: [PATCH 17/24] Remove staking exported --- simapp/export.go | 12 ++++---- x/distribution/keeper/allocation.go | 4 +-- x/distribution/keeper/delegation.go | 8 ++--- x/distribution/keeper/grpc_query.go | 6 ++-- x/distribution/keeper/invariants.go | 6 ++-- x/distribution/keeper/querier.go | 6 ++-- x/distribution/keeper/validator.go | 6 ++-- x/distribution/types/expected_keepers.go | 15 +++++----- x/evidence/types/expected_keepers.go | 4 +-- x/gov/keeper/tally.go | 6 ++-- x/gov/types/expected_keepers.go | 6 ++-- x/slashing/genesis.go | 4 +-- x/slashing/types/expected_keepers.go | 10 +++---- x/staking/exported/exported.go | 38 ------------------------ x/staking/genesis.go | 3 +- x/staking/keeper/alias_functions.go | 16 +++++----- x/staking/keeper/invariants.go | 3 +- x/staking/types/delegation.go | 3 +- x/staking/types/expected_keepers.go | 15 +++++----- x/staking/types/exported.go | 37 +++++++++++++++++++++++ x/staking/types/validator.go | 5 ++-- 21 files changed, 102 insertions(+), 111 deletions(-) create mode 100644 x/staking/types/exported.go diff --git a/simapp/export.go b/simapp/export.go index 7586a90ae7a5..03d30260cb42 100644 --- a/simapp/export.go +++ b/simapp/export.go @@ -6,11 +6,9 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - servertypes "github.com/cosmos/cosmos-sdk/server/types" sdk "github.com/cosmos/cosmos-sdk/types" slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" "github.com/cosmos/cosmos-sdk/x/staking" - "github.com/cosmos/cosmos-sdk/x/staking/exported" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -18,7 +16,7 @@ import ( // file. func (app *SimApp) ExportAppStateAndValidators( forZeroHeight bool, jailAllowedAddrs []string, -) (servertypes.ExportedApp, error) { +) (servertypes.stakingtypesApp, error) { // as if they could withdraw from the start of the next block ctx := app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()}) @@ -33,11 +31,11 @@ func (app *SimApp) ExportAppStateAndValidators( genState := app.mm.ExportGenesis(ctx, app.appCodec) appState, err := json.MarshalIndent(genState, "", " ") if err != nil { - return servertypes.ExportedApp{}, err + return servertypes.stakingtypesApp{}, err } validators := staking.WriteValidators(ctx, app.StakingKeeper) - return servertypes.ExportedApp{ + return servertypes.stakingtypesApp{ AppState: appState, Validators: validators, Height: height, @@ -72,7 +70,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [] /* Handle fee distribution state. */ // withdraw all validator commission - app.StakingKeeper.IterateValidators(ctx, func(_ int64, val exported.ValidatorI) (stop bool) { + app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) { _, _ = app.DistrKeeper.WithdrawValidatorCommission(ctx, val.GetOperator()) return false }) @@ -103,7 +101,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs [] ctx = ctx.WithBlockHeight(0) // reinitialize all validators - app.StakingKeeper.IterateValidators(ctx, func(_ int64, val exported.ValidatorI) (stop bool) { + app.StakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) { // donate any unwithdrawn outstanding reward fraction tokens to the community pool scraps := app.DistrKeeper.GetValidatorOutstandingRewardsCoins(ctx, val.GetOperator()) feePool := app.DistrKeeper.GetFeePool(ctx) diff --git a/x/distribution/keeper/allocation.go b/x/distribution/keeper/allocation.go index 593d02d04d34..9436bada9d69 100644 --- a/x/distribution/keeper/allocation.go +++ b/x/distribution/keeper/allocation.go @@ -7,7 +7,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // AllocateTokens handles distribution of the collected fees @@ -100,7 +100,7 @@ func (k Keeper) AllocateTokens( } // AllocateTokensToValidator allocate tokens to a particular validator, splitting according to commission -func (k Keeper) AllocateTokensToValidator(ctx sdk.Context, val exported.ValidatorI, tokens sdk.DecCoins) { +func (k Keeper) AllocateTokensToValidator(ctx sdk.Context, val stakingtypes.ValidatorI, tokens sdk.DecCoins) { // split tokens between validator and delegators according to commission commission := tokens.MulDec(val.GetCommission()) shared := tokens.Sub(commission) diff --git a/x/distribution/keeper/delegation.go b/x/distribution/keeper/delegation.go index 3febc9861493..7d1e66611b83 100644 --- a/x/distribution/keeper/delegation.go +++ b/x/distribution/keeper/delegation.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // initialize starting info for a new delegation @@ -28,7 +28,7 @@ func (k Keeper) initializeDelegation(ctx sdk.Context, val sdk.ValAddress, del sd } // calculate the rewards accrued by a delegation between two periods -func (k Keeper) calculateDelegationRewardsBetween(ctx sdk.Context, val exported.ValidatorI, +func (k Keeper) calculateDelegationRewardsBetween(ctx sdk.Context, val stakingtypes.ValidatorI, startingPeriod, endingPeriod uint64, stake sdk.Dec) (rewards sdk.DecCoins) { // sanity check if startingPeriod > endingPeriod { @@ -53,7 +53,7 @@ func (k Keeper) calculateDelegationRewardsBetween(ctx sdk.Context, val exported. } // calculate the total rewards accrued by a delegation -func (k Keeper) CalculateDelegationRewards(ctx sdk.Context, val exported.ValidatorI, del exported.DelegationI, endingPeriod uint64) (rewards sdk.DecCoins) { +func (k Keeper) CalculateDelegationRewards(ctx sdk.Context, val stakingtypes.ValidatorI, del stakingtypes.DelegationI, endingPeriod uint64) (rewards sdk.DecCoins) { // fetch starting info for delegation startingInfo := k.GetDelegatorStartingInfo(ctx, del.GetValidatorAddr(), del.GetDelegatorAddr()) @@ -136,7 +136,7 @@ func (k Keeper) CalculateDelegationRewards(ctx sdk.Context, val exported.Validat return rewards } -func (k Keeper) withdrawDelegationRewards(ctx sdk.Context, val exported.ValidatorI, del exported.DelegationI) (sdk.Coins, error) { +func (k Keeper) withdrawDelegationRewards(ctx sdk.Context, val stakingtypes.ValidatorI, del stakingtypes.DelegationI) (sdk.Coins, error) { // check existence of delegator starting info if !k.HasDelegatorStartingInfo(ctx, del.GetValidatorAddr(), del.GetDelegatorAddr()) { return nil, types.ErrEmptyDelegationDistInfo diff --git a/x/distribution/keeper/grpc_query.go b/x/distribution/keeper/grpc_query.go index 01817535e890..7991634fc401 100644 --- a/x/distribution/keeper/grpc_query.go +++ b/x/distribution/keeper/grpc_query.go @@ -11,7 +11,7 @@ import ( sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) var _ types.QueryServer = Keeper{} @@ -178,7 +178,7 @@ func (k Keeper) DelegationTotalRewards(c context.Context, req *types.QueryDelega k.stakingKeeper.IterateDelegations( ctx, delAdr, - func(_ int64, del exported.DelegationI) (stop bool) { + func(_ int64, del stakingtypes.DelegationI) (stop bool) { valAddr := del.GetValidatorAddr() val := k.stakingKeeper.Validator(ctx, valAddr) endingPeriod := k.IncrementValidatorPeriod(ctx, val) @@ -212,7 +212,7 @@ func (k Keeper) DelegatorValidators(c context.Context, req *types.QueryDelegator k.stakingKeeper.IterateDelegations( ctx, delAdr, - func(_ int64, del exported.DelegationI) (stop bool) { + func(_ int64, del stakingtypes.DelegationI) (stop bool) { validators = append(validators, del.GetValidatorAddr().String()) return false }, diff --git a/x/distribution/keeper/invariants.go b/x/distribution/keeper/invariants.go index 45534b622e50..0a23d36be8f7 100644 --- a/x/distribution/keeper/invariants.go +++ b/x/distribution/keeper/invariants.go @@ -5,7 +5,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // register all distribution invariants @@ -77,7 +77,7 @@ func CanWithdrawInvariant(k Keeper) sdk.Invariant { } // iterate over all validators - k.stakingKeeper.IterateValidators(ctx, func(_ int64, val exported.ValidatorI) (stop bool) { + k.stakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) { _, _ = k.WithdrawValidatorCommission(ctx, val.GetOperator()) delegationAddrs, ok := valDelegationAddrs[val.GetOperator().String()] @@ -108,7 +108,7 @@ func ReferenceCountInvariant(k Keeper) sdk.Invariant { return func(ctx sdk.Context) (string, bool) { valCount := uint64(0) - k.stakingKeeper.IterateValidators(ctx, func(_ int64, val exported.ValidatorI) (stop bool) { + k.stakingKeeper.IterateValidators(ctx, func(_ int64, val stakingtypes.ValidatorI) (stop bool) { valCount++ return false }) diff --git a/x/distribution/keeper/querier.go b/x/distribution/keeper/querier.go index e2621eec2a4e..3d4c257b0084 100644 --- a/x/distribution/keeper/querier.go +++ b/x/distribution/keeper/querier.go @@ -9,7 +9,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) func NewQuerier(k Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier { @@ -172,7 +172,7 @@ func queryDelegatorTotalRewards(ctx sdk.Context, _ []string, req abci.RequestQue k.stakingKeeper.IterateDelegations( ctx, params.DelegatorAddress, - func(_ int64, del exported.DelegationI) (stop bool) { + func(_ int64, del stakingtypes.DelegationI) (stop bool) { valAddr := del.GetValidatorAddr() val := k.stakingKeeper.Validator(ctx, valAddr) endingPeriod := k.IncrementValidatorPeriod(ctx, val) @@ -208,7 +208,7 @@ func queryDelegatorValidators(ctx sdk.Context, _ []string, req abci.RequestQuery k.stakingKeeper.IterateDelegations( ctx, params.DelegatorAddress, - func(_ int64, del exported.DelegationI) (stop bool) { + func(_ int64, del stakingtypes.DelegationI) (stop bool) { validators = append(validators, del.GetValidatorAddr()) return false }, diff --git a/x/distribution/keeper/validator.go b/x/distribution/keeper/validator.go index 3ebd6c8c6c6f..3d1953c3b5fa 100644 --- a/x/distribution/keeper/validator.go +++ b/x/distribution/keeper/validator.go @@ -6,11 +6,11 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/distribution/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // initialize rewards for a new validator -func (k Keeper) initializeValidator(ctx sdk.Context, val exported.ValidatorI) { +func (k Keeper) initializeValidator(ctx sdk.Context, val stakingtypes.ValidatorI) { // set initial historical rewards (period 0) with reference count of 1 k.SetValidatorHistoricalRewards(ctx, val.GetOperator(), 0, types.NewValidatorHistoricalRewards(sdk.DecCoins{}, 1)) @@ -25,7 +25,7 @@ func (k Keeper) initializeValidator(ctx sdk.Context, val exported.ValidatorI) { } // increment validator period, returning the period just ended -func (k Keeper) IncrementValidatorPeriod(ctx sdk.Context, val exported.ValidatorI) uint64 { +func (k Keeper) IncrementValidatorPeriod(ctx sdk.Context, val stakingtypes.ValidatorI) uint64 { // fetch current rewards rewards := k.GetValidatorCurrentRewards(ctx, val.GetOperator()) diff --git a/x/distribution/types/expected_keepers.go b/x/distribution/types/expected_keepers.go index c83464dea7ff..29346d39081e 100644 --- a/x/distribution/types/expected_keepers.go +++ b/x/distribution/types/expected_keepers.go @@ -3,7 +3,6 @@ package types import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/types" - stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -35,18 +34,18 @@ type BankKeeper interface { type StakingKeeper interface { // iterate through validators by operator address, execute func for each validator IterateValidators(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator stakingtypes.ValidatorI) (stop bool)) // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator stakingtypes.ValidatorI) (stop bool)) // iterate through the consensus validator set of the last block by operator address, execute func for each validator IterateLastValidators(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator stakingtypes.ValidatorI) (stop bool)) - Validator(sdk.Context, sdk.ValAddress) stakingexported.ValidatorI // get a particular validator by operator address - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI // get a particular validator by consensus address + Validator(sdk.Context, sdk.ValAddress) stakingtypes.ValidatorI // get a particular validator by operator address + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingtypes.ValidatorI // get a particular validator by consensus address // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) @@ -55,13 +54,13 @@ type StakingKeeper interface { // Delegation allows for getting a particular delegation for a given validator // and delegator outside the scope of the staking module. - Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingexported.DelegationI + Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingtypes.DelegationI // MaxValidators returns the maximum amount of bonded validators MaxValidators(sdk.Context) uint32 IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation stakingexported.DelegationI) (stop bool)) + fn func(index int64, delegation stakingtypes.DelegationI) (stop bool)) GetLastTotalPower(ctx sdk.Context) sdk.Int GetLastValidatorPower(ctx sdk.Context, valAddr sdk.ValAddress) int64 diff --git a/x/evidence/types/expected_keepers.go b/x/evidence/types/expected_keepers.go index 501371ce9a5d..23c9b40bdc62 100644 --- a/x/evidence/types/expected_keepers.go +++ b/x/evidence/types/expected_keepers.go @@ -6,14 +6,14 @@ import ( "github.com/tendermint/tendermint/crypto" sdk "github.com/cosmos/cosmos-sdk/types" - stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) type ( // StakingKeeper defines the staking module interface contract needed by the // evidence module. StakingKeeper interface { - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingtypes.ValidatorI } // SlashingKeeper defines the slashing module interface contract needed by the diff --git a/x/gov/keeper/tally.go b/x/gov/keeper/tally.go index 20fe742b24a9..796609db5a10 100644 --- a/x/gov/keeper/tally.go +++ b/x/gov/keeper/tally.go @@ -3,7 +3,7 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // TODO: Break into several smaller functions for clarity @@ -21,7 +21,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal types.Proposal) (passes boo currValidators := make(map[string]types.ValidatorGovInfo) // fetch all the bonded validators, insert them into currValidators - keeper.sk.IterateBondedValidatorsByPower(ctx, func(index int64, validator exported.ValidatorI) (stop bool) { + keeper.sk.IterateBondedValidatorsByPower(ctx, func(index int64, validator stakingtypes.ValidatorI) (stop bool) { currValidators[validator.GetOperator().String()] = types.NewValidatorGovInfo( validator.GetOperator(), validator.GetBondedTokens(), @@ -48,7 +48,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal types.Proposal) (passes boo } // iterate over all delegations from voter, deduct from any delegated-to validators - keeper.sk.IterateDelegations(ctx, voter, func(index int64, delegation exported.DelegationI) (stop bool) { + keeper.sk.IterateDelegations(ctx, voter, func(index int64, delegation stakingtypes.DelegationI) (stop bool) { valAddrStr := delegation.GetValidatorAddr().String() if val, ok := currValidators[valAddrStr]; ok { diff --git a/x/gov/types/expected_keepers.go b/x/gov/types/expected_keepers.go index fcaa095369db..f862a9bce563 100644 --- a/x/gov/types/expected_keepers.go +++ b/x/gov/types/expected_keepers.go @@ -3,7 +3,7 @@ package types import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/types" - stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // ParamSubspace defines the expected Subspace interface for parameters (noalias) @@ -16,13 +16,13 @@ type ParamSubspace interface { type StakingKeeper interface { // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower( - sdk.Context, func(index int64, validator stakingexported.ValidatorI) (stop bool), + sdk.Context, func(index int64, validator stakingtypes.ValidatorI) (stop bool), ) TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set IterateDelegations( ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation stakingexported.DelegationI) (stop bool), + fn func(index int64, delegation stakingtypes.DelegationI) (stop bool), ) } diff --git a/x/slashing/genesis.go b/x/slashing/genesis.go index 3c38fa431c53..87fa12237cc4 100644 --- a/x/slashing/genesis.go +++ b/x/slashing/genesis.go @@ -4,14 +4,14 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/slashing/keeper" "github.com/cosmos/cosmos-sdk/x/slashing/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // InitGenesis initialize default parameters // and the keeper's address to pubkey map func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, stakingKeeper types.StakingKeeper, data *types.GenesisState) { stakingKeeper.IterateValidators(ctx, - func(index int64, validator exported.ValidatorI) bool { + func(index int64, validator stakingtypes.ValidatorI) bool { keeper.AddPubkey(ctx, validator.GetConsPubKey()) return false }, diff --git a/x/slashing/types/expected_keepers.go b/x/slashing/types/expected_keepers.go index 4a09ca72988d..538a030baac0 100644 --- a/x/slashing/types/expected_keepers.go +++ b/x/slashing/types/expected_keepers.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" auth "github.com/cosmos/cosmos-sdk/x/auth/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" - stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) // AccountKeeper expected account keeper @@ -37,10 +37,10 @@ type ParamSubspace interface { type StakingKeeper interface { // iterate through validators by operator address, execute func for each validator IterateValidators(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator stakingtypes.ValidatorI) (stop bool)) - Validator(sdk.Context, sdk.ValAddress) stakingexported.ValidatorI // get a particular validator by operator address - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI // get a particular validator by consensus address + Validator(sdk.Context, sdk.ValAddress) stakingtypes.ValidatorI // get a particular validator by operator address + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingtypes.ValidatorI // get a particular validator by consensus address // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) @@ -49,7 +49,7 @@ type StakingKeeper interface { // Delegation allows for getting a particular delegation for a given validator // and delegator outside the scope of the staking module. - Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingexported.DelegationI + Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingtypes.DelegationI // MaxValidators returns the maximum amount of bonded validators MaxValidators(sdk.Context) uint32 diff --git a/x/staking/exported/exported.go b/x/staking/exported/exported.go index cd185d9eb8a0..eabd8aa3ddaa 100644 --- a/x/staking/exported/exported.go +++ b/x/staking/exported/exported.go @@ -1,39 +1 @@ package exported - -import ( - "github.com/tendermint/tendermint/crypto" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/types" -) - -// DelegationI delegation bond for a delegated proof of stake system -type DelegationI interface { - GetDelegatorAddr() sdk.AccAddress // delegator sdk.AccAddress for the bond - GetValidatorAddr() sdk.ValAddress // validator operator address - GetShares() sdk.Dec // amount of validator's shares held in this delegation -} - -// ValidatorI expected validator functions -type ValidatorI interface { - IsJailed() bool // whether the validator is jailed - GetMoniker() string // moniker of the validator - GetStatus() types.BondStatus // status of the validator - IsBonded() bool // check if has a bonded status - IsUnbonded() bool // check if has status unbonded - IsUnbonding() bool // check if has status unbonding - GetOperator() sdk.ValAddress // operator address to receive/return validators coins - GetConsPubKey() crypto.PubKey // validation consensus pubkey - GetConsAddr() sdk.ConsAddress // validation consensus address - GetTokens() sdk.Int // validation tokens - GetBondedTokens() sdk.Int // validator bonded tokens - GetConsensusPower() int64 // validation power in tendermint - GetCommission() sdk.Dec // validator commission rate - GetMinSelfDelegation() sdk.Int // validator minimum self delegation - GetDelegatorShares() sdk.Dec // total outstanding delegator shares - TokensFromShares(sdk.Dec) sdk.Dec // token worth of provided delegator shares - TokensFromSharesTruncated(sdk.Dec) sdk.Dec // token worth of provided delegator shares, truncated - TokensFromSharesRoundUp(sdk.Dec) sdk.Dec // token worth of provided delegator shares, rounded up - SharesFromTokens(amt sdk.Int) (sdk.Dec, error) // shares worth of delegator's bond - SharesFromTokensTruncated(amt sdk.Int) (sdk.Dec, error) // truncated shares worth of delegator's bond -} diff --git a/x/staking/genesis.go b/x/staking/genesis.go index c339707e536b..a04711df4edf 100644 --- a/x/staking/genesis.go +++ b/x/staking/genesis.go @@ -7,7 +7,6 @@ import ( tmtypes "github.com/tendermint/tendermint/types" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" "github.com/cosmos/cosmos-sdk/x/staking/keeper" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -192,7 +191,7 @@ func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState { // WriteValidators returns a slice of bonded genesis validators. func WriteValidators(ctx sdk.Context, keeper keeper.Keeper) (vals []tmtypes.GenesisValidator) { - keeper.IterateLastValidators(ctx, func(_ int64, validator exported.ValidatorI) (stop bool) { + keeper.IterateLastValidators(ctx, func(_ int64, validator types.ValidatorI) (stop bool) { vals = append(vals, tmtypes.GenesisValidator{ Address: validator.GetConsAddr().Bytes(), PubKey: validator.GetConsPubKey(), diff --git a/x/staking/keeper/alias_functions.go b/x/staking/keeper/alias_functions.go index 6722133e7fdf..da42b82d7aa7 100644 --- a/x/staking/keeper/alias_functions.go +++ b/x/staking/keeper/alias_functions.go @@ -4,15 +4,15 @@ import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" "github.com/cosmos/cosmos-sdk/x/staking/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) //_______________________________________________________________________ // Validator Set // iterate through the validator set and perform the provided function -func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validator exported.ValidatorI) (stop bool)) { +func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsKey) @@ -32,7 +32,7 @@ func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validato } // iterate through the bonded validator set and perform the provided function -func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index int64, validator exported.ValidatorI) (stop bool)) { +func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { store := ctx.KVStore(k.storeKey) maxValidators := k.MaxValidators(ctx) @@ -55,7 +55,7 @@ func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index in } // iterate through the active validator set and perform the provided function -func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, validator exported.ValidatorI) (stop bool)) { +func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { iterator := k.LastValidatorsIterator(ctx) defer iterator.Close() @@ -78,7 +78,7 @@ func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, vali } // Validator gets the Validator interface for a particular address -func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) exported.ValidatorI { +func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) stakingtypes.ValidatorI { val, found := k.GetValidator(ctx, address) if !found { return nil @@ -88,7 +88,7 @@ func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) exported.Vali } // ValidatorByConsAddr gets the validator interface for a particular pubkey -func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) exported.ValidatorI { +func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) stakingtypes.ValidatorI { val, found := k.GetValidatorByConsAddr(ctx, addr) if !found { return nil @@ -106,7 +106,7 @@ func (k Keeper) GetValidatorSet() types.ValidatorSet { } // Delegation get the delegation interface for a particular set of delegator and validator addresses -func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) exported.DelegationI { +func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) stakingtypes.DelegationI { bond, ok := k.GetDelegation(ctx, addrDel, addrVal) if !ok { return nil @@ -117,7 +117,7 @@ func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk. // iterate through all of the delegations from a delegator func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.AccAddress, - fn func(index int64, del exported.DelegationI) (stop bool)) { + fn func(index int64, del stakingtypes.DelegationI) (stop bool)) { store := ctx.KVStore(k.storeKey) delegatorPrefixKey := types.GetDelegationsKey(delAddr) diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go index 02287e91b075..45e726059dd2 100644 --- a/x/staking/keeper/invariants.go +++ b/x/staking/keeper/invariants.go @@ -5,7 +5,6 @@ import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -53,7 +52,7 @@ func ModuleAccountInvariants(k Keeper) sdk.Invariant { notBondedPool := k.GetNotBondedPool(ctx) bondDenom := k.BondDenom(ctx) - k.IterateValidators(ctx, func(_ int64, validator exported.ValidatorI) bool { + k.IterateValidators(ctx, func(_ int64, validator types.ValidatorI) bool { switch validator.GetStatus() { case sdk.Bonded: bonded = bonded.Add(validator.GetTokens()) diff --git a/x/staking/types/delegation.go b/x/staking/types/delegation.go index b3cb79bd33eb..a83321597297 100644 --- a/x/staking/types/delegation.go +++ b/x/staking/types/delegation.go @@ -10,11 +10,10 @@ import ( "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/exported" ) // Implements Delegation interface -var _ exported.DelegationI = Delegation{} +var _ DelegationI = Delegation{} // String implements the Stringer interface for a DVPair object. func (dv DVPair) String() string { diff --git a/x/staking/types/expected_keepers.go b/x/staking/types/expected_keepers.go index 9dd80419a4c6..4979adb2ab48 100644 --- a/x/staking/types/expected_keepers.go +++ b/x/staking/types/expected_keepers.go @@ -4,7 +4,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" bankexported "github.com/cosmos/cosmos-sdk/x/bank/exported" - stakingexported "github.com/cosmos/cosmos-sdk/x/staking/exported" ) // DistributionKeeper expected distribution keeper (noalias) @@ -46,18 +45,18 @@ type BankKeeper interface { type ValidatorSet interface { // iterate through validators by operator address, execute func for each validator IterateValidators(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator ValidatorI) (stop bool)) // iterate through bonded validators by operator address, execute func for each validator IterateBondedValidatorsByPower(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator ValidatorI) (stop bool)) // iterate through the consensus validator set of the last block by operator address, execute func for each validator IterateLastValidators(sdk.Context, - func(index int64, validator stakingexported.ValidatorI) (stop bool)) + func(index int64, validator ValidatorI) (stop bool)) - Validator(sdk.Context, sdk.ValAddress) stakingexported.ValidatorI // get a particular validator by operator address - ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingexported.ValidatorI // get a particular validator by consensus address + Validator(sdk.Context, sdk.ValAddress) ValidatorI // get a particular validator by operator address + ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) ValidatorI // get a particular validator by consensus address TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set StakingTokenSupply(sdk.Context) sdk.Int // total staking token supply @@ -68,7 +67,7 @@ type ValidatorSet interface { // Delegation allows for getting a particular delegation for a given validator // and delegator outside the scope of the staking module. - Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) stakingexported.DelegationI + Delegation(sdk.Context, sdk.AccAddress, sdk.ValAddress) DelegationI // MaxValidators returns the maximum amount of bonded validators MaxValidators(sdk.Context) uint32 @@ -81,7 +80,7 @@ type DelegationSet interface { // iterate through all delegations from one delegator by validator-AccAddress, // execute func for each validator IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress, - fn func(index int64, delegation stakingexported.DelegationI) (stop bool)) + fn func(index int64, delegation DelegationI) (stop bool)) } //_______________________________________________________________________________ diff --git a/x/staking/types/exported.go b/x/staking/types/exported.go new file mode 100644 index 000000000000..02f97dccea49 --- /dev/null +++ b/x/staking/types/exported.go @@ -0,0 +1,37 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/tendermint/tendermint/crypto" +) + +// DelegationI delegation bond for a delegated proof of stake system +type DelegationI interface { + GetDelegatorAddr() sdk.AccAddress // delegator sdk.AccAddress for the bond + GetValidatorAddr() sdk.ValAddress // validator operator address + GetShares() sdk.Dec // amount of validator's shares held in this delegation +} + +// ValidatorI expected validator functions +type ValidatorI interface { + IsJailed() bool // whether the validator is jailed + GetMoniker() string // moniker of the validator + GetStatus() BondStatus // status of the validator + IsBonded() bool // check if has a bonded status + IsUnbonded() bool // check if has status unbonded + IsUnbonding() bool // check if has status unbonding + GetOperator() sdk.ValAddress // operator address to receive/return validators coins + GetConsPubKey() crypto.PubKey // validation consensus pubkey + GetConsAddr() sdk.ConsAddress // validation consensus address + GetTokens() sdk.Int // validation tokens + GetBondedTokens() sdk.Int // validator bonded tokens + GetConsensusPower() int64 // validation power in tendermint + GetCommission() sdk.Dec // validator commission rate + GetMinSelfDelegation() sdk.Int // validator minimum self delegation + GetDelegatorShares() sdk.Dec // total outstanding delegator shares + TokensFromShares(sdk.Dec) sdk.Dec // token worth of provided delegator shares + TokensFromSharesTruncated(sdk.Dec) sdk.Dec // token worth of provided delegator shares, truncated + TokensFromSharesRoundUp(sdk.Dec) sdk.Dec // token worth of provided delegator shares, rounded up + SharesFromTokens(amt sdk.Int) (sdk.Dec, error) // shares worth of delegator's bond + SharesFromTokensTruncated(amt sdk.Int) (sdk.Dec, error) // truncated shares worth of delegator's bond +} diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index 532fe56a834c..c81da89198fb 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -17,7 +17,6 @@ import ( cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - "github.com/cosmos/cosmos-sdk/x/staking/exported" ) const ( @@ -29,7 +28,7 @@ const ( MaxDetailsLength = 280 ) -var _ exported.ValidatorI = Validator{} +var _ ValidatorI = Validator{} // NewValidator constructs a new Validator //nolint:interfacer @@ -72,7 +71,7 @@ func (v Validators) String() (out string) { } // ToSDKValidators - convenience function convert []Validators to []sdk.Validators -func (v Validators) ToSDKValidators() (validators []exported.ValidatorI) { +func (v Validators) ToSDKValidators() (validators []ValidatorI) { for _, val := range v { validators = append(validators, val) } From 2379a241865805cbff2fa663bae00078d766253d Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 18:04:02 +0200 Subject: [PATCH 18/24] fix references --- simapp/export.go | 7 +-- simapp/test_helpers.go | 2 +- types/staking_test.go | 10 ----- x/gov/keeper/common_test.go | 6 +-- x/gov/keeper/tally_test.go | 19 ++++---- x/ibc/core/02-client/keeper/keeper_test.go | 2 +- x/slashing/abci_test.go | 3 +- x/slashing/app_test.go | 2 +- x/slashing/handler_test.go | 10 ++--- x/slashing/keeper/keeper_test.go | 20 ++++----- x/staking/app_test.go | 2 +- x/staking/client/rest/grpc_query_test.go | 2 +- x/staking/client/rest/query.go | 2 +- x/staking/genesis.go | 4 +- x/staking/genesis_test.go | 12 +++--- x/staking/handler.go | 4 +- x/staking/handler_test.go | 14 +++--- x/staking/keeper/delegation.go | 10 ++--- x/staking/keeper/delegation_test.go | 14 +++--- x/staking/keeper/grpc_query.go | 2 +- x/staking/keeper/grpc_query_test.go | 10 ++--- x/staking/keeper/invariants.go | 4 +- x/staking/keeper/querier_test.go | 10 ++--- x/staking/keeper/slash.go | 4 +- x/staking/keeper/slash_test.go | 8 ++-- x/staking/keeper/val_state_change.go | 8 ++-- x/staking/keeper/validator_test.go | 48 ++++++++++----------- x/staking/spec/05_end_block.md | 8 ++-- x/staking/types/validator.go | 14 +++--- x/staking/types/validator_test.go | 50 +++++++++++++--------- 30 files changed, 158 insertions(+), 153 deletions(-) diff --git a/simapp/export.go b/simapp/export.go index 03d30260cb42..7105eca7fc52 100644 --- a/simapp/export.go +++ b/simapp/export.go @@ -6,6 +6,7 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + servertypes "github.com/cosmos/cosmos-sdk/server/types" sdk "github.com/cosmos/cosmos-sdk/types" slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" "github.com/cosmos/cosmos-sdk/x/staking" @@ -16,7 +17,7 @@ import ( // file. func (app *SimApp) ExportAppStateAndValidators( forZeroHeight bool, jailAllowedAddrs []string, -) (servertypes.stakingtypesApp, error) { +) (servertypes.ExportedApp, error) { // as if they could withdraw from the start of the next block ctx := app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()}) @@ -31,11 +32,11 @@ func (app *SimApp) ExportAppStateAndValidators( genState := app.mm.ExportGenesis(ctx, app.appCodec) appState, err := json.MarshalIndent(genState, "", " ") if err != nil { - return servertypes.stakingtypesApp{}, err + return servertypes.ExportedApp{}, err } validators := staking.WriteValidators(ctx, app.StakingKeeper) - return servertypes.stakingtypesApp{ + return servertypes.ExportedApp{ AppState: appState, Validators: validators, Height: height, diff --git a/simapp/test_helpers.go b/simapp/test_helpers.go index 136fde760e42..8be599139b1d 100644 --- a/simapp/test_helpers.go +++ b/simapp/test_helpers.go @@ -96,7 +96,7 @@ func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, genAccs OperatorAddress: sdk.ValAddress(val.Address).String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, val.PubKey), Jailed: false, - Status: sdk.Bonded, + Status: stakingtypes.Bonded, Tokens: bondAmt, DelegatorShares: sdk.OneDec(), Description: stakingtypes.Description{}, diff --git a/types/staking_test.go b/types/staking_test.go index 4ad06cc18b78..e307230cd990 100644 --- a/types/staking_test.go +++ b/types/staking_test.go @@ -20,16 +20,6 @@ func (s *stakingTestSuite) SetupSuite() { s.T().Parallel() } -func (s *stakingTestSuite) TestBondStatus() { - s.Require().False(sdk.Unbonded.Equal(sdk.Bonded)) - s.Require().False(sdk.Unbonded.Equal(sdk.Unbonding)) - s.Require().False(sdk.Bonded.Equal(sdk.Unbonding)) - s.Require().Panicsf(func() { sdk.BondStatus(0).String() }, "invalid bond status") // nolint:govet - s.Require().Equal(sdk.BondStatusUnbonded, sdk.Unbonded.String()) - s.Require().Equal(sdk.BondStatusBonded, sdk.Bonded.String()) - s.Require().Equal(sdk.BondStatusUnbonding, sdk.Unbonding.String()) -} - func (s *stakingTestSuite) TestTokensToConsensusPower() { s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999))) s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000))) diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index 461e4fe0be67..b9b8e2ba3513 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -41,9 +41,9 @@ func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sd app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), sdk.Unbonded, val1, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), sdk.Unbonded, val2, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val3, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), stakingtypes.Unbonded, val1, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), stakingtypes.Unbonded, val2, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2]), stakingtypes.Unbonded, val3, true) _ = staking.EndBlocker(ctx, app.StakingKeeper) diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go index 0589b59bb240..e4f6547e902f 100644 --- a/x/gov/keeper/tally_test.go +++ b/x/gov/keeper/tally_test.go @@ -10,6 +10,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/staking" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) func TestTallyNoOneVotes(t *testing.T) { @@ -248,7 +249,7 @@ func TestTallyDelgatorOverride(t *testing.T) { val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[4], delTokens, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[4], delTokens, stakingtypes.Unbonded, val1, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -284,7 +285,7 @@ func TestTallyDelgatorInherit(t *testing.T) { val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -321,9 +322,9 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) { val2, found := app.StakingKeeper.GetValidator(ctx, vals[1]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val1, true) require.NoError(t, err) - _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val2, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -363,9 +364,9 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) { val3, found := app.StakingKeeper.GetValidator(ctx, vals[2]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val2, true) require.NoError(t, err) - _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -402,9 +403,9 @@ func TestTallyJailedValidator(t *testing.T) { val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val2, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val2, true) require.NoError(t, err) - _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, sdk.Unbonded, val3, true) + _, err = app.StakingKeeper.Delegate(ctx, addrs[3], delTokens, stakingtypes.Unbonded, val3, true) require.NoError(t, err) _ = staking.EndBlocker(ctx, app.StakingKeeper) @@ -441,7 +442,7 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) { val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1]) require.True(t, found) - _, err := app.StakingKeeper.Delegate(ctx, addrs[0], delTokens, sdk.Unbonded, val2, true) + _, err := app.StakingKeeper.Delegate(ctx, addrs[0], delTokens, stakingtypes.Unbonded, val2, true) require.NoError(t, err) tp := TestProposal diff --git a/x/ibc/core/02-client/keeper/keeper_test.go b/x/ibc/core/02-client/keeper/keeper_test.go index 21da1ad63a0f..8db04b643249 100644 --- a/x/ibc/core/02-client/keeper/keeper_test.go +++ b/x/ibc/core/02-client/keeper/keeper_test.go @@ -103,7 +103,7 @@ func (suite *KeeperTestSuite) SetupTest() { pk, err := privVal.GetPubKey() suite.Require().NoError(err) val := stakingtypes.NewValidator(sdk.ValAddress(pk.Address()), pk, stakingtypes.Description{}) - val.Status = sdk.Bonded + val.Status = stakingtypes.Bonded val.Tokens = sdk.NewInt(rand.Int63()) validators = append(validators, val) diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go index 0b6026bcde66..484870719bad 100644 --- a/x/slashing/abci_test.go +++ b/x/slashing/abci_test.go @@ -13,6 +13,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/slashing" slashingkeeper "github.com/cosmos/cosmos-sdk/x/slashing/keeper" "github.com/cosmos/cosmos-sdk/x/staking" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) func TestBeginBlocker(t *testing.T) { @@ -100,5 +101,5 @@ func TestBeginBlocker(t *testing.T) { // validator should be jailed validator, found := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(pk)) require.True(t, found) - require.Equal(t, sdk.Unbonding, validator.GetStatus()) + require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) } diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index 72330875b27d..3e4735e43adf 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -78,7 +78,7 @@ func TestSlashingMsgs(t *testing.T) { validator := checkValidator(t, app, addr1, true) require.Equal(t, sdk.ValAddress(addr1).String(), validator.OperatorAddress) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, stakingtypes.Bonded, validator.Status) require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens())) unjailMsg := &types.MsgUnjail{ValidatorAddr: sdk.ValAddress(addr1).String()} diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go index 9e944fa2d065..3e5bba742c5d 100644 --- a/x/slashing/handler_test.go +++ b/x/slashing/handler_test.go @@ -231,7 +231,7 @@ func TestHandleAbsentValidator(t *testing.T) { // validator should be bonded still validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Bonded, validator.GetStatus()) + require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) bondPool := app.StakingKeeper.GetBondedPool(ctx) require.True(sdk.IntEq(t, amt, app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount)) @@ -250,7 +250,7 @@ func TestHandleAbsentValidator(t *testing.T) { // validator should have been jailed validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Unbonding, validator.GetStatus()) + require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) slashAmt := amt.ToDec().Mul(app.SlashingKeeper.SlashFractionDowntime(ctx)).RoundInt64() @@ -289,7 +289,7 @@ func TestHandleAbsentValidator(t *testing.T) { // validator should be rebonded now validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Bonded, validator.GetStatus()) + require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) // validator should have been slashed require.Equal(t, amt.Int64()-slashAmt, app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount.Int64()) @@ -306,7 +306,7 @@ func TestHandleAbsentValidator(t *testing.T) { ctx = ctx.WithBlockHeight(height) app.SlashingKeeper.HandleValidatorSignature(ctx, val.Address(), power, false) validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Bonded, validator.GetStatus()) + require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) // 500 signed blocks nextHeight := height + app.SlashingKeeper.MinSignedPerWindow(ctx) + 1 @@ -329,5 +329,5 @@ func TestHandleAbsentValidator(t *testing.T) { staking.EndBlocker(ctx, app.StakingKeeper) validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Unbonding, validator.GetStatus()) + require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) } diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go index 11ddb3ea6ea1..d8e49a11c503 100644 --- a/x/slashing/keeper/keeper_test.go +++ b/x/slashing/keeper/keeper_test.go @@ -9,7 +9,6 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/capability/types" "github.com/cosmos/cosmos-sdk/x/slashing/keeper" "github.com/cosmos/cosmos-sdk/x/staking" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -55,7 +54,7 @@ func TestUnJailNotBonded(t *testing.T) { validator, ok := app.StakingKeeper.GetValidator(ctx, addr) require.True(t, ok) require.False(t, validator.Jailed) - require.Equal(t, types.BondStatusUnbonded, validator.GetStatus().String()) + require.Equal(t, stakingtypes.BondStatusUnbonded, validator.GetStatus().String()) // unbond below minimum self-delegation msgUnbond := stakingtypes.NewMsgUndelegate(sdk.AccAddress(addr), addr, sdk.NewCoin(p.BondDenom, sdk.TokensFromConsensusPower(1))) @@ -138,7 +137,7 @@ func TestHandleNewValidator(t *testing.T) { // validator should be bonded still, should not have been jailed or slashed validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Bonded, validator.GetStatus()) + require.Equal(t, stakingtypes.Bonded, validator.GetStatus()) bondPool := app.StakingKeeper.GetBondedPool(ctx) expTokens := sdk.TokensFromConsensusPower(100) require.Equal(t, expTokens.Int64(), app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount.Int64()) @@ -183,7 +182,7 @@ func TestHandleAlreadyJailed(t *testing.T) { // validator should have been jailed and slashed validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val)) - require.Equal(t, sdk.Unbonding, validator.GetStatus()) + require.Equal(t, stakingtypes.Unbonding, validator.GetStatus()) // validator should have been slashed resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1)) @@ -243,7 +242,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { validatorUpdates := staking.EndBlocker(ctx, app.StakingKeeper) require.Equal(t, 2, len(validatorUpdates)) validator, _ := app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Unbonding, validator.Status) + require.Equal(t, stakingtypes.Unbonding, validator.Status) // 600 more blocks happened height = int64(700) @@ -258,7 +257,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { validatorUpdates = staking.EndBlocker(ctx, app.StakingKeeper) require.Equal(t, 2, len(validatorUpdates)) validator, _ = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, stakingtypes.Bonded, validator.Status) newPower := int64(150) // validator misses a block @@ -267,7 +266,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { // shouldn't be jailed/kicked yet validator, _ = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, stakingtypes.Bonded, validator.Status) // validator misses 500 more blocks, 501 total latest := height @@ -279,7 +278,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { // should now be jailed & kicked staking.EndBlocker(ctx, app.StakingKeeper) validator, _ = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Unbonding, validator.Status) + require.Equal(t, stakingtypes.Unbonding, validator.Status) // check all the signing information signInfo, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, consAddr) @@ -304,7 +303,7 @@ func TestValidatorDippingInAndOut(t *testing.T) { // validator should not be kicked since we reset counter/array when it was jailed staking.EndBlocker(ctx, app.StakingKeeper) validator, _ = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, stakingtypes.Bonded, validator.Status) // validator misses 501 blocks latest = height @@ -316,6 +315,5 @@ func TestValidatorDippingInAndOut(t *testing.T) { // validator should now be jailed & kicked staking.EndBlocker(ctx, app.StakingKeeper) validator, _ = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addr)) - require.Equal(t, sdk.Unbonding, validator.Status) - + require.Equal(t, stakingtypes.Unbonding, validator.Status) } diff --git a/x/staking/app_test.go b/x/staking/app_test.go index 7e74d51b661d..2f33961021a0 100644 --- a/x/staking/app_test.go +++ b/x/staking/app_test.go @@ -80,7 +80,7 @@ func TestStakingMsgs(t *testing.T) { validator := checkValidator(t, app, sdk.ValAddress(addr1), true) require.Equal(t, sdk.ValAddress(addr1).String(), validator.OperatorAddress) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, types.Bonded, validator.Status) require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens())) header = tmproto.Header{Height: app.LastBlockHeight() + 1} diff --git a/x/staking/client/rest/grpc_query_test.go b/x/staking/client/rest/grpc_query_test.go index 73386fb62a01..83835370558b 100644 --- a/x/staking/client/rest/grpc_query_test.go +++ b/x/staking/client/rest/grpc_query_test.go @@ -83,7 +83,7 @@ func (s *IntegrationTestSuite) TestQueryValidatorsGRPCHandler() { }, { "test query validators gRPC route with valid status", - fmt.Sprintf("%s/cosmos/staking/v1beta1/validators?status=%s", baseURL, sdk.Bonded.String()), + fmt.Sprintf("%s/cosmos/staking/v1beta1/validators?status=%s", baseURL, types.Bonded.String()), false, }, } diff --git a/x/staking/client/rest/query.go b/x/staking/client/rest/query.go index 8a326c93bc7d..cbe0813c32e3 100644 --- a/x/staking/client/rest/query.go +++ b/x/staking/client/rest/query.go @@ -279,7 +279,7 @@ func validatorsHandlerFn(clientCtx client.Context) http.HandlerFunc { status := r.FormValue("status") if status == "" { - status = sdk.BondStatusBonded + status = types.BondStatusBonded } params := types.NewQueryValidatorsParams(page, limit, status) diff --git a/x/staking/genesis.go b/x/staking/genesis.go index a04711df4edf..e55c32e551b4 100644 --- a/x/staking/genesis.go +++ b/x/staking/genesis.go @@ -51,9 +51,9 @@ func InitGenesis( } switch validator.GetStatus() { - case sdk.Bonded: + case types.Bonded: bondedTokens = bondedTokens.Add(validator.GetTokens()) - case sdk.Unbonding, sdk.Unbonded: + case types.Unbonding, types.Unbonded: notBondedTokens = notBondedTokens.Add(validator.GetTokens()) default: panic("invalid validator status") diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go index 6ee682b563de..d9a08e219cf9 100644 --- a/x/staking/genesis_test.go +++ b/x/staking/genesis_test.go @@ -53,13 +53,13 @@ func TestInitGenesis(t *testing.T) { validators[0].OperatorAddress = sdk.ValAddress(addrs[0]).String() validators[0].ConsensusPubkey = pk0 validators[0].Description = types.NewDescription("hoop", "", "", "", "") - validators[0].Status = sdk.Bonded + validators[0].Status = types.Bonded validators[0].Tokens = valTokens validators[0].DelegatorShares = valTokens.ToDec() validators[1].OperatorAddress = sdk.ValAddress(addrs[1]).String() validators[1].ConsensusPubkey = pk1 validators[1].Description = types.NewDescription("bloop", "", "", "", "") - validators[1].Status = sdk.Bonded + validators[1].Status = types.Bonded validators[1].Tokens = valTokens validators[1].DelegatorShares = valTokens.ToDec() @@ -79,11 +79,11 @@ func TestInitGenesis(t *testing.T) { // now make sure the validators are bonded and intra-tx counters are correct resVal, found := app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addrs[0])) require.True(t, found) - require.Equal(t, sdk.Bonded, resVal.Status) + require.Equal(t, types.Bonded, resVal.Status) resVal, found = app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addrs[1])) require.True(t, found) - require.Equal(t, sdk.Bonded, resVal.Status) + require.Equal(t, types.Bonded, resVal.Status) abcivals := make([]abci.ValidatorUpdate, len(vals)) for i, val := range validators { @@ -107,7 +107,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) { validators[i] = types.NewValidator(sdk.ValAddress(addrs[i]), PKs[i], types.NewDescription(fmt.Sprintf("#%d", i), "", "", "", "")) - validators[i].Status = sdk.Bonded + validators[i].Status = types.Bonded tokens := sdk.TokensFromConsensusPower(1) if i < 100 { @@ -153,7 +153,7 @@ func TestValidateGenesis(t *testing.T) { {"jailed and bonded validator", func(data *types.GenesisState) { data.Validators = genValidators1 data.Validators[0].Jailed = true - data.Validators[0].Status = sdk.Bonded + data.Validators[0].Status = types.Bonded }, true}, } diff --git a/x/staking/handler.go b/x/staking/handler.go index 6c647f9343a3..4da6b05a6654 100644 --- a/x/staking/handler.go +++ b/x/staking/handler.go @@ -111,7 +111,7 @@ func handleMsgCreateValidator(ctx sdk.Context, msg *types.MsgCreateValidator, k // move coins from the msg.Address account to a (self-delegation) delegator account // the validator account and global shares are updated within here // NOTE source will always be from a wallet which are unbonded - _, err = k.Delegate(ctx, delegatorAddress, msg.Value.Amount, sdk.Unbonded, validator, true) + _, err = k.Delegate(ctx, delegatorAddress, msg.Value.Amount, types.Unbonded, validator, true) if err != nil { return nil, err } @@ -215,7 +215,7 @@ func handleMsgDelegate(ctx sdk.Context, msg *types.MsgDelegate, k keeper.Keeper) } // NOTE: source funds are always unbonded - _, err = k.Delegate(ctx, delegatorAddress, msg.Amount.Amount, sdk.Unbonded, validator, true) + _, err = k.Delegate(ctx, delegatorAddress, msg.Amount.Amount, types.Unbonded, validator, true) if err != nil { return nil, err } diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go index f4cf4c72f14b..8114355d90e2 100644 --- a/x/staking/handler_test.go +++ b/x/staking/handler_test.go @@ -91,7 +91,7 @@ func TestValidatorByPowerIndex(t *testing.T) { validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr) require.True(t, found) - require.Equal(t, sdk.Unbonding, validator.Status) // ensure is unbonding + require.Equal(t, types.Unbonding, validator.Status) // ensure is unbonding require.Equal(t, initBond.QuoRaw(2), validator.Tokens) // ensure tokens slashed app.StakingKeeper.Unjail(ctx, consAddr0) @@ -152,7 +152,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) { validator, found := app.StakingKeeper.GetValidator(ctx, addr1) require.True(t, found) - assert.Equal(t, sdk.Bonded, validator.Status) + assert.Equal(t, types.Bonded, validator.Status) assert.Equal(t, addr1.String(), validator.OperatorAddress) assert.Equal(t, pk1.(cryptotypes.IntoTmPubKey).AsTmPubKey(), validator.GetConsPubKey()) assert.Equal(t, valTokens, validator.BondedTokens()) @@ -184,7 +184,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) { validator, found = app.StakingKeeper.GetValidator(ctx, addr2) require.True(t, found) - assert.Equal(t, sdk.Bonded, validator.Status) + assert.Equal(t, types.Bonded, validator.Status) assert.Equal(t, addr2.String(), validator.OperatorAddress) assert.Equal(t, pk2.(cryptotypes.IntoTmPubKey).AsTmPubKey(), validator.GetConsPubKey()) assert.True(sdk.IntEq(t, valTokens, validator.Tokens)) @@ -231,7 +231,7 @@ func TestLegacyValidatorDelegations(t *testing.T) { // verify the validator exists and has the correct attributes validator, found := app.StakingKeeper.GetValidator(ctx, valAddr) require.True(t, found) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, types.Bonded, validator.Status) require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt()) require.Equal(t, bondAmount, validator.BondedTokens()) @@ -332,7 +332,7 @@ func TestIncrementsMsgDelegate(t *testing.T) { validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr) require.True(t, found) - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, types.Bonded, validator.Status) require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt()) require.Equal(t, bondAmount, validator.BondedTokens(), "validator: %v", validator) @@ -1318,7 +1318,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) { require.Equal(t, 2, len(vals), "vals %v", vals) val1, found := app.StakingKeeper.GetValidator(ctx, validatorAddr1) require.True(t, found) - require.Equal(t, sdk.Bonded, val1.Status, "%v", val1) + require.Equal(t, types.Bonded, val1.Status, "%v", val1) } func TestBondUnbondRedelegateSlashTwice(t *testing.T) { @@ -1426,7 +1426,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) { // validator power should have been reduced to zero // validator should be in unbonding state validator, _ = app.StakingKeeper.GetValidator(ctx, valA) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) } func TestInvalidMsg(t *testing.T) { diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go index b62a26fdd850..283b308e767b 100644 --- a/x/staking/keeper/delegation.go +++ b/x/staking/keeper/delegation.go @@ -577,7 +577,7 @@ func (k Keeper) Delegate( // performing a delegation and not a redelegation, thus the source tokens are // all non bonded if subtractAccount { - if tokenSrc == sdk.Bonded { + if tokenSrc == types.Bonded { panic("delegation token source cannot be bonded") } @@ -599,14 +599,14 @@ func (k Keeper) Delegate( } else { // potentially transfer tokens between pools, if switch { - case tokenSrc == sdk.Bonded && validator.IsBonded(): + case tokenSrc == types.Bonded && validator.IsBonded(): // do nothing - case (tokenSrc == sdk.Unbonded || tokenSrc == sdk.Unbonding) && !validator.IsBonded(): + case (tokenSrc == types.Unbonded || tokenSrc == types.Unbonding) && !validator.IsBonded(): // do nothing - case (tokenSrc == sdk.Unbonded || tokenSrc == sdk.Unbonding) && validator.IsBonded(): + case (tokenSrc == types.Unbonded || tokenSrc == types.Unbonding) && validator.IsBonded(): // transfer pools k.notBondedTokensToBonded(ctx, bondAmt) - case tokenSrc == sdk.Bonded && !validator.IsBonded(): + case tokenSrc == types.Bonded && !validator.IsBonded(): // transfer pools k.bondedTokensToNotBonded(ctx, bondAmt) default: diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go index 64906bb65f38..03450614f1e1 100644 --- a/x/staking/keeper/delegation_test.go +++ b/x/staking/keeper/delegation_test.go @@ -367,7 +367,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) { validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) require.Equal(t, sdk.TokensFromConsensusPower(14), validator.Tokens) - require.Equal(t, sdk.Unbonding, validator.Status) + require.Equal(t, types.Unbonding, validator.Status) require.True(t, validator.Jailed) } @@ -533,7 +533,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) { // Make sure validator is still in state because there is still an outstanding delegation validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - require.Equal(t, validator.Status, sdk.Unbonded) + require.Equal(t, validator.Status, types.Unbonded) // unbond some of the other delegation's shares unbondTokens := sdk.TokensFromConsensusPower(6) @@ -615,7 +615,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) { // validator should still be in state and still be in unbonding state validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) - require.Equal(t, validator.Status, sdk.Unbonding) + require.Equal(t, validator.Status, types.Unbonding) // unbond the validator ctx = ctx.WithBlockTime(validator.UnbondingTime) @@ -780,7 +780,7 @@ func TestRedelegationMaxEntries(t *testing.T) { require.Equal(t, valTokens, issuedShares.RoundInt()) validator2 = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator2, true) - require.Equal(t, sdk.Bonded, validator2.Status) + require.Equal(t, types.Bonded, validator2.Status) maxEntries := app.StakingKeeper.MaxEntries(ctx) @@ -841,7 +841,7 @@ func TestRedelegateSelfDelegation(t *testing.T) { validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) validator2 = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator2, true) - require.Equal(t, sdk.Bonded, validator2.Status) + require.Equal(t, types.Bonded, validator2.Status) // create a second delegation to validator 1 delTokens := sdk.TokensFromConsensusPower(10) @@ -862,7 +862,7 @@ func TestRedelegateSelfDelegation(t *testing.T) { validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) require.True(t, found) require.Equal(t, valTokens, validator.Tokens) - require.Equal(t, sdk.Unbonding, validator.Status) + require.Equal(t, types.Unbonding, validator.Status) } func TestRedelegateFromUnbondingValidator(t *testing.T) { @@ -992,7 +992,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) { validator2, issuedShares = validator2.AddTokensFromDel(valTokens) require.Equal(t, valTokens, issuedShares.RoundInt()) validator2 = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator2, true) - require.Equal(t, sdk.Bonded, validator2.Status) + require.Equal(t, types.Bonded, validator2.Status) ctx = ctx.WithBlockHeight(10) ctx = ctx.WithBlockTime(time.Unix(333, 0)) diff --git a/x/staking/keeper/grpc_query.go b/x/staking/keeper/grpc_query.go index e553b2c72c0e..49d9b92ce26d 100644 --- a/x/staking/keeper/grpc_query.go +++ b/x/staking/keeper/grpc_query.go @@ -27,7 +27,7 @@ func (k Querier) Validators(c context.Context, req *types.QueryValidatorsRequest } // validate the provided status, return all the validators if the status is empty - if req.Status != "" && !(req.Status == sdk.Bonded.String() || req.Status == sdk.Unbonded.String() || req.Status == sdk.Unbonding.String()) { + if req.Status != "" && !(req.Status == types.Bonded.String() || req.Status == types.Unbonded.String() || req.Status == types.Unbonding.String()) { return nil, status.Errorf(codes.InvalidArgument, "invalid validator status %s", req.Status) } diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go index 8c8f979df937..fefa4877499f 100644 --- a/x/staking/keeper/grpc_query_test.go +++ b/x/staking/keeper/grpc_query_test.go @@ -50,7 +50,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidators() { }, {"valid request", func() { - req = &types.QueryValidatorsRequest{Status: sdk.Bonded.String(), + req = &types.QueryValidatorsRequest{Status: types.Bonded.String(), Pagination: &query.PageRequest{Limit: 1, CountTotal: true}} }, true, @@ -589,7 +589,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() { valAddrs := simapp.ConvertAddrsToValAddrs(addrs) val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4] delAmount := sdk.TokensFromConsensusPower(1) - _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) suite.NoError(err) _ = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -749,9 +749,9 @@ func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sd app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1) app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), sdk.Unbonded, val1, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), sdk.Unbonded, val2, true) - _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val2, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), types.Unbonded, val1, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), types.Unbonded, val2, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2]), types.Unbonded, val2, true) app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) return addrs, valAddrs, vals diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go index 45e726059dd2..e21de8f9511d 100644 --- a/x/staking/keeper/invariants.go +++ b/x/staking/keeper/invariants.go @@ -54,9 +54,9 @@ func ModuleAccountInvariants(k Keeper) sdk.Invariant { k.IterateValidators(ctx, func(_ int64, validator types.ValidatorI) bool { switch validator.GetStatus() { - case sdk.Bonded: + case types.Bonded: bonded = bonded.Add(validator.GetTokens()) - case sdk.Unbonding, sdk.Unbonded: + case types.Unbonding, types.Unbonded: notBonded = notBonded.Add(validator.GetTokens()) default: panic("invalid validator status") diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go index 429d928d8f43..4e7a94f06af0 100644 --- a/x/staking/keeper/querier_test.go +++ b/x/staking/keeper/querier_test.go @@ -143,7 +143,7 @@ func TestQueryValidators(t *testing.T) { // Create Validators amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} - status := []types.BondStatus{sdk.Bonded, sdk.Unbonded, sdk.Unbonding} + status := []types.BondStatus{types.Bonded, types.Unbonded, types.Unbonding} var validators [3]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(addrs[i]), PKs[i], types.Description{}) @@ -224,7 +224,7 @@ func TestQueryDelegation(t *testing.T) { app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2) delTokens := sdk.TokensFromConsensusPower(20) - _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true) require.NoError(t, err) // apply TM updates @@ -473,7 +473,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) { } delTokens := sdk.TokensFromConsensusPower(20) - _, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, sdk.Unbonded, validator, true) + _, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true) require.NoError(t, err) } @@ -552,7 +552,7 @@ func TestQueryRedelegations(t *testing.T) { app.StakingKeeper.SetValidator(ctx, val2) delAmount := sdk.TokensFromConsensusPower(100) - _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true) require.NoError(t, err) _ = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) @@ -623,7 +623,7 @@ func TestQueryUnbondingDelegation(t *testing.T) { // delegate delAmount := sdk.TokensFromConsensusPower(100) - _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true) + _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true) require.NoError(t, err) _ = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go index f35e84ef7714..7bef3220f731 100644 --- a/x/staking/keeper/slash.go +++ b/x/staking/keeper/slash.go @@ -120,11 +120,11 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh validator = k.RemoveValidatorTokens(ctx, validator, tokensToBurn) switch validator.GetStatus() { - case sdk.Bonded: + case types.Bonded: if err := k.burnBondedTokens(ctx, tokensToBurn); err != nil { panic(err) } - case sdk.Unbonding, sdk.Unbonded: + case types.Unbonding, types.Unbonded: if err := k.burnNotBondedTokens(ctx, tokensToBurn); err != nil { panic(err) } diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go index 954758b224fb..8aaba62a250e 100644 --- a/x/staking/keeper/slash_test.go +++ b/x/staking/keeper/slash_test.go @@ -385,7 +385,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) { // power decreased by 1 again, validator is out of stake // validator should be in unbonding period validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) } //_________________________________________________________________________________ @@ -515,14 +515,14 @@ func TestSlashWithRedelegation(t *testing.T) { // read updated validator // validator decreased to zero power, should be in unbonding period validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) // slash the validator again, by 100% // no stake remains to be slashed ctx = ctx.WithBlockHeight(12) // validator still in unbonding period validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) }) @@ -542,7 +542,7 @@ func TestSlashWithRedelegation(t *testing.T) { // read updated validator // power still zero, still in unbonding period validator, _ = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) } // tests Slash at a previous height with both an unbonding delegation and a redelegation diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go index 52992abbbe52..083efb694032 100644 --- a/x/staking/keeper/val_state_change.go +++ b/x/staking/keeper/val_state_change.go @@ -265,7 +265,7 @@ func (k Keeper) bondValidator(ctx sdk.Context, validator types.Validator) types. // delete the validator by power index, as the key will change k.DeleteValidatorByPowerIndex(ctx, validator) - validator = validator.UpdateStatus(sdk.Bonded) + validator = validator.UpdateStatus(types.Bonded) // save the now bonded validator record to the two referenced stores k.SetValidator(ctx, validator) @@ -288,11 +288,11 @@ func (k Keeper) beginUnbondingValidator(ctx sdk.Context, validator types.Validat k.DeleteValidatorByPowerIndex(ctx, validator) // sanity check - if validator.Status != sdk.Bonded { + if validator.Status != types.Bonded { panic(fmt.Sprintf("should not already be unbonded or unbonding, validator: %v\n", validator)) } - validator = validator.UpdateStatus(sdk.Unbonding) + validator = validator.UpdateStatus(types.Unbonding) // set the unbonding completion time and completion height appropriately validator.UnbondingTime = ctx.BlockHeader().Time.Add(params.UnbondingTime) @@ -313,7 +313,7 @@ func (k Keeper) beginUnbondingValidator(ctx sdk.Context, validator types.Validat // perform all the store operations for when a validator status becomes unbonded func (k Keeper) completeUnbondingValidator(ctx sdk.Context, validator types.Validator) types.Validator { - validator = validator.UpdateStatus(sdk.Unbonded) + validator = validator.UpdateStatus(types.Unbonded) k.SetValidator(ctx, validator) return validator diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go index 4da317a09026..26e894e27c91 100644 --- a/x/staking/keeper/validator_test.go +++ b/x/staking/keeper/validator_test.go @@ -44,7 +44,7 @@ func TestSetValidator(t *testing.T) { // test how the validator is set from a purely unbonbed pool validator := types.NewValidator(valAddr, valPubKey, types.Description{}) validator, _ = validator.AddTokensFromDel(valTokens) - require.Equal(t, sdk.Unbonded, validator.Status) + require.Equal(t, types.Unbonded, validator.Status) assert.Equal(t, valTokens, validator.Tokens) assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt()) app.StakingKeeper.SetValidator(ctx, validator) @@ -58,7 +58,7 @@ func TestSetValidator(t *testing.T) { require.Equal(t, validator.ABCIValidatorUpdate(), updates[0]) // after the save the validator should be bonded - require.Equal(t, sdk.Bonded, validator.Status) + require.Equal(t, types.Bonded, validator.Status) assert.Equal(t, valTokens, validator.Tokens) assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt()) @@ -106,7 +106,7 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) { // add a validator validator := types.NewValidator(addrVals[0], PKs[0], types.Description{}) validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100)) - require.Equal(t, sdk.Unbonded, validator.Status) + require.Equal(t, types.Unbonded, validator.Status) require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0]) @@ -176,8 +176,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) { nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true) expectedValStatus := map[int]types.BondStatus{ - 9: sdk.Bonded, 8: sdk.Bonded, 7: sdk.Bonded, 5: sdk.Bonded, 4: sdk.Bonded, - 0: sdk.Unbonding, 1: sdk.Unbonding, 2: sdk.Unbonding, 3: sdk.Unbonding, 6: sdk.Unbonding, + 9: types.Bonded, 8: types.Bonded, 7: types.Bonded, 5: types.Bonded, 4: types.Bonded, + 0: types.Unbonding, 1: types.Unbonding, 2: types.Unbonding, 3: types.Unbonding, 6: types.Unbonding, } // require all the validators have their respective statuses @@ -210,7 +210,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) { app.AccountKeeper.SetModuleAccount(ctx, bondedPool) validator, _ = validator.AddTokensFromDel(valTokens) - require.Equal(t, sdk.Unbonded, validator.Status) + require.Equal(t, types.Unbonded, validator.Status) require.Equal(t, valTokens, validator.Tokens) app.StakingKeeper.SetValidatorByConsAddr(ctx, validator) validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) @@ -222,7 +222,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) { app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) // validator should be unbonding validator, _ = app.StakingKeeper.GetValidator(ctx, addrVals[0]) - require.Equal(t, validator.GetStatus(), sdk.Unbonding) + require.Equal(t, validator.GetStatus(), types.Unbonding) } // This function tests UpdateValidator, GetValidator, GetLastValidators, RemoveValidator @@ -234,7 +234,7 @@ func TestValidatorBasics(t *testing.T) { powers := []int64{9, 8, 7} for i, power := range powers { validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{}) - validators[i].Status = sdk.Unbonded + validators[i].Status = types.Unbonded validators[i].Tokens = sdk.ZeroInt() tokens := sdk.TokensFromConsensusPower(power) @@ -271,11 +271,11 @@ func TestValidatorBasics(t *testing.T) { resVals = app.StakingKeeper.GetLastValidators(ctx) require.Equal(t, 1, len(resVals)) assert.True(ValEq(t, validators[0], resVals[0])) - assert.Equal(t, sdk.Bonded, validators[0].Status) + assert.Equal(t, types.Bonded, validators[0].Status) assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9), validators[0].BondedTokens())) // modify a records, save, and retrieve - validators[0].Status = sdk.Bonded + validators[0].Status = types.Bonded validators[0].Tokens = sdk.TokensFromConsensusPower(10) validators[0].DelegatorShares = validators[0].Tokens.ToDec() validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true) @@ -311,7 +311,7 @@ func TestValidatorBasics(t *testing.T) { func() { app.StakingKeeper.RemoveValidator(ctx, validators[1].GetOperator()) }) // shouldn't be able to remove if there are still tokens left - validators[1].Status = sdk.Unbonded + validators[1].Status = types.Unbonded app.StakingKeeper.SetValidator(ctx, validators[1]) assert.PanicsWithValue(t, "attempting to remove a validator which still contains tokens", @@ -339,7 +339,7 @@ func TestGetValidatorSortingUnmixed(t *testing.T) { var validators [5]types.Validator for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(addrs[i]), PKs[i], types.Description{}) - validators[i].Status = sdk.Bonded + validators[i].Status = types.Bonded validators[i].Tokens = sdk.NewInt(amt) validators[i].DelegatorShares = sdk.NewDec(amt) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true) @@ -436,7 +436,7 @@ func TestGetValidatorSortingMixed(t *testing.T) { for i, amt := range amts { validators[i] = types.NewValidator(sdk.ValAddress(addrs[i]), PKs[i], types.Description{}) validators[i].DelegatorShares = sdk.NewDec(amt) - validators[i].Status = sdk.Bonded + validators[i].Status = types.Bonded validators[i].Tokens = sdk.NewInt(amt) keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true) } @@ -451,11 +451,11 @@ func TestGetValidatorSortingMixed(t *testing.T) { require.True(t, found) val4, found := app.StakingKeeper.GetValidator(ctx, sdk.ValAddress(addrs[4])) require.True(t, found) - require.Equal(t, sdk.Bonded, val0.Status) - require.Equal(t, sdk.Unbonding, val1.Status) - require.Equal(t, sdk.Unbonding, val2.Status) - require.Equal(t, sdk.Bonded, val3.Status) - require.Equal(t, sdk.Bonded, val4.Status) + require.Equal(t, types.Bonded, val0.Status) + require.Equal(t, types.Unbonding, val1.Status) + require.Equal(t, types.Unbonding, val2.Status) + require.Equal(t, types.Bonded, val3.Status) + require.Equal(t, types.Bonded, val4.Status) // first make sure everything made it in to the gotValidator group resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) @@ -654,11 +654,11 @@ func TestFullValidatorSetPowerChange(t *testing.T) { validators[i], found = app.StakingKeeper.GetValidator(ctx, validators[i].GetOperator()) require.True(t, found) } - assert.Equal(t, sdk.Unbonded, validators[0].Status) - assert.Equal(t, sdk.Unbonding, validators[1].Status) - assert.Equal(t, sdk.Bonded, validators[2].Status) - assert.Equal(t, sdk.Bonded, validators[3].Status) - assert.Equal(t, sdk.Unbonded, validators[4].Status) + assert.Equal(t, types.Unbonded, validators[0].Status) + assert.Equal(t, types.Unbonding, validators[1].Status) + assert.Equal(t, types.Bonded, validators[2].Status) + assert.Equal(t, types.Bonded, validators[3].Status) + assert.Equal(t, types.Unbonded, validators[4].Status) resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx) assert.Equal(t, max, len(resValidators)) assert.True(ValEq(t, validators[2], resValidators[0])) // in the order of txs @@ -747,7 +747,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) { // test single value change // tendermintUpdate set: {} -> {c1'} - validators[0].Status = sdk.Bonded + validators[0].Status = types.Bonded validators[0].Tokens = sdk.TokensFromConsensusPower(600) validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false) diff --git a/x/staking/spec/05_end_block.md b/x/staking/spec/05_end_block.md index 3207c078cd30..c0777896fbfd 100644 --- a/x/staking/spec/05_end_block.md +++ b/x/staking/spec/05_end_block.md @@ -19,9 +19,9 @@ consensus layer. Operations are as following: validators retrieved from the ValidatorsByPower index - the previous validator set is compared with the new validator set: - missing validators begin unbonding and their `Tokens` are transferred from the - `BondedPool` to the `NotBondedPool` `ModuleAccount` + `BondedPool` to the `NotBondedPool` `ModuleAccount` - new validators are instantly bonded and their `Tokens` are transferred from the - `NotBondedPool` to the `BondedPool` `ModuleAccount` + `NotBondedPool` to the `BondedPool` `ModuleAccount` In all cases, any validators leaving or entering the bonded validator set or changing balances and staying within the bonded validator set incur an update @@ -48,8 +48,8 @@ Each block the validator queue is to be checked for mature unbonding validators (namely with a completion time <= current time). At this point any mature validators which do not have any delegations remaining are deleted from state. For all other mature unbonding validators that still have remaining -delegations, the `validator.Status` is switched from `sdk.Unbonding` to -`sdk.Unbonded`. +delegations, the `validator.Status` is switched from `types.Unbonding` to +`types.Unbonded`. ### Unbonding Delegations diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index c81da89198fb..e9b184ef6e1c 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -26,6 +26,10 @@ const ( MaxWebsiteLength = 140 MaxSecurityContactLength = 140 MaxDetailsLength = 280 + + BondStatusUnbonded = "Unbonded" + BondStatusUnbonding = "Unbonding" + BondStatusBonded = "Bonded" ) var _ ValidatorI = Validator{} @@ -42,7 +46,7 @@ func NewValidator(operator sdk.ValAddress, pubKey crypto.PubKey, description Des OperatorAddress: operator.String(), ConsensusPubkey: pkStr, Jailed: false, - Status: sdk.Unbonded, + Status: Unbonded, Tokens: sdk.ZeroInt(), DelegatorShares: sdk.ZeroDec(), Description: description, @@ -134,17 +138,17 @@ func UnmarshalValidator(cdc codec.BinaryMarshaler, value []byte) (v Validator, e // IsBonded checks if the validator status equals Bonded func (v Validator) IsBonded() bool { - return v.GetStatus().Equal(sdk.Bonded) + return v.GetStatus() == Bonded } // IsUnbonded checks if the validator status equals Unbonded func (v Validator) IsUnbonded() bool { - return v.GetStatus().Equal(sdk.Unbonded) + return v.GetStatus() == Unbonded } // IsUnbonding checks if the validator status equals Unbonding func (v Validator) IsUnbonding() bool { - return v.GetStatus().Equal(sdk.Unbonding) + return v.GetStatus() == Unbonding } // constant used in flags to indicate that description field should not be updated @@ -411,7 +415,7 @@ func (v Validator) RemoveDelShares(delShares sdk.Dec) (Validator, sdk.Int) { func (v Validator) MinEqual(other Validator) bool { return v.ConsensusPubkey == other.ConsensusPubkey && (v.OperatorAddress == other.OperatorAddress) && - v.Status.Equal(other.Status) && + v.Status == other.Status && v.Tokens.Equal(other.Tokens) && v.DelegatorShares.Equal(other.DelegatorShares) && v.Description == other.Description && diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go index 5ea04c2034c5..075b0fe23419 100644 --- a/x/staking/types/validator_test.go +++ b/x/staking/types/validator_test.go @@ -83,7 +83,7 @@ func TestShareTokens(t *testing.T) { validator := Validator{ OperatorAddress: valAddr1.String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, pk1), - Status: sdk.Bonded, + Status: Bonded, Tokens: sdk.NewInt(100), DelegatorShares: sdk.NewDec(100), } @@ -101,7 +101,7 @@ func TestRemoveTokens(t *testing.T) { validator := Validator{ OperatorAddress: valAddr.String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, valPubKey), - Status: sdk.Bonded, + Status: Bonded, Tokens: sdk.NewInt(100), DelegatorShares: sdk.NewDec(100), } @@ -111,8 +111,8 @@ func TestRemoveTokens(t *testing.T) { require.Equal(t, int64(90), validator.Tokens.Int64()) // update validator to from bonded -> unbonded - validator = validator.UpdateStatus(sdk.Unbonded) - require.Equal(t, sdk.Unbonded, validator.Status) + validator = validator.UpdateStatus(Unbonded) + require.Equal(t, Unbonded, validator.Status) validator = validator.RemoveTokens(sdk.NewInt(10)) require.Panics(t, func() { validator.RemoveTokens(sdk.NewInt(-1)) }) @@ -121,7 +121,7 @@ func TestRemoveTokens(t *testing.T) { func TestAddTokensValidatorBonded(t *testing.T) { validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) - validator = validator.UpdateStatus(sdk.Bonded) + validator = validator.UpdateStatus(Bonded) validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) @@ -131,11 +131,11 @@ func TestAddTokensValidatorBonded(t *testing.T) { func TestAddTokensValidatorUnbonding(t *testing.T) { validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) - validator = validator.UpdateStatus(sdk.Unbonding) + validator = validator.UpdateStatus(Unbonding) validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) - assert.Equal(t, sdk.Unbonding, validator.Status) + assert.Equal(t, Unbonding, validator.Status) assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens)) assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares)) } @@ -143,11 +143,11 @@ func TestAddTokensValidatorUnbonding(t *testing.T) { func TestAddTokensValidatorUnbonded(t *testing.T) { validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) - validator = validator.UpdateStatus(sdk.Unbonded) + validator = validator.UpdateStatus(Unbonded) validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) assert.True(sdk.DecEq(t, sdk.NewDec(10), delShares)) - assert.Equal(t, sdk.Unbonded, validator.Status) + assert.Equal(t, Unbonded, validator.Status) assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens)) assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares)) } @@ -157,7 +157,7 @@ func TestRemoveDelShares(t *testing.T) { valA := Validator{ OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()).String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, pk1), - Status: sdk.Bonded, + Status: Bonded, Tokens: sdk.NewInt(100), DelegatorShares: sdk.NewDec(100), } @@ -174,7 +174,7 @@ func TestRemoveDelShares(t *testing.T) { validator := Validator{ OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()).String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, pk1), - Status: sdk.Bonded, + Status: Bonded, Tokens: poolTokens, DelegatorShares: delShares, } @@ -202,20 +202,20 @@ func TestAddTokensFromDel(t *testing.T) { func TestUpdateStatus(t *testing.T) { validator := NewValidator(sdk.ValAddress(pk1.Address().Bytes()), pk1, Description{}) validator, _ = validator.AddTokensFromDel(sdk.NewInt(100)) - require.Equal(t, sdk.Unbonded, validator.Status) + require.Equal(t, Unbonded, validator.Status) require.Equal(t, int64(100), validator.Tokens.Int64()) // Unbonded to Bonded - validator = validator.UpdateStatus(sdk.Bonded) - require.Equal(t, sdk.Bonded, validator.Status) + validator = validator.UpdateStatus(Bonded) + require.Equal(t, Bonded, validator.Status) // Bonded to Unbonding - validator = validator.UpdateStatus(sdk.Unbonding) - require.Equal(t, sdk.Unbonding, validator.Status) + validator = validator.UpdateStatus(Unbonding) + require.Equal(t, Unbonding, validator.Status) // Unbonding to Bonded - validator = validator.UpdateStatus(sdk.Bonded) - require.Equal(t, sdk.Bonded, validator.Status) + validator = validator.UpdateStatus(Bonded) + require.Equal(t, Bonded, validator.Status) } func TestPossibleOverflow(t *testing.T) { @@ -223,7 +223,7 @@ func TestPossibleOverflow(t *testing.T) { validator := Validator{ OperatorAddress: sdk.ValAddress(pk1.Address().Bytes()).String(), ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, pk1), - Status: sdk.Bonded, + Status: Bonded, Tokens: sdk.NewInt(2159), DelegatorShares: delShares, } @@ -315,7 +315,7 @@ func TestValidatorToTm(t *testing.T) { for i := range vals { pk := ed25519.GenPrivKey().PubKey() val := NewValidator(sdk.ValAddress(pk.Address()), pk, Description{}) - val.Status = sdk.Bonded + val.Status = Bonded val.Tokens = sdk.NewInt(rand.Int63()) vals[i] = val expected[i] = tmtypes.NewValidator(pk.(cryptotypes.IntoTmPubKey).AsTmPubKey(), val.ConsensusPower()) @@ -323,3 +323,13 @@ func TestValidatorToTm(t *testing.T) { require.Equal(t, expected, vals.ToTmValidators()) } + +func TestBondStatus(t *testing.T) { + require.False(t, Unbonded == Bonded) + require.False(t, Unbonded == Unbonding) + require.False(t, Bonded == Unbonding) + require.Panicsf(t, func() { BondStatus(4).String() }, "invalid bond status") // nolint:govet + require.Equal(t, BondStatusUnbonded, Unbonded.String()) + require.Equal(t, BondStatusBonded, Bonded.String()) + require.Equal(t, BondStatusUnbonding, Unbonding.String()) +} From 7c276aabc7dbd2119a9b70a552d32ae6bea264d1 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Fri, 9 Oct 2020 18:10:34 +0200 Subject: [PATCH 19/24] Better constants --- x/staking/types/validator.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index e9b184ef6e1c..8d83c39faea1 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -27,9 +27,10 @@ const ( MaxSecurityContactLength = 140 MaxDetailsLength = 280 - BondStatusUnbonded = "Unbonded" - BondStatusUnbonding = "Unbonding" - BondStatusBonded = "Bonded" + BondStatusUnspecified = BondStatus_name[Unspecified] + BondStatusUnbonded = BondStatus_name[Unbonded] + BondStatusUnbonding = BondStatus_name[Unbonding] + BondStatusBonded = BondStatus_name[Bonded] ) var _ ValidatorI = Validator{} From 7c4329a0b51b43428d72b8409ac7540fd9afdb57 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Mon, 12 Oct 2020 11:24:20 +0200 Subject: [PATCH 20/24] Fix build --- x/staking/types/validator.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index 8d83c39faea1..3bac25fe79e2 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -26,11 +26,13 @@ const ( MaxWebsiteLength = 140 MaxSecurityContactLength = 140 MaxDetailsLength = 280 +) - BondStatusUnspecified = BondStatus_name[Unspecified] - BondStatusUnbonded = BondStatus_name[Unbonded] - BondStatusUnbonding = BondStatus_name[Unbonding] - BondStatusBonded = BondStatus_name[Bonded] +var ( + BondStatusUnspecified = BondStatus_name[int32(Unspecified)] + BondStatusUnbonded = BondStatus_name[int32(Unbonded)] + BondStatusUnbonding = BondStatus_name[int32(Unbonding)] + BondStatusBonded = BondStatus_name[int32(Bonded)] ) var _ ValidatorI = Validator{} From 510c3b6c8f80c46ead0831ba901504ec3f40c731 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Mon, 12 Oct 2020 11:30:27 +0200 Subject: [PATCH 21/24] Fix lint --- buf.yaml | 1 + proto/cosmos/staking/v1beta1/staking.proto | 8 +- x/staking/keeper/alias_functions.go | 15 +- x/staking/types/expected_keepers.go | 4 +- x/staking/types/staking.pb.go | 1396 ++++++++++---------- 5 files changed, 713 insertions(+), 711 deletions(-) diff --git a/buf.yaml b/buf.yaml index adaef5ff18ef..89e406ec6653 100644 --- a/buf.yaml +++ b/buf.yaml @@ -1,3 +1,4 @@ +version: v1beta1 build: roots: - proto diff --git a/proto/cosmos/staking/v1beta1/staking.proto b/proto/cosmos/staking/v1beta1/staking.proto index 51767a7f8898..7201b7fa01d7 100644 --- a/proto/cosmos/staking/v1beta1/staking.proto +++ b/proto/cosmos/staking/v1beta1/staking.proto @@ -99,13 +99,13 @@ enum BondStatus { option (gogoproto.goproto_enum_prefix) = false; // UNSPECIFIED defines an invalid validator status. - UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unspecified"]; + BOND_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "Unspecified"]; // UNBONDED defines a validator that is not bonded. - UNBONDED = 1 [(gogoproto.enumvalue_customname) = "Unbonded"]; + BOND_STATUS_UNBONDED = 1 [(gogoproto.enumvalue_customname) = "Unbonded"]; // UNBONDING defines a validator that is unbonding. - UNBONDING = 2 [(gogoproto.enumvalue_customname) = "Unbonding"]; + BOND_STATUS_UNBONDING = 2 [(gogoproto.enumvalue_customname) = "Unbonding"]; // BONDED defines a validator that is bonded. - BONDED = 3 [(gogoproto.enumvalue_customname) = "Bonded"]; + BOND_STATUS_BONDED = 3 [(gogoproto.enumvalue_customname) = "Bonded"]; } // ValAddresses defines a repeated set of validator addresses. diff --git a/x/staking/keeper/alias_functions.go b/x/staking/keeper/alias_functions.go index da42b82d7aa7..1d563c690783 100644 --- a/x/staking/keeper/alias_functions.go +++ b/x/staking/keeper/alias_functions.go @@ -5,14 +5,13 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking/types" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) //_______________________________________________________________________ // Validator Set // iterate through the validator set and perform the provided function -func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { +func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validator types.ValidatorI) (stop bool)) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, types.ValidatorsKey) @@ -32,7 +31,7 @@ func (k Keeper) IterateValidators(ctx sdk.Context, fn func(index int64, validato } // iterate through the bonded validator set and perform the provided function -func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { +func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index int64, validator types.ValidatorI) (stop bool)) { store := ctx.KVStore(k.storeKey) maxValidators := k.MaxValidators(ctx) @@ -55,7 +54,7 @@ func (k Keeper) IterateBondedValidatorsByPower(ctx sdk.Context, fn func(index in } // iterate through the active validator set and perform the provided function -func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) { +func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, validator types.ValidatorI) (stop bool)) { iterator := k.LastValidatorsIterator(ctx) defer iterator.Close() @@ -78,7 +77,7 @@ func (k Keeper) IterateLastValidators(ctx sdk.Context, fn func(index int64, vali } // Validator gets the Validator interface for a particular address -func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) stakingtypes.ValidatorI { +func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) types.ValidatorI { val, found := k.GetValidator(ctx, address) if !found { return nil @@ -88,7 +87,7 @@ func (k Keeper) Validator(ctx sdk.Context, address sdk.ValAddress) stakingtypes. } // ValidatorByConsAddr gets the validator interface for a particular pubkey -func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) stakingtypes.ValidatorI { +func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) types.ValidatorI { val, found := k.GetValidatorByConsAddr(ctx, addr) if !found { return nil @@ -106,7 +105,7 @@ func (k Keeper) GetValidatorSet() types.ValidatorSet { } // Delegation get the delegation interface for a particular set of delegator and validator addresses -func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) stakingtypes.DelegationI { +func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) types.DelegationI { bond, ok := k.GetDelegation(ctx, addrDel, addrVal) if !ok { return nil @@ -117,7 +116,7 @@ func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk. // iterate through all of the delegations from a delegator func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.AccAddress, - fn func(index int64, del stakingtypes.DelegationI) (stop bool)) { + fn func(index int64, del types.DelegationI) (stop bool)) { store := ctx.KVStore(k.storeKey) delegatorPrefixKey := types.GetDelegationsKey(delAddr) diff --git a/x/staking/types/expected_keepers.go b/x/staking/types/expected_keepers.go index 4979adb2ab48..1c1d7f7de96b 100644 --- a/x/staking/types/expected_keepers.go +++ b/x/staking/types/expected_keepers.go @@ -57,8 +57,8 @@ type ValidatorSet interface { Validator(sdk.Context, sdk.ValAddress) ValidatorI // get a particular validator by operator address ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) ValidatorI // get a particular validator by consensus address - TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set - StakingTokenSupply(sdk.Context) sdk.Int // total staking token supply + TotalBondedTokens(sdk.Context) sdk.Int // total bonded tokens within the validator set + StakingTokenSupply(sdk.Context) sdk.Int // total staking token supply // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go index 43ac3cda6638..08d6ccc7614d 100644 --- a/x/staking/types/staking.pb.go +++ b/x/staking/types/staking.pb.go @@ -53,17 +53,17 @@ const ( ) var BondStatus_name = map[int32]string{ - 0: "UNSPECIFIED", - 1: "UNBONDED", - 2: "UNBONDING", - 3: "BONDED", + 0: "BOND_STATUS_UNSPECIFIED", + 1: "BOND_STATUS_UNBONDED", + 2: "BOND_STATUS_UNBONDING", + 3: "BOND_STATUS_BONDED", } var BondStatus_value = map[string]int32{ - "UNSPECIFIED": 0, - "UNBONDED": 1, - "UNBONDING": 2, - "BONDED": 3, + "BOND_STATUS_UNSPECIFIED": 0, + "BOND_STATUS_UNBONDED": 1, + "BOND_STATUS_UNBONDING": 2, + "BOND_STATUS_BONDED": 3, } func (x BondStatus) String() string { @@ -1092,116 +1092,117 @@ func init() { } var fileDescriptor_64c30c6cf92913c9 = []byte{ - // 1740 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x23, 0x49, - 0x15, 0x77, 0xdb, 0x5e, 0xc7, 0x7e, 0x4e, 0xe2, 0xb8, 0x66, 0x26, 0x78, 0xcc, 0xe0, 0xf6, 0x36, - 0x2b, 0x18, 0x10, 0x38, 0x4c, 0x40, 0x8b, 0xc8, 0x05, 0xd6, 0x71, 0x86, 0x58, 0x2c, 0x21, 0x74, - 0x66, 0x82, 0x04, 0x2b, 0xac, 0x72, 0x77, 0xc5, 0x69, 0xe2, 0xee, 0x36, 0x5d, 0xe5, 0x21, 0x91, - 0xf6, 0xc0, 0x09, 0x2d, 0x83, 0x10, 0xcb, 0x6d, 0x2f, 0x91, 0x22, 0xed, 0x15, 0x89, 0x3f, 0x81, - 0xeb, 0x22, 0x2e, 0xc3, 0x0d, 0x21, 0x64, 0xd0, 0xcc, 0x05, 0x71, 0x42, 0x3e, 0x20, 0x4e, 0x80, - 0xea, 0xa3, 0x3f, 0xd2, 0x8e, 0x67, 0xc6, 0xd1, 0x1e, 0x56, 0x62, 0x2f, 0x89, 0xeb, 0xd5, 0x7b, - 0xbf, 0x57, 0xef, 0xb3, 0x5e, 0x35, 0xbc, 0x66, 0xf9, 0xd4, 0xf5, 0xe9, 0x06, 0x65, 0xf8, 0xc4, - 0xf1, 0x06, 0x1b, 0x8f, 0xee, 0xf5, 0x09, 0xc3, 0xf7, 0xc2, 0x75, 0x6b, 0x14, 0xf8, 0xcc, 0x47, - 0xeb, 0x92, 0xab, 0x15, 0x52, 0x15, 0x57, 0xfd, 0xe6, 0xc0, 0x1f, 0xf8, 0x82, 0x65, 0x83, 0xff, - 0x92, 0xdc, 0xf5, 0x3b, 0x8c, 0x78, 0x36, 0x09, 0x5c, 0xc7, 0x63, 0x1b, 0xec, 0x6c, 0x44, 0xa8, - 0xfc, 0xab, 0x76, 0xf5, 0x81, 0xef, 0x0f, 0x86, 0x64, 0x43, 0xac, 0xfa, 0xe3, 0xa3, 0x0d, 0xe6, - 0xb8, 0x84, 0x32, 0xec, 0x8e, 0x14, 0x43, 0x23, 0xcd, 0x60, 0x8f, 0x03, 0xcc, 0x1c, 0xdf, 0x0b, - 0xf7, 0xd5, 0x91, 0xfb, 0x98, 0x92, 0xe8, 0xbc, 0x96, 0xef, 0xa8, 0x7d, 0xe3, 0xe7, 0x1a, 0xac, - 0xee, 0x3a, 0x94, 0xf9, 0x81, 0x63, 0xe1, 0x61, 0xd7, 0x3b, 0xf2, 0xd1, 0xeb, 0x50, 0x38, 0x26, - 0xd8, 0x26, 0x41, 0x4d, 0x6b, 0x6a, 0x77, 0xcb, 0x9b, 0xb5, 0x56, 0x7c, 0xc4, 0x96, 0x3c, 0xdc, - 0xae, 0xd8, 0x6f, 0xe7, 0x3f, 0x98, 0xe8, 0x19, 0x53, 0x71, 0xa3, 0xaf, 0x43, 0xe1, 0x11, 0x1e, - 0x52, 0xc2, 0x6a, 0xd9, 0x66, 0xee, 0x6e, 0x79, 0xf3, 0xd5, 0xd6, 0xd5, 0x8e, 0x68, 0x1d, 0xe2, - 0xa1, 0x63, 0x63, 0xe6, 0x47, 0x00, 0x52, 0xcc, 0xf8, 0x6d, 0x16, 0x2a, 0xdb, 0xbe, 0xeb, 0x3a, - 0x94, 0x3a, 0xbe, 0x67, 0x62, 0x46, 0x28, 0x6a, 0x43, 0x3e, 0xc0, 0x8c, 0x88, 0xa3, 0x94, 0xda, - 0x2d, 0xce, 0xff, 0xe7, 0x89, 0xfe, 0x99, 0x81, 0xc3, 0x8e, 0xc7, 0xfd, 0x96, 0xe5, 0xbb, 0x1b, - 0xca, 0x40, 0xf9, 0xef, 0x8b, 0xd4, 0x3e, 0x51, 0x0e, 0xec, 0x10, 0xcb, 0x14, 0xb2, 0xe8, 0x2d, - 0x28, 0xba, 0xf8, 0xb4, 0x27, 0x70, 0xb2, 0x02, 0xe7, 0x8d, 0xc5, 0x70, 0xa6, 0x13, 0xbd, 0x72, - 0x86, 0xdd, 0xe1, 0x96, 0x11, 0xe2, 0x18, 0xe6, 0x92, 0x8b, 0x4f, 0xf9, 0x11, 0xd1, 0x08, 0x2a, - 0x9c, 0x6a, 0x1d, 0x63, 0x6f, 0x40, 0xa4, 0x92, 0x9c, 0x50, 0xb2, 0xbb, 0xb0, 0x92, 0xf5, 0x58, - 0x49, 0x02, 0xce, 0x30, 0x57, 0x5c, 0x7c, 0xba, 0x2d, 0x08, 0x5c, 0xe3, 0x56, 0xf1, 0xbd, 0x0b, - 0x3d, 0xf3, 0xf7, 0x0b, 0x5d, 0x33, 0xfe, 0xa8, 0x01, 0xc4, 0x1e, 0x43, 0x6f, 0xc1, 0x9a, 0x15, - 0xad, 0x84, 0x2c, 0x55, 0x31, 0xfc, 0xec, 0xbc, 0x58, 0xa4, 0xfc, 0xdd, 0x2e, 0xf2, 0x43, 0x3f, - 0x99, 0xe8, 0x9a, 0x59, 0xb1, 0x52, 0xa1, 0xf8, 0x01, 0x94, 0xc7, 0x23, 0x1b, 0x33, 0xd2, 0xe3, - 0x49, 0x28, 0x3c, 0x59, 0xde, 0xac, 0xb7, 0x64, 0x02, 0xb6, 0xc2, 0x04, 0x6c, 0x3d, 0x08, 0x33, - 0xb4, 0xdd, 0xe0, 0x58, 0xd3, 0x89, 0x8e, 0xa4, 0x59, 0x09, 0x61, 0xe3, 0xdd, 0xbf, 0xea, 0x9a, - 0x09, 0x92, 0xc2, 0x05, 0x12, 0x36, 0xfd, 0x5e, 0x83, 0x72, 0x87, 0x50, 0x2b, 0x70, 0x46, 0x3c, - 0x8f, 0x51, 0x0d, 0x96, 0x5c, 0xdf, 0x73, 0x4e, 0x54, 0x3e, 0x96, 0xcc, 0x70, 0x89, 0xea, 0x50, - 0x74, 0x6c, 0xe2, 0x31, 0x87, 0x9d, 0xc9, 0xb8, 0x9a, 0xd1, 0x9a, 0x4b, 0xfd, 0x84, 0xf4, 0xa9, - 0x13, 0x46, 0xc3, 0x0c, 0x97, 0xe8, 0x3e, 0xac, 0x51, 0x62, 0x8d, 0x03, 0x87, 0x9d, 0xf5, 0x2c, - 0xdf, 0x63, 0xd8, 0x62, 0xb5, 0xbc, 0x08, 0xd8, 0x27, 0xa7, 0x13, 0xfd, 0x13, 0xf2, 0xac, 0x69, - 0x0e, 0xc3, 0xac, 0x84, 0xa4, 0x6d, 0x49, 0xe1, 0x1a, 0x6c, 0xc2, 0xb0, 0x33, 0xa4, 0xb5, 0x57, - 0xa4, 0x06, 0xb5, 0x4c, 0xd8, 0xf2, 0x9f, 0x02, 0x94, 0xa2, 0x6c, 0xe7, 0x9a, 0xfd, 0x11, 0x09, - 0xf8, 0xef, 0x1e, 0xb6, 0xed, 0x80, 0x50, 0xaa, 0xf2, 0x3a, 0xa1, 0x39, 0xcd, 0x61, 0x98, 0x95, - 0x90, 0xf4, 0x86, 0xa4, 0x70, 0x1c, 0xcb, 0xf7, 0x28, 0xf1, 0xe8, 0x98, 0xf6, 0x46, 0xe3, 0xfe, - 0x09, 0x51, 0xf6, 0x27, 0x71, 0xd2, 0x1c, 0x06, 0x0f, 0xa8, 0x22, 0xed, 0x0b, 0x0a, 0x5a, 0x87, - 0xc2, 0x8f, 0xb0, 0x33, 0x24, 0xb6, 0x70, 0x51, 0xd1, 0x54, 0x2b, 0xb4, 0x05, 0x05, 0xca, 0x30, - 0x1b, 0x53, 0xe1, 0x97, 0xd5, 0x4d, 0x63, 0x5e, 0xf2, 0xb4, 0x7d, 0xcf, 0x3e, 0x10, 0x9c, 0xa6, - 0x92, 0x40, 0xf7, 0xa1, 0xc0, 0xfc, 0x13, 0xe2, 0x29, 0xa7, 0x2c, 0x54, 0xb1, 0x5d, 0x8f, 0x99, - 0x4a, 0x1a, 0x31, 0x58, 0xb3, 0xc9, 0x90, 0x0c, 0x84, 0x2b, 0xe8, 0x31, 0x0e, 0x08, 0xad, 0x15, - 0x04, 0x62, 0x77, 0xe1, 0xb2, 0x52, 0x1e, 0x49, 0xe3, 0x19, 0x66, 0x25, 0x22, 0x1d, 0x08, 0x0a, - 0xfa, 0x16, 0x94, 0xed, 0x38, 0xf5, 0x6a, 0x4b, 0x22, 0xc5, 0x3f, 0x3d, 0xcf, 0xfc, 0x44, 0x96, - 0xaa, 0x4e, 0x96, 0x94, 0xe6, 0x61, 0x1a, 0x7b, 0x7d, 0xdf, 0xb3, 0x1d, 0x6f, 0xd0, 0x3b, 0x26, - 0xce, 0xe0, 0x98, 0xd5, 0x8a, 0x4d, 0xed, 0x6e, 0x2e, 0x19, 0xa6, 0x34, 0x87, 0x61, 0x56, 0x22, - 0xd2, 0xae, 0xa0, 0x20, 0x1b, 0x56, 0x63, 0x2e, 0x51, 0x7a, 0xa5, 0x17, 0x96, 0xde, 0xab, 0xaa, - 0xf4, 0x6e, 0xa5, 0xb5, 0xc4, 0xd5, 0xb7, 0x12, 0x11, 0xb9, 0x18, 0xda, 0x05, 0x88, 0x0b, 0xbe, - 0x06, 0x42, 0x83, 0xf1, 0xe2, 0xae, 0xa1, 0x0c, 0x4f, 0xc8, 0xa2, 0xb7, 0xe1, 0x86, 0xeb, 0x78, - 0x3d, 0x4a, 0x86, 0x47, 0x3d, 0xe5, 0x60, 0x0e, 0x59, 0x16, 0xd1, 0x7b, 0x73, 0xb1, 0x7c, 0x98, - 0x4e, 0xf4, 0xba, 0x6a, 0x8a, 0xb3, 0x90, 0x86, 0x59, 0x75, 0x1d, 0xef, 0x80, 0x0c, 0x8f, 0x3a, - 0x11, 0x6d, 0x6b, 0xf9, 0x9d, 0x0b, 0x3d, 0xa3, 0x0a, 0x30, 0x63, 0xbc, 0x0e, 0xcb, 0x87, 0x78, - 0xa8, 0x0a, 0x87, 0x50, 0x74, 0x07, 0x4a, 0x38, 0x5c, 0xd4, 0xb4, 0x66, 0xee, 0x6e, 0xc9, 0x8c, - 0x09, 0xb2, 0x70, 0x7f, 0xfa, 0x97, 0xa6, 0x66, 0xfc, 0x46, 0x83, 0x42, 0xe7, 0x70, 0x1f, 0x3b, - 0x01, 0xea, 0x42, 0x35, 0xce, 0x9c, 0xcb, 0x65, 0x7b, 0x67, 0x3a, 0xd1, 0x6b, 0xe9, 0xe4, 0x8a, - 0xea, 0x36, 0x4e, 0xe0, 0xb0, 0x70, 0xbb, 0x50, 0x7d, 0x14, 0x76, 0x83, 0x08, 0x2a, 0x9b, 0x86, - 0x9a, 0x61, 0x31, 0xcc, 0xb5, 0x88, 0xa6, 0xa0, 0x52, 0x66, 0xee, 0xc0, 0x92, 0x3c, 0x2d, 0x45, - 0x5b, 0xf0, 0xca, 0x88, 0xff, 0x10, 0xd6, 0x95, 0x37, 0x1b, 0x73, 0x93, 0x57, 0xf0, 0xab, 0xf0, - 0x49, 0x11, 0xe3, 0xd7, 0x59, 0x80, 0xce, 0xe1, 0xe1, 0x83, 0xc0, 0x19, 0x0d, 0x09, 0xfb, 0x30, - 0x2d, 0x7f, 0x00, 0xb7, 0x62, 0xb3, 0x68, 0x60, 0xa5, 0xac, 0x6f, 0x4e, 0x27, 0xfa, 0x9d, 0xb4, - 0xf5, 0x09, 0x36, 0xc3, 0xbc, 0x11, 0xd1, 0x0f, 0x02, 0xeb, 0x4a, 0x54, 0x9b, 0xb2, 0x08, 0x35, - 0x37, 0x1f, 0x35, 0xc1, 0x96, 0x44, 0xed, 0x50, 0x76, 0xb5, 0x6b, 0x0f, 0xa0, 0x1c, 0xbb, 0x84, - 0xa2, 0x0e, 0x14, 0x99, 0xfa, 0xad, 0x3c, 0x6c, 0xcc, 0xf7, 0x70, 0x28, 0xa6, 0xbc, 0x1c, 0x49, - 0x1a, 0xff, 0xd6, 0x00, 0xe2, 0x9c, 0xfd, 0x68, 0xa6, 0x18, 0x6f, 0xe5, 0xaa, 0xf1, 0xe6, 0xae, - 0x35, 0x7c, 0x29, 0xe9, 0x94, 0x3f, 0x7f, 0x91, 0x85, 0x1b, 0x0f, 0xc3, 0xce, 0xf3, 0x91, 0xf7, - 0xc1, 0x3e, 0x2c, 0x11, 0x8f, 0x05, 0x8e, 0x70, 0x02, 0x8f, 0xf6, 0x97, 0xe6, 0x45, 0xfb, 0x0a, - 0x9b, 0x76, 0x3c, 0x16, 0x9c, 0xa9, 0xd8, 0x87, 0x30, 0x29, 0x6f, 0xfc, 0x2a, 0x07, 0xb5, 0x79, - 0x92, 0x68, 0x1b, 0x2a, 0x56, 0x40, 0x04, 0x21, 0xbc, 0x3f, 0x34, 0x71, 0x7f, 0xd4, 0xe3, 0x59, - 0x31, 0xc5, 0x60, 0x98, 0xab, 0x21, 0x45, 0xdd, 0x1e, 0x03, 0xe0, 0x83, 0x1c, 0x4f, 0x3b, 0xce, - 0xf5, 0x92, 0x93, 0x9b, 0xa1, 0xae, 0x8f, 0x50, 0xc9, 0x65, 0x00, 0x79, 0x7f, 0xac, 0xc6, 0x54, - 0x71, 0x81, 0xfc, 0x18, 0x2a, 0x8e, 0xe7, 0x30, 0x07, 0x0f, 0x7b, 0x7d, 0x3c, 0xc4, 0x9e, 0x75, - 0x9d, 0x39, 0x58, 0xb6, 0x7c, 0xa5, 0x36, 0x05, 0x67, 0x98, 0xab, 0x8a, 0xd2, 0x96, 0x04, 0xb4, - 0x0b, 0x4b, 0xa1, 0xaa, 0xfc, 0xb5, 0xa6, 0x8d, 0x50, 0x3c, 0x31, 0xb2, 0xfd, 0x32, 0x07, 0x55, - 0x93, 0xd8, 0x1f, 0x87, 0x62, 0xb1, 0x50, 0x7c, 0x1b, 0x40, 0x96, 0x3b, 0x6f, 0xb0, 0xd7, 0x88, - 0x06, 0x6f, 0x18, 0x25, 0x89, 0xd0, 0xa1, 0x2c, 0x11, 0x8f, 0x49, 0x16, 0x96, 0x93, 0xf1, 0xf8, - 0x3f, 0xbd, 0x95, 0x50, 0x37, 0xee, 0x44, 0x79, 0xd1, 0x89, 0x3e, 0x37, 0xaf, 0x13, 0xcd, 0x64, - 0xef, 0xf3, 0x5b, 0xd0, 0xbf, 0xb2, 0x50, 0xd8, 0xc7, 0x01, 0x76, 0x29, 0xb2, 0x66, 0x26, 0x4d, - 0xf9, 0x7a, 0xbc, 0x3d, 0x93, 0x9f, 0x1d, 0xf5, 0x95, 0xe1, 0x05, 0x83, 0xe6, 0x7b, 0x57, 0x0c, - 0x9a, 0xdf, 0x80, 0x55, 0xfe, 0xc0, 0x8d, 0x6c, 0x94, 0xde, 0x5e, 0x69, 0xdf, 0x8e, 0x51, 0x2e, - 0xef, 0xcb, 0xf7, 0x6f, 0xf4, 0x8c, 0xa2, 0xe8, 0xab, 0x50, 0xe6, 0x1c, 0x71, 0x63, 0xe6, 0xe2, - 0xeb, 0xf1, 0x43, 0x33, 0xb1, 0x69, 0x98, 0xe0, 0xe2, 0xd3, 0x1d, 0xb9, 0x40, 0x6f, 0x02, 0x3a, - 0x8e, 0xbe, 0x75, 0xf4, 0x62, 0x77, 0x72, 0xf9, 0x4f, 0x4d, 0x27, 0xfa, 0x6d, 0x29, 0x3f, 0xcb, - 0x63, 0x98, 0xd5, 0x98, 0x18, 0xa2, 0x7d, 0x05, 0x80, 0xdb, 0xd5, 0xb3, 0x89, 0xe7, 0xbb, 0xea, - 0xb9, 0x73, 0x6b, 0x3a, 0xd1, 0xab, 0x12, 0x25, 0xde, 0x33, 0xcc, 0x12, 0x5f, 0x74, 0xf8, 0xef, - 0x44, 0x66, 0xbf, 0xaf, 0x01, 0x8a, 0x5b, 0xbe, 0x49, 0xe8, 0x88, 0xbf, 0xcf, 0xf8, 0x20, 0x9e, - 0x98, 0x9a, 0xb5, 0xe7, 0x0f, 0xe2, 0xb1, 0x7c, 0x38, 0x88, 0x27, 0x2a, 0xe5, 0x6b, 0x71, 0x7b, - 0xcc, 0xaa, 0x38, 0x2a, 0x98, 0x3e, 0xa6, 0x24, 0x31, 0xcc, 0x3b, 0xa1, 0xf4, 0x4c, 0x3f, 0xcc, - 0x18, 0x7f, 0xd0, 0xe0, 0xf6, 0x4c, 0x46, 0x45, 0x87, 0xfd, 0x21, 0xa0, 0x20, 0xb1, 0x29, 0xfc, - 0x75, 0xa6, 0x0e, 0xbd, 0x70, 0x82, 0x56, 0x83, 0x99, 0xbe, 0xfb, 0xe1, 0x75, 0xf8, 0xbc, 0xf0, - 0xf9, 0xef, 0x34, 0xb8, 0x99, 0x54, 0x1f, 0x19, 0xb2, 0x07, 0xcb, 0x49, 0xed, 0xca, 0x84, 0xd7, - 0x5e, 0xc6, 0x04, 0x75, 0xfa, 0x4b, 0xf2, 0xe8, 0xbb, 0x71, 0xb9, 0xca, 0xaf, 0x61, 0xf7, 0x5e, - 0xda, 0x1b, 0xe1, 0x99, 0xd2, 0x65, 0x9b, 0x17, 0xf1, 0xf8, 0xaf, 0x06, 0xf9, 0x7d, 0xdf, 0x1f, - 0x22, 0x1f, 0xaa, 0x9e, 0xcf, 0x7a, 0x3c, 0xb3, 0x88, 0xdd, 0x53, 0x8f, 0x6e, 0xd9, 0x07, 0xb7, - 0x17, 0x73, 0xd2, 0x3f, 0x26, 0xfa, 0x2c, 0x94, 0x59, 0xf1, 0x7c, 0xd6, 0x16, 0x94, 0x07, 0xf2, - 0x49, 0xfe, 0x36, 0xac, 0x5c, 0x56, 0x26, 0xbb, 0xe4, 0xf7, 0x16, 0x56, 0x76, 0x19, 0x66, 0x3a, - 0xd1, 0x6f, 0xc6, 0x15, 0x13, 0x91, 0x0d, 0x73, 0xb9, 0x9f, 0xd0, 0xbe, 0x55, 0xe4, 0xf1, 0xfb, - 0xe7, 0x85, 0xae, 0x7d, 0xfe, 0x67, 0x1a, 0x40, 0xfc, 0xe5, 0x01, 0x35, 0xa1, 0xfc, 0x70, 0xef, - 0x60, 0x7f, 0x67, 0xbb, 0x7b, 0xbf, 0xbb, 0xd3, 0x59, 0xcb, 0xd4, 0x2b, 0x8f, 0xcf, 0x9b, 0xe5, - 0x87, 0x1e, 0x1d, 0x11, 0xcb, 0x39, 0x72, 0x88, 0x8d, 0xea, 0x50, 0x7c, 0xb8, 0xd7, 0xfe, 0xce, - 0x5e, 0x67, 0xa7, 0xb3, 0xa6, 0xd5, 0x97, 0x1f, 0x9f, 0x37, 0x8b, 0x72, 0xe6, 0x22, 0x36, 0x7f, - 0x10, 0xca, 0xbd, 0xee, 0xde, 0x37, 0xd7, 0xb2, 0xf5, 0x95, 0xc7, 0xe7, 0xcd, 0x52, 0x34, 0x90, - 0xa1, 0x75, 0x28, 0x28, 0xb9, 0x5c, 0x1d, 0x1e, 0x9f, 0x37, 0x0b, 0xd2, 0x21, 0xf5, 0xfc, 0x3b, - 0xef, 0x37, 0x32, 0xed, 0xfb, 0x1f, 0x3c, 0x6d, 0x68, 0x4f, 0x9e, 0x36, 0xb4, 0xbf, 0x3d, 0x6d, - 0x68, 0xef, 0x3e, 0x6b, 0x64, 0x9e, 0x3c, 0x6b, 0x64, 0xfe, 0xf4, 0xac, 0x91, 0xf9, 0xfe, 0x17, - 0x9e, 0xeb, 0x8b, 0xd3, 0xe8, 0x03, 0xb2, 0xf0, 0x4a, 0xbf, 0x20, 0xda, 0xea, 0x97, 0xff, 0x17, - 0x00, 0x00, 0xff, 0xff, 0xcb, 0x6b, 0x6c, 0xa9, 0x5f, 0x16, 0x00, 0x00, + // 1754 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4d, 0x6c, 0x23, 0x49, + 0x15, 0x76, 0xdb, 0x5e, 0xc7, 0x7e, 0x4e, 0xe2, 0xb8, 0xe6, 0x67, 0x3d, 0x66, 0x70, 0x7b, 0x9b, + 0xd5, 0x12, 0xd0, 0xe2, 0x30, 0x01, 0x2d, 0x22, 0x17, 0x18, 0xc7, 0x19, 0x62, 0xb1, 0x0c, 0xa1, + 0x9d, 0x09, 0x12, 0xac, 0xb0, 0xca, 0xdd, 0x15, 0xa7, 0x89, 0xbb, 0xdb, 0x74, 0x95, 0x87, 0x44, + 0xda, 0x03, 0xc7, 0x65, 0x10, 0x62, 0xb9, 0xed, 0x65, 0xa4, 0x91, 0xf6, 0x8a, 0xc4, 0x8d, 0x2b, + 0xd7, 0x45, 0x5c, 0x86, 0x1b, 0x42, 0xc8, 0xa0, 0x99, 0x0b, 0xe2, 0x84, 0x7c, 0x40, 0x9c, 0x00, + 0xd5, 0x4f, 0xff, 0xa4, 0x1d, 0xcf, 0x8c, 0x47, 0x7b, 0x58, 0x09, 0x2e, 0x89, 0xeb, 0xd5, 0x7b, + 0xdf, 0xab, 0xf7, 0x5b, 0xaf, 0x1a, 0x5e, 0xb7, 0x7c, 0xea, 0xfa, 0x74, 0x8b, 0x32, 0x7c, 0xea, + 0x78, 0xc3, 0xad, 0xfb, 0xb7, 0x06, 0x84, 0xe1, 0x5b, 0xe1, 0xba, 0x35, 0x0e, 0x7c, 0xe6, 0xa3, + 0xeb, 0x92, 0xab, 0x15, 0x52, 0x15, 0x57, 0xfd, 0xea, 0xd0, 0x1f, 0xfa, 0x82, 0x65, 0x8b, 0xff, + 0x92, 0xdc, 0xf5, 0x9b, 0x8c, 0x78, 0x36, 0x09, 0x5c, 0xc7, 0x63, 0x5b, 0xec, 0x7c, 0x4c, 0xa8, + 0xfc, 0xab, 0x76, 0xf5, 0xa1, 0xef, 0x0f, 0x47, 0x64, 0x4b, 0xac, 0x06, 0x93, 0xe3, 0x2d, 0xe6, + 0xb8, 0x84, 0x32, 0xec, 0x8e, 0x15, 0x43, 0x23, 0xcd, 0x60, 0x4f, 0x02, 0xcc, 0x1c, 0xdf, 0x0b, + 0xf7, 0xd5, 0x91, 0x07, 0x98, 0x92, 0xe8, 0xbc, 0x96, 0xef, 0xa8, 0x7d, 0xe3, 0xa7, 0x1a, 0xac, + 0xef, 0x3b, 0x94, 0xf9, 0x81, 0x63, 0xe1, 0x51, 0xd7, 0x3b, 0xf6, 0xd1, 0x5b, 0x50, 0x38, 0x21, + 0xd8, 0x26, 0x41, 0x4d, 0x6b, 0x6a, 0x9b, 0xe5, 0xed, 0x5a, 0x2b, 0x3e, 0x62, 0x4b, 0x1e, 0x6e, + 0x5f, 0xec, 0xb7, 0xf3, 0x1f, 0x4d, 0xf5, 0x8c, 0xa9, 0xb8, 0xd1, 0xd7, 0xa0, 0x70, 0x1f, 0x8f, + 0x28, 0x61, 0xb5, 0x6c, 0x33, 0xb7, 0x59, 0xde, 0x7e, 0xad, 0x75, 0xb9, 0x23, 0x5a, 0x47, 0x78, + 0xe4, 0xd8, 0x98, 0xf9, 0x11, 0x80, 0x14, 0x33, 0x7e, 0x9d, 0x85, 0xca, 0xae, 0xef, 0xba, 0x0e, + 0xa5, 0x8e, 0xef, 0x99, 0x98, 0x11, 0x8a, 0xda, 0x90, 0x0f, 0x30, 0x23, 0xe2, 0x28, 0xa5, 0x76, + 0x8b, 0xf3, 0xff, 0x69, 0xaa, 0xbf, 0x31, 0x74, 0xd8, 0xc9, 0x64, 0xd0, 0xb2, 0x7c, 0x77, 0x4b, + 0x19, 0x28, 0xff, 0x7d, 0x81, 0xda, 0xa7, 0xca, 0x81, 0x1d, 0x62, 0x99, 0x42, 0x16, 0xbd, 0x03, + 0x45, 0x17, 0x9f, 0xf5, 0x05, 0x4e, 0x56, 0xe0, 0xdc, 0x5e, 0x0e, 0x67, 0x36, 0xd5, 0x2b, 0xe7, + 0xd8, 0x1d, 0xed, 0x18, 0x21, 0x8e, 0x61, 0xae, 0xb8, 0xf8, 0x8c, 0x1f, 0x11, 0x8d, 0xa1, 0xc2, + 0xa9, 0xd6, 0x09, 0xf6, 0x86, 0x44, 0x2a, 0xc9, 0x09, 0x25, 0xfb, 0x4b, 0x2b, 0xb9, 0x1e, 0x2b, + 0x49, 0xc0, 0x19, 0xe6, 0x9a, 0x8b, 0xcf, 0x76, 0x05, 0x81, 0x6b, 0xdc, 0x29, 0x7e, 0xf0, 0x48, + 0xcf, 0xfc, 0xed, 0x91, 0xae, 0x19, 0x7f, 0xd0, 0x00, 0x62, 0x8f, 0xa1, 0x77, 0x60, 0xc3, 0x8a, + 0x56, 0x42, 0x96, 0xaa, 0x18, 0x7e, 0x76, 0x51, 0x2c, 0x52, 0xfe, 0x6e, 0x17, 0xf9, 0xa1, 0x1f, + 0x4f, 0x75, 0xcd, 0xac, 0x58, 0xa9, 0x50, 0x7c, 0x1f, 0xca, 0x93, 0xb1, 0x8d, 0x19, 0xe9, 0xf3, + 0x24, 0x14, 0x9e, 0x2c, 0x6f, 0xd7, 0x5b, 0x32, 0x01, 0x5b, 0x61, 0x02, 0xb6, 0x0e, 0xc3, 0x0c, + 0x6d, 0x37, 0x38, 0xd6, 0x6c, 0xaa, 0x23, 0x69, 0x56, 0x42, 0xd8, 0x78, 0xff, 0x2f, 0xba, 0x66, + 0x82, 0xa4, 0x70, 0x81, 0x84, 0x4d, 0xbf, 0xd3, 0xa0, 0xdc, 0x21, 0xd4, 0x0a, 0x9c, 0x31, 0xcf, + 0x63, 0x54, 0x83, 0x15, 0xd7, 0xf7, 0x9c, 0x53, 0x95, 0x8f, 0x25, 0x33, 0x5c, 0xa2, 0x3a, 0x14, + 0x1d, 0x9b, 0x78, 0xcc, 0x61, 0xe7, 0x32, 0xae, 0x66, 0xb4, 0xe6, 0x52, 0x3f, 0x26, 0x03, 0xea, + 0x84, 0xd1, 0x30, 0xc3, 0x25, 0xba, 0x03, 0x1b, 0x94, 0x58, 0x93, 0xc0, 0x61, 0xe7, 0x7d, 0xcb, + 0xf7, 0x18, 0xb6, 0x58, 0x2d, 0x2f, 0x02, 0xf6, 0xa9, 0xd9, 0x54, 0x7f, 0x55, 0x9e, 0x35, 0xcd, + 0x61, 0x98, 0x95, 0x90, 0xb4, 0x2b, 0x29, 0x5c, 0x83, 0x4d, 0x18, 0x76, 0x46, 0xb4, 0xf6, 0x8a, + 0xd4, 0xa0, 0x96, 0x09, 0x5b, 0xfe, 0x5d, 0x80, 0x52, 0x94, 0xed, 0x5c, 0xb3, 0x3f, 0x26, 0x01, + 0xff, 0xdd, 0xc7, 0xb6, 0x1d, 0x10, 0x4a, 0x55, 0x5e, 0x27, 0x34, 0xa7, 0x39, 0x0c, 0xb3, 0x12, + 0x92, 0x6e, 0x4b, 0x0a, 0xc7, 0xb1, 0x7c, 0x8f, 0x12, 0x8f, 0x4e, 0x68, 0x7f, 0x3c, 0x19, 0x9c, + 0x12, 0x65, 0x7f, 0x12, 0x27, 0xcd, 0x61, 0xf0, 0x80, 0x2a, 0xd2, 0x81, 0xa0, 0xa0, 0xeb, 0x50, + 0xf8, 0x21, 0x76, 0x46, 0xc4, 0x16, 0x2e, 0x2a, 0x9a, 0x6a, 0x85, 0x76, 0xa0, 0x40, 0x19, 0x66, + 0x13, 0x2a, 0xfc, 0xb2, 0xbe, 0x6d, 0x2c, 0x4a, 0x9e, 0xb6, 0xef, 0xd9, 0x3d, 0xc1, 0x69, 0x2a, + 0x09, 0x74, 0x07, 0x0a, 0xcc, 0x3f, 0x25, 0x9e, 0x72, 0xca, 0x52, 0x15, 0xdb, 0xf5, 0x98, 0xa9, + 0xa4, 0x11, 0x83, 0x0d, 0x9b, 0x8c, 0xc8, 0x50, 0xb8, 0x82, 0x9e, 0xe0, 0x80, 0xd0, 0x5a, 0x41, + 0x20, 0x76, 0x97, 0x2e, 0x2b, 0xe5, 0x91, 0x34, 0x9e, 0x61, 0x56, 0x22, 0x52, 0x4f, 0x50, 0xd0, + 0x37, 0xa1, 0x6c, 0xc7, 0xa9, 0x57, 0x5b, 0x11, 0x29, 0xfe, 0x99, 0x45, 0xe6, 0x27, 0xb2, 0x54, + 0x75, 0xb2, 0xa4, 0x34, 0x0f, 0xd3, 0xc4, 0x1b, 0xf8, 0x9e, 0xed, 0x78, 0xc3, 0xfe, 0x09, 0x71, + 0x86, 0x27, 0xac, 0x56, 0x6c, 0x6a, 0x9b, 0xb9, 0x64, 0x98, 0xd2, 0x1c, 0x86, 0x59, 0x89, 0x48, + 0xfb, 0x82, 0x82, 0x6c, 0x58, 0x8f, 0xb9, 0x44, 0xe9, 0x95, 0x9e, 0x5b, 0x7a, 0xaf, 0xa9, 0xd2, + 0xbb, 0x96, 0xd6, 0x12, 0x57, 0xdf, 0x5a, 0x44, 0xe4, 0x62, 0x68, 0x1f, 0x20, 0x2e, 0xf8, 0x1a, + 0x08, 0x0d, 0xc6, 0xf3, 0xbb, 0x86, 0x32, 0x3c, 0x21, 0x8b, 0xde, 0x85, 0x2b, 0xae, 0xe3, 0xf5, + 0x29, 0x19, 0x1d, 0xf7, 0x95, 0x83, 0x39, 0x64, 0x59, 0x44, 0xef, 0xed, 0xe5, 0xf2, 0x61, 0x36, + 0xd5, 0xeb, 0xaa, 0x29, 0xce, 0x43, 0x1a, 0x66, 0xd5, 0x75, 0xbc, 0x1e, 0x19, 0x1d, 0x77, 0x22, + 0xda, 0xce, 0xea, 0x7b, 0x8f, 0xf4, 0x8c, 0x2a, 0xc0, 0x8c, 0xf1, 0x16, 0xac, 0x1e, 0xe1, 0x91, + 0x2a, 0x1c, 0x42, 0xd1, 0x4d, 0x28, 0xe1, 0x70, 0x51, 0xd3, 0x9a, 0xb9, 0xcd, 0x92, 0x19, 0x13, + 0x64, 0xe1, 0xfe, 0xe4, 0xcf, 0x4d, 0xcd, 0xf8, 0x95, 0x06, 0x85, 0xce, 0xd1, 0x01, 0x76, 0x02, + 0xd4, 0x85, 0x6a, 0x9c, 0x39, 0x17, 0xcb, 0xf6, 0xe6, 0x6c, 0xaa, 0xd7, 0xd2, 0xc9, 0x15, 0xd5, + 0x6d, 0x9c, 0xc0, 0x61, 0xe1, 0x76, 0xa1, 0x7a, 0x3f, 0xec, 0x06, 0x11, 0x54, 0x36, 0x0d, 0x35, + 0xc7, 0x62, 0x98, 0x1b, 0x11, 0x4d, 0x41, 0xa5, 0xcc, 0xdc, 0x83, 0x15, 0x79, 0x5a, 0x8a, 0x76, + 0xe0, 0x95, 0x31, 0xff, 0x21, 0xac, 0x2b, 0x6f, 0x37, 0x16, 0x26, 0xaf, 0xe0, 0x57, 0xe1, 0x93, + 0x22, 0xc6, 0x2f, 0xb3, 0x00, 0x9d, 0xa3, 0xa3, 0xc3, 0xc0, 0x19, 0x8f, 0x08, 0xfb, 0x38, 0x2d, + 0x3f, 0x84, 0x6b, 0xb1, 0x59, 0x34, 0xb0, 0x52, 0xd6, 0x37, 0x67, 0x53, 0xfd, 0x66, 0xda, 0xfa, + 0x04, 0x9b, 0x61, 0x5e, 0x89, 0xe8, 0xbd, 0xc0, 0xba, 0x14, 0xd5, 0xa6, 0x2c, 0x42, 0xcd, 0x2d, + 0x46, 0x4d, 0xb0, 0x25, 0x51, 0x3b, 0x94, 0x5d, 0xee, 0xda, 0x1e, 0x94, 0x63, 0x97, 0x50, 0xd4, + 0x81, 0x22, 0x53, 0xbf, 0x95, 0x87, 0x8d, 0xc5, 0x1e, 0x0e, 0xc5, 0x94, 0x97, 0x23, 0x49, 0xe3, + 0x5f, 0x1a, 0x40, 0x9c, 0xb3, 0x9f, 0xcc, 0x14, 0xe3, 0xad, 0x5c, 0x35, 0xde, 0xdc, 0x4b, 0x0d, + 0x5f, 0x4a, 0x3a, 0xe5, 0xcf, 0x9f, 0x65, 0xe1, 0xca, 0xbd, 0xb0, 0xf3, 0x7c, 0xe2, 0x7d, 0x70, + 0x00, 0x2b, 0xc4, 0x63, 0x81, 0x23, 0x9c, 0xc0, 0xa3, 0xfd, 0xc5, 0x45, 0xd1, 0xbe, 0xc4, 0xa6, + 0x3d, 0x8f, 0x05, 0xe7, 0x2a, 0xf6, 0x21, 0x4c, 0xca, 0x1b, 0xbf, 0xc8, 0x41, 0x6d, 0x91, 0x24, + 0xda, 0x85, 0x8a, 0x15, 0x10, 0x41, 0x08, 0xef, 0x0f, 0x4d, 0xdc, 0x1f, 0xf5, 0x78, 0x56, 0x4c, + 0x31, 0x18, 0xe6, 0x7a, 0x48, 0x51, 0xb7, 0xc7, 0x10, 0xf8, 0x20, 0xc7, 0xd3, 0x8e, 0x73, 0xbd, + 0xe0, 0xe4, 0x66, 0xa8, 0xeb, 0x23, 0x54, 0x72, 0x11, 0x40, 0xde, 0x1f, 0xeb, 0x31, 0x55, 0x5c, + 0x20, 0x3f, 0x82, 0x8a, 0xe3, 0x39, 0xcc, 0xc1, 0xa3, 0xfe, 0x00, 0x8f, 0xb0, 0x67, 0xbd, 0xcc, + 0x1c, 0x2c, 0x5b, 0xbe, 0x52, 0x9b, 0x82, 0x33, 0xcc, 0x75, 0x45, 0x69, 0x4b, 0x02, 0xda, 0x87, + 0x95, 0x50, 0x55, 0xfe, 0xa5, 0xa6, 0x8d, 0x50, 0x3c, 0x31, 0xb2, 0xfd, 0x3c, 0x07, 0x55, 0x93, + 0xd8, 0xff, 0x0f, 0xc5, 0x72, 0xa1, 0xf8, 0x16, 0x80, 0x2c, 0x77, 0xde, 0x60, 0x5f, 0x22, 0x1a, + 0xbc, 0x61, 0x94, 0x24, 0x42, 0x87, 0xb2, 0x44, 0x3c, 0xa6, 0x59, 0x58, 0x4d, 0xc6, 0xe3, 0x7f, + 0xf4, 0x56, 0x42, 0xdd, 0xb8, 0x13, 0xe5, 0x45, 0x27, 0xfa, 0xdc, 0xa2, 0x4e, 0x34, 0x97, 0xbd, + 0xcf, 0x6e, 0x41, 0xff, 0xcc, 0x42, 0xe1, 0x00, 0x07, 0xd8, 0xa5, 0xc8, 0x9a, 0x9b, 0x34, 0xe5, + 0xeb, 0xf1, 0xc6, 0x5c, 0x7e, 0x76, 0xd4, 0x57, 0x86, 0xe7, 0x0c, 0x9a, 0x1f, 0x5c, 0x32, 0x68, + 0x7e, 0x1d, 0xd6, 0xf9, 0x03, 0x37, 0xb2, 0x51, 0x7a, 0x7b, 0xad, 0x7d, 0x23, 0x46, 0xb9, 0xb8, + 0x2f, 0xdf, 0xbf, 0xd1, 0x33, 0x8a, 0xa2, 0xaf, 0x40, 0x99, 0x73, 0xc4, 0x8d, 0x99, 0x8b, 0x5f, + 0x8f, 0x1f, 0x9a, 0x89, 0x4d, 0xc3, 0x04, 0x17, 0x9f, 0xed, 0xc9, 0x05, 0x7a, 0x1b, 0xd0, 0x49, + 0xf4, 0xad, 0xa3, 0x1f, 0xbb, 0x93, 0xcb, 0x7f, 0x7a, 0x36, 0xd5, 0x6f, 0x48, 0xf9, 0x79, 0x1e, + 0xc3, 0xac, 0xc6, 0xc4, 0x10, 0xed, 0xcb, 0x00, 0xdc, 0xae, 0xbe, 0x4d, 0x3c, 0xdf, 0x55, 0xcf, + 0x9d, 0x6b, 0xb3, 0xa9, 0x5e, 0x95, 0x28, 0xf1, 0x9e, 0x61, 0x96, 0xf8, 0xa2, 0xc3, 0x7f, 0x27, + 0x32, 0xfb, 0x43, 0x0d, 0x50, 0xdc, 0xf2, 0x4d, 0x42, 0xc7, 0xfc, 0x7d, 0xc6, 0x07, 0xf1, 0xc4, + 0xd4, 0xac, 0x3d, 0x7b, 0x10, 0x8f, 0xe5, 0xc3, 0x41, 0x3c, 0x51, 0x29, 0x5f, 0x8d, 0xdb, 0x63, + 0x56, 0xc5, 0x51, 0xc1, 0x0c, 0x30, 0x25, 0x89, 0x61, 0xde, 0x09, 0xa5, 0xe7, 0xfa, 0x61, 0xc6, + 0xf8, 0xbd, 0x06, 0x37, 0xe6, 0x32, 0x2a, 0x3a, 0xec, 0x0f, 0x00, 0x05, 0x89, 0x4d, 0xe1, 0xaf, + 0x73, 0x75, 0xe8, 0xa5, 0x13, 0xb4, 0x1a, 0xcc, 0xf5, 0xdd, 0x8f, 0xaf, 0xc3, 0xe7, 0x85, 0xcf, + 0x7f, 0xab, 0xc1, 0xd5, 0xa4, 0xfa, 0xc8, 0x90, 0xbb, 0xb0, 0x9a, 0xd4, 0xae, 0x4c, 0x78, 0xfd, + 0x45, 0x4c, 0x50, 0xa7, 0xbf, 0x20, 0x8f, 0xbe, 0x13, 0x97, 0xab, 0xfc, 0x1a, 0x76, 0xeb, 0x85, + 0xbd, 0x11, 0x9e, 0x29, 0x5d, 0xb6, 0x79, 0x11, 0x8f, 0xff, 0x68, 0x90, 0x3f, 0xf0, 0xfd, 0x11, + 0xf2, 0xa1, 0xea, 0xf9, 0xac, 0xcf, 0x33, 0x8b, 0xd8, 0x7d, 0xf5, 0xe8, 0x96, 0x7d, 0x70, 0x77, + 0x39, 0x27, 0xfd, 0x7d, 0xaa, 0xcf, 0x43, 0x99, 0x15, 0xcf, 0x67, 0x6d, 0x41, 0x39, 0x94, 0x4f, + 0xf2, 0x77, 0x61, 0xed, 0xa2, 0x32, 0xd9, 0x25, 0xbf, 0xbb, 0xb4, 0xb2, 0x8b, 0x30, 0xb3, 0xa9, + 0x7e, 0x35, 0xae, 0x98, 0x88, 0x6c, 0x98, 0xab, 0x83, 0x84, 0xf6, 0x9d, 0x22, 0x8f, 0xdf, 0x3f, + 0x1e, 0xe9, 0xda, 0xe7, 0x7f, 0xa3, 0x01, 0xc4, 0x5f, 0x1e, 0xd0, 0x9b, 0xf0, 0x6a, 0xfb, 0xdb, + 0x77, 0x3b, 0xfd, 0xde, 0xe1, 0xed, 0xc3, 0x7b, 0xbd, 0xfe, 0xbd, 0xbb, 0xbd, 0x83, 0xbd, 0xdd, + 0xee, 0x9d, 0xee, 0x5e, 0x67, 0x23, 0x53, 0xaf, 0x3c, 0x78, 0xd8, 0x2c, 0xdf, 0xf3, 0xe8, 0x98, + 0x58, 0xce, 0xb1, 0x43, 0x6c, 0xf4, 0x06, 0x5c, 0xbd, 0xc8, 0xcd, 0x57, 0x7b, 0x9d, 0x0d, 0xad, + 0xbe, 0xfa, 0xe0, 0x61, 0xb3, 0x28, 0x67, 0x31, 0x62, 0xa3, 0x4d, 0xb8, 0x36, 0xcf, 0xd7, 0xbd, + 0xfb, 0x8d, 0x8d, 0x6c, 0x7d, 0xed, 0xc1, 0xc3, 0x66, 0x29, 0x1a, 0xda, 0x90, 0x01, 0x28, 0xc9, + 0xa9, 0xf0, 0x72, 0x75, 0x78, 0xf0, 0xb0, 0x59, 0x90, 0x0e, 0xac, 0xe7, 0xdf, 0xfb, 0xb0, 0x91, + 0x69, 0xdf, 0xf9, 0xe8, 0x49, 0x43, 0x7b, 0xfc, 0xa4, 0xa1, 0xfd, 0xf5, 0x49, 0x43, 0x7b, 0xff, + 0x69, 0x23, 0xf3, 0xf8, 0x69, 0x23, 0xf3, 0xc7, 0xa7, 0x8d, 0xcc, 0xf7, 0xde, 0x7c, 0xa6, 0xef, + 0xce, 0xa2, 0x0f, 0xce, 0xc2, 0x8b, 0x83, 0x82, 0x68, 0xc3, 0x5f, 0xfa, 0x6f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x27, 0x47, 0x69, 0xe7, 0x8f, 0x16, 0x00, 0x00, } func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { @@ -1210,589 +1211,590 @@ func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_ func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ - // 9310 bytes of a gzipped FileDescriptorSet + // 9322 bytes of a gzipped FileDescriptorSet 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x5c, 0xd7, - 0x75, 0x18, 0xdf, 0x7e, 0x00, 0xbb, 0x67, 0x17, 0xc0, 0xe2, 0x02, 0x84, 0x96, 0x4b, 0x12, 0x80, + 0x75, 0x18, 0xdf, 0x7e, 0x00, 0xbb, 0x67, 0x17, 0xc0, 0xe2, 0x02, 0x04, 0x97, 0x4b, 0x12, 0x80, 0x9e, 0x64, 0x89, 0xa2, 0x28, 0x40, 0xa2, 0x48, 0x8a, 0x5c, 0xda, 0x92, 0xb1, 0xd8, 0x25, 0x08, - 0x12, 0x5f, 0x7a, 0x00, 0x28, 0x7f, 0x24, 0xdd, 0x79, 0xd8, 0xbd, 0x58, 0x3c, 0x71, 0xf7, 0xbd, - 0xe7, 0xf7, 0xde, 0x92, 0x80, 0x6c, 0xcf, 0x28, 0xb1, 0xeb, 0xda, 0x4a, 0x53, 0xdb, 0x75, 0x26, - 0xb5, 0x1d, 0xd3, 0xb5, 0xe3, 0xb4, 0x4e, 0x9d, 0xb4, 0xf9, 0x70, 0x9a, 0x36, 0x6d, 0x67, 0x6a, - 0xb7, 0x4d, 0xe3, 0xb4, 0xd3, 0x8c, 0x34, 0xcd, 0x4c, 0xd3, 0x4c, 0x43, 0xa7, 0xb2, 0x26, 0x55, - 0x5d, 0xb7, 0x75, 0x58, 0x35, 0x4d, 0xc7, 0x33, 0x6d, 0xe7, 0x7e, 0xbd, 0xaf, 0xdd, 0xc5, 0xee, - 0x42, 0xa4, 0xe4, 0x34, 0xf9, 0x85, 0xbd, 0xe7, 0x9e, 0x73, 0xee, 0x39, 0xe7, 0x9e, 0x73, 0xee, - 0xb9, 0xf7, 0xdd, 0xf7, 0x00, 0xff, 0xfc, 0x22, 0x4c, 0xd7, 0x0c, 0xa3, 0x56, 0xc7, 0xb3, 0xa6, - 0x65, 0x38, 0xc6, 0x56, 0x73, 0x7b, 0xb6, 0x8a, 0xed, 0x8a, 0xa5, 0x99, 0x8e, 0x61, 0xcd, 0x50, - 0x18, 0x1a, 0x61, 0x18, 0x33, 0x02, 0x43, 0x5e, 0x86, 0xd1, 0x4b, 0x5a, 0x1d, 0x17, 0x5d, 0xc4, - 0x75, 0xec, 0xa0, 0xf3, 0x10, 0xdb, 0xd6, 0xea, 0x38, 0x2b, 0x4d, 0x47, 0x4f, 0xa4, 0x4e, 0x3f, - 0x38, 0x13, 0x22, 0x9a, 0x09, 0x52, 0xac, 0x11, 0xb0, 0x42, 0x29, 0xe4, 0xd7, 0x62, 0x30, 0xd6, - 0xa6, 0x17, 0x21, 0x88, 0xe9, 0x6a, 0x83, 0x70, 0x94, 0x4e, 0x24, 0x15, 0xfa, 0x1b, 0x65, 0x61, - 0xd0, 0x54, 0x2b, 0xd7, 0xd5, 0x1a, 0xce, 0x46, 0x28, 0x58, 0x34, 0xd1, 0x24, 0x40, 0x15, 0x9b, - 0x58, 0xaf, 0x62, 0xbd, 0xb2, 0x97, 0x8d, 0x4e, 0x47, 0x4f, 0x24, 0x15, 0x1f, 0x04, 0x3d, 0x0a, - 0xa3, 0x66, 0x73, 0xab, 0xae, 0x55, 0xca, 0x3e, 0x34, 0x98, 0x8e, 0x9e, 0x88, 0x2b, 0x19, 0xd6, - 0x51, 0xf4, 0x90, 0x1f, 0x86, 0x91, 0x9b, 0x58, 0xbd, 0xee, 0x47, 0x4d, 0x51, 0xd4, 0x61, 0x02, - 0xf6, 0x21, 0xce, 0x43, 0xba, 0x81, 0x6d, 0x5b, 0xad, 0xe1, 0xb2, 0xb3, 0x67, 0xe2, 0x6c, 0x8c, - 0x6a, 0x3f, 0xdd, 0xa2, 0x7d, 0x58, 0xf3, 0x14, 0xa7, 0xda, 0xd8, 0x33, 0x31, 0x9a, 0x83, 0x24, + 0x12, 0x5f, 0x7a, 0x00, 0x28, 0xc9, 0x4e, 0xba, 0xf3, 0xb0, 0x7b, 0xb1, 0x78, 0xe2, 0xee, 0x7b, + 0x4f, 0xef, 0xbd, 0x25, 0x01, 0xd9, 0x9e, 0x51, 0x62, 0xd7, 0xb5, 0x95, 0xa6, 0xb6, 0xea, 0x4c, + 0x6a, 0x2b, 0xa6, 0x2b, 0xc7, 0x69, 0x9d, 0x3a, 0x69, 0xf3, 0xe1, 0xd4, 0x6d, 0xda, 0xce, 0xd4, + 0x6e, 0x9b, 0xc6, 0x69, 0xa7, 0x19, 0x69, 0x9a, 0x99, 0xa6, 0x99, 0x86, 0x49, 0x65, 0x4d, 0xaa, + 0xba, 0x6e, 0xeb, 0xb0, 0x6a, 0x9a, 0x8e, 0x67, 0xda, 0xce, 0xfd, 0x7a, 0x5f, 0xbb, 0x8b, 0x5d, + 0x40, 0xa4, 0xe4, 0x34, 0xf9, 0x85, 0xbd, 0xe7, 0x9e, 0x73, 0xee, 0x39, 0xe7, 0x9e, 0x73, 0xee, + 0xb9, 0xf7, 0xdd, 0xf7, 0x00, 0xff, 0xfc, 0x02, 0x4c, 0xd6, 0x0c, 0xa3, 0x56, 0xc7, 0xd3, 0xa6, + 0x65, 0x38, 0xc6, 0x46, 0x73, 0x73, 0xba, 0x8a, 0xed, 0x8a, 0xa5, 0x99, 0x8e, 0x61, 0x4d, 0x51, + 0x18, 0x1a, 0x62, 0x18, 0x53, 0x02, 0x43, 0x5e, 0x84, 0xe1, 0x8b, 0x5a, 0x1d, 0x17, 0x5d, 0xc4, + 0x55, 0xec, 0xa0, 0x73, 0x10, 0xdb, 0xd4, 0xea, 0x38, 0x2b, 0x4d, 0x46, 0x8f, 0xa7, 0x4e, 0xdd, + 0x37, 0x15, 0x22, 0x9a, 0x0a, 0x52, 0xac, 0x10, 0xb0, 0x42, 0x29, 0xe4, 0x37, 0x63, 0x30, 0xd2, + 0xa6, 0x17, 0x21, 0x88, 0xe9, 0x6a, 0x83, 0x70, 0x94, 0x8e, 0x27, 0x15, 0xfa, 0x1b, 0x65, 0xa1, + 0xdf, 0x54, 0x2b, 0xd7, 0xd4, 0x1a, 0xce, 0x46, 0x28, 0x58, 0x34, 0xd1, 0x38, 0x40, 0x15, 0x9b, + 0x58, 0xaf, 0x62, 0xbd, 0xb2, 0x93, 0x8d, 0x4e, 0x46, 0x8f, 0x27, 0x15, 0x1f, 0x04, 0x3d, 0x04, + 0xc3, 0x66, 0x73, 0xa3, 0xae, 0x55, 0xca, 0x3e, 0x34, 0x98, 0x8c, 0x1e, 0x8f, 0x2b, 0x19, 0xd6, + 0x51, 0xf4, 0x90, 0x1f, 0x80, 0xa1, 0x1b, 0x58, 0xbd, 0xe6, 0x47, 0x4d, 0x51, 0xd4, 0x41, 0x02, + 0xf6, 0x21, 0xce, 0x42, 0xba, 0x81, 0x6d, 0x5b, 0xad, 0xe1, 0xb2, 0xb3, 0x63, 0xe2, 0x6c, 0x8c, + 0x6a, 0x3f, 0xd9, 0xa2, 0x7d, 0x58, 0xf3, 0x14, 0xa7, 0x5a, 0xdb, 0x31, 0x31, 0x9a, 0x81, 0x24, 0xd6, 0x9b, 0x0d, 0xc6, 0x21, 0xde, 0xc1, 0x7e, 0x25, 0xbd, 0xd9, 0x08, 0x73, 0x49, 0x10, 0x32, - 0xce, 0x62, 0xd0, 0xc6, 0xd6, 0x0d, 0xad, 0x82, 0xb3, 0x03, 0x94, 0xc1, 0xc3, 0x2d, 0x0c, 0xd6, - 0x59, 0x7f, 0x98, 0x87, 0xa0, 0x43, 0xf3, 0x90, 0xc4, 0xbb, 0x0e, 0xd6, 0x6d, 0xcd, 0xd0, 0xb3, - 0x83, 0x94, 0xc9, 0x3b, 0xda, 0xcc, 0x22, 0xae, 0x57, 0xc3, 0x2c, 0x3c, 0x3a, 0x74, 0x0e, 0x06, - 0x0d, 0xd3, 0xd1, 0x0c, 0xdd, 0xce, 0x26, 0xa6, 0xa5, 0x13, 0xa9, 0xd3, 0xc7, 0xda, 0x3a, 0xc2, - 0x2a, 0xc3, 0x51, 0x04, 0x32, 0x5a, 0x84, 0x8c, 0x6d, 0x34, 0xad, 0x0a, 0x2e, 0x57, 0x8c, 0x2a, - 0x2e, 0x6b, 0xfa, 0xb6, 0x91, 0x4d, 0x52, 0x06, 0x53, 0xad, 0x8a, 0x50, 0xc4, 0x79, 0xa3, 0x8a, - 0x17, 0xf5, 0x6d, 0x43, 0x19, 0xb6, 0x03, 0x6d, 0x34, 0x01, 0x03, 0xf6, 0x9e, 0xee, 0xa8, 0xbb, - 0xd9, 0x34, 0xf5, 0x10, 0xde, 0x92, 0x7f, 0x63, 0x00, 0x46, 0x7a, 0x71, 0xb1, 0x8b, 0x10, 0xdf, - 0x26, 0x5a, 0x66, 0x23, 0xfd, 0xd8, 0x80, 0xd1, 0x04, 0x8d, 0x38, 0x70, 0x40, 0x23, 0xce, 0x41, - 0x4a, 0xc7, 0xb6, 0x83, 0xab, 0xcc, 0x23, 0xa2, 0x3d, 0xfa, 0x14, 0x30, 0xa2, 0x56, 0x97, 0x8a, - 0x1d, 0xc8, 0xa5, 0xde, 0x03, 0x23, 0xae, 0x48, 0x65, 0x4b, 0xd5, 0x6b, 0xc2, 0x37, 0x67, 0xbb, - 0x49, 0x32, 0x53, 0x12, 0x74, 0x0a, 0x21, 0x53, 0x86, 0x71, 0xa0, 0x8d, 0x8a, 0x00, 0x86, 0x8e, - 0x8d, 0xed, 0x72, 0x15, 0x57, 0xea, 0xd9, 0x44, 0x07, 0x2b, 0xad, 0x12, 0x94, 0x16, 0x2b, 0x19, - 0x0c, 0x5a, 0xa9, 0xa3, 0x0b, 0x9e, 0xab, 0x0d, 0x76, 0xf0, 0x94, 0x65, 0x16, 0x64, 0x2d, 0xde, - 0xb6, 0x09, 0xc3, 0x16, 0x26, 0x7e, 0x8f, 0xab, 0x5c, 0xb3, 0x24, 0x15, 0x62, 0xa6, 0xab, 0x66, - 0x0a, 0x27, 0x63, 0x8a, 0x0d, 0x59, 0xfe, 0x26, 0x7a, 0x00, 0x5c, 0x40, 0x99, 0xba, 0x15, 0xd0, - 0x2c, 0x94, 0x16, 0xc0, 0x15, 0xb5, 0x81, 0x73, 0x2f, 0xc0, 0x70, 0xd0, 0x3c, 0x68, 0x1c, 0xe2, + 0xce, 0xa2, 0xdf, 0xc6, 0xd6, 0x75, 0xad, 0x82, 0xb3, 0x7d, 0x94, 0xc1, 0x03, 0x2d, 0x0c, 0x56, + 0x59, 0x7f, 0x98, 0x87, 0xa0, 0x43, 0xb3, 0x90, 0xc4, 0xdb, 0x0e, 0xd6, 0x6d, 0xcd, 0xd0, 0xb3, + 0xfd, 0x94, 0xc9, 0xfb, 0xda, 0xcc, 0x22, 0xae, 0x57, 0xc3, 0x2c, 0x3c, 0x3a, 0x74, 0x16, 0xfa, + 0x0d, 0xd3, 0xd1, 0x0c, 0xdd, 0xce, 0x26, 0x26, 0xa5, 0xe3, 0xa9, 0x53, 0x47, 0xdb, 0x3a, 0xc2, + 0x32, 0xc3, 0x51, 0x04, 0x32, 0x9a, 0x87, 0x8c, 0x6d, 0x34, 0xad, 0x0a, 0x2e, 0x57, 0x8c, 0x2a, + 0x2e, 0x6b, 0xfa, 0xa6, 0x91, 0x4d, 0x52, 0x06, 0x13, 0xad, 0x8a, 0x50, 0xc4, 0x59, 0xa3, 0x8a, + 0xe7, 0xf5, 0x4d, 0x43, 0x19, 0xb4, 0x03, 0x6d, 0x34, 0x06, 0x7d, 0xf6, 0x8e, 0xee, 0xa8, 0xdb, + 0xd9, 0x34, 0xf5, 0x10, 0xde, 0x92, 0x7f, 0xbd, 0x0f, 0x86, 0x7a, 0x71, 0xb1, 0x0b, 0x10, 0xdf, + 0x24, 0x5a, 0x66, 0x23, 0x7b, 0xb1, 0x01, 0xa3, 0x09, 0x1a, 0xb1, 0x6f, 0x9f, 0x46, 0x9c, 0x81, + 0x94, 0x8e, 0x6d, 0x07, 0x57, 0x99, 0x47, 0x44, 0x7b, 0xf4, 0x29, 0x60, 0x44, 0xad, 0x2e, 0x15, + 0xdb, 0x97, 0x4b, 0x3d, 0x03, 0x43, 0xae, 0x48, 0x65, 0x4b, 0xd5, 0x6b, 0xc2, 0x37, 0xa7, 0xbb, + 0x49, 0x32, 0x55, 0x12, 0x74, 0x0a, 0x21, 0x53, 0x06, 0x71, 0xa0, 0x8d, 0x8a, 0x00, 0x86, 0x8e, + 0x8d, 0xcd, 0x72, 0x15, 0x57, 0xea, 0xd9, 0x44, 0x07, 0x2b, 0x2d, 0x13, 0x94, 0x16, 0x2b, 0x19, + 0x0c, 0x5a, 0xa9, 0xa3, 0xf3, 0x9e, 0xab, 0xf5, 0x77, 0xf0, 0x94, 0x45, 0x16, 0x64, 0x2d, 0xde, + 0xb6, 0x0e, 0x83, 0x16, 0x26, 0x7e, 0x8f, 0xab, 0x5c, 0xb3, 0x24, 0x15, 0x62, 0xaa, 0xab, 0x66, + 0x0a, 0x27, 0x63, 0x8a, 0x0d, 0x58, 0xfe, 0x26, 0xba, 0x17, 0x5c, 0x40, 0x99, 0xba, 0x15, 0xd0, + 0x2c, 0x94, 0x16, 0xc0, 0x25, 0xb5, 0x81, 0x73, 0x2f, 0xc0, 0x60, 0xd0, 0x3c, 0x68, 0x14, 0xe2, 0xb6, 0xa3, 0x5a, 0x0e, 0xf5, 0xc2, 0xb8, 0xc2, 0x1a, 0x28, 0x03, 0x51, 0xac, 0x57, 0x69, 0x96, - 0x8b, 0x2b, 0xe4, 0x27, 0x7a, 0xb7, 0xa7, 0x70, 0x94, 0x2a, 0xfc, 0x50, 0xeb, 0x8c, 0x06, 0x38, - 0x87, 0xf5, 0xce, 0x3d, 0x05, 0x43, 0x01, 0x05, 0x7a, 0x1d, 0x5a, 0xfe, 0x10, 0x1c, 0x6e, 0xcb, - 0x1a, 0xbd, 0x07, 0xc6, 0x9b, 0xba, 0xa6, 0x3b, 0xd8, 0x32, 0x2d, 0x4c, 0x3c, 0x96, 0x0d, 0x95, - 0xfd, 0x4f, 0x83, 0x1d, 0x7c, 0x6e, 0xd3, 0x8f, 0xcd, 0xb8, 0x28, 0x63, 0xcd, 0x56, 0xe0, 0xc9, - 0x64, 0xe2, 0xf5, 0xc1, 0xcc, 0x8b, 0x2f, 0xbe, 0xf8, 0x62, 0x44, 0xfe, 0xe6, 0x00, 0x8c, 0xb7, - 0x8b, 0x99, 0xb6, 0xe1, 0x3b, 0x01, 0x03, 0x7a, 0xb3, 0xb1, 0x85, 0x2d, 0x6a, 0xa4, 0xb8, 0xc2, - 0x5b, 0x68, 0x0e, 0xe2, 0x75, 0x75, 0x0b, 0xd7, 0xb3, 0xb1, 0x69, 0xe9, 0xc4, 0xf0, 0xe9, 0x47, - 0x7b, 0x8a, 0xca, 0x99, 0x25, 0x42, 0xa2, 0x30, 0x4a, 0xf4, 0x34, 0xc4, 0x78, 0x8a, 0x26, 0x1c, - 0x4e, 0xf6, 0xc6, 0x81, 0xc4, 0x92, 0x42, 0xe9, 0xd0, 0x51, 0x48, 0x92, 0xbf, 0xcc, 0x37, 0x06, - 0xa8, 0xcc, 0x09, 0x02, 0x20, 0x7e, 0x81, 0x72, 0x90, 0xa0, 0x61, 0x52, 0xc5, 0x62, 0x69, 0x73, - 0xdb, 0xc4, 0xb1, 0xaa, 0x78, 0x5b, 0x6d, 0xd6, 0x9d, 0xf2, 0x0d, 0xb5, 0xde, 0xc4, 0xd4, 0xe1, - 0x93, 0x4a, 0x9a, 0x03, 0xaf, 0x11, 0x18, 0x9a, 0x82, 0x14, 0x8b, 0x2a, 0x4d, 0xaf, 0xe2, 0x5d, - 0x9a, 0x3d, 0xe3, 0x0a, 0x0b, 0xb4, 0x45, 0x02, 0x21, 0xc3, 0x3f, 0x6f, 0x1b, 0xba, 0x70, 0x4d, - 0x3a, 0x04, 0x01, 0xd0, 0xe1, 0x9f, 0x0a, 0x27, 0xee, 0xe3, 0xed, 0xd5, 0x6b, 0x89, 0xa5, 0x87, - 0x61, 0x84, 0x62, 0x3c, 0xc9, 0xa7, 0x5e, 0xad, 0x67, 0x47, 0xa7, 0xa5, 0x13, 0x09, 0x65, 0x98, - 0x81, 0x57, 0x39, 0x54, 0xfe, 0xf5, 0x08, 0xc4, 0x68, 0x62, 0x19, 0x81, 0xd4, 0xc6, 0x7b, 0xd7, - 0x4a, 0xe5, 0xe2, 0xea, 0x66, 0x61, 0xa9, 0x94, 0x91, 0xd0, 0x30, 0x00, 0x05, 0x5c, 0x5a, 0x5a, - 0x9d, 0xdb, 0xc8, 0x44, 0xdc, 0xf6, 0xe2, 0xca, 0xc6, 0xb9, 0x33, 0x99, 0xa8, 0x4b, 0xb0, 0xc9, - 0x00, 0x31, 0x3f, 0xc2, 0x93, 0xa7, 0x33, 0x71, 0x94, 0x81, 0x34, 0x63, 0xb0, 0xf8, 0x9e, 0x52, - 0xf1, 0xdc, 0x99, 0xcc, 0x40, 0x10, 0xf2, 0xe4, 0xe9, 0xcc, 0x20, 0x1a, 0x82, 0x24, 0x85, 0x14, - 0x56, 0x57, 0x97, 0x32, 0x09, 0x97, 0xe7, 0xfa, 0x86, 0xb2, 0xb8, 0xb2, 0x90, 0x49, 0xba, 0x3c, - 0x17, 0x94, 0xd5, 0xcd, 0xb5, 0x0c, 0xb8, 0x1c, 0x96, 0x4b, 0xeb, 0xeb, 0x73, 0x0b, 0xa5, 0x4c, - 0xca, 0xc5, 0x28, 0xbc, 0x77, 0xa3, 0xb4, 0x9e, 0x49, 0x07, 0xc4, 0x7a, 0xf2, 0x74, 0x66, 0xc8, - 0x1d, 0xa2, 0xb4, 0xb2, 0xb9, 0x9c, 0x19, 0x46, 0xa3, 0x30, 0xc4, 0x86, 0x10, 0x42, 0x8c, 0x84, - 0x40, 0xe7, 0xce, 0x64, 0x32, 0x9e, 0x20, 0x8c, 0xcb, 0x68, 0x00, 0x70, 0xee, 0x4c, 0x06, 0xc9, - 0xf3, 0x10, 0xa7, 0x6e, 0x88, 0x10, 0x0c, 0x2f, 0xcd, 0x15, 0x4a, 0x4b, 0xe5, 0xd5, 0xb5, 0x8d, - 0xc5, 0xd5, 0x95, 0xb9, 0xa5, 0x8c, 0xe4, 0xc1, 0x94, 0xd2, 0xb3, 0x9b, 0x8b, 0x4a, 0xa9, 0x98, - 0x89, 0xf8, 0x61, 0x6b, 0xa5, 0xb9, 0x8d, 0x52, 0x31, 0x13, 0x95, 0x2b, 0x30, 0xde, 0x2e, 0xa1, - 0xb6, 0x0d, 0x21, 0x9f, 0x2f, 0x44, 0x3a, 0xf8, 0x02, 0xe5, 0x15, 0xf6, 0x05, 0xf9, 0x3b, 0x11, - 0x18, 0x6b, 0xb3, 0xa8, 0xb4, 0x1d, 0xe4, 0x19, 0x88, 0x33, 0x5f, 0x66, 0xcb, 0xec, 0x23, 0x6d, - 0x57, 0x27, 0xea, 0xd9, 0x2d, 0x4b, 0x2d, 0xa5, 0xf3, 0x97, 0x1a, 0xd1, 0x0e, 0xa5, 0x06, 0x61, - 0xd1, 0xe2, 0xb0, 0x3f, 0xda, 0x92, 0xfc, 0xd9, 0xfa, 0x78, 0xae, 0x97, 0xf5, 0x91, 0xc2, 0xfa, - 0x5b, 0x04, 0xe2, 0x6d, 0x16, 0x81, 0x8b, 0x30, 0xda, 0xc2, 0xa8, 0xe7, 0x64, 0xfc, 0x11, 0x09, - 0xb2, 0x9d, 0x8c, 0xd3, 0x25, 0x25, 0x46, 0x02, 0x29, 0xf1, 0x62, 0xd8, 0x82, 0xf7, 0x77, 0x9e, - 0x84, 0x96, 0xb9, 0xfe, 0xaa, 0x04, 0x13, 0xed, 0x4b, 0xca, 0xb6, 0x32, 0x3c, 0x0d, 0x03, 0x0d, - 0xec, 0xec, 0x18, 0xa2, 0xac, 0x7a, 0xa8, 0xcd, 0x62, 0x4d, 0xba, 0xc3, 0x93, 0xcd, 0xa9, 0xfc, - 0xab, 0x7d, 0xb4, 0x53, 0x5d, 0xc8, 0xa4, 0x69, 0x91, 0xf4, 0x13, 0x11, 0x38, 0xdc, 0x96, 0x79, - 0x5b, 0x41, 0x8f, 0x03, 0x68, 0xba, 0xd9, 0x74, 0x58, 0xe9, 0xc4, 0x32, 0x71, 0x92, 0x42, 0x68, - 0xf2, 0x22, 0x59, 0xb6, 0xe9, 0xb8, 0xfd, 0x51, 0xda, 0x0f, 0x0c, 0x44, 0x11, 0xce, 0x7b, 0x82, - 0xc6, 0xa8, 0xa0, 0x93, 0x1d, 0x34, 0x6d, 0x71, 0xcc, 0xc7, 0x21, 0x53, 0xa9, 0x6b, 0x58, 0x77, - 0xca, 0xb6, 0x63, 0x61, 0xb5, 0xa1, 0xe9, 0x35, 0xba, 0xd4, 0x24, 0xf2, 0xf1, 0x6d, 0xb5, 0x6e, - 0x63, 0x65, 0x84, 0x75, 0xaf, 0x8b, 0x5e, 0x42, 0x41, 0x1d, 0xc8, 0xf2, 0x51, 0x0c, 0x04, 0x28, - 0x58, 0xb7, 0x4b, 0x21, 0x7f, 0x3a, 0x09, 0x29, 0x5f, 0x01, 0x8e, 0xee, 0x87, 0xf4, 0xf3, 0xea, - 0x0d, 0xb5, 0x2c, 0x36, 0x55, 0xcc, 0x12, 0x29, 0x02, 0x5b, 0xe3, 0x1b, 0xab, 0xc7, 0x61, 0x9c, - 0xa2, 0x18, 0x4d, 0x07, 0x5b, 0xe5, 0x4a, 0x5d, 0xb5, 0x6d, 0x6a, 0xb4, 0x04, 0x45, 0x45, 0xa4, - 0x6f, 0x95, 0x74, 0xcd, 0x8b, 0x1e, 0x74, 0x16, 0xc6, 0x28, 0x45, 0xa3, 0x59, 0x77, 0x34, 0xb3, - 0x8e, 0xcb, 0x64, 0x9b, 0x67, 0xd3, 0x25, 0xc7, 0x95, 0x6c, 0x94, 0x60, 0x2c, 0x73, 0x04, 0x22, - 0x91, 0x8d, 0x8a, 0x70, 0x9c, 0x92, 0xd5, 0xb0, 0x8e, 0x2d, 0xd5, 0xc1, 0x65, 0xfc, 0x81, 0xa6, - 0x5a, 0xb7, 0xcb, 0xaa, 0x5e, 0x2d, 0xef, 0xa8, 0xf6, 0x4e, 0x76, 0x9c, 0x30, 0x28, 0x44, 0xb2, - 0x92, 0x72, 0x84, 0x20, 0x2e, 0x70, 0xbc, 0x12, 0x45, 0x9b, 0xd3, 0xab, 0x97, 0x55, 0x7b, 0x07, - 0xe5, 0x61, 0x82, 0x72, 0xb1, 0x1d, 0x4b, 0xd3, 0x6b, 0xe5, 0xca, 0x0e, 0xae, 0x5c, 0x2f, 0x37, - 0x9d, 0xed, 0xf3, 0xd9, 0xa3, 0xfe, 0xf1, 0xa9, 0x84, 0xeb, 0x14, 0x67, 0x9e, 0xa0, 0x6c, 0x3a, - 0xdb, 0xe7, 0xd1, 0x3a, 0xa4, 0xc9, 0x64, 0x34, 0xb4, 0x17, 0x70, 0x79, 0xdb, 0xb0, 0xe8, 0x1a, - 0x3a, 0xdc, 0x26, 0x35, 0xf9, 0x2c, 0x38, 0xb3, 0xca, 0x09, 0x96, 0x8d, 0x2a, 0xce, 0xc7, 0xd7, - 0xd7, 0x4a, 0xa5, 0xa2, 0x92, 0x12, 0x5c, 0x2e, 0x19, 0x16, 0x71, 0xa8, 0x9a, 0xe1, 0x1a, 0x38, - 0xc5, 0x1c, 0xaa, 0x66, 0x08, 0xf3, 0x9e, 0x85, 0xb1, 0x4a, 0x85, 0xe9, 0xac, 0x55, 0xca, 0x7c, - 0x33, 0x66, 0x67, 0x33, 0x01, 0x63, 0x55, 0x2a, 0x0b, 0x0c, 0x81, 0xfb, 0xb8, 0x8d, 0x2e, 0xc0, - 0x61, 0xcf, 0x58, 0x7e, 0xc2, 0xd1, 0x16, 0x2d, 0xc3, 0xa4, 0x67, 0x61, 0xcc, 0xdc, 0x6b, 0x25, - 0x44, 0x81, 0x11, 0xcd, 0xbd, 0x30, 0xd9, 0x53, 0x30, 0x6e, 0xee, 0x98, 0xad, 0x74, 0x27, 0xfd, - 0x74, 0xc8, 0xdc, 0x31, 0xc3, 0x84, 0xef, 0xa0, 0x3b, 0x73, 0x0b, 0x57, 0x54, 0x07, 0x57, 0xb3, - 0xf7, 0xf9, 0xd1, 0x7d, 0x1d, 0x68, 0x06, 0x32, 0x95, 0x4a, 0x19, 0xeb, 0xea, 0x56, 0x1d, 0x97, - 0x55, 0x0b, 0xeb, 0xaa, 0x9d, 0x9d, 0xa2, 0xc8, 0x31, 0xc7, 0x6a, 0x62, 0x65, 0xb8, 0x52, 0x29, - 0xd1, 0xce, 0x39, 0xda, 0x87, 0x4e, 0xc2, 0xa8, 0xb1, 0xf5, 0x7c, 0x85, 0x79, 0x64, 0xd9, 0xb4, - 0xf0, 0xb6, 0xb6, 0x9b, 0x7d, 0x90, 0x9a, 0x77, 0x84, 0x74, 0x50, 0x7f, 0x5c, 0xa3, 0x60, 0xf4, - 0x08, 0x64, 0x2a, 0xf6, 0x8e, 0x6a, 0x99, 0x34, 0x25, 0xdb, 0xa6, 0x5a, 0xc1, 0xd9, 0x77, 0x30, - 0x54, 0x06, 0x5f, 0x11, 0x60, 0x12, 0x11, 0xf6, 0x4d, 0x6d, 0xdb, 0x11, 0x1c, 0x1f, 0x66, 0x11, - 0x41, 0x61, 0x9c, 0xdb, 0x09, 0xc8, 0x10, 0x4b, 0x04, 0x06, 0x3e, 0x41, 0xd1, 0x86, 0xcd, 0x1d, - 0xd3, 0x3f, 0xee, 0x03, 0x30, 0x44, 0x30, 0xbd, 0x41, 0x1f, 0x61, 0x85, 0x9b, 0xb9, 0xe3, 0x1b, - 0xf1, 0x0c, 0x4c, 0x10, 0xa4, 0x06, 0x76, 0xd4, 0xaa, 0xea, 0xa8, 0x3e, 0xec, 0x53, 0x14, 0x9b, - 0x98, 0x7d, 0x99, 0x77, 0x06, 0xe4, 0xb4, 0x9a, 0x5b, 0x7b, 0xae, 0x63, 0x3d, 0xc6, 0xe4, 0x24, - 0x30, 0xe1, 0x5a, 0xf7, 0xac, 0x38, 0x97, 0xf3, 0x90, 0xf6, 0xfb, 0x3d, 0x4a, 0x02, 0xf3, 0xfc, - 0x8c, 0x44, 0x8a, 0xa0, 0xf9, 0xd5, 0x22, 0x29, 0x5f, 0xde, 0x57, 0xca, 0x44, 0x48, 0x19, 0xb5, - 0xb4, 0xb8, 0x51, 0x2a, 0x2b, 0x9b, 0x2b, 0x1b, 0x8b, 0xcb, 0xa5, 0x4c, 0xd4, 0x57, 0xd8, 0x5f, - 0x89, 0x25, 0x1e, 0xca, 0x3c, 0x2c, 0xbf, 0x12, 0x81, 0xe1, 0xe0, 0x4e, 0x0d, 0xbd, 0x13, 0xee, - 0x13, 0xc7, 0x2a, 0x36, 0x76, 0xca, 0x37, 0x35, 0x8b, 0x06, 0x64, 0x43, 0x65, 0x8b, 0xa3, 0xeb, - 0x3f, 0xe3, 0x1c, 0x6b, 0x1d, 0x3b, 0xcf, 0x69, 0x16, 0x09, 0xb7, 0x86, 0xea, 0xa0, 0x25, 0x98, - 0xd2, 0x8d, 0xb2, 0xed, 0xa8, 0x7a, 0x55, 0xb5, 0xaa, 0x65, 0xef, 0x40, 0xab, 0xac, 0x56, 0x2a, - 0xd8, 0xb6, 0x0d, 0xb6, 0x10, 0xba, 0x5c, 0x8e, 0xe9, 0xc6, 0x3a, 0x47, 0xf6, 0x56, 0x88, 0x39, - 0x8e, 0x1a, 0x72, 0xdf, 0x68, 0x27, 0xf7, 0x3d, 0x0a, 0xc9, 0x86, 0x6a, 0x96, 0xb1, 0xee, 0x58, - 0x7b, 0xb4, 0x3e, 0x4f, 0x28, 0x89, 0x86, 0x6a, 0x96, 0x48, 0xfb, 0x2d, 0xd9, 0x26, 0x5d, 0x89, - 0x25, 0x12, 0x99, 0xe4, 0x95, 0x58, 0x22, 0x99, 0x01, 0xf9, 0xd5, 0x28, 0xa4, 0xfd, 0xf5, 0x3a, - 0xd9, 0xfe, 0x54, 0xe8, 0x8a, 0x25, 0xd1, 0x9c, 0xf6, 0xc0, 0xbe, 0xd5, 0xfd, 0xcc, 0x3c, 0x59, - 0xca, 0xf2, 0x03, 0xac, 0x38, 0x56, 0x18, 0x25, 0x29, 0x23, 0x88, 0xb3, 0x61, 0x56, 0x8c, 0x24, - 0x14, 0xde, 0x42, 0x0b, 0x30, 0xf0, 0xbc, 0x4d, 0x79, 0x0f, 0x50, 0xde, 0x0f, 0xee, 0xcf, 0xfb, - 0xca, 0x3a, 0x65, 0x9e, 0xbc, 0xb2, 0x5e, 0x5e, 0x59, 0x55, 0x96, 0xe7, 0x96, 0x14, 0x4e, 0x8e, - 0x8e, 0x40, 0xac, 0xae, 0xbe, 0xb0, 0x17, 0x5c, 0xf4, 0x28, 0xa8, 0xd7, 0x49, 0x38, 0x02, 0xb1, - 0x9b, 0x58, 0xbd, 0x1e, 0x5c, 0x6a, 0x28, 0xe8, 0x1e, 0x06, 0xc3, 0x2c, 0xc4, 0xa9, 0xbd, 0x10, - 0x00, 0xb7, 0x58, 0xe6, 0x10, 0x4a, 0x40, 0x6c, 0x7e, 0x55, 0x21, 0x01, 0x91, 0x81, 0x34, 0x83, - 0x96, 0xd7, 0x16, 0x4b, 0xf3, 0xa5, 0x4c, 0x44, 0x3e, 0x0b, 0x03, 0xcc, 0x08, 0x24, 0x58, 0x5c, - 0x33, 0x64, 0x0e, 0xf1, 0x26, 0xe7, 0x21, 0x89, 0xde, 0xcd, 0xe5, 0x42, 0x49, 0xc9, 0x44, 0x82, - 0x53, 0x1d, 0xcb, 0xc4, 0x65, 0x1b, 0xd2, 0xfe, 0x3a, 0xfc, 0xad, 0xd9, 0x8c, 0x7f, 0x43, 0x82, - 0x94, 0xaf, 0xae, 0x26, 0x05, 0x91, 0x5a, 0xaf, 0x1b, 0x37, 0xcb, 0x6a, 0x5d, 0x53, 0x6d, 0xee, - 0x1a, 0x40, 0x41, 0x73, 0x04, 0xd2, 0xeb, 0xd4, 0xbd, 0x45, 0x21, 0x12, 0xcf, 0x0c, 0xc8, 0x5f, - 0x94, 0x20, 0x13, 0x2e, 0x6c, 0x43, 0x62, 0x4a, 0x6f, 0xa7, 0x98, 0xf2, 0x17, 0x24, 0x18, 0x0e, - 0x56, 0xb3, 0x21, 0xf1, 0xee, 0x7f, 0x5b, 0xc5, 0xfb, 0xc3, 0x08, 0x0c, 0x05, 0x6a, 0xd8, 0x5e, - 0xa5, 0xfb, 0x00, 0x8c, 0x6a, 0x55, 0xdc, 0x30, 0x0d, 0x07, 0xeb, 0x95, 0xbd, 0x72, 0x1d, 0xdf, - 0xc0, 0xf5, 0xac, 0x4c, 0x93, 0xc6, 0xec, 0xfe, 0x55, 0xf2, 0xcc, 0xa2, 0x47, 0xb7, 0x44, 0xc8, - 0xf2, 0x63, 0x8b, 0xc5, 0xd2, 0xf2, 0xda, 0xea, 0x46, 0x69, 0x65, 0xfe, 0xbd, 0xe5, 0xcd, 0x95, - 0xab, 0x2b, 0xab, 0xcf, 0xad, 0x28, 0x19, 0x2d, 0x84, 0x76, 0x0f, 0xc3, 0x7e, 0x0d, 0x32, 0x61, - 0xa1, 0xd0, 0x7d, 0xd0, 0x4e, 0xac, 0xcc, 0x21, 0x34, 0x06, 0x23, 0x2b, 0xab, 0xe5, 0xf5, 0xc5, - 0x62, 0xa9, 0x5c, 0xba, 0x74, 0xa9, 0x34, 0xbf, 0xb1, 0xce, 0xce, 0x3d, 0x5c, 0xec, 0x8d, 0x40, - 0x80, 0xcb, 0x9f, 0x8f, 0xc2, 0x58, 0x1b, 0x49, 0xd0, 0x1c, 0xdf, 0xb1, 0xb0, 0x4d, 0xd4, 0x63, - 0xbd, 0x48, 0x3f, 0x43, 0x6a, 0x86, 0x35, 0xd5, 0x72, 0xf8, 0x06, 0xe7, 0x11, 0x20, 0x56, 0xd2, - 0x1d, 0x6d, 0x5b, 0xc3, 0x16, 0x3f, 0x4f, 0x62, 0xdb, 0x98, 0x11, 0x0f, 0xce, 0x8e, 0x94, 0x4e, - 0x01, 0x32, 0x0d, 0x5b, 0x73, 0xb4, 0x1b, 0xb8, 0xac, 0xe9, 0xe2, 0xf0, 0x89, 0x6c, 0x6b, 0x62, - 0x4a, 0x46, 0xf4, 0x2c, 0xea, 0x8e, 0x8b, 0xad, 0xe3, 0x9a, 0x1a, 0xc2, 0x26, 0xc9, 0x3c, 0xaa, - 0x64, 0x44, 0x8f, 0x8b, 0x7d, 0x3f, 0xa4, 0xab, 0x46, 0x93, 0xd4, 0x7a, 0x0c, 0x8f, 0xac, 0x1d, - 0x92, 0x92, 0x62, 0x30, 0x17, 0x85, 0x57, 0xf1, 0xde, 0xa9, 0x57, 0x5a, 0x49, 0x31, 0x18, 0x43, - 0x79, 0x18, 0x46, 0xd4, 0x5a, 0xcd, 0x22, 0xcc, 0x05, 0x23, 0xb6, 0x2f, 0x19, 0x76, 0xc1, 0x14, - 0x31, 0x77, 0x05, 0x12, 0xc2, 0x0e, 0x64, 0xa9, 0x26, 0x96, 0x28, 0x9b, 0x6c, 0xb3, 0x1d, 0x39, - 0x91, 0x54, 0x12, 0xba, 0xe8, 0xbc, 0x1f, 0xd2, 0x9a, 0x5d, 0xf6, 0x0e, 0xf1, 0x23, 0xd3, 0x91, - 0x13, 0x09, 0x25, 0xa5, 0xd9, 0xee, 0x01, 0xa8, 0xfc, 0xd5, 0x08, 0x0c, 0x07, 0x1f, 0x42, 0xa0, - 0x22, 0x24, 0xea, 0x46, 0x45, 0xa5, 0xae, 0xc5, 0x9e, 0x80, 0x9d, 0xe8, 0xf2, 0xdc, 0x62, 0x66, - 0x89, 0xe3, 0x2b, 0x2e, 0x65, 0xee, 0x77, 0x24, 0x48, 0x08, 0x30, 0x9a, 0x80, 0x98, 0xa9, 0x3a, - 0x3b, 0x94, 0x5d, 0xbc, 0x10, 0xc9, 0x48, 0x0a, 0x6d, 0x13, 0xb8, 0x6d, 0xaa, 0x3a, 0x75, 0x01, - 0x0e, 0x27, 0x6d, 0x32, 0xaf, 0x75, 0xac, 0x56, 0xe9, 0xa6, 0xc7, 0x68, 0x34, 0xb0, 0xee, 0xd8, - 0x62, 0x5e, 0x39, 0x7c, 0x9e, 0x83, 0xd1, 0xa3, 0x30, 0xea, 0x58, 0xaa, 0x56, 0x0f, 0xe0, 0xc6, - 0x28, 0x6e, 0x46, 0x74, 0xb8, 0xc8, 0x79, 0x38, 0x22, 0xf8, 0x56, 0xb1, 0xa3, 0x56, 0x76, 0x70, - 0xd5, 0x23, 0x1a, 0xa0, 0x87, 0x1b, 0xf7, 0x71, 0x84, 0x22, 0xef, 0x17, 0xb4, 0xf2, 0x2b, 0x12, - 0x8c, 0x8a, 0x6d, 0x5a, 0xd5, 0x35, 0xd6, 0x32, 0x80, 0xaa, 0xeb, 0x86, 0xe3, 0x37, 0x57, 0xab, - 0x2b, 0xb7, 0xd0, 0xcd, 0xcc, 0xb9, 0x44, 0x8a, 0x8f, 0x41, 0xae, 0x01, 0xe0, 0xf5, 0x74, 0x34, - 0xdb, 0x14, 0xa4, 0xf8, 0x13, 0x26, 0xfa, 0x98, 0x92, 0x6d, 0xec, 0x81, 0x81, 0xc8, 0x7e, 0x0e, - 0x8d, 0x43, 0x7c, 0x0b, 0xd7, 0x34, 0x9d, 0x9f, 0x1b, 0xb3, 0x86, 0x38, 0x7e, 0x89, 0xb9, 0xc7, - 0x2f, 0x85, 0x4f, 0x4a, 0x30, 0x56, 0x31, 0x1a, 0x61, 0x79, 0x0b, 0x99, 0xd0, 0xe9, 0x82, 0x7d, - 0x59, 0x7a, 0xdf, 0xd3, 0x35, 0xcd, 0xd9, 0x69, 0x6e, 0xcd, 0x54, 0x8c, 0xc6, 0x6c, 0xcd, 0xa8, - 0xab, 0x7a, 0xcd, 0x7b, 0xce, 0x4a, 0x7f, 0x54, 0x1e, 0xab, 0x61, 0xfd, 0xb1, 0x9a, 0xe1, 0x7b, - 0xea, 0x7a, 0xd1, 0xfb, 0xf9, 0xa7, 0x92, 0xf4, 0xb3, 0x91, 0xe8, 0xc2, 0x5a, 0xe1, 0x6b, 0x91, - 0xdc, 0x02, 0x1b, 0x6e, 0x4d, 0x98, 0x47, 0xc1, 0xdb, 0x75, 0x5c, 0x21, 0x2a, 0xc3, 0x77, 0x1f, - 0x85, 0xf1, 0x9a, 0x51, 0x33, 0x28, 0xc7, 0x59, 0xf2, 0x8b, 0x3f, 0xb9, 0x4d, 0xba, 0xd0, 0x5c, - 0xd7, 0xc7, 0xbc, 0xf9, 0x15, 0x18, 0xe3, 0xc8, 0x65, 0xfa, 0xe8, 0x88, 0x6d, 0x6c, 0xd0, 0xbe, - 0xa7, 0x6a, 0xd9, 0x5f, 0x79, 0x8d, 0x2e, 0xe8, 0xca, 0x28, 0x27, 0x25, 0x7d, 0x6c, 0xef, 0x93, - 0x57, 0xe0, 0x70, 0x80, 0x1f, 0x0b, 0x5b, 0x6c, 0x75, 0xe1, 0xf8, 0x9b, 0x9c, 0xe3, 0x98, 0x8f, - 0xe3, 0x3a, 0x27, 0xcd, 0xcf, 0xc3, 0x50, 0x3f, 0xbc, 0xfe, 0x25, 0xe7, 0x95, 0xc6, 0x7e, 0x26, - 0x0b, 0x30, 0x42, 0x99, 0x54, 0x9a, 0xb6, 0x63, 0x34, 0x68, 0x4e, 0xdc, 0x9f, 0xcd, 0x6f, 0xbd, - 0xc6, 0xe2, 0x68, 0x98, 0x90, 0xcd, 0xbb, 0x54, 0xf9, 0x3c, 0xd0, 0xa7, 0x65, 0x55, 0x5c, 0xa9, - 0x77, 0xe1, 0xf0, 0x2d, 0x2e, 0x88, 0x8b, 0x9f, 0xbf, 0x06, 0xe3, 0xe4, 0x37, 0x4d, 0x59, 0x7e, - 0x49, 0xba, 0x1f, 0xc1, 0x65, 0x5f, 0xf9, 0x08, 0x0b, 0xd5, 0x31, 0x97, 0x81, 0x4f, 0x26, 0xdf, - 0x2c, 0xd6, 0xb0, 0xe3, 0x60, 0xcb, 0x2e, 0xab, 0xf5, 0x76, 0xe2, 0xf9, 0xce, 0x30, 0xb2, 0x9f, - 0xfb, 0x5e, 0x70, 0x16, 0x17, 0x18, 0xe5, 0x5c, 0xbd, 0x9e, 0xdf, 0x84, 0xfb, 0xda, 0x78, 0x45, - 0x0f, 0x3c, 0x3f, 0xcf, 0x79, 0x8e, 0xb7, 0x78, 0x06, 0x61, 0xbb, 0x06, 0x02, 0xee, 0xce, 0x65, - 0x0f, 0x3c, 0x7f, 0x86, 0xf3, 0x44, 0x9c, 0x56, 0x4c, 0x29, 0xe1, 0x78, 0x05, 0x46, 0x6f, 0x60, - 0x6b, 0xcb, 0xb0, 0xf9, 0xb9, 0x51, 0x0f, 0xec, 0xbe, 0xc0, 0xd9, 0x8d, 0x70, 0x42, 0x7a, 0x90, - 0x44, 0x78, 0x5d, 0x80, 0xc4, 0xb6, 0x5a, 0xc1, 0x3d, 0xb0, 0xb8, 0xc5, 0x59, 0x0c, 0x12, 0x7c, - 0x42, 0x3a, 0x07, 0xe9, 0x9a, 0xc1, 0x57, 0xad, 0xee, 0xe4, 0x5f, 0xe4, 0xe4, 0x29, 0x41, 0xc3, - 0x59, 0x98, 0x86, 0xd9, 0xac, 0x93, 0x25, 0xad, 0x3b, 0x8b, 0xbf, 0x29, 0x58, 0x08, 0x1a, 0xce, - 0xa2, 0x0f, 0xb3, 0x7e, 0x49, 0xb0, 0xb0, 0x7d, 0xf6, 0x7c, 0x06, 0x52, 0x86, 0x5e, 0xdf, 0x33, - 0xf4, 0x5e, 0x84, 0xf8, 0x32, 0xe7, 0x00, 0x9c, 0x84, 0x30, 0xb8, 0x08, 0xc9, 0x5e, 0x27, 0xe2, - 0x6f, 0x7d, 0x4f, 0x84, 0x87, 0x98, 0x81, 0x05, 0x18, 0x11, 0x09, 0x4a, 0x33, 0xf4, 0x1e, 0x58, - 0xfc, 0x6d, 0xce, 0x62, 0xd8, 0x47, 0xc6, 0xd5, 0x70, 0xb0, 0xed, 0xd4, 0x70, 0x2f, 0x4c, 0xbe, - 0x2a, 0xd4, 0xe0, 0x24, 0xdc, 0x94, 0x5b, 0x58, 0xaf, 0xec, 0xf4, 0xc6, 0xe1, 0xe7, 0x85, 0x29, - 0x05, 0x0d, 0x61, 0x31, 0x0f, 0x43, 0x0d, 0xd5, 0xb2, 0x77, 0xd4, 0x7a, 0x4f, 0xd3, 0xf1, 0x77, - 0x38, 0x8f, 0xb4, 0x4b, 0xc4, 0x2d, 0xd2, 0xd4, 0xfb, 0x61, 0xf3, 0x35, 0x61, 0x11, 0x1f, 0x19, - 0x0f, 0x3d, 0xdb, 0xa1, 0x87, 0x6c, 0xfd, 0x70, 0xfb, 0x05, 0x11, 0x7a, 0x8c, 0x76, 0xd9, 0xcf, - 0xf1, 0x22, 0x24, 0x6d, 0xed, 0x85, 0x9e, 0xd8, 0xfc, 0xa2, 0x98, 0x69, 0x4a, 0x40, 0x88, 0xdf, - 0x0b, 0x47, 0xda, 0x2e, 0x13, 0x3d, 0x30, 0xfb, 0xbb, 0x9c, 0xd9, 0x44, 0x9b, 0xa5, 0x82, 0xa7, - 0x84, 0x7e, 0x59, 0xfe, 0x3d, 0x91, 0x12, 0x70, 0x88, 0xd7, 0x1a, 0xd9, 0x47, 0xd8, 0xea, 0x76, - 0x7f, 0x56, 0xfb, 0x25, 0x61, 0x35, 0x46, 0x1b, 0xb0, 0xda, 0x06, 0x4c, 0x70, 0x8e, 0xfd, 0xcd, - 0xeb, 0x2f, 0x8b, 0xc4, 0xca, 0xa8, 0x37, 0x83, 0xb3, 0xfb, 0x7e, 0xc8, 0xb9, 0xe6, 0x14, 0x05, - 0xab, 0x5d, 0x6e, 0xa8, 0x66, 0x0f, 0x9c, 0x7f, 0x85, 0x73, 0x16, 0x19, 0xdf, 0xad, 0x78, 0xed, - 0x65, 0xd5, 0x24, 0xcc, 0xdf, 0x03, 0x59, 0xc1, 0xbc, 0xa9, 0x5b, 0xb8, 0x62, 0xd4, 0x74, 0xed, - 0x05, 0x5c, 0xed, 0x81, 0xf5, 0xaf, 0x86, 0xa6, 0x6a, 0xd3, 0x47, 0x4e, 0x38, 0x2f, 0x42, 0xc6, - 0xad, 0x55, 0xca, 0x5a, 0xc3, 0x34, 0x2c, 0xa7, 0x0b, 0xc7, 0xaf, 0x8b, 0x99, 0x72, 0xe9, 0x16, - 0x29, 0x59, 0xbe, 0x04, 0xec, 0xc9, 0x73, 0xaf, 0x2e, 0xf9, 0x6b, 0x9c, 0xd1, 0x90, 0x47, 0xc5, - 0x13, 0x47, 0xc5, 0x68, 0x98, 0xaa, 0xd5, 0x4b, 0xfe, 0xfb, 0xfb, 0x22, 0x71, 0x70, 0x12, 0x9e, - 0x38, 0x9c, 0x3d, 0x13, 0x93, 0xd5, 0xbe, 0x07, 0x0e, 0xbf, 0x2e, 0x12, 0x87, 0xa0, 0xe1, 0x2c, - 0x44, 0xc1, 0xd0, 0x03, 0x8b, 0x7f, 0x20, 0x58, 0x08, 0x1a, 0xc2, 0xe2, 0x59, 0x6f, 0xa1, 0xb5, - 0x70, 0x4d, 0xb3, 0x1d, 0x8b, 0x95, 0xc9, 0xfb, 0xb3, 0xfa, 0x87, 0xdf, 0x0b, 0x16, 0x61, 0x8a, - 0x8f, 0x94, 0x64, 0x22, 0x7e, 0xec, 0x4a, 0x77, 0x51, 0xdd, 0x05, 0xfb, 0x0d, 0x91, 0x89, 0x7c, - 0x64, 0x44, 0x36, 0x5f, 0x85, 0x48, 0xcc, 0x5e, 0x21, 0x7b, 0x87, 0x1e, 0xd8, 0xfd, 0xa3, 0x90, - 0x70, 0xeb, 0x82, 0x96, 0xf0, 0xf4, 0xd5, 0x3f, 0x4d, 0xfd, 0x3a, 0xde, 0xeb, 0xc9, 0x3b, 0xff, - 0x71, 0xa8, 0xfe, 0xd9, 0x64, 0x94, 0x2c, 0x87, 0x8c, 0x84, 0xea, 0x29, 0xd4, 0xed, 0x9e, 0x51, - 0xf6, 0xc7, 0xde, 0xe0, 0xfa, 0x06, 0xcb, 0xa9, 0xfc, 0x12, 0x71, 0xf2, 0x60, 0xd1, 0xd3, 0x9d, - 0xd9, 0x47, 0xde, 0x70, 0xfd, 0x3c, 0x50, 0xf3, 0xe4, 0x2f, 0xc1, 0x50, 0xa0, 0xe0, 0xe9, 0xce, - 0xea, 0xa3, 0x9c, 0x55, 0xda, 0x5f, 0xef, 0xe4, 0xcf, 0x42, 0x8c, 0x14, 0x2f, 0xdd, 0xc9, 0xff, - 0x32, 0x27, 0xa7, 0xe8, 0xf9, 0x77, 0x41, 0x42, 0x14, 0x2d, 0xdd, 0x49, 0x3f, 0xc6, 0x49, 0x5d, - 0x12, 0x42, 0x2e, 0x0a, 0x96, 0xee, 0xe4, 0x7f, 0x45, 0x90, 0x0b, 0x12, 0x42, 0xde, 0xbb, 0x09, - 0xbf, 0xf1, 0x13, 0x31, 0xbe, 0xe8, 0x08, 0xdb, 0x5d, 0x84, 0x41, 0x5e, 0xa9, 0x74, 0xa7, 0xfe, - 0x04, 0x1f, 0x5c, 0x50, 0xe4, 0x9f, 0x82, 0x78, 0x8f, 0x06, 0xff, 0x49, 0x4e, 0xca, 0xf0, 0xf3, - 0xf3, 0x90, 0xf2, 0x55, 0x27, 0xdd, 0xc9, 0xff, 0x1a, 0x27, 0xf7, 0x53, 0x11, 0xd1, 0x79, 0x75, - 0xd2, 0x9d, 0xc1, 0x27, 0x85, 0xe8, 0x9c, 0x82, 0x98, 0x4d, 0x14, 0x26, 0xdd, 0xa9, 0x3f, 0x25, - 0xac, 0x2e, 0x48, 0xf2, 0xcf, 0x40, 0xd2, 0x5d, 0x6c, 0xba, 0xd3, 0x7f, 0x9a, 0xd3, 0x7b, 0x34, - 0xc4, 0x02, 0xbe, 0xc5, 0xae, 0x3b, 0x8b, 0xbf, 0x2e, 0x2c, 0xe0, 0xa3, 0x22, 0x61, 0x14, 0x2e, - 0x60, 0xba, 0x73, 0xfa, 0x8c, 0x08, 0xa3, 0x50, 0xfd, 0x42, 0x66, 0x93, 0xe6, 0xfc, 0xee, 0x2c, - 0x7e, 0x4a, 0xcc, 0x26, 0xc5, 0x27, 0x62, 0x84, 0x2b, 0x82, 0xee, 0x3c, 0xfe, 0x86, 0x10, 0x23, - 0x54, 0x10, 0xe4, 0xd7, 0x00, 0xb5, 0x56, 0x03, 0xdd, 0xf9, 0x7d, 0x96, 0xf3, 0x1b, 0x6d, 0x29, - 0x06, 0xf2, 0xcf, 0xc1, 0x44, 0xfb, 0x4a, 0xa0, 0x3b, 0xd7, 0xcf, 0xbd, 0x11, 0xda, 0xbb, 0xf9, - 0x0b, 0x81, 0xfc, 0x86, 0xb7, 0xa4, 0xf8, 0xab, 0x80, 0xee, 0x6c, 0x3f, 0xff, 0x46, 0x30, 0x71, - 0xfb, 0x8b, 0x80, 0xfc, 0x1c, 0x80, 0xb7, 0x00, 0x77, 0xe7, 0xf5, 0x05, 0xce, 0xcb, 0x47, 0x44, - 0x42, 0x83, 0xaf, 0xbf, 0xdd, 0xe9, 0x6f, 0x89, 0xd0, 0xe0, 0x14, 0x24, 0x34, 0xc4, 0xd2, 0xdb, - 0x9d, 0xfa, 0x8b, 0x22, 0x34, 0x04, 0x09, 0xf1, 0x6c, 0xdf, 0xea, 0xd6, 0x9d, 0xc3, 0x97, 0x85, - 0x67, 0xfb, 0xa8, 0xf2, 0x2b, 0x30, 0xda, 0xb2, 0x20, 0x76, 0x67, 0xf5, 0xb3, 0x9c, 0x55, 0x26, - 0xbc, 0x1e, 0xfa, 0x17, 0x2f, 0xbe, 0x18, 0x76, 0xe7, 0xf6, 0x95, 0xd0, 0xe2, 0xc5, 0xd7, 0xc2, - 0xfc, 0x45, 0x48, 0xe8, 0xcd, 0x7a, 0x9d, 0x04, 0x0f, 0xda, 0xff, 0x6e, 0x60, 0xf6, 0x3f, 0xff, - 0x80, 0x5b, 0x47, 0x10, 0xe4, 0xcf, 0x42, 0x1c, 0x37, 0xb6, 0x70, 0xb5, 0x1b, 0xe5, 0x77, 0x7f, - 0x20, 0x12, 0x26, 0xc1, 0xce, 0x3f, 0x03, 0xc0, 0x8e, 0x46, 0xe8, 0xe3, 0xc1, 0x2e, 0xb4, 0xff, - 0xe5, 0x07, 0xfc, 0x32, 0x8e, 0x47, 0xe2, 0x31, 0x60, 0x57, 0x7b, 0xf6, 0x67, 0xf0, 0xbd, 0x20, - 0x03, 0x3a, 0x23, 0x17, 0x60, 0xf0, 0x79, 0xdb, 0xd0, 0x1d, 0xb5, 0xd6, 0x8d, 0xfa, 0xbf, 0x72, - 0x6a, 0x81, 0x4f, 0x0c, 0xd6, 0x30, 0x2c, 0xec, 0xa8, 0x35, 0xbb, 0x1b, 0xed, 0x7f, 0xe3, 0xb4, - 0x2e, 0x01, 0x21, 0xae, 0xa8, 0xb6, 0xd3, 0x8b, 0xde, 0xff, 0x5d, 0x10, 0x0b, 0x02, 0x22, 0x34, - 0xf9, 0x7d, 0x1d, 0xef, 0x75, 0xa3, 0xfd, 0xbe, 0x10, 0x9a, 0xe3, 0xe7, 0xdf, 0x05, 0x49, 0xf2, - 0x93, 0xdd, 0xb0, 0xeb, 0x42, 0xfc, 0xc7, 0x9c, 0xd8, 0xa3, 0x20, 0x23, 0xdb, 0x4e, 0xd5, 0xd1, - 0xba, 0x1b, 0xfb, 0x0e, 0x9f, 0x69, 0x81, 0x9f, 0x9f, 0x83, 0x94, 0xed, 0x54, 0xab, 0x4d, 0x5e, - 0x9f, 0x76, 0x21, 0xff, 0x1f, 0x3f, 0x70, 0x8f, 0x2c, 0x5c, 0x1a, 0x32, 0xdb, 0x37, 0xaf, 0x3b, - 0xa6, 0x41, 0x1f, 0x81, 0x74, 0xe3, 0xf0, 0x06, 0xe7, 0xe0, 0x23, 0xc9, 0xcf, 0x43, 0x9a, 0xe8, - 0x62, 0x61, 0x13, 0xd3, 0xe7, 0x55, 0x5d, 0x58, 0xfc, 0x4f, 0x6e, 0x80, 0x00, 0x51, 0xe1, 0x47, - 0xbf, 0xf5, 0xea, 0xa4, 0xf4, 0xf2, 0xab, 0x93, 0xd2, 0x1f, 0xbe, 0x3a, 0x29, 0x7d, 0xea, 0x3b, - 0x93, 0x87, 0x5e, 0xfe, 0xce, 0xe4, 0xa1, 0xdf, 0xfb, 0xce, 0xe4, 0xa1, 0xf6, 0xc7, 0xc6, 0xb0, - 0x60, 0x2c, 0x18, 0xec, 0xc0, 0xf8, 0x7d, 0x72, 0xe0, 0xb8, 0xb8, 0x66, 0x78, 0xa7, 0xb5, 0xee, - 0x26, 0x07, 0x3e, 0x1a, 0x85, 0xc9, 0x8a, 0x61, 0x37, 0x0c, 0x7b, 0x76, 0x4b, 0xb5, 0xf1, 0xec, - 0x8d, 0x27, 0xb6, 0xb0, 0xa3, 0x3e, 0x31, 0x5b, 0x31, 0x34, 0x9d, 0x1f, 0xfb, 0x8e, 0xb1, 0xfe, - 0x19, 0xd2, 0x3f, 0xc3, 0xfb, 0x73, 0x6d, 0x4f, 0x88, 0xe5, 0x05, 0x88, 0xcd, 0x1b, 0x9a, 0x8e, - 0xc6, 0x21, 0x5e, 0xc5, 0xba, 0xd1, 0xe0, 0x17, 0xc0, 0x58, 0x03, 0x3d, 0x00, 0x03, 0x6a, 0xc3, - 0x68, 0xea, 0x0e, 0x3b, 0x2e, 0x2f, 0xa4, 0xbe, 0x75, 0x7b, 0xea, 0xd0, 0xef, 0xdf, 0x9e, 0x8a, - 0x2e, 0xea, 0x8e, 0xc2, 0xbb, 0xf2, 0xb1, 0xd7, 0xbf, 0x34, 0x25, 0xc9, 0x57, 0x60, 0xb0, 0x88, - 0x2b, 0x07, 0xe1, 0x55, 0xc4, 0x95, 0x10, 0xaf, 0x47, 0x20, 0xb1, 0xa8, 0x3b, 0xec, 0x8a, 0xde, - 0x71, 0x88, 0x6a, 0x3a, 0xbb, 0xf5, 0x11, 0x1a, 0x9f, 0xc0, 0x09, 0x6a, 0x11, 0x57, 0x5c, 0xd4, - 0x2a, 0xae, 0x84, 0x51, 0x09, 0x7b, 0x02, 0x2f, 0x14, 0x7f, 0xef, 0x3f, 0x4e, 0x1e, 0x7a, 0xf1, - 0xd5, 0xc9, 0x43, 0x9d, 0xe6, 0x27, 0x60, 0x7e, 0x6e, 0x62, 0xf6, 0xe7, 0x31, 0xbb, 0x7a, 0x7d, - 0x96, 0x84, 0x96, 0xbd, 0x35, 0xc0, 0x6e, 0x35, 0xc3, 0xa7, 0x22, 0x30, 0x15, 0x3e, 0x52, 0x27, - 0x7e, 0x6c, 0x3b, 0x6a, 0xc3, 0xec, 0xf4, 0xe2, 0xd4, 0x45, 0x48, 0x6e, 0x08, 0x1c, 0x94, 0x85, - 0x41, 0x1b, 0x57, 0x0c, 0xbd, 0x6a, 0x53, 0x91, 0xa3, 0x8a, 0x68, 0x12, 0x03, 0xea, 0xaa, 0x6e, - 0xd8, 0xfc, 0xba, 0x26, 0x6b, 0x14, 0x7e, 0x5a, 0xea, 0xcf, 0xb1, 0x86, 0xdd, 0xa1, 0xa8, 0x79, - 0xd6, 0xa4, 0xf7, 0x3d, 0xba, 0xdf, 0xd3, 0x08, 0xaa, 0x9e, 0xa7, 0x82, 0xef, 0xd1, 0xc3, 0x64, - 0xf8, 0xd1, 0xc3, 0x73, 0xb8, 0x5e, 0xbf, 0xaa, 0x1b, 0x37, 0xf5, 0x8d, 0x80, 0x49, 0xfe, 0x8d, - 0x04, 0xd3, 0xf4, 0xc2, 0xba, 0xd5, 0xd0, 0x74, 0x67, 0xb6, 0xae, 0x6d, 0xd9, 0xb3, 0x5b, 0x9a, - 0x63, 0x33, 0xcb, 0x71, 0x9b, 0x8c, 0x7b, 0x18, 0x33, 0x04, 0x63, 0x86, 0x60, 0xc8, 0x67, 0x20, - 0x51, 0xd0, 0x9c, 0x39, 0xcb, 0x52, 0xf7, 0x10, 0x82, 0x18, 0x81, 0x71, 0xa3, 0xd0, 0xdf, 0xc4, - 0x22, 0xb8, 0x8e, 0x1b, 0x36, 0x7d, 0xe8, 0x15, 0x53, 0x58, 0xa3, 0xb0, 0xd9, 0x71, 0x26, 0x2f, - 0xfa, 0x34, 0xf5, 0x89, 0xe4, 0xfb, 0xc9, 0x22, 0xa1, 0x9d, 0xb8, 0xae, 0x3e, 0x5f, 0x8b, 0xc1, - 0x71, 0x1f, 0x42, 0xc5, 0xda, 0x33, 0x1d, 0x1a, 0x92, 0xc6, 0x36, 0x57, 0x66, 0xd4, 0xa7, 0x0c, - 0xeb, 0xee, 0x10, 0x66, 0xdb, 0x10, 0x5f, 0x23, 0x74, 0x44, 0x11, 0xc7, 0x70, 0xd4, 0x3a, 0xd7, - 0x8e, 0x35, 0x08, 0x94, 0x5d, 0xda, 0x8f, 0x30, 0xa8, 0x26, 0xee, 0xeb, 0xd7, 0xb1, 0xba, 0xcd, - 0xee, 0x3e, 0x46, 0xe9, 0xb3, 0xcf, 0x04, 0x01, 0xd0, 0x6b, 0x8e, 0xe3, 0x10, 0x57, 0x9b, 0xec, - 0xb1, 0x5d, 0xf4, 0x44, 0x5a, 0x61, 0x0d, 0xf9, 0x2a, 0x0c, 0xf2, 0x47, 0x05, 0x28, 0x03, 0xd1, - 0xeb, 0x78, 0x8f, 0x8e, 0x93, 0x56, 0xc8, 0x4f, 0x34, 0x03, 0x71, 0x2a, 0x3c, 0xbf, 0xd4, 0x9d, - 0x9d, 0x69, 0x91, 0x7e, 0x86, 0x0a, 0xa9, 0x30, 0x34, 0xf9, 0x0a, 0x24, 0x8a, 0x46, 0x43, 0xd3, - 0x8d, 0x20, 0xb7, 0x24, 0xe3, 0x46, 0x65, 0x36, 0x9b, 0x3c, 0x9c, 0x15, 0xd6, 0x40, 0x13, 0x30, - 0xc0, 0xee, 0xc2, 0xf2, 0x47, 0x8f, 0xbc, 0x25, 0xcf, 0xc3, 0x20, 0xe5, 0xbd, 0x6a, 0x92, 0xf9, - 0x75, 0x2f, 0x22, 0x25, 0xf9, 0x9b, 0x11, 0x9c, 0x7d, 0xc4, 0x13, 0x16, 0x41, 0xac, 0xaa, 0x3a, - 0x2a, 0xd7, 0x9b, 0xfe, 0x96, 0x9f, 0x86, 0x04, 0x67, 0x62, 0xa3, 0xd3, 0x10, 0x35, 0x4c, 0x9b, - 0x3f, 0x3c, 0xcc, 0x75, 0x52, 0x65, 0xd5, 0x2c, 0xc4, 0x48, 0x22, 0x50, 0x08, 0x72, 0x41, 0xe9, - 0xe8, 0x2f, 0xe7, 0xfb, 0xf7, 0x17, 0x36, 0x8c, 0xeb, 0x2c, 0x5f, 0x8e, 0xc0, 0xa4, 0xaf, 0xf7, - 0x06, 0xb6, 0x48, 0xbd, 0x1c, 0x70, 0x7d, 0xe4, 0x13, 0x92, 0xf7, 0x77, 0x70, 0x97, 0x77, 0x41, - 0x74, 0xce, 0x34, 0x51, 0x0e, 0x12, 0xec, 0x21, 0xa1, 0xc1, 0xfc, 0x25, 0xa6, 0xb8, 0x6d, 0xd2, - 0x67, 0x1b, 0xdb, 0xce, 0x4d, 0xd5, 0x72, 0x5f, 0x17, 0x11, 0x6d, 0xf9, 0x02, 0x24, 0xe7, 0x0d, - 0xdd, 0xc6, 0xba, 0xdd, 0xa4, 0xa1, 0xb3, 0x55, 0x37, 0x2a, 0xd7, 0x39, 0x07, 0xd6, 0x20, 0x06, - 0x57, 0x4d, 0x93, 0x52, 0xc6, 0x14, 0xf2, 0x93, 0xa5, 0xde, 0xc2, 0x7a, 0x47, 0x13, 0x5d, 0xe8, - 0xdf, 0x44, 0x5c, 0x49, 0xd7, 0x46, 0x7f, 0x20, 0xc1, 0xb1, 0xd6, 0x80, 0xba, 0x8e, 0xf7, 0xec, - 0x7e, 0xe3, 0xe9, 0x3c, 0x24, 0xd7, 0xe8, 0x3b, 0x9b, 0x57, 0xf1, 0x1e, 0xca, 0xc1, 0x20, 0xae, - 0x9e, 0x3e, 0x7b, 0xf6, 0x89, 0x0b, 0xcc, 0xdb, 0x2f, 0x1f, 0x52, 0x04, 0x20, 0x9f, 0x20, 0x5a, - 0xbd, 0xfe, 0xe5, 0x29, 0xa9, 0x10, 0x87, 0xa8, 0xdd, 0x6c, 0xdc, 0x53, 0x1f, 0xf8, 0x7c, 0x3c, - 0x90, 0x00, 0x59, 0x46, 0xbd, 0xa1, 0xd6, 0xb5, 0xaa, 0xea, 0xbd, 0x4d, 0x9b, 0xf1, 0xe9, 0x48, - 0x31, 0xda, 0xab, 0x98, 0xdb, 0xd7, 0x52, 0xf2, 0xaf, 0x4a, 0x90, 0xbe, 0x26, 0x38, 0xaf, 0x63, - 0x07, 0x5d, 0x04, 0x70, 0x47, 0x12, 0x61, 0x71, 0x74, 0x26, 0x3c, 0xd6, 0x8c, 0x4b, 0xa3, 0xf8, - 0xd0, 0xd1, 0x53, 0xd4, 0xd1, 0x4c, 0xc3, 0xe6, 0xaf, 0x08, 0x74, 0x21, 0x75, 0x91, 0xd1, 0x29, - 0x40, 0x34, 0x83, 0x95, 0x6f, 0x18, 0x8e, 0xa6, 0xd7, 0xca, 0xa6, 0x71, 0x93, 0xbf, 0x78, 0x15, - 0x55, 0x32, 0xb4, 0xe7, 0x1a, 0xed, 0x58, 0x23, 0x70, 0x22, 0x74, 0xd2, 0xe5, 0x42, 0xd6, 0x3f, - 0xb5, 0x5a, 0xb5, 0xb0, 0x6d, 0xf3, 0x24, 0x25, 0x9a, 0xe8, 0x22, 0x0c, 0x9a, 0xcd, 0xad, 0xb2, - 0xc8, 0x08, 0xa9, 0xd3, 0xc7, 0xda, 0xc5, 0xb7, 0x98, 0x7f, 0x1e, 0xe1, 0x03, 0x66, 0x73, 0x8b, - 0x78, 0xc3, 0xfd, 0x90, 0x6e, 0x23, 0x4c, 0xea, 0x86, 0x27, 0x07, 0x7d, 0x15, 0x98, 0x6b, 0x50, - 0x36, 0x2d, 0xcd, 0xb0, 0x34, 0x67, 0x8f, 0x3e, 0xe1, 0x8f, 0x2a, 0x19, 0xd1, 0xb1, 0xc6, 0xe1, - 0xf2, 0x75, 0x18, 0x59, 0xd7, 0x1a, 0x26, 0xbd, 0x93, 0xc2, 0x25, 0x3f, 0xeb, 0xc9, 0x27, 0x75, - 0x97, 0xaf, 0xa3, 0x64, 0x91, 0x16, 0xc9, 0x0a, 0xcf, 0x76, 0xf4, 0xce, 0xa7, 0xfa, 0xf7, 0xce, - 0x60, 0xc1, 0xf2, 0x27, 0xb9, 0x40, 0xf0, 0xf1, 0xe5, 0xde, 0x97, 0x9e, 0x7a, 0x75, 0xcc, 0x6e, - 0x65, 0x4f, 0xae, 0x6b, 0x11, 0x90, 0xdb, 0x7f, 0x59, 0xcd, 0x75, 0x49, 0xa4, 0xb9, 0xae, 0x41, - 0x26, 0x5f, 0x80, 0xa1, 0x35, 0xd5, 0x72, 0xd6, 0xb1, 0x73, 0x19, 0xab, 0x55, 0x6c, 0x05, 0xd7, - 0xdd, 0x21, 0xb1, 0xee, 0x22, 0x88, 0xd1, 0xc5, 0x95, 0xad, 0x3b, 0xf4, 0xb7, 0xbc, 0x03, 0x31, - 0x7a, 0x0f, 0xc8, 0x5d, 0x93, 0x39, 0x05, 0x5b, 0x93, 0x49, 0x36, 0xdd, 0x73, 0xb0, 0xcd, 0x49, - 0x58, 0x03, 0x9d, 0x11, 0x2b, 0x6b, 0x74, 0xff, 0x95, 0x95, 0xbb, 0x2a, 0x5f, 0x5f, 0xeb, 0x30, - 0x58, 0x20, 0xc9, 0x78, 0xb1, 0xe8, 0x0a, 0x22, 0x79, 0x82, 0xa0, 0x65, 0x18, 0x31, 0x55, 0xcb, - 0xa1, 0x17, 0xa0, 0x77, 0xa8, 0x16, 0x3c, 0x1a, 0xa6, 0x5a, 0x63, 0x33, 0xa0, 0x2c, 0x1f, 0x65, - 0xc8, 0xf4, 0x03, 0xe5, 0x3f, 0x8a, 0xc1, 0x00, 0x37, 0xc6, 0xbb, 0x60, 0x90, 0x9b, 0x95, 0xfb, - 0xef, 0xf1, 0x99, 0xd6, 0xa5, 0x69, 0xc6, 0x5d, 0x42, 0x38, 0x3f, 0x41, 0x83, 0x1e, 0x82, 0x44, - 0x65, 0x47, 0xd5, 0xf4, 0xb2, 0x56, 0x15, 0xb5, 0xfc, 0xab, 0xb7, 0xa7, 0x06, 0xe7, 0x09, 0x6c, - 0xb1, 0xa8, 0x0c, 0xd2, 0xce, 0xc5, 0x2a, 0xa9, 0x05, 0x76, 0xb0, 0x56, 0xdb, 0x71, 0x78, 0x0c, - 0xf2, 0x16, 0x3a, 0x0f, 0x31, 0xe2, 0x32, 0xfc, 0xf5, 0x98, 0x5c, 0xcb, 0x1e, 0xcb, 0xad, 0x5b, - 0x0b, 0x09, 0x32, 0xf0, 0xa7, 0xbe, 0x3d, 0x25, 0x29, 0x94, 0x02, 0xcd, 0xc3, 0x50, 0x5d, 0xb5, - 0x9d, 0x32, 0x5d, 0xc3, 0xc8, 0xf0, 0x71, 0xca, 0xe2, 0x48, 0xab, 0x41, 0xb8, 0x61, 0xb9, 0xe8, - 0x29, 0x42, 0xc5, 0x40, 0x55, 0x74, 0x02, 0x32, 0x94, 0x49, 0xc5, 0x68, 0x34, 0x34, 0x87, 0x55, - 0x57, 0x03, 0xd4, 0xee, 0xc3, 0x04, 0x3e, 0x4f, 0xc1, 0xb4, 0xc6, 0x3a, 0x0a, 0x49, 0x7a, 0x21, - 0x9f, 0xa2, 0xb0, 0xcb, 0x67, 0x09, 0x02, 0xa0, 0x9d, 0x0f, 0xc3, 0x88, 0x97, 0x41, 0x19, 0x4a, - 0x82, 0x71, 0xf1, 0xc0, 0x14, 0xf1, 0x71, 0x18, 0xd7, 0xf1, 0x2e, 0xbd, 0x0e, 0x17, 0xc0, 0x4e, - 0x52, 0x6c, 0x44, 0xfa, 0xae, 0x05, 0x29, 0xde, 0x01, 0xc3, 0x15, 0x61, 0x7c, 0x86, 0x0b, 0x14, - 0x77, 0xc8, 0x85, 0x52, 0xb4, 0x23, 0x90, 0x50, 0x4d, 0x93, 0x21, 0xa4, 0x78, 0x06, 0x35, 0x4d, - 0xda, 0x75, 0x12, 0x46, 0xa9, 0x8e, 0x16, 0xb6, 0x9b, 0x75, 0x87, 0x33, 0x49, 0x53, 0x9c, 0x11, - 0xd2, 0xa1, 0x30, 0x38, 0xc5, 0x7d, 0x00, 0x86, 0xf0, 0x0d, 0xad, 0x8a, 0xf5, 0x0a, 0x66, 0x78, - 0x43, 0x14, 0x2f, 0x2d, 0x80, 0x14, 0xe9, 0x11, 0x70, 0x33, 0x63, 0x59, 0x64, 0xed, 0x61, 0xc6, - 0x4f, 0xc0, 0xe7, 0x18, 0x58, 0x3e, 0x05, 0xb1, 0xa2, 0xea, 0xa8, 0xa4, 0xc4, 0x70, 0x76, 0xd9, - 0x52, 0x94, 0x56, 0xc8, 0xcf, 0xb6, 0xe1, 0xf6, 0x7a, 0x04, 0x62, 0xd7, 0x0c, 0x07, 0xa3, 0x27, - 0x7d, 0x65, 0xe1, 0x70, 0x3b, 0x1f, 0x5f, 0xd7, 0x6a, 0x3a, 0xae, 0x2e, 0xdb, 0x35, 0xdf, 0x1b, - 0xb5, 0x9e, 0x8b, 0x45, 0x02, 0x2e, 0x36, 0x0e, 0x71, 0xcb, 0x68, 0xea, 0x55, 0x71, 0x97, 0x8b, - 0x36, 0x50, 0x09, 0x12, 0xae, 0xe7, 0xc4, 0xba, 0x79, 0xce, 0x08, 0xf1, 0x1c, 0xe2, 0xd7, 0x1c, - 0xa0, 0x0c, 0x6e, 0x71, 0x07, 0x2a, 0x40, 0xd2, 0x4d, 0x79, 0xdc, 0x03, 0x7b, 0x73, 0x62, 0x8f, - 0x8c, 0x2c, 0x41, 0xae, 0x3f, 0xb8, 0x06, 0x65, 0x5e, 0x98, 0x71, 0x3b, 0xb8, 0x45, 0x03, 0xae, - 0xc6, 0xdf, 0xee, 0x1d, 0xa4, 0x7a, 0x79, 0xae, 0xc6, 0xde, 0xf0, 0x3d, 0x06, 0x49, 0x5b, 0xab, - 0xe9, 0xaa, 0xd3, 0xb4, 0x30, 0xf7, 0x46, 0x0f, 0x20, 0x7f, 0x3a, 0x02, 0x03, 0xcc, 0xbb, 0x7d, - 0x76, 0x93, 0xda, 0xdb, 0x2d, 0xd2, 0xc9, 0x6e, 0xd1, 0x83, 0xdb, 0x6d, 0x0e, 0xc0, 0x15, 0xc6, - 0xe6, 0x2f, 0x5d, 0xb6, 0xa9, 0x33, 0x98, 0x88, 0xeb, 0x5a, 0x8d, 0x07, 0xaf, 0x8f, 0xc8, 0xf5, - 0xa0, 0xb8, 0x2f, 0x4f, 0x5e, 0x84, 0xe4, 0x96, 0xe6, 0x94, 0x55, 0xb2, 0x79, 0xa4, 0x26, 0x4c, - 0x9d, 0x9e, 0x9c, 0x69, 0xb7, 0xcb, 0x9c, 0x11, 0x5b, 0x4c, 0x25, 0xb1, 0xc5, 0x7f, 0xc9, 0x7f, - 0x20, 0x91, 0x5a, 0x99, 0x0f, 0x88, 0xe6, 0x60, 0x48, 0x28, 0x5a, 0xde, 0xae, 0xab, 0x35, 0xee, - 0x8c, 0xc7, 0x3b, 0x6a, 0x7b, 0xa9, 0xae, 0xd6, 0x94, 0x14, 0x57, 0x90, 0x34, 0xda, 0x4f, 0x6c, - 0xa4, 0xc3, 0xc4, 0x06, 0x3c, 0x29, 0x7a, 0x30, 0x4f, 0x0a, 0xcc, 0x79, 0x2c, 0x3c, 0xe7, 0x5f, - 0x8f, 0xd0, 0x3d, 0x93, 0x69, 0xd8, 0x6a, 0xfd, 0xad, 0x08, 0xb1, 0xa3, 0x90, 0x34, 0x8d, 0x7a, - 0x99, 0xf5, 0xb0, 0x4b, 0x93, 0x09, 0xd3, 0xa8, 0x2b, 0x2d, 0x7e, 0x14, 0xbf, 0x4b, 0xf1, 0x37, - 0x70, 0x17, 0xac, 0x36, 0x18, 0xb6, 0x9a, 0x05, 0x69, 0x66, 0x0a, 0xbe, 0x60, 0x3e, 0x4e, 0x6c, - 0x40, 0x57, 0x60, 0xa9, 0x75, 0x81, 0x67, 0x62, 0x33, 0x4c, 0x85, 0xe3, 0x11, 0x0a, 0xb6, 0xbe, - 0xb4, 0xdb, 0x6c, 0xfb, 0xfd, 0x5c, 0xe1, 0x78, 0xf2, 0x4f, 0x4b, 0x00, 0x4b, 0xc4, 0xb2, 0x54, - 0x5f, 0xb2, 0xd4, 0xd9, 0x54, 0x84, 0x72, 0x60, 0xe4, 0xc9, 0x4e, 0x93, 0xc6, 0xc7, 0x4f, 0xdb, - 0x7e, 0xb9, 0xe7, 0x61, 0xc8, 0x73, 0x46, 0x1b, 0x0b, 0x61, 0x26, 0xf7, 0x29, 0xee, 0xd7, 0xb1, - 0xa3, 0xa4, 0x6f, 0xf8, 0x5a, 0xf2, 0x3f, 0x93, 0x20, 0x49, 0x65, 0x5a, 0xc6, 0x8e, 0x1a, 0x98, - 0x43, 0xe9, 0xe0, 0x73, 0x78, 0x1c, 0x80, 0xb1, 0xb1, 0xb5, 0x17, 0x30, 0xf7, 0xac, 0x24, 0x85, - 0xac, 0x6b, 0x2f, 0x60, 0x74, 0xce, 0x35, 0x78, 0x74, 0x7f, 0x83, 0x8b, 0xe2, 0x9f, 0x9b, 0xfd, - 0x3e, 0x18, 0xa4, 0x5f, 0x3d, 0xd9, 0xb5, 0x79, 0x3d, 0x3f, 0xa0, 0x37, 0x1b, 0x1b, 0xbb, 0xb6, - 0xfc, 0x3c, 0x0c, 0x6e, 0xec, 0xb2, 0x23, 0x98, 0xa3, 0x90, 0xb4, 0x0c, 0x83, 0x2f, 0xfc, 0xac, - 0xe0, 0x4a, 0x10, 0x00, 0x5d, 0xe7, 0xc4, 0xb1, 0x43, 0xc4, 0x3b, 0x76, 0xf0, 0xce, 0x4d, 0xa2, - 0x3d, 0x9d, 0x9b, 0x9c, 0xfc, 0x77, 0x12, 0xa4, 0x7c, 0xf9, 0x01, 0x3d, 0x01, 0x87, 0x0b, 0x4b, - 0xab, 0xf3, 0x57, 0xcb, 0x8b, 0xc5, 0xf2, 0xa5, 0xa5, 0xb9, 0x05, 0xef, 0xb5, 0x80, 0xdc, 0xc4, - 0x4b, 0xb7, 0xa6, 0x91, 0x0f, 0x77, 0x53, 0xbf, 0xae, 0x1b, 0x37, 0x75, 0x34, 0x0b, 0xe3, 0x41, - 0x92, 0xb9, 0xc2, 0x7a, 0x69, 0x65, 0x23, 0x23, 0xe5, 0x0e, 0xbf, 0x74, 0x6b, 0x7a, 0xd4, 0x47, - 0x31, 0xb7, 0x65, 0x63, 0xdd, 0x69, 0x25, 0x98, 0x5f, 0x5d, 0x5e, 0x5e, 0xdc, 0xc8, 0x44, 0x5a, - 0x08, 0xf8, 0x0a, 0xf0, 0x08, 0x8c, 0x06, 0x09, 0x56, 0x16, 0x97, 0x32, 0xd1, 0x1c, 0x7a, 0xe9, - 0xd6, 0xf4, 0xb0, 0x0f, 0x7b, 0x45, 0xab, 0xe7, 0x12, 0x1f, 0xff, 0xca, 0xe4, 0xa1, 0x9f, 0xff, - 0xb9, 0x49, 0x89, 0x68, 0x36, 0x14, 0xc8, 0x11, 0xe8, 0x14, 0xdc, 0xb7, 0xbe, 0xb8, 0xb0, 0x52, - 0x2a, 0x96, 0x97, 0xd7, 0x17, 0xca, 0xec, 0x73, 0x08, 0xae, 0x76, 0x23, 0x2f, 0xdd, 0x9a, 0x4e, - 0x71, 0x95, 0x3a, 0x61, 0xaf, 0x29, 0xa5, 0x6b, 0xab, 0x1b, 0xa5, 0x8c, 0xc4, 0xb0, 0xd7, 0x2c, - 0x7c, 0xc3, 0x70, 0xd8, 0x67, 0x91, 0x1e, 0x87, 0x23, 0x6d, 0xb0, 0x5d, 0xc5, 0x46, 0x5f, 0xba, - 0x35, 0x3d, 0xb4, 0x66, 0x61, 0x16, 0x3f, 0x94, 0x62, 0x06, 0xb2, 0xad, 0x14, 0xab, 0x6b, 0xab, - 0xeb, 0x73, 0x4b, 0x99, 0xe9, 0x5c, 0xe6, 0xa5, 0x5b, 0xd3, 0x69, 0x91, 0x0c, 0x09, 0xbe, 0xa7, - 0xd9, 0xbd, 0xdc, 0x78, 0xfd, 0xd5, 0x08, 0x4c, 0xb6, 0x5c, 0xbe, 0xe6, 0x8f, 0x2c, 0x3a, 0x1d, - 0x14, 0xe7, 0x21, 0x51, 0x14, 0x4f, 0x42, 0xfa, 0x3d, 0x27, 0xfe, 0xa9, 0x3e, 0xcf, 0x89, 0x87, - 0xc4, 0x48, 0xe2, 0x98, 0xf8, 0x64, 0xf7, 0x63, 0x62, 0x21, 0xff, 0x01, 0x4e, 0x89, 0xbf, 0x7d, - 0x0a, 0x1e, 0xe4, 0x87, 0xeb, 0xb6, 0xa3, 0x5e, 0xd7, 0xf4, 0x9a, 0xfb, 0x08, 0x83, 0xb7, 0xb9, - 0x51, 0x26, 0xf8, 0x53, 0x0c, 0x01, 0xdd, 0xf7, 0x41, 0x46, 0x6e, 0xdf, 0xbd, 0x6d, 0xf7, 0x3d, - 0x6b, 0x97, 0x19, 0xca, 0x75, 0x79, 0xe4, 0x22, 0x7f, 0x42, 0x82, 0xe1, 0xcb, 0x9a, 0xed, 0x18, - 0x96, 0x56, 0x51, 0xeb, 0xf4, 0x2d, 0x87, 0x73, 0xbd, 0x2e, 0x1a, 0xa1, 0x1c, 0xf6, 0x0c, 0x0c, - 0xdc, 0x50, 0xeb, 0x2c, 0x5b, 0x47, 0xe9, 0x47, 0x19, 0xda, 0x1b, 0xc2, 0xcb, 0xd9, 0x82, 0x01, - 0x23, 0x93, 0x7f, 0x29, 0x02, 0x23, 0x34, 0xca, 0x6d, 0xf6, 0xb9, 0x1e, 0xb2, 0x43, 0x2d, 0x40, - 0xcc, 0x52, 0x1d, 0x7e, 0xe8, 0x5a, 0x98, 0xe1, 0x0f, 0x47, 0x1e, 0xea, 0xfe, 0xc0, 0x63, 0xa6, - 0x88, 0x2b, 0x0a, 0xa5, 0x45, 0x3f, 0x02, 0x89, 0x86, 0xba, 0x5b, 0xa6, 0x7c, 0xd8, 0xbe, 0x6f, - 0xae, 0x3f, 0x3e, 0x77, 0x6e, 0x4f, 0x8d, 0xec, 0xa9, 0x8d, 0x7a, 0x5e, 0x16, 0x7c, 0x64, 0x65, - 0xb0, 0xa1, 0xee, 0x12, 0x11, 0x91, 0x09, 0x23, 0x04, 0x5a, 0xd9, 0x51, 0xf5, 0x1a, 0x66, 0x83, - 0xd0, 0x23, 0xe4, 0xc2, 0xe5, 0xbe, 0x07, 0x99, 0xf0, 0x06, 0xf1, 0xb1, 0x93, 0x95, 0xa1, 0x86, - 0xba, 0x3b, 0x4f, 0x01, 0x64, 0xc4, 0x7c, 0xe2, 0xb3, 0x5f, 0x9a, 0x3a, 0x44, 0x1f, 0x38, 0xbd, - 0x22, 0x01, 0x78, 0x16, 0x43, 0x3f, 0x02, 0x99, 0x8a, 0xdb, 0xa2, 0xb4, 0x36, 0x9f, 0xc3, 0x87, - 0x3b, 0xcd, 0x45, 0xc8, 0xde, 0xac, 0xe8, 0x78, 0xf9, 0xf6, 0x94, 0xa4, 0x8c, 0x54, 0x42, 0x53, - 0xf1, 0x7e, 0x48, 0x35, 0xcd, 0xaa, 0xea, 0xe0, 0x32, 0xdd, 0x05, 0x47, 0xba, 0x16, 0x30, 0x93, - 0x84, 0xd7, 0x9d, 0xdb, 0x53, 0x88, 0xa9, 0xe5, 0x23, 0x96, 0x69, 0x59, 0x03, 0x0c, 0x42, 0x08, - 0x7c, 0x3a, 0xfd, 0xb6, 0x04, 0xa9, 0xa2, 0xef, 0xb6, 0x51, 0x16, 0x06, 0x1b, 0x86, 0xae, 0x5d, - 0xe7, 0xfe, 0x98, 0x54, 0x44, 0x13, 0xe5, 0x20, 0xc1, 0x5e, 0xfc, 0x72, 0xf6, 0xc4, 0x51, 0xb2, - 0x68, 0x13, 0xaa, 0x9b, 0x78, 0xcb, 0xd6, 0xc4, 0x6c, 0x28, 0xa2, 0x89, 0x2e, 0x41, 0xc6, 0xc6, - 0x95, 0xa6, 0xa5, 0x39, 0x7b, 0xe5, 0x8a, 0xa1, 0x3b, 0x6a, 0xc5, 0x61, 0xaf, 0x10, 0x15, 0x8e, - 0xde, 0xb9, 0x3d, 0x75, 0x1f, 0x93, 0x35, 0x8c, 0x21, 0x2b, 0x23, 0x02, 0x34, 0xcf, 0x20, 0x64, - 0x84, 0x2a, 0x76, 0x54, 0xad, 0x6e, 0xd3, 0x9a, 0x30, 0xa9, 0x88, 0xa6, 0x4f, 0x97, 0xff, 0x33, - 0xe0, 0x3f, 0x38, 0xbc, 0x04, 0x19, 0xc3, 0xc4, 0x56, 0xa0, 0xc2, 0x96, 0xc2, 0x23, 0x87, 0x31, - 0x64, 0x65, 0x44, 0x80, 0x44, 0xf5, 0x7d, 0x89, 0x4c, 0xb3, 0xd8, 0x66, 0x9b, 0xcd, 0x2d, 0x71, - 0xde, 0x18, 0xe0, 0x13, 0xc6, 0x90, 0xc9, 0x84, 0x72, 0xd0, 0x1a, 0x85, 0x90, 0x0a, 0xf9, 0x79, - 0x55, 0xab, 0x8b, 0x97, 0x5b, 0x15, 0xde, 0x42, 0x79, 0x18, 0xb0, 0x1d, 0xd5, 0x69, 0xda, 0xfc, - 0x93, 0x53, 0x72, 0x27, 0xe7, 0x29, 0x18, 0x7a, 0x75, 0x9d, 0x62, 0x2a, 0x9c, 0x02, 0x5d, 0x82, - 0x01, 0xc7, 0xb8, 0x8e, 0x75, 0x6e, 0x94, 0xbe, 0x22, 0x96, 0x3e, 0x9c, 0x65, 0xd4, 0xc8, 0x81, - 0x4c, 0x15, 0xd7, 0x71, 0x8d, 0x55, 0x80, 0x3b, 0x2a, 0xd9, 0x79, 0xd1, 0x2f, 0x4f, 0x15, 0x16, - 0xfb, 0x0e, 0x2b, 0x6e, 0x91, 0x30, 0x3f, 0x59, 0x19, 0x71, 0x41, 0xeb, 0x14, 0x82, 0xae, 0x06, - 0x2e, 0xba, 0xf1, 0xcf, 0xb3, 0x3d, 0xd0, 0x49, 0x7d, 0x9f, 0x97, 0x8a, 0xf3, 0x1a, 0xff, 0x35, - 0xb9, 0x4b, 0x90, 0x69, 0xea, 0x5b, 0x86, 0x4e, 0xdf, 0x40, 0xe3, 0x5b, 0x11, 0xb2, 0xb7, 0x8d, - 0xfa, 0xa7, 0x29, 0x8c, 0x21, 0x2b, 0x23, 0x2e, 0xe8, 0x32, 0xdb, 0xb0, 0x54, 0x61, 0xd8, 0xc3, - 0xa2, 0xa1, 0x97, 0xec, 0x1a, 0x7a, 0xf7, 0xf3, 0xd0, 0x3b, 0x1c, 0x1e, 0xc5, 0x8b, 0xbe, 0x21, - 0x17, 0x48, 0xc8, 0xd0, 0x65, 0x00, 0x2f, 0xe0, 0xe9, 0xb9, 0x4d, 0xaa, 0xf3, 0xc4, 0x7b, 0x59, - 0x43, 0xec, 0x75, 0x3d, 0x5a, 0xf4, 0x21, 0x18, 0x6b, 0x68, 0x7a, 0xd9, 0xc6, 0xf5, 0xed, 0x32, - 0x37, 0x30, 0x61, 0x49, 0x3f, 0x20, 0x52, 0x58, 0xea, 0xcf, 0x1f, 0xee, 0xdc, 0x9e, 0xca, 0xf1, - 0xa4, 0xd8, 0xca, 0x52, 0x56, 0x46, 0x1b, 0x9a, 0xbe, 0x8e, 0xeb, 0xdb, 0x45, 0x17, 0x96, 0x4f, - 0x7f, 0xfc, 0x4b, 0x53, 0x87, 0x78, 0x00, 0x1e, 0x92, 0xcf, 0xd1, 0xa7, 0x0d, 0x3c, 0x70, 0xb0, - 0x4d, 0xb6, 0x4f, 0xaa, 0x68, 0xd0, 0x13, 0x9e, 0xa4, 0xe2, 0x01, 0x58, 0xe0, 0xbe, 0xf8, 0x1f, - 0xa6, 0x25, 0xf9, 0x17, 0x25, 0x18, 0x28, 0x5e, 0x5b, 0x53, 0x35, 0x0b, 0x2d, 0xc2, 0xa8, 0xe7, - 0x39, 0xc1, 0xb0, 0x3d, 0x76, 0xe7, 0xf6, 0x54, 0x36, 0xec, 0x5c, 0x6e, 0xdc, 0x7a, 0x0e, 0x2c, - 0x02, 0x77, 0xb1, 0xd3, 0x1e, 0x3b, 0xc0, 0xaa, 0x05, 0x45, 0x6e, 0xdd, 0x81, 0x87, 0xd4, 0x2c, - 0xc1, 0x20, 0x93, 0xd6, 0x46, 0x79, 0x88, 0x9b, 0xe4, 0x07, 0x7f, 0x94, 0x32, 0xd9, 0xd1, 0x79, - 0x29, 0xbe, 0x7b, 0xb0, 0x4b, 0x48, 0xe4, 0x4f, 0x47, 0x00, 0x8a, 0xd7, 0xae, 0x6d, 0x58, 0x9a, - 0x59, 0xc7, 0xce, 0xdd, 0xd4, 0x7c, 0x03, 0x0e, 0xfb, 0x36, 0x74, 0x56, 0x25, 0xa4, 0xfd, 0xf4, - 0x9d, 0xdb, 0x53, 0xc7, 0xc2, 0xda, 0xfb, 0xd0, 0x64, 0x65, 0xcc, 0xdb, 0xda, 0x59, 0x95, 0xb6, - 0x5c, 0xab, 0xb6, 0xe3, 0x72, 0x8d, 0x76, 0xe6, 0xea, 0x43, 0xf3, 0x73, 0x2d, 0xda, 0x4e, 0x7b, - 0xd3, 0xae, 0x43, 0xca, 0x33, 0x89, 0x8d, 0x8a, 0x90, 0x70, 0xf8, 0x6f, 0x6e, 0x61, 0xb9, 0xb3, - 0x85, 0x05, 0x19, 0xb7, 0xb2, 0x4b, 0x29, 0xff, 0xa9, 0x04, 0xe0, 0xf9, 0xec, 0x0f, 0xa7, 0x8b, - 0x91, 0x54, 0xce, 0x13, 0x6f, 0xf4, 0x40, 0xc5, 0x17, 0xa7, 0x0e, 0xd9, 0xf3, 0x27, 0x22, 0x30, - 0xb6, 0x29, 0x32, 0xcf, 0x0f, 0xbd, 0x0d, 0xd6, 0x60, 0x10, 0xeb, 0x8e, 0xa5, 0x51, 0x23, 0x90, - 0xd9, 0x7e, 0xbc, 0xd3, 0x6c, 0xb7, 0xd1, 0x89, 0x7e, 0x42, 0x45, 0x3c, 0x84, 0xe0, 0x6c, 0x42, - 0xd6, 0xf8, 0x64, 0x14, 0xb2, 0x9d, 0x28, 0xd1, 0x3c, 0x8c, 0x54, 0x2c, 0x4c, 0x01, 0x65, 0xff, - 0xa9, 0x67, 0x21, 0xe7, 0xd5, 0x8a, 0x21, 0x04, 0x59, 0x19, 0x16, 0x10, 0xbe, 0x7a, 0xd4, 0x80, - 0x14, 0x72, 0xc4, 0xed, 0x08, 0x56, 0x8f, 0x95, 0x9b, 0xcc, 0x97, 0x0f, 0x31, 0x48, 0x90, 0x01, - 0x5b, 0x3f, 0x86, 0x3d, 0x28, 0x5d, 0x40, 0x3e, 0x00, 0x23, 0x9a, 0xae, 0x39, 0x9a, 0x5a, 0x2f, - 0x6f, 0xa9, 0x75, 0x55, 0xaf, 0x1c, 0xa4, 0x0e, 0x66, 0x29, 0x9f, 0x0f, 0x1b, 0x62, 0x27, 0x2b, - 0xc3, 0x1c, 0x52, 0x60, 0x00, 0x74, 0x19, 0x06, 0xc5, 0x50, 0xb1, 0x03, 0x55, 0x1b, 0x82, 0xdc, - 0x57, 0xb2, 0xfd, 0x64, 0x14, 0x46, 0x15, 0x5c, 0xfd, 0x8b, 0xa9, 0xe8, 0x6f, 0x2a, 0x96, 0x01, - 0x58, 0xb8, 0x93, 0x04, 0x7b, 0x80, 0xd9, 0x20, 0x09, 0x23, 0xc9, 0x38, 0x14, 0x6d, 0xc7, 0x37, - 0x1f, 0xb7, 0x23, 0x90, 0xf6, 0xcf, 0xc7, 0x9f, 0xd3, 0x55, 0x09, 0x2d, 0x7a, 0x99, 0x28, 0xc6, - 0x3f, 0x3c, 0xd9, 0x21, 0x13, 0xb5, 0x78, 0xef, 0xfe, 0x29, 0xe8, 0x4f, 0x22, 0x30, 0xb0, 0xa6, - 0x5a, 0x6a, 0xc3, 0x46, 0x95, 0x96, 0x4a, 0x53, 0x9c, 0x94, 0xb6, 0x7c, 0x5e, 0x98, 0x9f, 0x32, - 0x74, 0x29, 0x34, 0x3f, 0xdb, 0xa6, 0xd0, 0x7c, 0x37, 0x0c, 0x93, 0x0d, 0xae, 0xef, 0xd2, 0x07, - 0xb1, 0xf6, 0x50, 0xe1, 0x88, 0xc7, 0x25, 0xd8, 0xcf, 0xf6, 0xbf, 0xd7, 0xfc, 0xb7, 0x3e, 0x52, - 0x04, 0xc3, 0x4b, 0xcc, 0x84, 0x7c, 0xc2, 0xdb, 0x68, 0xfa, 0x3a, 0x65, 0x05, 0x1a, 0xea, 0x6e, - 0x89, 0x35, 0xd0, 0x12, 0xa0, 0x1d, 0xf7, 0xac, 0xa3, 0xec, 0x99, 0x93, 0xd0, 0x1f, 0xbf, 0x73, - 0x7b, 0xea, 0x08, 0xa3, 0x6f, 0xc5, 0x91, 0x95, 0x51, 0x0f, 0x28, 0xb8, 0x9d, 0x01, 0x20, 0x7a, - 0x95, 0xd9, 0x9d, 0x51, 0xb6, 0xdd, 0x39, 0x7c, 0xe7, 0xf6, 0xd4, 0x28, 0xe3, 0xe2, 0xf5, 0xc9, - 0x4a, 0x92, 0x34, 0x8a, 0xe4, 0xb7, 0xcf, 0xb3, 0xbf, 0x22, 0x01, 0xf2, 0x52, 0xbe, 0x82, 0x6d, - 0x93, 0xec, 0xcf, 0x48, 0x21, 0xee, 0xab, 0x9a, 0xa5, 0xfd, 0x0b, 0x71, 0x8f, 0x5e, 0x14, 0xe2, - 0xbe, 0x48, 0xb9, 0xe0, 0xa5, 0xc7, 0x08, 0x9f, 0xc7, 0x36, 0x17, 0x6c, 0x67, 0xe6, 0x0d, 0x4d, - 0x50, 0xb7, 0xe4, 0xc3, 0x43, 0xf2, 0xbf, 0x96, 0xe0, 0x48, 0x8b, 0x47, 0xb9, 0xc2, 0xfe, 0x25, - 0x40, 0x96, 0xaf, 0x93, 0x7f, 0x45, 0x8c, 0x09, 0xdd, 0xb7, 0x83, 0x8e, 0x5a, 0x2d, 0x79, 0xf7, - 0xee, 0x65, 0x78, 0x76, 0x43, 0xf7, 0x9f, 0x4a, 0x30, 0xee, 0x1f, 0xde, 0x55, 0x64, 0x05, 0xd2, - 0xfe, 0xd1, 0xb9, 0x0a, 0x0f, 0xf6, 0xa2, 0x02, 0x97, 0x3e, 0x40, 0x8f, 0x9e, 0xf5, 0xc2, 0x95, - 0x9d, 0x86, 0x3d, 0xd1, 0xb3, 0x35, 0x84, 0x4c, 0xe1, 0xb0, 0x8d, 0xd1, 0xf9, 0xf8, 0xbf, 0x12, - 0xc4, 0xd6, 0x0c, 0xa3, 0x8e, 0x0c, 0x18, 0xd5, 0x0d, 0xa7, 0x4c, 0x3c, 0x0b, 0x57, 0xcb, 0x7c, - 0xd3, 0xcd, 0xf2, 0xe0, 0x7c, 0x7f, 0x46, 0xfa, 0xee, 0xed, 0xa9, 0x56, 0x56, 0xca, 0x88, 0x6e, - 0x38, 0x05, 0x0a, 0xd9, 0x60, 0x5b, 0xf2, 0x0f, 0xc1, 0x50, 0x70, 0x30, 0x96, 0x25, 0x9f, 0xeb, - 0x7b, 0xb0, 0x20, 0x9b, 0x3b, 0xb7, 0xa7, 0xc6, 0xbd, 0x88, 0x71, 0xc1, 0xb2, 0x92, 0xde, 0xf2, - 0x8d, 0xce, 0x2e, 0xc4, 0x7d, 0xff, 0x4b, 0x53, 0xd2, 0xc9, 0x8f, 0x49, 0x00, 0xde, 0xc9, 0x03, - 0x9a, 0x86, 0xd4, 0xe6, 0xca, 0xfa, 0x5a, 0x69, 0x7e, 0xf1, 0xd2, 0x62, 0xa9, 0xe8, 0x9d, 0xde, - 0xdb, 0x26, 0xae, 0x68, 0xdb, 0x1a, 0xae, 0xa2, 0x1c, 0x24, 0x36, 0x57, 0x0a, 0xab, 0x2b, 0xc5, - 0x52, 0x31, 0x23, 0xe5, 0xd2, 0x2f, 0xdd, 0x9a, 0x4e, 0xb0, 0x9a, 0x0b, 0x57, 0xc9, 0x86, 0x90, - 0xf5, 0x2d, 0xae, 0x2c, 0x64, 0x22, 0xb9, 0xa1, 0x97, 0x6e, 0x4d, 0x27, 0xdd, 0x82, 0x0c, 0x4d, - 0xc0, 0x00, 0xa7, 0x8b, 0xe6, 0xe0, 0xa5, 0x5b, 0xd3, 0x03, 0xcc, 0x20, 0xb9, 0xd8, 0xc7, 0xbf, - 0x32, 0x79, 0xa8, 0x70, 0xa9, 0xe3, 0xd9, 0xfb, 0xa9, 0x7d, 0x6d, 0xb1, 0xeb, 0x1e, 0x20, 0x07, - 0x0f, 0xdc, 0xbf, 0x31, 0x02, 0x53, 0x1d, 0x4e, 0x98, 0x9d, 0xdd, 0x03, 0x1d, 0x2e, 0x77, 0x39, - 0xfd, 0xcd, 0xf5, 0x74, 0xa0, 0x2d, 0xdf, 0x8a, 0x01, 0x5a, 0xb6, 0x6b, 0xf3, 0xa4, 0x9a, 0xf1, - 0xdd, 0x26, 0x0b, 0x1d, 0x96, 0x48, 0x6f, 0xea, 0xb0, 0x64, 0x39, 0x70, 0xfc, 0x10, 0xe9, 0xef, - 0xd0, 0xb2, 0xe7, 0x33, 0x88, 0xe8, 0x5b, 0x72, 0x06, 0xd1, 0xbe, 0x44, 0x89, 0xdd, 0xbd, 0xbd, - 0x4c, 0xfc, 0x40, 0x7b, 0x99, 0x09, 0x18, 0xe0, 0x87, 0x85, 0xec, 0x13, 0xee, 0xbc, 0x85, 0xce, - 0x8a, 0x0f, 0x5a, 0x0f, 0xf6, 0xb6, 0x48, 0x30, 0xec, 0x7c, 0xe2, 0xe3, 0x62, 0x89, 0xf8, 0x4c, - 0x14, 0x32, 0xcb, 0x76, 0xad, 0x54, 0xd5, 0x9c, 0x7b, 0xe4, 0x1d, 0xcf, 0x74, 0xde, 0xd1, 0xa1, - 0x3b, 0xb7, 0xa7, 0x86, 0x99, 0x15, 0xf6, 0xd1, 0xbd, 0x01, 0x23, 0xa1, 0x93, 0x71, 0xee, 0x0b, - 0xc5, 0x83, 0x1c, 0xd0, 0x87, 0x58, 0xc9, 0xb4, 0x00, 0xf7, 0x79, 0x24, 0xda, 0x6d, 0xef, 0x7e, - 0xcc, 0x05, 0x2e, 0xdf, 0xcb, 0xe3, 0x2f, 0x6f, 0x56, 0xfe, 0x48, 0x82, 0xd4, 0xb2, 0x2d, 0x36, - 0x95, 0xf8, 0x87, 0x74, 0x83, 0xfd, 0x94, 0xfb, 0x76, 0x4d, 0xb4, 0x37, 0xef, 0x13, 0x6f, 0xdc, - 0x78, 0x8a, 0xfe, 0x4e, 0x84, 0xa6, 0xa7, 0x02, 0xae, 0x69, 0xba, 0xbb, 0x98, 0xe2, 0x3f, 0xaf, - 0xfb, 0x04, 0xcf, 0xa0, 0xb1, 0x83, 0x1a, 0xf4, 0x75, 0x09, 0x86, 0x96, 0xed, 0xda, 0xa6, 0x5e, - 0xfd, 0xff, 0xdd, 0x77, 0xee, 0xfa, 0x12, 0xfe, 0x2f, 0x22, 0x70, 0xd2, 0xbf, 0xe6, 0x7e, 0xa0, - 0x89, 0xad, 0x3d, 0x77, 0x59, 0x35, 0xd5, 0x9a, 0xa6, 0xfb, 0x9f, 0x9f, 0x1f, 0xf1, 0x0b, 0x4c, - 0x71, 0x85, 0xd8, 0xb2, 0x0e, 0xa9, 0x35, 0xb5, 0x86, 0x15, 0xfc, 0x81, 0x26, 0xb6, 0x9d, 0x36, - 0x6f, 0xc5, 0x4c, 0xc0, 0x80, 0xb1, 0xbd, 0x2d, 0x2e, 0xc7, 0xc4, 0x14, 0xde, 0x42, 0xe3, 0x10, - 0xaf, 0x6b, 0x0d, 0x8d, 0x19, 0x25, 0xa6, 0xb0, 0x06, 0x9a, 0x82, 0x54, 0x85, 0xe8, 0x5e, 0x66, - 0xb7, 0x89, 0x63, 0xe2, 0xab, 0x1f, 0x4d, 0xdd, 0xd9, 0x20, 0x10, 0xf9, 0x19, 0x48, 0xb3, 0xf1, - 0x78, 0x41, 0x7c, 0x04, 0x12, 0xf4, 0xf6, 0xa7, 0x37, 0xea, 0x20, 0x69, 0x5f, 0x65, 0x6f, 0xd0, - 0x30, 0x2e, 0x6c, 0x60, 0xd6, 0x28, 0x14, 0x3a, 0x9a, 0xf2, 0x44, 0xf7, 0x64, 0xc7, 0x0c, 0xe5, - 0x9a, 0xf1, 0x37, 0xe3, 0x70, 0x98, 0x3f, 0xd8, 0x56, 0x4d, 0x6d, 0x76, 0xc7, 0x71, 0xc4, 0xab, - 0x69, 0xc0, 0x77, 0xa2, 0xaa, 0xa9, 0xc9, 0x7b, 0x10, 0xbb, 0xec, 0x38, 0x26, 0x3a, 0x09, 0x71, - 0xab, 0x59, 0xc7, 0xe2, 0x40, 0x76, 0x7c, 0xc6, 0xc3, 0x99, 0x21, 0x08, 0x4a, 0xb3, 0x8e, 0x15, - 0x86, 0x82, 0x4a, 0x30, 0xb5, 0xdd, 0xac, 0xd7, 0xf7, 0xca, 0x55, 0x4c, 0xff, 0x61, 0x93, 0xfb, - 0x2f, 0x0f, 0xf0, 0xae, 0xa9, 0xea, 0x6e, 0xf1, 0x91, 0x50, 0x8e, 0x51, 0xb4, 0x22, 0xc5, 0x12, - 0xff, 0xee, 0xa0, 0x24, 0x70, 0xe4, 0xdf, 0x8f, 0x40, 0x42, 0xb0, 0xa6, 0xaf, 0xb4, 0xe0, 0x3a, - 0xae, 0x38, 0x86, 0x78, 0x44, 0xe9, 0xb6, 0x11, 0x82, 0x68, 0x8d, 0x4f, 0x51, 0xf2, 0xf2, 0x21, - 0x85, 0x34, 0x08, 0xcc, 0x7d, 0xd1, 0x88, 0xc0, 0xcc, 0x26, 0x99, 0xb5, 0x98, 0x69, 0x88, 0x93, - 0x93, 0xcb, 0x87, 0x14, 0xda, 0x42, 0x59, 0x18, 0x20, 0x01, 0xe4, 0xb0, 0xaf, 0x51, 0x12, 0x38, - 0x6f, 0xa3, 0x09, 0x88, 0x9b, 0xaa, 0x53, 0x61, 0x37, 0x80, 0x49, 0x07, 0x6b, 0x92, 0x98, 0x60, - 0x6f, 0x01, 0x87, 0xff, 0x1b, 0x0a, 0x31, 0x06, 0xfb, 0xdc, 0x1a, 0x91, 0x7b, 0x4d, 0x75, 0x1c, - 0x6c, 0xe9, 0x84, 0x21, 0x43, 0xa7, 0x6f, 0xaf, 0x19, 0xd5, 0x3d, 0xfe, 0x1f, 0x5a, 0xe8, 0x6f, - 0xfe, 0x2f, 0x21, 0xa8, 0x3f, 0x94, 0x69, 0x27, 0xfb, 0xc7, 0x54, 0x69, 0x01, 0x2c, 0x10, 0xa4, - 0x12, 0x8c, 0xa9, 0xd5, 0xaa, 0xc6, 0xfe, 0x59, 0x4a, 0x79, 0x4b, 0xa3, 0x95, 0xb3, 0x4d, 0xff, - 0xed, 0x58, 0xa7, 0xb9, 0x40, 0x1e, 0x41, 0x81, 0xe3, 0x17, 0x92, 0x30, 0x68, 0x32, 0xa1, 0xe4, - 0x8b, 0x30, 0xda, 0x22, 0x29, 0x91, 0xef, 0xba, 0xa6, 0x57, 0xc5, 0xdb, 0x57, 0xe4, 0x37, 0x81, - 0xd1, 0x4f, 0x26, 0xb2, 0x87, 0xbf, 0xf4, 0x77, 0xe1, 0xc7, 0x3b, 0xdf, 0x22, 0x19, 0xf6, 0xdd, - 0x22, 0x51, 0x4d, 0xad, 0x90, 0xa4, 0xfc, 0xf9, 0xe5, 0x91, 0x39, 0xde, 0xc1, 0x2e, 0x8e, 0xcc, - 0x18, 0x56, 0x6d, 0xb6, 0x86, 0x75, 0x51, 0x51, 0x93, 0x2e, 0xd5, 0xd4, 0x6c, 0xea, 0x8e, 0xde, - 0x27, 0x1c, 0xed, 0x8b, 0xbe, 0xdf, 0xf4, 0x4e, 0x49, 0x6c, 0x61, 0x6e, 0x6d, 0xd1, 0xf5, 0xe3, - 0x6f, 0x46, 0xe0, 0x98, 0xcf, 0x8f, 0x7d, 0xc8, 0xad, 0xee, 0x9c, 0x6b, 0xef, 0xf1, 0x3d, 0x7c, - 0x00, 0xf1, 0x2a, 0xc4, 0x08, 0x3e, 0xea, 0xf2, 0x0f, 0x1b, 0xb2, 0xbf, 0xfc, 0xaf, 0xfe, 0x89, - 0x4c, 0x9d, 0xa2, 0xfd, 0xac, 0x50, 0x26, 0x85, 0x8f, 0xf5, 0x6e, 0xbf, 0x8c, 0xf7, 0xf5, 0x4a, - 0xfb, 0xee, 0x99, 0x31, 0x6c, 0xc3, 0xd7, 0xce, 0x82, 0xdc, 0x61, 0x9b, 0xc2, 0x32, 0xe6, 0xfe, - 0x1b, 0xa3, 0x3e, 0xd2, 0x71, 0xa7, 0x1b, 0x3a, 0xfb, 0xcd, 0x60, 0x8f, 0x5b, 0xa8, 0x5d, 0x98, - 0x78, 0x96, 0x8c, 0xed, 0x9d, 0x62, 0x89, 0xc4, 0x3e, 0xe1, 0x3e, 0x6c, 0x97, 0xf8, 0x7f, 0x7d, - 0x13, 0x0f, 0xd2, 0xc1, 0x93, 0x8f, 0x6f, 0x88, 0x1e, 0x9a, 0xe9, 0xb8, 0x5e, 0xcc, 0xf8, 0x16, - 0x0b, 0xc5, 0x47, 0x29, 0xff, 0x82, 0x04, 0xf7, 0xb5, 0x0c, 0xcd, 0x73, 0xfc, 0x42, 0x9b, 0x77, - 0xaf, 0x7a, 0xbe, 0xb5, 0xe3, 0x7f, 0x0f, 0x6b, 0xa1, 0x8d, 0xb0, 0x0f, 0x77, 0x15, 0x96, 0x49, - 0x11, 0x90, 0xf6, 0x69, 0x38, 0x1c, 0x14, 0x56, 0x98, 0xe9, 0x1d, 0x30, 0x1c, 0xac, 0x09, 0xb8, - 0xb9, 0x86, 0x02, 0x55, 0x81, 0x5c, 0x0e, 0xdb, 0xd9, 0xd5, 0xb5, 0x04, 0x49, 0x17, 0x95, 0xef, - 0x46, 0x7a, 0x56, 0xd5, 0xa3, 0x94, 0x3f, 0x2d, 0xc1, 0x74, 0x70, 0x04, 0xaf, 0xf8, 0xb6, 0xfb, - 0x13, 0xf6, 0xae, 0x4d, 0xf1, 0xeb, 0x12, 0xdc, 0xbf, 0x8f, 0x4c, 0xdc, 0x00, 0x2f, 0xc0, 0xb8, - 0xef, 0xa0, 0x4e, 0xa4, 0x70, 0x31, 0xed, 0x27, 0xbb, 0x9f, 0x30, 0xba, 0xe7, 0x52, 0x47, 0x89, - 0x51, 0xbe, 0xf6, 0xed, 0xa9, 0xb1, 0xd6, 0x3e, 0x5b, 0x19, 0x6b, 0x3d, 0x5c, 0xbb, 0x8b, 0xfe, - 0xf1, 0x79, 0x09, 0x1e, 0x09, 0xaa, 0xda, 0xe6, 0xe9, 0xd9, 0xdb, 0x35, 0x0f, 0xff, 0x5e, 0x82, - 0x93, 0xbd, 0x08, 0xc7, 0x27, 0x64, 0x0b, 0xc6, 0xbc, 0xe3, 0xf2, 0xf0, 0x7c, 0x3c, 0xda, 0xc7, - 0x73, 0x46, 0xee, 0xa5, 0xc8, 0xe5, 0x76, 0x0f, 0x0c, 0x6f, 0xf2, 0xc0, 0xf2, 0x4f, 0xb9, 0x6b, - 0xe4, 0x60, 0xe1, 0x2f, 0x8c, 0x1c, 0x28, 0xfd, 0xdb, 0xcc, 0x45, 0xa4, 0xcd, 0x5c, 0xf8, 0x76, - 0x21, 0x37, 0x78, 0xde, 0x6a, 0x73, 0x44, 0xfe, 0x7e, 0x18, 0x6b, 0xe3, 0xca, 0x3c, 0xaa, 0xfb, - 0xf0, 0x64, 0x05, 0xb5, 0x3a, 0xab, 0xbc, 0x07, 0x53, 0x74, 0xdc, 0x36, 0x86, 0xbe, 0xd7, 0x2a, - 0x37, 0x78, 0x6e, 0x69, 0x3b, 0x34, 0xd7, 0x7d, 0x11, 0x06, 0xd8, 0x3c, 0x73, 0x75, 0x0f, 0xe0, - 0x28, 0x9c, 0x81, 0xfc, 0x33, 0x22, 0x97, 0x15, 0x85, 0xd8, 0xed, 0x63, 0xa8, 0x17, 0x5d, 0xef, - 0x52, 0x0c, 0xf9, 0x8c, 0xf1, 0x8a, 0xc8, 0x6a, 0xed, 0xa5, 0xe3, 0xe6, 0xa8, 0xdc, 0xb5, 0xac, - 0xc6, 0x6c, 0x73, 0x6f, 0xd3, 0xd7, 0xcf, 0x89, 0xf4, 0xe5, 0xea, 0xd4, 0x25, 0x7d, 0xbd, 0x3d, - 0xa6, 0x77, 0x13, 0x59, 0x17, 0x31, 0xff, 0x2c, 0x26, 0xb2, 0xef, 0x4b, 0x70, 0x84, 0xea, 0xe6, - 0x7f, 0xee, 0xd2, 0xaf, 0xc9, 0x4f, 0x01, 0xb2, 0xad, 0x4a, 0xb9, 0x6d, 0x74, 0x67, 0x6c, 0xab, - 0x72, 0x2d, 0xb0, 0xbe, 0x9c, 0x02, 0x54, 0xb5, 0x9d, 0x30, 0x36, 0xbb, 0x96, 0x9a, 0xa9, 0xda, - 0xce, 0xb5, 0x7d, 0x56, 0xa3, 0xd8, 0x5d, 0x98, 0xce, 0x97, 0x25, 0xc8, 0xb5, 0x53, 0x99, 0x4f, - 0x9f, 0x06, 0x13, 0x81, 0x67, 0x78, 0xe1, 0x19, 0x3c, 0xd5, 0xcb, 0x93, 0xab, 0x50, 0x18, 0x1d, - 0xb6, 0xf0, 0xbd, 0xae, 0x03, 0xa6, 0x82, 0x1e, 0xda, 0x5a, 0x59, 0xbf, 0x6d, 0xe1, 0xf3, 0x6b, - 0x2d, 0x79, 0xf5, 0xcf, 0x44, 0xed, 0xbd, 0x0b, 0x93, 0x1d, 0xa4, 0xbe, 0xd7, 0xeb, 0xde, 0x4e, - 0xc7, 0xc9, 0xbc, 0xdb, 0xe5, 0xfb, 0x19, 0x1e, 0x09, 0xc1, 0x57, 0x1e, 0x7c, 0x7b, 0xb1, 0x76, - 0x6f, 0x97, 0xca, 0xef, 0x85, 0xa3, 0x6d, 0xa9, 0xb8, 0x6c, 0x79, 0x88, 0xed, 0x68, 0xb6, 0xc3, - 0xc5, 0x7a, 0xa8, 0x93, 0x58, 0x21, 0x6a, 0x4a, 0x23, 0x23, 0xc8, 0x50, 0xd6, 0x6b, 0x86, 0x51, - 0xe7, 0x62, 0xc8, 0x57, 0x61, 0xd4, 0x07, 0xe3, 0x83, 0x9c, 0x83, 0x98, 0x69, 0xf0, 0xef, 0xa9, - 0xa4, 0x4e, 0x1f, 0xeb, 0x34, 0x08, 0xa1, 0xe1, 0x6a, 0x53, 0x7c, 0x79, 0x1c, 0x10, 0x63, 0x46, - 0xaf, 0x78, 0x88, 0x21, 0xd6, 0x61, 0x2c, 0x00, 0xe5, 0x83, 0xbc, 0x13, 0x06, 0x4c, 0x0a, 0x71, - 0xdf, 0xda, 0xeb, 0x34, 0x0c, 0xc5, 0x72, 0xbf, 0x60, 0x41, 0x5b, 0xa7, 0xbf, 0x7b, 0x18, 0xe2, - 0x94, 0x2b, 0xfa, 0x9c, 0x04, 0xe0, 0xbb, 0xb0, 0x31, 0xd3, 0x89, 0x4d, 0xfb, 0x3d, 0x71, 0x6e, - 0xb6, 0x67, 0x7c, 0x5e, 0xb3, 0x9d, 0xfc, 0xf1, 0x7f, 0xfb, 0xda, 0x67, 0x22, 0x0f, 0x22, 0x79, - 0xb6, 0xc3, 0x6e, 0xdc, 0x17, 0x2f, 0x5f, 0x0d, 0x7c, 0xcc, 0xe3, 0xb1, 0xde, 0x86, 0x12, 0x92, - 0xcd, 0xf4, 0x8a, 0xce, 0x05, 0xbb, 0x48, 0x05, 0x3b, 0x8b, 0x9e, 0xec, 0x2e, 0xd8, 0xec, 0x07, - 0x83, 0x41, 0xf3, 0x61, 0xf4, 0xbb, 0x12, 0x8c, 0xb7, 0xdb, 0xd2, 0xa1, 0xf3, 0xbd, 0x49, 0xd1, - 0x5a, 0x52, 0xe4, 0x2e, 0x1c, 0x80, 0x92, 0xab, 0xb2, 0x40, 0x55, 0x99, 0x43, 0xcf, 0x1c, 0x40, - 0x95, 0x59, 0xdf, 0xba, 0x83, 0xfe, 0xb7, 0x04, 0xc7, 0xf7, 0xdd, 0x21, 0xa1, 0xb9, 0xde, 0xa4, - 0xdc, 0xa7, 0x76, 0xca, 0x15, 0xde, 0x0c, 0x0b, 0xae, 0xf1, 0xb3, 0x54, 0xe3, 0xab, 0x68, 0xf1, - 0x20, 0x1a, 0x7b, 0x15, 0x91, 0x5f, 0xf7, 0xdf, 0x0a, 0x5e, 0xfc, 0xdd, 0xdf, 0x9d, 0x5a, 0x36, - 0x1e, 0x5d, 0x02, 0xa3, 0xb5, 0xa8, 0x95, 0xdf, 0x43, 0x55, 0x50, 0xd0, 0xda, 0x9b, 0x9c, 0xb4, - 0xd9, 0x0f, 0x06, 0x13, 0xff, 0x87, 0xd1, 0xff, 0x92, 0xda, 0xdf, 0xe3, 0x7d, 0x6a, 0x5f, 0x11, - 0x3b, 0x6f, 0xaa, 0x72, 0xe7, 0xfb, 0x27, 0xe4, 0x4a, 0x36, 0xa8, 0x92, 0x35, 0x84, 0xef, 0xb6, - 0x92, 0x6d, 0x27, 0x11, 0xfd, 0xb6, 0x04, 0xe3, 0xed, 0xf6, 0x24, 0x5d, 0xc2, 0x72, 0x9f, 0x4d, - 0x56, 0x97, 0xb0, 0xdc, 0x6f, 0x03, 0x24, 0xbf, 0x93, 0x2a, 0x7f, 0x0e, 0x9d, 0xe9, 0xa4, 0xfc, - 0xbe, 0xb3, 0x48, 0x62, 0x71, 0xdf, 0x22, 0xbf, 0x4b, 0x2c, 0xf6, 0xb2, 0x8f, 0xe9, 0x12, 0x8b, - 0x3d, 0xed, 0x31, 0xba, 0xc7, 0xa2, 0xab, 0x59, 0x8f, 0xd3, 0x68, 0xa3, 0x6f, 0x4a, 0x30, 0x14, - 0xa8, 0x88, 0xd1, 0x13, 0xfb, 0x0a, 0xda, 0x6e, 0xc3, 0x90, 0x3b, 0xdd, 0x0f, 0x09, 0xd7, 0x65, - 0x91, 0xea, 0x32, 0x8f, 0xe6, 0x0e, 0xa2, 0x8b, 0x15, 0x90, 0xf8, 0x65, 0x09, 0xc6, 0xda, 0x54, - 0x99, 0x5d, 0xa2, 0xb0, 0x73, 0xd1, 0x9c, 0x3b, 0xdf, 0x3f, 0x21, 0xd7, 0xea, 0x12, 0xd5, 0xea, - 0xdd, 0xe8, 0xe9, 0x83, 0x68, 0xe5, 0x5b, 0x9f, 0x6f, 0x7b, 0xd7, 0x22, 0x7d, 0xe3, 0xa0, 0x73, - 0x7d, 0x0a, 0x26, 0x14, 0x7a, 0xaa, 0x6f, 0x3a, 0xae, 0xcf, 0x73, 0x54, 0x9f, 0x67, 0xd1, 0xea, - 0x9b, 0xd3, 0xa7, 0x75, 0x59, 0xff, 0x7a, 0xeb, 0x2b, 0xb7, 0xfb, 0x7b, 0x51, 0xdb, 0x62, 0x35, - 0xf7, 0x64, 0x5f, 0x34, 0x5c, 0xa9, 0xf3, 0x54, 0xa9, 0xd3, 0xe8, 0xf1, 0x4e, 0x4a, 0xf9, 0xee, - 0xbe, 0x6a, 0xfa, 0xb6, 0x31, 0xfb, 0x41, 0x56, 0x02, 0x7f, 0x18, 0xfd, 0x98, 0xb8, 0x77, 0x78, - 0x62, 0xdf, 0x71, 0x7d, 0x75, 0x6c, 0xee, 0x91, 0x1e, 0x30, 0xb9, 0x5c, 0x0f, 0x52, 0xb9, 0x26, - 0xd1, 0xb1, 0x4e, 0x72, 0x91, 0x5a, 0x16, 0x7d, 0x42, 0x72, 0xaf, 0x2a, 0x9f, 0xdc, 0x9f, 0xb7, - 0xbf, 0xd8, 0xcd, 0x3d, 0xda, 0x13, 0x2e, 0x97, 0xe4, 0x21, 0x2a, 0xc9, 0x34, 0x9a, 0xec, 0x28, - 0x09, 0x2b, 0x7d, 0xef, 0xf6, 0xcd, 0x81, 0x3f, 0x1e, 0xec, 0xf8, 0x7a, 0x79, 0x0d, 0xeb, 0xd8, - 0xd6, 0xec, 0x03, 0xdd, 0x00, 0xec, 0xed, 0xf1, 0xd4, 0xef, 0xc6, 0x21, 0xbd, 0xc0, 0x46, 0x59, - 0x77, 0x54, 0xe7, 0x4d, 0x6e, 0x04, 0x90, 0xcd, 0xbf, 0x54, 0xc5, 0x3e, 0xb1, 0xe7, 0x7d, 0x34, - 0x2e, 0xdd, 0xd7, 0xcb, 0x9b, 0xec, 0xfe, 0x13, 0x7f, 0x4f, 0x32, 0xcc, 0x4f, 0x66, 0x1f, 0xbd, - 0xa2, 0x77, 0x17, 0xd8, 0xc7, 0xf1, 0x3e, 0x2a, 0xc1, 0x61, 0x8a, 0xe5, 0xc5, 0x1b, 0xc5, 0x14, - 0x6f, 0xee, 0x74, 0xf4, 0x98, 0x25, 0xd5, 0x77, 0x04, 0xc3, 0x3e, 0x67, 0xf7, 0x20, 0xbf, 0xd5, - 0x7e, 0xcc, 0x37, 0x78, 0x98, 0xad, 0xac, 0x8c, 0xd5, 0x5b, 0x28, 0xed, 0xd0, 0xbe, 0x3e, 0x76, - 0xf0, 0x7d, 0xfd, 0x15, 0x48, 0xf9, 0x32, 0x7d, 0x36, 0xde, 0xe5, 0x65, 0xb3, 0xf0, 0x21, 0x9a, - 0x9f, 0x18, 0x7d, 0x4c, 0x82, 0xc3, 0x6d, 0x17, 0x41, 0xfa, 0x7f, 0x10, 0xfb, 0x3c, 0xa4, 0x0b, - 0x19, 0xa7, 0x2d, 0x5f, 0x59, 0x19, 0x6f, 0xb6, 0xab, 0x26, 0xd6, 0x60, 0x28, 0xb0, 0x80, 0x65, - 0xc5, 0x7f, 0x33, 0xed, 0xfd, 0x9e, 0x75, 0x90, 0x01, 0xca, 0x41, 0x02, 0xef, 0x9a, 0x86, 0xe5, - 0xe0, 0x2a, 0xbd, 0xf2, 0x90, 0x50, 0xdc, 0xb6, 0xbc, 0x02, 0xa8, 0x75, 0x72, 0xc3, 0xdf, 0x6f, - 0x4c, 0x7a, 0xdf, 0x6f, 0x1c, 0x87, 0xb8, 0xff, 0x0b, 0x87, 0xac, 0x71, 0xef, 0x6e, 0x0b, 0xfd, - 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xa9, 0xa8, 0x2a, 0xc6, 0x8e, 0x00, 0x00, + 0x8b, 0x2b, 0xe4, 0x27, 0xfa, 0xa0, 0xa7, 0x70, 0x94, 0x2a, 0x7c, 0x7f, 0xeb, 0x8c, 0x06, 0x38, + 0x87, 0xf5, 0xce, 0x3d, 0x0e, 0x03, 0x01, 0x05, 0x7a, 0x1d, 0x5a, 0xfe, 0x28, 0x1c, 0x6c, 0xcb, + 0x1a, 0x3d, 0x03, 0xa3, 0x4d, 0x5d, 0xd3, 0x1d, 0x6c, 0x99, 0x16, 0x26, 0x1e, 0xcb, 0x86, 0xca, + 0xfe, 0xa7, 0xfe, 0x0e, 0x3e, 0xb7, 0xee, 0xc7, 0x66, 0x5c, 0x94, 0x91, 0x66, 0x2b, 0xf0, 0x44, + 0x32, 0xf1, 0x56, 0x7f, 0xe6, 0xc5, 0x17, 0x5f, 0x7c, 0x31, 0x22, 0x7f, 0xab, 0x0f, 0x46, 0xdb, + 0xc5, 0x4c, 0xdb, 0xf0, 0x1d, 0x83, 0x3e, 0xbd, 0xd9, 0xd8, 0xc0, 0x16, 0x35, 0x52, 0x5c, 0xe1, + 0x2d, 0x34, 0x03, 0xf1, 0xba, 0xba, 0x81, 0xeb, 0xd9, 0xd8, 0xa4, 0x74, 0x7c, 0xf0, 0xd4, 0x43, + 0x3d, 0x45, 0xe5, 0xd4, 0x02, 0x21, 0x51, 0x18, 0x25, 0x7a, 0x02, 0x62, 0x3c, 0x45, 0x13, 0x0e, + 0x27, 0x7a, 0xe3, 0x40, 0x62, 0x49, 0xa1, 0x74, 0xe8, 0x08, 0x24, 0xc9, 0x5f, 0xe6, 0x1b, 0x7d, + 0x54, 0xe6, 0x04, 0x01, 0x10, 0xbf, 0x40, 0x39, 0x48, 0xd0, 0x30, 0xa9, 0x62, 0xb1, 0xb4, 0xb9, + 0x6d, 0xe2, 0x58, 0x55, 0xbc, 0xa9, 0x36, 0xeb, 0x4e, 0xf9, 0xba, 0x5a, 0x6f, 0x62, 0xea, 0xf0, + 0x49, 0x25, 0xcd, 0x81, 0x57, 0x09, 0x0c, 0x4d, 0x40, 0x8a, 0x45, 0x95, 0xa6, 0x57, 0xf1, 0x36, + 0xcd, 0x9e, 0x71, 0x85, 0x05, 0xda, 0x3c, 0x81, 0x90, 0xe1, 0x9f, 0xb3, 0x0d, 0x5d, 0xb8, 0x26, + 0x1d, 0x82, 0x00, 0xe8, 0xf0, 0x8f, 0x87, 0x13, 0xf7, 0xb1, 0xf6, 0xea, 0xb5, 0xc4, 0xd2, 0x03, + 0x30, 0x44, 0x31, 0x1e, 0xe3, 0x53, 0xaf, 0xd6, 0xb3, 0xc3, 0x93, 0xd2, 0xf1, 0x84, 0x32, 0xc8, + 0xc0, 0xcb, 0x1c, 0x2a, 0x7f, 0x23, 0x02, 0x31, 0x9a, 0x58, 0x86, 0x20, 0xb5, 0xf6, 0xec, 0x4a, + 0xa9, 0x5c, 0x5c, 0x5e, 0x2f, 0x2c, 0x94, 0x32, 0x12, 0x1a, 0x04, 0xa0, 0x80, 0x8b, 0x0b, 0xcb, + 0x33, 0x6b, 0x99, 0x88, 0xdb, 0x9e, 0x5f, 0x5a, 0x3b, 0x7b, 0x3a, 0x13, 0x75, 0x09, 0xd6, 0x19, + 0x20, 0xe6, 0x47, 0x78, 0xec, 0x54, 0x26, 0x8e, 0x32, 0x90, 0x66, 0x0c, 0xe6, 0x9f, 0x29, 0x15, + 0xcf, 0x9e, 0xce, 0xf4, 0x05, 0x21, 0x8f, 0x9d, 0xca, 0xf4, 0xa3, 0x01, 0x48, 0x52, 0x48, 0x61, + 0x79, 0x79, 0x21, 0x93, 0x70, 0x79, 0xae, 0xae, 0x29, 0xf3, 0x4b, 0x73, 0x99, 0xa4, 0xcb, 0x73, + 0x4e, 0x59, 0x5e, 0x5f, 0xc9, 0x80, 0xcb, 0x61, 0xb1, 0xb4, 0xba, 0x3a, 0x33, 0x57, 0xca, 0xa4, + 0x5c, 0x8c, 0xc2, 0xb3, 0x6b, 0xa5, 0xd5, 0x4c, 0x3a, 0x20, 0xd6, 0x63, 0xa7, 0x32, 0x03, 0xee, + 0x10, 0xa5, 0xa5, 0xf5, 0xc5, 0xcc, 0x20, 0x1a, 0x86, 0x01, 0x36, 0x84, 0x10, 0x62, 0x28, 0x04, + 0x3a, 0x7b, 0x3a, 0x93, 0xf1, 0x04, 0x61, 0x5c, 0x86, 0x03, 0x80, 0xb3, 0xa7, 0x33, 0x48, 0x9e, + 0x85, 0x38, 0x75, 0x43, 0x84, 0x60, 0x70, 0x61, 0xa6, 0x50, 0x5a, 0x28, 0x2f, 0xaf, 0xac, 0xcd, + 0x2f, 0x2f, 0xcd, 0x2c, 0x64, 0x24, 0x0f, 0xa6, 0x94, 0x9e, 0x5a, 0x9f, 0x57, 0x4a, 0xc5, 0x4c, + 0xc4, 0x0f, 0x5b, 0x29, 0xcd, 0xac, 0x95, 0x8a, 0x99, 0xa8, 0x5c, 0x81, 0xd1, 0x76, 0x09, 0xb5, + 0x6d, 0x08, 0xf9, 0x7c, 0x21, 0xd2, 0xc1, 0x17, 0x28, 0xaf, 0xb0, 0x2f, 0xc8, 0xdf, 0x89, 0xc0, + 0x48, 0x9b, 0x45, 0xa5, 0xed, 0x20, 0x4f, 0x42, 0x9c, 0xf9, 0x32, 0x5b, 0x66, 0x1f, 0x6c, 0xbb, + 0x3a, 0x51, 0xcf, 0x6e, 0x59, 0x6a, 0x29, 0x9d, 0xbf, 0xd4, 0x88, 0x76, 0x28, 0x35, 0x08, 0x8b, + 0x16, 0x87, 0xfd, 0xd1, 0x96, 0xe4, 0xcf, 0xd6, 0xc7, 0xb3, 0xbd, 0xac, 0x8f, 0x14, 0xb6, 0xb7, + 0x45, 0x20, 0xde, 0x66, 0x11, 0xb8, 0x00, 0xc3, 0x2d, 0x8c, 0x7a, 0x4e, 0xc6, 0x1f, 0x97, 0x20, + 0xdb, 0xc9, 0x38, 0x5d, 0x52, 0x62, 0x24, 0x90, 0x12, 0x2f, 0x84, 0x2d, 0x78, 0x4f, 0xe7, 0x49, + 0x68, 0x99, 0xeb, 0xaf, 0x4a, 0x30, 0xd6, 0xbe, 0xa4, 0x6c, 0x2b, 0xc3, 0x13, 0xd0, 0xd7, 0xc0, + 0xce, 0x96, 0x21, 0xca, 0xaa, 0xfb, 0xdb, 0x2c, 0xd6, 0xa4, 0x3b, 0x3c, 0xd9, 0x9c, 0xca, 0xbf, + 0xda, 0x47, 0x3b, 0xd5, 0x85, 0x4c, 0x9a, 0x16, 0x49, 0x3f, 0x1d, 0x81, 0x83, 0x6d, 0x99, 0xb7, + 0x15, 0xf4, 0x18, 0x80, 0xa6, 0x9b, 0x4d, 0x87, 0x95, 0x4e, 0x2c, 0x13, 0x27, 0x29, 0x84, 0x26, + 0x2f, 0x92, 0x65, 0x9b, 0x8e, 0xdb, 0x1f, 0xa5, 0xfd, 0xc0, 0x40, 0x14, 0xe1, 0x9c, 0x27, 0x68, + 0x8c, 0x0a, 0x3a, 0xde, 0x41, 0xd3, 0x16, 0xc7, 0x7c, 0x04, 0x32, 0x95, 0xba, 0x86, 0x75, 0xa7, + 0x6c, 0x3b, 0x16, 0x56, 0x1b, 0x9a, 0x5e, 0xa3, 0x4b, 0x4d, 0x22, 0x1f, 0xdf, 0x54, 0xeb, 0x36, + 0x56, 0x86, 0x58, 0xf7, 0xaa, 0xe8, 0x25, 0x14, 0xd4, 0x81, 0x2c, 0x1f, 0x45, 0x5f, 0x80, 0x82, + 0x75, 0xbb, 0x14, 0xf2, 0xcb, 0x49, 0x48, 0xf9, 0x0a, 0x70, 0x74, 0x0f, 0xa4, 0x9f, 0x53, 0xaf, + 0xab, 0x65, 0xb1, 0xa9, 0x62, 0x96, 0x48, 0x11, 0xd8, 0x0a, 0xdf, 0x58, 0x3d, 0x02, 0xa3, 0x14, + 0xc5, 0x68, 0x3a, 0xd8, 0x2a, 0x57, 0xea, 0xaa, 0x6d, 0x53, 0xa3, 0x25, 0x28, 0x2a, 0x22, 0x7d, + 0xcb, 0xa4, 0x6b, 0x56, 0xf4, 0xa0, 0x33, 0x30, 0x42, 0x29, 0x1a, 0xcd, 0xba, 0xa3, 0x99, 0x75, + 0x5c, 0x26, 0xdb, 0x3c, 0x9b, 0x2e, 0x39, 0xae, 0x64, 0xc3, 0x04, 0x63, 0x91, 0x23, 0x10, 0x89, + 0x6c, 0x54, 0x84, 0x63, 0x94, 0xac, 0x86, 0x75, 0x6c, 0xa9, 0x0e, 0x2e, 0xe3, 0xe7, 0x9b, 0x6a, + 0xdd, 0x2e, 0xab, 0x7a, 0xb5, 0xbc, 0xa5, 0xda, 0x5b, 0xd9, 0x51, 0xc2, 0xa0, 0x10, 0xc9, 0x4a, + 0xca, 0x61, 0x82, 0x38, 0xc7, 0xf1, 0x4a, 0x14, 0x6d, 0x46, 0xaf, 0x5e, 0x52, 0xed, 0x2d, 0x94, + 0x87, 0x31, 0xca, 0xc5, 0x76, 0x2c, 0x4d, 0xaf, 0x95, 0x2b, 0x5b, 0xb8, 0x72, 0xad, 0xdc, 0x74, + 0x36, 0xcf, 0x65, 0x8f, 0xf8, 0xc7, 0xa7, 0x12, 0xae, 0x52, 0x9c, 0x59, 0x82, 0xb2, 0xee, 0x6c, + 0x9e, 0x43, 0xab, 0x90, 0x26, 0x93, 0xd1, 0xd0, 0x5e, 0xc0, 0xe5, 0x4d, 0xc3, 0xa2, 0x6b, 0xe8, + 0x60, 0x9b, 0xd4, 0xe4, 0xb3, 0xe0, 0xd4, 0x32, 0x27, 0x58, 0x34, 0xaa, 0x38, 0x1f, 0x5f, 0x5d, + 0x29, 0x95, 0x8a, 0x4a, 0x4a, 0x70, 0xb9, 0x68, 0x58, 0xc4, 0xa1, 0x6a, 0x86, 0x6b, 0xe0, 0x14, + 0x73, 0xa8, 0x9a, 0x21, 0xcc, 0x7b, 0x06, 0x46, 0x2a, 0x15, 0xa6, 0xb3, 0x56, 0x29, 0xf3, 0xcd, + 0x98, 0x9d, 0xcd, 0x04, 0x8c, 0x55, 0xa9, 0xcc, 0x31, 0x04, 0xee, 0xe3, 0x36, 0x3a, 0x0f, 0x07, + 0x3d, 0x63, 0xf9, 0x09, 0x87, 0x5b, 0xb4, 0x0c, 0x93, 0x9e, 0x81, 0x11, 0x73, 0xa7, 0x95, 0x10, + 0x05, 0x46, 0x34, 0x77, 0xc2, 0x64, 0x8f, 0xc3, 0xa8, 0xb9, 0x65, 0xb6, 0xd2, 0x9d, 0xf0, 0xd3, + 0x21, 0x73, 0xcb, 0x0c, 0x13, 0xbe, 0x8f, 0xee, 0xcc, 0x2d, 0x5c, 0x51, 0x1d, 0x5c, 0xcd, 0x1e, + 0xf2, 0xa3, 0xfb, 0x3a, 0xd0, 0x14, 0x64, 0x2a, 0x95, 0x32, 0xd6, 0xd5, 0x8d, 0x3a, 0x2e, 0xab, + 0x16, 0xd6, 0x55, 0x3b, 0x3b, 0x41, 0x91, 0x63, 0x8e, 0xd5, 0xc4, 0xca, 0x60, 0xa5, 0x52, 0xa2, + 0x9d, 0x33, 0xb4, 0x0f, 0x9d, 0x80, 0x61, 0x63, 0xe3, 0xb9, 0x0a, 0xf3, 0xc8, 0xb2, 0x69, 0xe1, + 0x4d, 0x6d, 0x3b, 0x7b, 0x1f, 0x35, 0xef, 0x10, 0xe9, 0xa0, 0xfe, 0xb8, 0x42, 0xc1, 0xe8, 0x41, + 0xc8, 0x54, 0xec, 0x2d, 0xd5, 0x32, 0x69, 0x4a, 0xb6, 0x4d, 0xb5, 0x82, 0xb3, 0xef, 0x63, 0xa8, + 0x0c, 0xbe, 0x24, 0xc0, 0x24, 0x22, 0xec, 0x1b, 0xda, 0xa6, 0x23, 0x38, 0x3e, 0xc0, 0x22, 0x82, + 0xc2, 0x38, 0xb7, 0xe3, 0x90, 0x21, 0x96, 0x08, 0x0c, 0x7c, 0x9c, 0xa2, 0x0d, 0x9a, 0x5b, 0xa6, + 0x7f, 0xdc, 0x7b, 0x61, 0x80, 0x60, 0x7a, 0x83, 0x3e, 0xc8, 0x0a, 0x37, 0x73, 0xcb, 0x37, 0xe2, + 0x69, 0x18, 0x23, 0x48, 0x0d, 0xec, 0xa8, 0x55, 0xd5, 0x51, 0x7d, 0xd8, 0x27, 0x29, 0x36, 0x31, + 0xfb, 0x22, 0xef, 0x0c, 0xc8, 0x69, 0x35, 0x37, 0x76, 0x5c, 0xc7, 0x7a, 0x98, 0xc9, 0x49, 0x60, + 0xc2, 0xb5, 0xee, 0x5a, 0x71, 0x2e, 0xe7, 0x21, 0xed, 0xf7, 0x7b, 0x94, 0x04, 0xe6, 0xf9, 0x19, + 0x89, 0x14, 0x41, 0xb3, 0xcb, 0x45, 0x52, 0xbe, 0x7c, 0xa8, 0x94, 0x89, 0x90, 0x32, 0x6a, 0x61, + 0x7e, 0xad, 0x54, 0x56, 0xd6, 0x97, 0xd6, 0xe6, 0x17, 0x4b, 0x99, 0xa8, 0xaf, 0xb0, 0xbf, 0x1c, + 0x4b, 0xdc, 0x9f, 0x79, 0x40, 0x7e, 0x3d, 0x02, 0x83, 0xc1, 0x9d, 0x1a, 0x7a, 0x3f, 0x1c, 0x12, + 0xc7, 0x2a, 0x36, 0x76, 0xca, 0x37, 0x34, 0x8b, 0x06, 0x64, 0x43, 0x65, 0x8b, 0xa3, 0xeb, 0x3f, + 0xa3, 0x1c, 0x6b, 0x15, 0x3b, 0x4f, 0x6b, 0x16, 0x09, 0xb7, 0x86, 0xea, 0xa0, 0x05, 0x98, 0xd0, + 0x8d, 0xb2, 0xed, 0xa8, 0x7a, 0x55, 0xb5, 0xaa, 0x65, 0xef, 0x40, 0xab, 0xac, 0x56, 0x2a, 0xd8, + 0xb6, 0x0d, 0xb6, 0x10, 0xba, 0x5c, 0x8e, 0xea, 0xc6, 0x2a, 0x47, 0xf6, 0x56, 0x88, 0x19, 0x8e, + 0x1a, 0x72, 0xdf, 0x68, 0x27, 0xf7, 0x3d, 0x02, 0xc9, 0x86, 0x6a, 0x96, 0xb1, 0xee, 0x58, 0x3b, + 0xb4, 0x3e, 0x4f, 0x28, 0x89, 0x86, 0x6a, 0x96, 0x48, 0xfb, 0x5d, 0xd9, 0x26, 0x5d, 0x8e, 0x25, + 0x12, 0x99, 0xe4, 0xe5, 0x58, 0x22, 0x99, 0x01, 0xf9, 0x8d, 0x28, 0xa4, 0xfd, 0xf5, 0x3a, 0xd9, + 0xfe, 0x54, 0xe8, 0x8a, 0x25, 0xd1, 0x9c, 0x76, 0xef, 0xae, 0xd5, 0xfd, 0xd4, 0x2c, 0x59, 0xca, + 0xf2, 0x7d, 0xac, 0x38, 0x56, 0x18, 0x25, 0x29, 0x23, 0x88, 0xb3, 0x61, 0x56, 0x8c, 0x24, 0x14, + 0xde, 0x42, 0x73, 0xd0, 0xf7, 0x9c, 0x4d, 0x79, 0xf7, 0x51, 0xde, 0xf7, 0xed, 0xce, 0xfb, 0xf2, + 0x2a, 0x65, 0x9e, 0xbc, 0xbc, 0x5a, 0x5e, 0x5a, 0x56, 0x16, 0x67, 0x16, 0x14, 0x4e, 0x8e, 0x0e, + 0x43, 0xac, 0xae, 0xbe, 0xb0, 0x13, 0x5c, 0xf4, 0x28, 0xa8, 0xd7, 0x49, 0x38, 0x0c, 0xb1, 0x1b, + 0x58, 0xbd, 0x16, 0x5c, 0x6a, 0x28, 0xe8, 0x2e, 0x06, 0xc3, 0x34, 0xc4, 0xa9, 0xbd, 0x10, 0x00, + 0xb7, 0x58, 0xe6, 0x00, 0x4a, 0x40, 0x6c, 0x76, 0x59, 0x21, 0x01, 0x91, 0x81, 0x34, 0x83, 0x96, + 0x57, 0xe6, 0x4b, 0xb3, 0xa5, 0x4c, 0x44, 0x3e, 0x03, 0x7d, 0xcc, 0x08, 0x24, 0x58, 0x5c, 0x33, + 0x64, 0x0e, 0xf0, 0x26, 0xe7, 0x21, 0x89, 0xde, 0xf5, 0xc5, 0x42, 0x49, 0xc9, 0x44, 0x82, 0x53, + 0x1d, 0xcb, 0xc4, 0x65, 0x1b, 0xd2, 0xfe, 0x3a, 0xfc, 0xdd, 0xd9, 0x8c, 0x7f, 0x53, 0x82, 0x94, + 0xaf, 0xae, 0x26, 0x05, 0x91, 0x5a, 0xaf, 0x1b, 0x37, 0xca, 0x6a, 0x5d, 0x53, 0x6d, 0xee, 0x1a, + 0x40, 0x41, 0x33, 0x04, 0xd2, 0xeb, 0xd4, 0xbd, 0x4b, 0x21, 0x12, 0xcf, 0xf4, 0xc9, 0x5f, 0x92, + 0x20, 0x13, 0x2e, 0x6c, 0x43, 0x62, 0x4a, 0xef, 0xa5, 0x98, 0xf2, 0x17, 0x25, 0x18, 0x0c, 0x56, + 0xb3, 0x21, 0xf1, 0xee, 0x79, 0x4f, 0xc5, 0xfb, 0xc3, 0x08, 0x0c, 0x04, 0x6a, 0xd8, 0x5e, 0xa5, + 0x7b, 0x1e, 0x86, 0xb5, 0x2a, 0x6e, 0x98, 0x86, 0x83, 0xf5, 0xca, 0x4e, 0xb9, 0x8e, 0xaf, 0xe3, + 0x7a, 0x56, 0xa6, 0x49, 0x63, 0x7a, 0xf7, 0x2a, 0x79, 0x6a, 0xde, 0xa3, 0x5b, 0x20, 0x64, 0xf9, + 0x91, 0xf9, 0x62, 0x69, 0x71, 0x65, 0x79, 0xad, 0xb4, 0x34, 0xfb, 0x6c, 0x79, 0x7d, 0xe9, 0xca, + 0xd2, 0xf2, 0xd3, 0x4b, 0x4a, 0x46, 0x0b, 0xa1, 0xdd, 0xc5, 0xb0, 0x5f, 0x81, 0x4c, 0x58, 0x28, + 0x74, 0x08, 0xda, 0x89, 0x95, 0x39, 0x80, 0x46, 0x60, 0x68, 0x69, 0xb9, 0xbc, 0x3a, 0x5f, 0x2c, + 0x95, 0x4b, 0x17, 0x2f, 0x96, 0x66, 0xd7, 0x56, 0xd9, 0xb9, 0x87, 0x8b, 0xbd, 0x16, 0x08, 0x70, + 0xf9, 0x95, 0x28, 0x8c, 0xb4, 0x91, 0x04, 0xcd, 0xf0, 0x1d, 0x0b, 0xdb, 0x44, 0x3d, 0xdc, 0x8b, + 0xf4, 0x53, 0xa4, 0x66, 0x58, 0x51, 0x2d, 0x87, 0x6f, 0x70, 0x1e, 0x04, 0x62, 0x25, 0xdd, 0xd1, + 0x36, 0x35, 0x6c, 0xf1, 0xf3, 0x24, 0xb6, 0x8d, 0x19, 0xf2, 0xe0, 0xec, 0x48, 0xe9, 0x24, 0x20, + 0xd3, 0xb0, 0x35, 0x47, 0xbb, 0x8e, 0xcb, 0x9a, 0x2e, 0x0e, 0x9f, 0xc8, 0xb6, 0x26, 0xa6, 0x64, + 0x44, 0xcf, 0xbc, 0xee, 0xb8, 0xd8, 0x3a, 0xae, 0xa9, 0x21, 0x6c, 0x92, 0xcc, 0xa3, 0x4a, 0x46, + 0xf4, 0xb8, 0xd8, 0xf7, 0x40, 0xba, 0x6a, 0x34, 0x49, 0xad, 0xc7, 0xf0, 0xc8, 0xda, 0x21, 0x29, + 0x29, 0x06, 0x73, 0x51, 0x78, 0x15, 0xef, 0x9d, 0x7a, 0xa5, 0x95, 0x14, 0x83, 0x31, 0x94, 0x07, + 0x60, 0x48, 0xad, 0xd5, 0x2c, 0xc2, 0x5c, 0x30, 0x62, 0xfb, 0x92, 0x41, 0x17, 0x4c, 0x11, 0x73, + 0x97, 0x21, 0x21, 0xec, 0x40, 0x96, 0x6a, 0x62, 0x89, 0xb2, 0xc9, 0x36, 0xdb, 0x91, 0xe3, 0x49, + 0x25, 0xa1, 0x8b, 0xce, 0x7b, 0x20, 0xad, 0xd9, 0x65, 0xef, 0x10, 0x3f, 0x32, 0x19, 0x39, 0x9e, + 0x50, 0x52, 0x9a, 0xed, 0x1e, 0x80, 0xca, 0x5f, 0x8d, 0xc0, 0x60, 0xf0, 0x21, 0x04, 0x2a, 0x42, + 0xa2, 0x6e, 0x54, 0x54, 0xea, 0x5a, 0xec, 0x09, 0xd8, 0xf1, 0x2e, 0xcf, 0x2d, 0xa6, 0x16, 0x38, + 0xbe, 0xe2, 0x52, 0xe6, 0x7e, 0x5b, 0x82, 0x84, 0x00, 0xa3, 0x31, 0x88, 0x99, 0xaa, 0xb3, 0x45, + 0xd9, 0xc5, 0x0b, 0x91, 0x8c, 0xa4, 0xd0, 0x36, 0x81, 0xdb, 0xa6, 0xaa, 0x53, 0x17, 0xe0, 0x70, + 0xd2, 0x26, 0xf3, 0x5a, 0xc7, 0x6a, 0x95, 0x6e, 0x7a, 0x8c, 0x46, 0x03, 0xeb, 0x8e, 0x2d, 0xe6, + 0x95, 0xc3, 0x67, 0x39, 0x18, 0x3d, 0x04, 0xc3, 0x8e, 0xa5, 0x6a, 0xf5, 0x00, 0x6e, 0x8c, 0xe2, + 0x66, 0x44, 0x87, 0x8b, 0x9c, 0x87, 0xc3, 0x82, 0x6f, 0x15, 0x3b, 0x6a, 0x65, 0x0b, 0x57, 0x3d, + 0xa2, 0x3e, 0x7a, 0xb8, 0x71, 0x88, 0x23, 0x14, 0x79, 0xbf, 0xa0, 0x95, 0x5f, 0x97, 0x60, 0x58, + 0x6c, 0xd3, 0xaa, 0xae, 0xb1, 0x16, 0x01, 0x54, 0x5d, 0x37, 0x1c, 0xbf, 0xb9, 0x5a, 0x5d, 0xb9, + 0x85, 0x6e, 0x6a, 0xc6, 0x25, 0x52, 0x7c, 0x0c, 0x72, 0x0d, 0x00, 0xaf, 0xa7, 0xa3, 0xd9, 0x26, + 0x20, 0xc5, 0x9f, 0x30, 0xd1, 0xc7, 0x94, 0x6c, 0x63, 0x0f, 0x0c, 0x44, 0xf6, 0x73, 0x68, 0x14, + 0xe2, 0x1b, 0xb8, 0xa6, 0xe9, 0xfc, 0xdc, 0x98, 0x35, 0xc4, 0xf1, 0x4b, 0xcc, 0x3d, 0x7e, 0x29, + 0x7c, 0x46, 0x82, 0x91, 0x8a, 0xd1, 0x08, 0xcb, 0x5b, 0xc8, 0x84, 0x4e, 0x17, 0xec, 0x4b, 0xd2, + 0x87, 0x9e, 0xa8, 0x69, 0xce, 0x56, 0x73, 0x63, 0xaa, 0x62, 0x34, 0xa6, 0x6b, 0x46, 0x5d, 0xd5, + 0x6b, 0xde, 0x73, 0x56, 0xfa, 0xa3, 0xf2, 0x70, 0x0d, 0xeb, 0x0f, 0xd7, 0x0c, 0xdf, 0x53, 0xd7, + 0x0b, 0xde, 0xcf, 0x3f, 0x95, 0xa4, 0x9f, 0x8d, 0x44, 0xe7, 0x56, 0x0a, 0x5f, 0x8b, 0xe4, 0xe6, + 0xd8, 0x70, 0x2b, 0xc2, 0x3c, 0x0a, 0xde, 0xac, 0xe3, 0x0a, 0x51, 0x19, 0xbe, 0xfb, 0x10, 0x8c, + 0xd6, 0x8c, 0x9a, 0x41, 0x39, 0x4e, 0x93, 0x5f, 0xfc, 0xc9, 0x6d, 0xd2, 0x85, 0xe6, 0xba, 0x3e, + 0xe6, 0xcd, 0x2f, 0xc1, 0x08, 0x47, 0x2e, 0xd3, 0x47, 0x47, 0x6c, 0x63, 0x83, 0x76, 0x3d, 0x55, + 0xcb, 0xfe, 0xca, 0x9b, 0x74, 0x41, 0x57, 0x86, 0x39, 0x29, 0xe9, 0x63, 0x7b, 0x9f, 0xbc, 0x02, + 0x07, 0x03, 0xfc, 0x58, 0xd8, 0x62, 0xab, 0x0b, 0xc7, 0xdf, 0xe0, 0x1c, 0x47, 0x7c, 0x1c, 0x57, + 0x39, 0x69, 0x7e, 0x16, 0x06, 0xf6, 0xc2, 0xeb, 0x5f, 0x72, 0x5e, 0x69, 0xec, 0x67, 0x32, 0x07, + 0x43, 0x94, 0x49, 0xa5, 0x69, 0x3b, 0x46, 0x83, 0xe6, 0xc4, 0xdd, 0xd9, 0xfc, 0xe6, 0x9b, 0x2c, + 0x8e, 0x06, 0x09, 0xd9, 0xac, 0x4b, 0x95, 0xcf, 0x03, 0x7d, 0x5a, 0x56, 0xc5, 0x95, 0x7a, 0x17, + 0x0e, 0xdf, 0xe6, 0x82, 0xb8, 0xf8, 0xf9, 0xab, 0x30, 0x4a, 0x7e, 0xd3, 0x94, 0xe5, 0x97, 0xa4, + 0xfb, 0x11, 0x5c, 0xf6, 0xf5, 0x8f, 0xb3, 0x50, 0x1d, 0x71, 0x19, 0xf8, 0x64, 0xf2, 0xcd, 0x62, + 0x0d, 0x3b, 0x0e, 0xb6, 0xec, 0xb2, 0x5a, 0x6f, 0x27, 0x9e, 0xef, 0x0c, 0x23, 0xfb, 0x85, 0xef, + 0x05, 0x67, 0x71, 0x8e, 0x51, 0xce, 0xd4, 0xeb, 0xf9, 0x75, 0x38, 0xd4, 0xc6, 0x2b, 0x7a, 0xe0, + 0xf9, 0x0a, 0xe7, 0x39, 0xda, 0xe2, 0x19, 0x84, 0xed, 0x0a, 0x08, 0xb8, 0x3b, 0x97, 0x3d, 0xf0, + 0xfc, 0x19, 0xce, 0x13, 0x71, 0x5a, 0x31, 0xa5, 0x84, 0xe3, 0x65, 0x18, 0xbe, 0x8e, 0xad, 0x0d, + 0xc3, 0xe6, 0xe7, 0x46, 0x3d, 0xb0, 0xfb, 0x22, 0x67, 0x37, 0xc4, 0x09, 0xe9, 0x41, 0x12, 0xe1, + 0x75, 0x1e, 0x12, 0x9b, 0x6a, 0x05, 0xf7, 0xc0, 0xe2, 0x26, 0x67, 0xd1, 0x4f, 0xf0, 0x09, 0xe9, + 0x0c, 0xa4, 0x6b, 0x06, 0x5f, 0xb5, 0xba, 0x93, 0x7f, 0x89, 0x93, 0xa7, 0x04, 0x0d, 0x67, 0x61, + 0x1a, 0x66, 0xb3, 0x4e, 0x96, 0xb4, 0xee, 0x2c, 0xfe, 0xa6, 0x60, 0x21, 0x68, 0x38, 0x8b, 0x3d, + 0x98, 0xf5, 0x55, 0xc1, 0xc2, 0xf6, 0xd9, 0xf3, 0x49, 0x48, 0x19, 0x7a, 0x7d, 0xc7, 0xd0, 0x7b, + 0x11, 0xe2, 0xcb, 0x9c, 0x03, 0x70, 0x12, 0xc2, 0xe0, 0x02, 0x24, 0x7b, 0x9d, 0x88, 0xbf, 0xf5, + 0x3d, 0x11, 0x1e, 0x62, 0x06, 0xe6, 0x60, 0x48, 0x24, 0x28, 0xcd, 0xd0, 0x7b, 0x60, 0xf1, 0xb7, + 0x39, 0x8b, 0x41, 0x1f, 0x19, 0x57, 0xc3, 0xc1, 0xb6, 0x53, 0xc3, 0xbd, 0x30, 0xf9, 0xaa, 0x50, + 0x83, 0x93, 0x70, 0x53, 0x6e, 0x60, 0xbd, 0xb2, 0xd5, 0x1b, 0x87, 0x9f, 0x17, 0xa6, 0x14, 0x34, + 0x84, 0xc5, 0x2c, 0x0c, 0x34, 0x54, 0xcb, 0xde, 0x52, 0xeb, 0x3d, 0x4d, 0xc7, 0xdf, 0xe1, 0x3c, + 0xd2, 0x2e, 0x11, 0xb7, 0x48, 0x53, 0xdf, 0x0b, 0x9b, 0xaf, 0x09, 0x8b, 0xf8, 0xc8, 0x78, 0xe8, + 0xd9, 0x0e, 0x3d, 0x64, 0xdb, 0x0b, 0xb7, 0x5f, 0x10, 0xa1, 0xc7, 0x68, 0x17, 0xfd, 0x1c, 0x2f, + 0x40, 0xd2, 0xd6, 0x5e, 0xe8, 0x89, 0xcd, 0x2f, 0x8a, 0x99, 0xa6, 0x04, 0x84, 0xf8, 0x59, 0x38, + 0xdc, 0x76, 0x99, 0xe8, 0x81, 0xd9, 0xdf, 0xe5, 0xcc, 0xc6, 0xda, 0x2c, 0x15, 0x3c, 0x25, 0xec, + 0x95, 0xe5, 0xdf, 0x13, 0x29, 0x01, 0x87, 0x78, 0xad, 0x90, 0x7d, 0x84, 0xad, 0x6e, 0xee, 0xcd, + 0x6a, 0xbf, 0x24, 0xac, 0xc6, 0x68, 0x03, 0x56, 0x5b, 0x83, 0x31, 0xce, 0x71, 0x6f, 0xf3, 0xfa, + 0xcb, 0x22, 0xb1, 0x32, 0xea, 0xf5, 0xe0, 0xec, 0x7e, 0x18, 0x72, 0xae, 0x39, 0x45, 0xc1, 0x6a, + 0x97, 0x1b, 0xaa, 0xd9, 0x03, 0xe7, 0x5f, 0xe1, 0x9c, 0x45, 0xc6, 0x77, 0x2b, 0x5e, 0x7b, 0x51, + 0x35, 0x09, 0xf3, 0x67, 0x20, 0x2b, 0x98, 0x37, 0x75, 0x0b, 0x57, 0x8c, 0x9a, 0xae, 0xbd, 0x80, + 0xab, 0x3d, 0xb0, 0xfe, 0xd5, 0xd0, 0x54, 0xad, 0xfb, 0xc8, 0x09, 0xe7, 0x79, 0xc8, 0xb8, 0xb5, + 0x4a, 0x59, 0x6b, 0x98, 0x86, 0xe5, 0x74, 0xe1, 0xf8, 0x75, 0x31, 0x53, 0x2e, 0xdd, 0x3c, 0x25, + 0xcb, 0x97, 0x80, 0x3d, 0x79, 0xee, 0xd5, 0x25, 0x7f, 0x8d, 0x33, 0x1a, 0xf0, 0xa8, 0x78, 0xe2, + 0xa8, 0x18, 0x0d, 0x53, 0xb5, 0x7a, 0xc9, 0x7f, 0x7f, 0x5f, 0x24, 0x0e, 0x4e, 0xc2, 0x13, 0x87, + 0xb3, 0x63, 0x62, 0xb2, 0xda, 0xf7, 0xc0, 0xe1, 0x1b, 0x22, 0x71, 0x08, 0x1a, 0xce, 0x42, 0x14, + 0x0c, 0x3d, 0xb0, 0xf8, 0x07, 0x82, 0x85, 0xa0, 0x21, 0x2c, 0x9e, 0xf2, 0x16, 0x5a, 0x0b, 0xd7, + 0x34, 0xdb, 0xb1, 0x58, 0x99, 0xbc, 0x3b, 0xab, 0x7f, 0xf8, 0xbd, 0x60, 0x11, 0xa6, 0xf8, 0x48, + 0x49, 0x26, 0xe2, 0xc7, 0xae, 0x74, 0x17, 0xd5, 0x5d, 0xb0, 0x5f, 0x17, 0x99, 0xc8, 0x47, 0x46, + 0x64, 0xf3, 0x55, 0x88, 0xc4, 0xec, 0x15, 0xb2, 0x77, 0xe8, 0x81, 0xdd, 0x3f, 0x0a, 0x09, 0xb7, + 0x2a, 0x68, 0x09, 0x4f, 0x5f, 0xfd, 0xd3, 0xd4, 0xaf, 0xe1, 0x9d, 0x9e, 0xbc, 0xf3, 0x1f, 0x87, + 0xea, 0x9f, 0x75, 0x46, 0xc9, 0x72, 0xc8, 0x50, 0xa8, 0x9e, 0x42, 0xdd, 0xee, 0x19, 0x65, 0x7f, + 0xec, 0x6d, 0xae, 0x6f, 0xb0, 0x9c, 0xca, 0x2f, 0x10, 0x27, 0x0f, 0x16, 0x3d, 0xdd, 0x99, 0x7d, + 0xfc, 0x6d, 0xd7, 0xcf, 0x03, 0x35, 0x4f, 0xfe, 0x22, 0x0c, 0x04, 0x0a, 0x9e, 0xee, 0xac, 0x3e, + 0xc1, 0x59, 0xa5, 0xfd, 0xf5, 0x4e, 0xfe, 0x0c, 0xc4, 0x48, 0xf1, 0xd2, 0x9d, 0xfc, 0x2f, 0x73, + 0x72, 0x8a, 0x9e, 0xff, 0x00, 0x24, 0x44, 0xd1, 0xd2, 0x9d, 0xf4, 0x93, 0x9c, 0xd4, 0x25, 0x21, + 0xe4, 0xa2, 0x60, 0xe9, 0x4e, 0xfe, 0x57, 0x04, 0xb9, 0x20, 0x21, 0xe4, 0xbd, 0x9b, 0xf0, 0x9b, + 0x3f, 0x11, 0xe3, 0x8b, 0x8e, 0xb0, 0xdd, 0x05, 0xe8, 0xe7, 0x95, 0x4a, 0x77, 0xea, 0x4f, 0xf3, + 0xc1, 0x05, 0x45, 0xfe, 0x71, 0x88, 0xf7, 0x68, 0xf0, 0x9f, 0xe4, 0xa4, 0x0c, 0x3f, 0x3f, 0x0b, + 0x29, 0x5f, 0x75, 0xd2, 0x9d, 0xfc, 0xaf, 0x71, 0x72, 0x3f, 0x15, 0x11, 0x9d, 0x57, 0x27, 0xdd, + 0x19, 0x7c, 0x46, 0x88, 0xce, 0x29, 0x88, 0xd9, 0x44, 0x61, 0xd2, 0x9d, 0xfa, 0xb3, 0xc2, 0xea, + 0x82, 0x24, 0xff, 0x24, 0x24, 0xdd, 0xc5, 0xa6, 0x3b, 0xfd, 0xcb, 0x9c, 0xde, 0xa3, 0x21, 0x16, + 0xf0, 0x2d, 0x76, 0xdd, 0x59, 0xfc, 0x75, 0x61, 0x01, 0x1f, 0x15, 0x09, 0xa3, 0x70, 0x01, 0xd3, + 0x9d, 0xd3, 0xe7, 0x44, 0x18, 0x85, 0xea, 0x17, 0x32, 0x9b, 0x34, 0xe7, 0x77, 0x67, 0xf1, 0x53, + 0x62, 0x36, 0x29, 0x3e, 0x11, 0x23, 0x5c, 0x11, 0x74, 0xe7, 0xf1, 0x37, 0x84, 0x18, 0xa1, 0x82, + 0x20, 0xbf, 0x02, 0xa8, 0xb5, 0x1a, 0xe8, 0xce, 0xef, 0xf3, 0x9c, 0xdf, 0x70, 0x4b, 0x31, 0x90, + 0x7f, 0x1a, 0xc6, 0xda, 0x57, 0x02, 0xdd, 0xb9, 0x7e, 0xe1, 0xed, 0xd0, 0xde, 0xcd, 0x5f, 0x08, + 0xe4, 0xd7, 0xbc, 0x25, 0xc5, 0x5f, 0x05, 0x74, 0x67, 0xfb, 0xca, 0xdb, 0xc1, 0xc4, 0xed, 0x2f, + 0x02, 0xf2, 0x33, 0x00, 0xde, 0x02, 0xdc, 0x9d, 0xd7, 0x17, 0x39, 0x2f, 0x1f, 0x11, 0x09, 0x0d, + 0xbe, 0xfe, 0x76, 0xa7, 0xbf, 0x29, 0x42, 0x83, 0x53, 0x90, 0xd0, 0x10, 0x4b, 0x6f, 0x77, 0xea, + 0x2f, 0x89, 0xd0, 0x10, 0x24, 0xc4, 0xb3, 0x7d, 0xab, 0x5b, 0x77, 0x0e, 0x5f, 0x16, 0x9e, 0xed, + 0xa3, 0xca, 0x2f, 0xc1, 0x70, 0xcb, 0x82, 0xd8, 0x9d, 0xd5, 0xcf, 0x72, 0x56, 0x99, 0xf0, 0x7a, + 0xe8, 0x5f, 0xbc, 0xf8, 0x62, 0xd8, 0x9d, 0xdb, 0x57, 0x42, 0x8b, 0x17, 0x5f, 0x0b, 0xf3, 0x17, + 0x20, 0xa1, 0x37, 0xeb, 0x75, 0x12, 0x3c, 0x68, 0xf7, 0xbb, 0x81, 0xd9, 0xff, 0xfc, 0x03, 0x6e, + 0x1d, 0x41, 0x90, 0x3f, 0x03, 0x71, 0xdc, 0xd8, 0xc0, 0xd5, 0x6e, 0x94, 0xdf, 0xfd, 0x81, 0x48, + 0x98, 0x04, 0x3b, 0xff, 0x24, 0x00, 0x3b, 0x1a, 0xa1, 0x8f, 0x07, 0xbb, 0xd0, 0xfe, 0x97, 0x1f, + 0xf0, 0xcb, 0x38, 0x1e, 0x89, 0xc7, 0x80, 0x5d, 0xed, 0xd9, 0x9d, 0xc1, 0xf7, 0x82, 0x0c, 0xe8, + 0x8c, 0x9c, 0x87, 0xfe, 0xe7, 0x6c, 0x43, 0x77, 0xd4, 0x5a, 0x37, 0xea, 0xff, 0xca, 0xa9, 0x05, + 0x3e, 0x31, 0x58, 0xc3, 0xb0, 0xb0, 0xa3, 0xd6, 0xec, 0x6e, 0xb4, 0xff, 0x8d, 0xd3, 0xba, 0x04, + 0x84, 0xb8, 0xa2, 0xda, 0x4e, 0x2f, 0x7a, 0xff, 0x77, 0x41, 0x2c, 0x08, 0x88, 0xd0, 0xe4, 0xf7, + 0x35, 0xbc, 0xd3, 0x8d, 0xf6, 0xfb, 0x42, 0x68, 0x8e, 0x9f, 0xff, 0x00, 0x24, 0xc9, 0x4f, 0x76, + 0xc3, 0xae, 0x0b, 0xf1, 0x1f, 0x73, 0x62, 0x8f, 0x82, 0x8c, 0x6c, 0x3b, 0x55, 0x47, 0xeb, 0x6e, + 0xec, 0xdb, 0x7c, 0xa6, 0x05, 0x7e, 0x7e, 0x06, 0x52, 0xb6, 0x53, 0xad, 0x36, 0x79, 0x7d, 0xda, + 0x85, 0xfc, 0x7f, 0xfc, 0xc0, 0x3d, 0xb2, 0x70, 0x69, 0xc8, 0x6c, 0xdf, 0xb8, 0xe6, 0x98, 0x06, + 0x7d, 0x04, 0xd2, 0x8d, 0xc3, 0xdb, 0x9c, 0x83, 0x8f, 0x24, 0x3f, 0x0b, 0x69, 0xa2, 0x8b, 0x85, + 0x4d, 0x4c, 0x9f, 0x57, 0x75, 0x61, 0xf1, 0x3f, 0xb9, 0x01, 0x02, 0x44, 0x85, 0x1f, 0xfd, 0xf6, + 0x1b, 0xe3, 0xd2, 0x6b, 0x6f, 0x8c, 0x4b, 0x7f, 0xf8, 0xc6, 0xb8, 0xf4, 0xd9, 0xef, 0x8c, 0x1f, + 0x78, 0xed, 0x3b, 0xe3, 0x07, 0x7e, 0xf7, 0x3b, 0xe3, 0x07, 0xda, 0x1f, 0x1b, 0xc3, 0x9c, 0x31, + 0x67, 0xb0, 0x03, 0xe3, 0x0f, 0xc9, 0x81, 0xe3, 0xe2, 0x9a, 0xe1, 0x9d, 0xd6, 0xba, 0x9b, 0x1c, + 0xf8, 0x44, 0x14, 0xc6, 0x2b, 0x86, 0xdd, 0x30, 0xec, 0xe9, 0x0d, 0xd5, 0xc6, 0xd3, 0xd7, 0x1f, + 0xdd, 0xc0, 0x8e, 0xfa, 0xe8, 0x74, 0xc5, 0xd0, 0x74, 0x7e, 0xec, 0x3b, 0xc2, 0xfa, 0xa7, 0x48, + 0xff, 0x14, 0xef, 0xcf, 0xb5, 0x3d, 0x21, 0x96, 0xe7, 0x20, 0x36, 0x6b, 0x68, 0x3a, 0x1a, 0x85, + 0x78, 0x15, 0xeb, 0x46, 0x83, 0x5f, 0x00, 0x63, 0x0d, 0x74, 0x2f, 0xf4, 0xa9, 0x0d, 0xa3, 0xa9, + 0x3b, 0xec, 0xb8, 0xbc, 0x90, 0xfa, 0xf6, 0xad, 0x89, 0x03, 0xbf, 0x77, 0x6b, 0x22, 0x3a, 0xaf, + 0x3b, 0x0a, 0xef, 0xca, 0xc7, 0xde, 0x7a, 0x75, 0x42, 0x92, 0x2f, 0x43, 0x7f, 0x11, 0x57, 0xf6, + 0xc3, 0xab, 0x88, 0x2b, 0x21, 0x5e, 0x0f, 0x42, 0x62, 0x5e, 0x77, 0xd8, 0x15, 0xbd, 0x63, 0x10, + 0xd5, 0x74, 0x76, 0xeb, 0x23, 0x34, 0x3e, 0x81, 0x13, 0xd4, 0x22, 0xae, 0xb8, 0xa8, 0x55, 0x5c, + 0x09, 0xa3, 0x12, 0xf6, 0x04, 0x5e, 0x28, 0xfe, 0xee, 0x7f, 0x1c, 0x3f, 0xf0, 0xe2, 0x1b, 0xe3, + 0x07, 0x3a, 0xcd, 0x4f, 0xc0, 0xfc, 0xdc, 0xc4, 0xec, 0xcf, 0xc3, 0x76, 0xf5, 0xda, 0x34, 0x09, + 0x2d, 0x7b, 0xa3, 0x8f, 0xdd, 0x6a, 0x86, 0xcf, 0x46, 0x60, 0x22, 0x7c, 0xa4, 0x4e, 0xfc, 0xd8, + 0x76, 0xd4, 0x86, 0xd9, 0xe9, 0xc5, 0xa9, 0x0b, 0x90, 0x5c, 0x13, 0x38, 0x28, 0x0b, 0xfd, 0x36, + 0xae, 0x18, 0x7a, 0xd5, 0xa6, 0x22, 0x47, 0x15, 0xd1, 0x24, 0x06, 0xd4, 0x55, 0xdd, 0xb0, 0xf9, + 0x75, 0x4d, 0xd6, 0x28, 0xfc, 0xb4, 0xb4, 0x37, 0xc7, 0x1a, 0x74, 0x87, 0xa2, 0xe6, 0x59, 0x91, + 0x3e, 0xf4, 0xd0, 0x6e, 0x4f, 0x23, 0xa8, 0x7a, 0x9e, 0x0a, 0xbe, 0x47, 0x0f, 0xe3, 0xe1, 0x47, + 0x0f, 0x4f, 0xe3, 0x7a, 0xfd, 0x8a, 0x6e, 0xdc, 0xd0, 0xd7, 0x02, 0x26, 0xf9, 0x37, 0x12, 0x4c, + 0xd2, 0x0b, 0xeb, 0x56, 0x43, 0xd3, 0x9d, 0xe9, 0xba, 0xb6, 0x61, 0x4f, 0x6f, 0x68, 0x8e, 0xcd, + 0x2c, 0xc7, 0x6d, 0x32, 0xea, 0x61, 0x4c, 0x11, 0x8c, 0x29, 0x82, 0x21, 0x9f, 0x86, 0x44, 0x41, + 0x73, 0x66, 0x2c, 0x4b, 0xdd, 0x41, 0x08, 0x62, 0x04, 0xc6, 0x8d, 0x42, 0x7f, 0x13, 0x8b, 0xe0, + 0x3a, 0x6e, 0xd8, 0xf4, 0xa1, 0x57, 0x4c, 0x61, 0x8d, 0xc2, 0x7a, 0xc7, 0x99, 0xbc, 0xe0, 0xd3, + 0xd4, 0x27, 0x92, 0xef, 0x27, 0x8b, 0x84, 0x76, 0xe2, 0xba, 0xfa, 0x7c, 0x2d, 0x06, 0xc7, 0x7c, + 0x08, 0x15, 0x6b, 0xc7, 0x74, 0x68, 0x48, 0x1a, 0x9b, 0x5c, 0x99, 0x61, 0x9f, 0x32, 0xac, 0xbb, + 0x43, 0x98, 0x6d, 0x42, 0x7c, 0x85, 0xd0, 0x11, 0x45, 0x1c, 0xc3, 0x51, 0xeb, 0x5c, 0x3b, 0xd6, + 0x20, 0x50, 0x76, 0x69, 0x3f, 0xc2, 0xa0, 0x9a, 0xb8, 0xaf, 0x5f, 0xc7, 0xea, 0x26, 0xbb, 0xfb, + 0x18, 0xa5, 0xcf, 0x3e, 0x13, 0x04, 0x40, 0xaf, 0x39, 0x8e, 0x42, 0x5c, 0x6d, 0xb2, 0xc7, 0x76, + 0xd1, 0xe3, 0x69, 0x85, 0x35, 0xe4, 0x2b, 0xd0, 0xcf, 0x1f, 0x15, 0xa0, 0x0c, 0x44, 0xaf, 0xe1, + 0x1d, 0x3a, 0x4e, 0x5a, 0x21, 0x3f, 0xd1, 0x14, 0xc4, 0xa9, 0xf0, 0xfc, 0x52, 0x77, 0x76, 0xaa, + 0x45, 0xfa, 0x29, 0x2a, 0xa4, 0xc2, 0xd0, 0xe4, 0xcb, 0x90, 0x28, 0x1a, 0x0d, 0x4d, 0x37, 0x82, + 0xdc, 0x92, 0x8c, 0x1b, 0x95, 0xd9, 0x6c, 0xf2, 0x70, 0x56, 0x58, 0x03, 0x8d, 0x41, 0x1f, 0xbb, + 0x0b, 0xcb, 0x1f, 0x3d, 0xf2, 0x96, 0x3c, 0x0b, 0xfd, 0x94, 0xf7, 0xb2, 0x49, 0xe6, 0xd7, 0xbd, + 0x88, 0x94, 0xe4, 0x6f, 0x46, 0x70, 0xf6, 0x11, 0x4f, 0x58, 0x04, 0xb1, 0xaa, 0xea, 0xa8, 0x5c, + 0x6f, 0xfa, 0x5b, 0x7e, 0x02, 0x12, 0x9c, 0x89, 0x8d, 0x4e, 0x41, 0xd4, 0x30, 0x6d, 0xfe, 0xf0, + 0x30, 0xd7, 0x49, 0x95, 0x65, 0xb3, 0x10, 0x23, 0x89, 0x40, 0x21, 0xc8, 0x05, 0xa5, 0xa3, 0xbf, + 0x9c, 0xdb, 0xbb, 0xbf, 0xb0, 0x61, 0x5c, 0x67, 0xf9, 0x72, 0x04, 0xc6, 0x7d, 0xbd, 0xd7, 0xb1, + 0x45, 0xea, 0xe5, 0x80, 0xeb, 0x23, 0x9f, 0x90, 0xbc, 0xbf, 0x83, 0xbb, 0x7c, 0x00, 0xa2, 0x33, + 0xa6, 0x89, 0x72, 0x90, 0x60, 0x0f, 0x09, 0x0d, 0xe6, 0x2f, 0x31, 0xc5, 0x6d, 0x93, 0x3e, 0xdb, + 0xd8, 0x74, 0x6e, 0xa8, 0x96, 0xfb, 0xba, 0x88, 0x68, 0xcb, 0xe7, 0x21, 0x39, 0x6b, 0xe8, 0x36, + 0xd6, 0xed, 0x26, 0x0d, 0x9d, 0x8d, 0xba, 0x51, 0xb9, 0xc6, 0x39, 0xb0, 0x06, 0x31, 0xb8, 0x6a, + 0x9a, 0x94, 0x32, 0xa6, 0x90, 0x9f, 0x2c, 0xf5, 0x16, 0x56, 0x3b, 0x9a, 0xe8, 0xfc, 0xde, 0x4d, + 0xc4, 0x95, 0x74, 0x6d, 0xf4, 0xfb, 0x12, 0x1c, 0x6d, 0x0d, 0xa8, 0x6b, 0x78, 0xc7, 0xde, 0x6b, + 0x3c, 0x9d, 0x83, 0xe4, 0x0a, 0x7d, 0x67, 0xf3, 0x0a, 0xde, 0x41, 0x39, 0xe8, 0xc7, 0xd5, 0x53, + 0x67, 0xce, 0x3c, 0x7a, 0x9e, 0x79, 0xfb, 0xa5, 0x03, 0x8a, 0x00, 0xe4, 0x13, 0x44, 0xab, 0xb7, + 0xbe, 0x3c, 0x21, 0x15, 0xe2, 0x10, 0xb5, 0x9b, 0x8d, 0xbb, 0xea, 0x03, 0xaf, 0xc4, 0x03, 0x09, + 0x90, 0x65, 0xd4, 0xeb, 0x6a, 0x5d, 0xab, 0xaa, 0xde, 0xdb, 0xb4, 0x19, 0x9f, 0x8e, 0x14, 0xa3, + 0xbd, 0x8a, 0xb9, 0x5d, 0x2d, 0x25, 0xff, 0xaa, 0x04, 0xe9, 0xab, 0x82, 0xf3, 0x2a, 0x76, 0xd0, + 0x05, 0x00, 0x77, 0x24, 0x11, 0x16, 0x47, 0xa6, 0xc2, 0x63, 0x4d, 0xb9, 0x34, 0x8a, 0x0f, 0x1d, + 0x3d, 0x4e, 0x1d, 0xcd, 0x34, 0x6c, 0xfe, 0x8a, 0x40, 0x17, 0x52, 0x17, 0x19, 0x9d, 0x04, 0x44, + 0x33, 0x58, 0xf9, 0xba, 0xe1, 0x68, 0x7a, 0xad, 0x6c, 0x1a, 0x37, 0xf8, 0x8b, 0x57, 0x51, 0x25, + 0x43, 0x7b, 0xae, 0xd2, 0x8e, 0x15, 0x02, 0x27, 0x42, 0x27, 0x5d, 0x2e, 0x64, 0xfd, 0x53, 0xab, + 0x55, 0x0b, 0xdb, 0x36, 0x4f, 0x52, 0xa2, 0x89, 0x2e, 0x40, 0xbf, 0xd9, 0xdc, 0x28, 0x8b, 0x8c, + 0x90, 0x3a, 0x75, 0xb4, 0x5d, 0x7c, 0x8b, 0xf9, 0xe7, 0x11, 0xde, 0x67, 0x36, 0x37, 0x88, 0x37, + 0xdc, 0x03, 0xe9, 0x36, 0xc2, 0xa4, 0xae, 0x7b, 0x72, 0xd0, 0x57, 0x81, 0xb9, 0x06, 0x65, 0xd3, + 0xd2, 0x0c, 0x4b, 0x73, 0x76, 0xe8, 0x13, 0xfe, 0xa8, 0x92, 0x11, 0x1d, 0x2b, 0x1c, 0x2e, 0x5f, + 0x83, 0xa1, 0x55, 0xad, 0x61, 0xd2, 0x3b, 0x29, 0x5c, 0xf2, 0x33, 0x9e, 0x7c, 0x52, 0x77, 0xf9, + 0x3a, 0x4a, 0x16, 0x69, 0x91, 0xac, 0xf0, 0x54, 0x47, 0xef, 0x7c, 0x7c, 0xef, 0xde, 0x19, 0x2c, + 0x58, 0xfe, 0x24, 0x17, 0x08, 0x3e, 0xbe, 0xdc, 0xfb, 0xd2, 0x53, 0xaf, 0x8e, 0xd9, 0xad, 0xec, + 0xc9, 0x75, 0x2d, 0x02, 0x72, 0xbb, 0x2f, 0xab, 0xb9, 0x2e, 0x89, 0x34, 0xd7, 0x35, 0xc8, 0xe4, + 0xf3, 0x30, 0xb0, 0xa2, 0x5a, 0xce, 0x2a, 0x76, 0x2e, 0x61, 0xb5, 0x8a, 0xad, 0xe0, 0xba, 0x3b, + 0x20, 0xd6, 0x5d, 0x04, 0x31, 0xba, 0xb8, 0xb2, 0x75, 0x87, 0xfe, 0x96, 0xb7, 0x20, 0x46, 0xef, + 0x01, 0xb9, 0x6b, 0x32, 0xa7, 0x60, 0x6b, 0x32, 0xc9, 0xa6, 0x3b, 0x0e, 0xb6, 0x39, 0x09, 0x6b, + 0xa0, 0xd3, 0x62, 0x65, 0x8d, 0xee, 0xbe, 0xb2, 0x72, 0x57, 0xe5, 0xeb, 0x6b, 0x1d, 0xfa, 0x0b, + 0x24, 0x19, 0xcf, 0x17, 0x5d, 0x41, 0x24, 0x4f, 0x10, 0xb4, 0x08, 0x43, 0xa6, 0x6a, 0x39, 0xf4, + 0x02, 0xf4, 0x16, 0xd5, 0x82, 0x47, 0xc3, 0x44, 0x6b, 0x6c, 0x06, 0x94, 0xe5, 0xa3, 0x0c, 0x98, + 0x7e, 0xa0, 0xfc, 0x47, 0x31, 0xe8, 0xe3, 0xc6, 0xf8, 0x00, 0xf4, 0x73, 0xb3, 0x72, 0xff, 0x3d, + 0x36, 0xd5, 0xba, 0x34, 0x4d, 0xb9, 0x4b, 0x08, 0xe7, 0x27, 0x68, 0xd0, 0xfd, 0x90, 0xa8, 0x6c, + 0xa9, 0x9a, 0x5e, 0xd6, 0xaa, 0xa2, 0x96, 0x7f, 0xe3, 0xd6, 0x44, 0xff, 0x2c, 0x81, 0xcd, 0x17, + 0x95, 0x7e, 0xda, 0x39, 0x5f, 0x25, 0xb5, 0xc0, 0x16, 0xd6, 0x6a, 0x5b, 0x0e, 0x8f, 0x41, 0xde, + 0x42, 0xe7, 0x20, 0x46, 0x5c, 0x86, 0xbf, 0x1e, 0x93, 0x6b, 0xd9, 0x63, 0xb9, 0x75, 0x6b, 0x21, + 0x41, 0x06, 0xfe, 0xec, 0x1f, 0x4c, 0x48, 0x0a, 0xa5, 0x40, 0xb3, 0x30, 0x50, 0x57, 0x6d, 0xa7, + 0x4c, 0xd7, 0x30, 0x32, 0x7c, 0x9c, 0xb2, 0x38, 0xdc, 0x6a, 0x10, 0x6e, 0x58, 0x2e, 0x7a, 0x8a, + 0x50, 0x31, 0x50, 0x15, 0x1d, 0x87, 0x0c, 0x65, 0x52, 0x31, 0x1a, 0x0d, 0xcd, 0x61, 0xd5, 0x55, + 0x1f, 0xb5, 0xfb, 0x20, 0x81, 0xcf, 0x52, 0x30, 0xad, 0xb1, 0x8e, 0x40, 0x92, 0x5e, 0xc8, 0xa7, + 0x28, 0xec, 0xf2, 0x59, 0x82, 0x00, 0x68, 0xe7, 0x03, 0x30, 0xe4, 0x65, 0x50, 0x86, 0x92, 0x60, + 0x5c, 0x3c, 0x30, 0x45, 0x7c, 0x04, 0x46, 0x75, 0xbc, 0x4d, 0xaf, 0xc3, 0x05, 0xb0, 0x93, 0x14, + 0x1b, 0x91, 0xbe, 0xab, 0x41, 0x8a, 0xf7, 0xc1, 0x60, 0x45, 0x18, 0x9f, 0xe1, 0x02, 0xc5, 0x1d, + 0x70, 0xa1, 0x14, 0xed, 0x30, 0x24, 0x54, 0xd3, 0x64, 0x08, 0x29, 0x9e, 0x41, 0x4d, 0x93, 0x76, + 0x9d, 0x80, 0x61, 0xaa, 0xa3, 0x85, 0xed, 0x66, 0xdd, 0xe1, 0x4c, 0xd2, 0x14, 0x67, 0x88, 0x74, + 0x28, 0x0c, 0x4e, 0x71, 0xef, 0x85, 0x01, 0x7c, 0x5d, 0xab, 0x62, 0xbd, 0x82, 0x19, 0xde, 0x00, + 0xc5, 0x4b, 0x0b, 0x20, 0x45, 0x7a, 0x10, 0xdc, 0xcc, 0x58, 0x16, 0x59, 0x7b, 0x90, 0xf1, 0x13, + 0xf0, 0x19, 0x06, 0x96, 0x4f, 0x42, 0xac, 0xa8, 0x3a, 0x2a, 0x29, 0x31, 0x9c, 0x6d, 0xb6, 0x14, + 0xa5, 0x15, 0xf2, 0xb3, 0x6d, 0xb8, 0xbd, 0x15, 0x81, 0xd8, 0x55, 0xc3, 0xc1, 0xe8, 0x31, 0x5f, + 0x59, 0x38, 0xd8, 0xce, 0xc7, 0x57, 0xb5, 0x9a, 0x8e, 0xab, 0x8b, 0x76, 0xcd, 0xf7, 0x46, 0xad, + 0xe7, 0x62, 0x91, 0x80, 0x8b, 0x8d, 0x42, 0xdc, 0x32, 0x9a, 0x7a, 0x55, 0xdc, 0xe5, 0xa2, 0x0d, + 0x54, 0x82, 0x84, 0xeb, 0x39, 0xb1, 0x6e, 0x9e, 0x33, 0x44, 0x3c, 0x87, 0xf8, 0x35, 0x07, 0x28, + 0xfd, 0x1b, 0xdc, 0x81, 0x0a, 0x90, 0x74, 0x53, 0x1e, 0xf7, 0xc0, 0xde, 0x9c, 0xd8, 0x23, 0x23, + 0x4b, 0x90, 0xeb, 0x0f, 0xae, 0x41, 0x99, 0x17, 0x66, 0xdc, 0x0e, 0x6e, 0xd1, 0x80, 0xab, 0xf1, + 0xb7, 0x7b, 0xfb, 0xa9, 0x5e, 0x9e, 0xab, 0xb1, 0x37, 0x7c, 0x8f, 0x42, 0xd2, 0xd6, 0x6a, 0xba, + 0xea, 0x34, 0x2d, 0xcc, 0xbd, 0xd1, 0x03, 0xc8, 0x2f, 0x47, 0xa0, 0x8f, 0x79, 0xb7, 0xcf, 0x6e, + 0x52, 0x7b, 0xbb, 0x45, 0x3a, 0xd9, 0x2d, 0xba, 0x7f, 0xbb, 0xcd, 0x00, 0xb8, 0xc2, 0xd8, 0xfc, + 0xa5, 0xcb, 0x36, 0x75, 0x06, 0x13, 0x71, 0x55, 0xab, 0xf1, 0xe0, 0xf5, 0x11, 0xb9, 0x1e, 0x14, + 0xf7, 0xe5, 0xc9, 0x0b, 0x90, 0xdc, 0xd0, 0x9c, 0xb2, 0x4a, 0x36, 0x8f, 0xd4, 0x84, 0xa9, 0x53, + 0xe3, 0x53, 0xed, 0x76, 0x99, 0x53, 0x62, 0x8b, 0xa9, 0x24, 0x36, 0xf8, 0x2f, 0xf9, 0xf7, 0x25, + 0x52, 0x2b, 0xf3, 0x01, 0xd1, 0x0c, 0x0c, 0x08, 0x45, 0xcb, 0x9b, 0x75, 0xb5, 0xc6, 0x9d, 0xf1, + 0x58, 0x47, 0x6d, 0x2f, 0xd6, 0xd5, 0x9a, 0x92, 0xe2, 0x0a, 0x92, 0x46, 0xfb, 0x89, 0x8d, 0x74, + 0x98, 0xd8, 0x80, 0x27, 0x45, 0xf7, 0xe7, 0x49, 0x81, 0x39, 0x8f, 0x85, 0xe7, 0xfc, 0xeb, 0x11, + 0xba, 0x67, 0x32, 0x0d, 0x5b, 0xad, 0xbf, 0x1b, 0x21, 0x76, 0x04, 0x92, 0xa6, 0x51, 0x2f, 0xb3, + 0x1e, 0x76, 0x69, 0x32, 0x61, 0x1a, 0x75, 0xa5, 0xc5, 0x8f, 0xe2, 0x77, 0x28, 0xfe, 0xfa, 0xee, + 0x80, 0xd5, 0xfa, 0xc3, 0x56, 0xb3, 0x20, 0xcd, 0x4c, 0xc1, 0x17, 0xcc, 0x47, 0x88, 0x0d, 0xe8, + 0x0a, 0x2c, 0xb5, 0x2e, 0xf0, 0x4c, 0x6c, 0x86, 0xa9, 0x70, 0x3c, 0x42, 0xc1, 0xd6, 0x97, 0x76, + 0x9b, 0x6d, 0xbf, 0x9f, 0x2b, 0x1c, 0x4f, 0xfe, 0x69, 0x09, 0x60, 0x81, 0x58, 0x96, 0xea, 0x4b, + 0x96, 0x3a, 0x9b, 0x8a, 0x50, 0x0e, 0x8c, 0x3c, 0xde, 0x69, 0xd2, 0xf8, 0xf8, 0x69, 0xdb, 0x2f, + 0xf7, 0x2c, 0x0c, 0x78, 0xce, 0x68, 0x63, 0x21, 0xcc, 0xf8, 0x2e, 0xc5, 0xfd, 0x2a, 0x76, 0x94, + 0xf4, 0x75, 0x5f, 0x4b, 0xfe, 0x67, 0x12, 0x24, 0xa9, 0x4c, 0x8b, 0xd8, 0x51, 0x03, 0x73, 0x28, + 0xed, 0x7f, 0x0e, 0x8f, 0x01, 0x30, 0x36, 0xb6, 0xf6, 0x02, 0xe6, 0x9e, 0x95, 0xa4, 0x90, 0x55, + 0xed, 0x05, 0x8c, 0xce, 0xba, 0x06, 0x8f, 0xee, 0x6e, 0x70, 0x51, 0xfc, 0x73, 0xb3, 0x1f, 0x82, + 0x7e, 0xfa, 0xd5, 0x93, 0x6d, 0x9b, 0xd7, 0xf3, 0x7d, 0x7a, 0xb3, 0xb1, 0xb6, 0x6d, 0xcb, 0xcf, + 0x41, 0xff, 0xda, 0x36, 0x3b, 0x82, 0x39, 0x02, 0x49, 0xcb, 0x30, 0xf8, 0xc2, 0xcf, 0x0a, 0xae, + 0x04, 0x01, 0xd0, 0x75, 0x4e, 0x1c, 0x3b, 0x44, 0xbc, 0x63, 0x07, 0xef, 0xdc, 0x24, 0xda, 0xd3, + 0xb9, 0xc9, 0x89, 0x7f, 0x27, 0x41, 0xca, 0x97, 0x1f, 0xd0, 0xa3, 0x70, 0xb0, 0xb0, 0xb0, 0x3c, + 0x7b, 0xa5, 0x3c, 0x5f, 0x2c, 0x5f, 0x5c, 0x98, 0x99, 0xf3, 0x5e, 0x0b, 0xc8, 0x8d, 0xbd, 0x74, + 0x73, 0x12, 0xf9, 0x70, 0xd7, 0xf5, 0x6b, 0xba, 0x71, 0x43, 0x47, 0xd3, 0x30, 0x1a, 0x24, 0x99, + 0x29, 0xac, 0x96, 0x96, 0xd6, 0x32, 0x52, 0xee, 0xe0, 0x4b, 0x37, 0x27, 0x87, 0x7d, 0x14, 0x33, + 0x1b, 0x36, 0xd6, 0x9d, 0x56, 0x82, 0xd9, 0xe5, 0xc5, 0xc5, 0xf9, 0xb5, 0x4c, 0xa4, 0x85, 0x80, + 0xaf, 0x00, 0x0f, 0xc2, 0x70, 0x90, 0x60, 0x69, 0x7e, 0x21, 0x13, 0xcd, 0xa1, 0x97, 0x6e, 0x4e, + 0x0e, 0xfa, 0xb0, 0x97, 0xb4, 0x7a, 0x2e, 0xf1, 0xa9, 0xaf, 0x8c, 0x1f, 0xf8, 0xf9, 0x9f, 0x1b, + 0x97, 0x88, 0x66, 0x03, 0x81, 0x1c, 0x81, 0x4e, 0xc2, 0xa1, 0xd5, 0xf9, 0xb9, 0xa5, 0x52, 0xb1, + 0xbc, 0xb8, 0x3a, 0x57, 0x66, 0x9f, 0x43, 0x70, 0xb5, 0x1b, 0x7a, 0xe9, 0xe6, 0x64, 0x8a, 0xab, + 0xd4, 0x09, 0x7b, 0x45, 0x29, 0x5d, 0x5d, 0x5e, 0x2b, 0x65, 0x24, 0x86, 0xbd, 0x62, 0xe1, 0xeb, + 0x86, 0xc3, 0x3e, 0x8b, 0xf4, 0x08, 0x1c, 0x6e, 0x83, 0xed, 0x2a, 0x36, 0xfc, 0xd2, 0xcd, 0xc9, + 0x81, 0x15, 0x0b, 0xb3, 0xf8, 0xa1, 0x14, 0x53, 0x90, 0x6d, 0xa5, 0x58, 0x5e, 0x59, 0x5e, 0x9d, + 0x59, 0xc8, 0x4c, 0xe6, 0x32, 0x2f, 0xdd, 0x9c, 0x4c, 0x8b, 0x64, 0x48, 0xf0, 0x3d, 0xcd, 0xee, + 0xe6, 0xc6, 0xeb, 0xaf, 0x46, 0x60, 0xbc, 0xe5, 0xf2, 0x35, 0x7f, 0x64, 0xd1, 0xe9, 0xa0, 0x38, + 0x0f, 0x89, 0xa2, 0x78, 0x12, 0xb2, 0xd7, 0x73, 0xe2, 0x9f, 0xda, 0xe3, 0x39, 0xf1, 0x80, 0x18, + 0x49, 0x1c, 0x13, 0x9f, 0xe8, 0x7e, 0x4c, 0x2c, 0xe4, 0xdf, 0xc7, 0x29, 0xf1, 0x67, 0x1e, 0x86, + 0xfb, 0xf8, 0xe1, 0xba, 0xed, 0xa8, 0xd7, 0x34, 0xbd, 0xe6, 0x3e, 0xc2, 0xe0, 0x6d, 0x6e, 0x94, + 0x31, 0xfe, 0x14, 0x43, 0x40, 0x77, 0x7d, 0x90, 0x91, 0xdb, 0x75, 0x6f, 0xdb, 0x7d, 0xcf, 0xda, + 0x65, 0x86, 0x72, 0x5d, 0x1e, 0xb9, 0xc8, 0x9f, 0x96, 0x60, 0xf0, 0x92, 0x66, 0x3b, 0x86, 0xa5, + 0x55, 0xd4, 0x3a, 0x7d, 0xcb, 0xe1, 0x6c, 0xaf, 0x8b, 0x46, 0x28, 0x87, 0x3d, 0x09, 0x7d, 0xd7, + 0xd5, 0x3a, 0xcb, 0xd6, 0x51, 0xfa, 0x51, 0x86, 0xf6, 0x86, 0xf0, 0x72, 0xb6, 0x60, 0xc0, 0xc8, + 0xe4, 0x5f, 0x8a, 0xc0, 0x10, 0x8d, 0x72, 0x9b, 0x7d, 0xae, 0x87, 0xec, 0x50, 0x0b, 0x10, 0xb3, + 0x54, 0x87, 0x1f, 0xba, 0x16, 0xa6, 0xf8, 0xc3, 0x91, 0xfb, 0xbb, 0x3f, 0xf0, 0x98, 0x2a, 0xe2, + 0x8a, 0x42, 0x69, 0xd1, 0x8f, 0x40, 0xa2, 0xa1, 0x6e, 0x97, 0x29, 0x1f, 0xb6, 0xef, 0x9b, 0xd9, + 0x1b, 0x9f, 0xdb, 0xb7, 0x26, 0x86, 0x76, 0xd4, 0x46, 0x3d, 0x2f, 0x0b, 0x3e, 0xb2, 0xd2, 0xdf, + 0x50, 0xb7, 0x89, 0x88, 0xc8, 0x84, 0x21, 0x02, 0xad, 0x6c, 0xa9, 0x7a, 0x0d, 0xb3, 0x41, 0xe8, + 0x11, 0x72, 0xe1, 0xd2, 0x9e, 0x07, 0x19, 0xf3, 0x06, 0xf1, 0xb1, 0x93, 0x95, 0x81, 0x86, 0xba, + 0x3d, 0x4b, 0x01, 0x64, 0xc4, 0x7c, 0xe2, 0xf3, 0xaf, 0x4e, 0x1c, 0xa0, 0x0f, 0x9c, 0x5e, 0x97, + 0x00, 0x3c, 0x8b, 0xa1, 0x1f, 0x81, 0x4c, 0xc5, 0x6d, 0x51, 0x5a, 0x9b, 0xcf, 0xe1, 0x03, 0x9d, + 0xe6, 0x22, 0x64, 0x6f, 0x56, 0x74, 0xbc, 0x76, 0x6b, 0x42, 0x52, 0x86, 0x2a, 0xa1, 0xa9, 0xf8, + 0x30, 0xa4, 0x9a, 0x66, 0x55, 0x75, 0x70, 0x99, 0xee, 0x82, 0x23, 0x5d, 0x0b, 0x98, 0x71, 0xc2, + 0xeb, 0xf6, 0xad, 0x09, 0xc4, 0xd4, 0xf2, 0x11, 0xcb, 0xb4, 0xac, 0x01, 0x06, 0x21, 0x04, 0x3e, + 0x9d, 0x7e, 0x4b, 0x82, 0x54, 0xd1, 0x77, 0xdb, 0x28, 0x0b, 0xfd, 0x0d, 0x43, 0xd7, 0xae, 0x71, + 0x7f, 0x4c, 0x2a, 0xa2, 0x89, 0x72, 0x90, 0x60, 0x2f, 0x7e, 0x39, 0x3b, 0xe2, 0x28, 0x59, 0xb4, + 0x09, 0xd5, 0x0d, 0xbc, 0x61, 0x6b, 0x62, 0x36, 0x14, 0xd1, 0x44, 0x17, 0x21, 0x63, 0xe3, 0x4a, + 0xd3, 0xd2, 0x9c, 0x9d, 0x72, 0xc5, 0xd0, 0x1d, 0xb5, 0xe2, 0xb0, 0x57, 0x88, 0x0a, 0x47, 0x6e, + 0xdf, 0x9a, 0x38, 0xc4, 0x64, 0x0d, 0x63, 0xc8, 0xca, 0x90, 0x00, 0xcd, 0x32, 0x08, 0x19, 0xa1, + 0x8a, 0x1d, 0x55, 0xab, 0xdb, 0xb4, 0x26, 0x4c, 0x2a, 0xa2, 0xe9, 0xd3, 0xe5, 0xff, 0xf4, 0xf9, + 0x0f, 0x0e, 0x2f, 0x42, 0xc6, 0x30, 0xb1, 0x15, 0xa8, 0xb0, 0xa5, 0xf0, 0xc8, 0x61, 0x0c, 0x59, + 0x19, 0x12, 0x20, 0x51, 0x7d, 0x5f, 0x24, 0xd3, 0x2c, 0xb6, 0xd9, 0x66, 0x73, 0x43, 0x9c, 0x37, + 0x06, 0xf8, 0x84, 0x31, 0x64, 0x32, 0xa1, 0x1c, 0xb4, 0x42, 0x21, 0xa4, 0x42, 0x7e, 0x4e, 0xd5, + 0xea, 0xe2, 0xe5, 0x56, 0x85, 0xb7, 0x50, 0x1e, 0xfa, 0x6c, 0x47, 0x75, 0x9a, 0x36, 0xff, 0xe4, + 0x94, 0xdc, 0xc9, 0x79, 0x0a, 0x86, 0x5e, 0x5d, 0xa5, 0x98, 0x0a, 0xa7, 0x40, 0x17, 0xa1, 0xcf, + 0x31, 0xae, 0x61, 0x9d, 0x1b, 0x65, 0x4f, 0x11, 0x4b, 0x1f, 0xce, 0x32, 0x6a, 0xe4, 0x40, 0xa6, + 0x8a, 0xeb, 0xb8, 0xc6, 0x2a, 0xc0, 0x2d, 0x95, 0xec, 0xbc, 0xe8, 0x97, 0xa7, 0x0a, 0xf3, 0x7b, + 0x0e, 0x2b, 0x6e, 0x91, 0x30, 0x3f, 0x59, 0x19, 0x72, 0x41, 0xab, 0x14, 0x82, 0xae, 0x04, 0x2e, + 0xba, 0xf1, 0xcf, 0xb3, 0xdd, 0xdb, 0x49, 0x7d, 0x9f, 0x97, 0x8a, 0xf3, 0x1a, 0xff, 0x35, 0xb9, + 0x8b, 0x90, 0x69, 0xea, 0x1b, 0x86, 0x4e, 0xdf, 0x40, 0xe3, 0x5b, 0x11, 0xb2, 0xb7, 0x8d, 0xfa, + 0xa7, 0x29, 0x8c, 0x21, 0x2b, 0x43, 0x2e, 0xe8, 0x12, 0xdb, 0xb0, 0x54, 0x61, 0xd0, 0xc3, 0xa2, + 0xa1, 0x97, 0xec, 0x1a, 0x7a, 0xf7, 0xf0, 0xd0, 0x3b, 0x18, 0x1e, 0xc5, 0x8b, 0xbe, 0x01, 0x17, + 0x48, 0xc8, 0xd0, 0x25, 0x00, 0x2f, 0xe0, 0xe9, 0xb9, 0x4d, 0xaa, 0xf3, 0xc4, 0x7b, 0x59, 0x43, + 0xec, 0x75, 0x3d, 0x5a, 0xf4, 0x51, 0x18, 0x69, 0x68, 0x7a, 0xd9, 0xc6, 0xf5, 0xcd, 0x32, 0x37, + 0x30, 0x61, 0x49, 0x3f, 0x20, 0x52, 0x58, 0xd8, 0x9b, 0x3f, 0xdc, 0xbe, 0x35, 0x91, 0xe3, 0x49, + 0xb1, 0x95, 0xa5, 0xac, 0x0c, 0x37, 0x34, 0x7d, 0x15, 0xd7, 0x37, 0x8b, 0x2e, 0x2c, 0x9f, 0xfe, + 0xd4, 0xab, 0x13, 0x07, 0x78, 0x00, 0x1e, 0x90, 0xcf, 0xd2, 0xa7, 0x0d, 0x3c, 0x70, 0xb0, 0x4d, + 0xb6, 0x4f, 0xaa, 0x68, 0xd0, 0x13, 0x9e, 0xa4, 0xe2, 0x01, 0x58, 0xe0, 0xbe, 0xf8, 0x1f, 0x26, + 0x25, 0xf9, 0x17, 0x25, 0xe8, 0x2b, 0x5e, 0x5d, 0x51, 0x35, 0x0b, 0xcd, 0xc3, 0xb0, 0xe7, 0x39, + 0xc1, 0xb0, 0x3d, 0x7a, 0xfb, 0xd6, 0x44, 0x36, 0xec, 0x5c, 0x6e, 0xdc, 0x7a, 0x0e, 0x2c, 0x02, + 0x77, 0xbe, 0xd3, 0x1e, 0x3b, 0xc0, 0xaa, 0x05, 0x45, 0x6e, 0xdd, 0x81, 0x87, 0xd4, 0x2c, 0x41, + 0x3f, 0x93, 0xd6, 0x46, 0x79, 0x88, 0x9b, 0xe4, 0x07, 0x7f, 0x94, 0x32, 0xde, 0xd1, 0x79, 0x29, + 0xbe, 0x7b, 0xb0, 0x4b, 0x48, 0xe4, 0x97, 0x23, 0x00, 0xc5, 0xab, 0x57, 0xd7, 0x2c, 0xcd, 0xac, + 0x63, 0xe7, 0x4e, 0x6a, 0xbe, 0x06, 0x07, 0x7d, 0x1b, 0x3a, 0xab, 0x12, 0xd2, 0x7e, 0xf2, 0xf6, + 0xad, 0x89, 0xa3, 0x61, 0xed, 0x7d, 0x68, 0xb2, 0x32, 0xe2, 0x6d, 0xed, 0xac, 0x4a, 0x5b, 0xae, + 0x55, 0xdb, 0x71, 0xb9, 0x46, 0x3b, 0x73, 0xf5, 0xa1, 0xf9, 0xb9, 0x16, 0x6d, 0xa7, 0xbd, 0x69, + 0x57, 0x21, 0xe5, 0x99, 0xc4, 0x46, 0x45, 0x48, 0x38, 0xfc, 0x37, 0xb7, 0xb0, 0xdc, 0xd9, 0xc2, + 0x82, 0x8c, 0x5b, 0xd9, 0xa5, 0x94, 0xff, 0x54, 0x02, 0xf0, 0x7c, 0xf6, 0x87, 0xd3, 0xc5, 0x48, + 0x2a, 0xe7, 0x89, 0x37, 0xba, 0xaf, 0xe2, 0x8b, 0x53, 0x87, 0xec, 0xf9, 0x13, 0x11, 0x18, 0x59, + 0x17, 0x99, 0xe7, 0x87, 0xde, 0x06, 0x2b, 0xd0, 0x8f, 0x75, 0xc7, 0xd2, 0xa8, 0x11, 0xc8, 0x6c, + 0x3f, 0xd2, 0x69, 0xb6, 0xdb, 0xe8, 0x44, 0x3f, 0xa1, 0x22, 0x1e, 0x42, 0x70, 0x36, 0x21, 0x6b, + 0x7c, 0x26, 0x0a, 0xd9, 0x4e, 0x94, 0x68, 0x16, 0x86, 0x2a, 0x16, 0xa6, 0x80, 0xb2, 0xff, 0xd4, + 0xb3, 0x90, 0xf3, 0x6a, 0xc5, 0x10, 0x82, 0xac, 0x0c, 0x0a, 0x08, 0x5f, 0x3d, 0x6a, 0x40, 0x0a, + 0x39, 0xe2, 0x76, 0x04, 0xab, 0xc7, 0xca, 0x4d, 0xe6, 0xcb, 0x87, 0x18, 0x24, 0xc8, 0x80, 0xad, + 0x1f, 0x83, 0x1e, 0x94, 0x2e, 0x20, 0xcf, 0xc3, 0x90, 0xa6, 0x6b, 0x8e, 0xa6, 0xd6, 0xcb, 0x1b, + 0x6a, 0x5d, 0xd5, 0x2b, 0xfb, 0xa9, 0x83, 0x59, 0xca, 0xe7, 0xc3, 0x86, 0xd8, 0xc9, 0xca, 0x20, + 0x87, 0x14, 0x18, 0x00, 0x5d, 0x82, 0x7e, 0x31, 0x54, 0x6c, 0x5f, 0xd5, 0x86, 0x20, 0xf7, 0x95, + 0x6c, 0x3f, 0x19, 0x85, 0x61, 0x05, 0x57, 0xff, 0x62, 0x2a, 0xf6, 0x36, 0x15, 0x8b, 0x00, 0x2c, + 0xdc, 0x49, 0x82, 0xdd, 0xc7, 0x6c, 0x90, 0x84, 0x91, 0x64, 0x1c, 0x8a, 0xb6, 0xe3, 0x9b, 0x8f, + 0x5b, 0x11, 0x48, 0xfb, 0xe7, 0xe3, 0xcf, 0xe9, 0xaa, 0x84, 0xe6, 0xbd, 0x4c, 0x14, 0xe3, 0x1f, + 0x9e, 0xec, 0x90, 0x89, 0x5a, 0xbc, 0x77, 0xf7, 0x14, 0xf4, 0x27, 0x11, 0xe8, 0x5b, 0x51, 0x2d, + 0xb5, 0x61, 0xa3, 0x4a, 0x4b, 0xa5, 0x29, 0x4e, 0x4a, 0x5b, 0x3e, 0x2f, 0xcc, 0x4f, 0x19, 0xba, + 0x14, 0x9a, 0x9f, 0x6f, 0x53, 0x68, 0x7e, 0x10, 0x06, 0xc9, 0x06, 0xd7, 0x77, 0xe9, 0x83, 0x58, + 0x7b, 0xa0, 0x70, 0xd8, 0xe3, 0x12, 0xec, 0x67, 0xfb, 0xdf, 0xab, 0xfe, 0x5b, 0x1f, 0x29, 0x82, + 0xe1, 0x25, 0x66, 0x42, 0x3e, 0xe6, 0x6d, 0x34, 0x7d, 0x9d, 0xb2, 0x02, 0x0d, 0x75, 0xbb, 0xc4, + 0x1a, 0x68, 0x01, 0xd0, 0x96, 0x7b, 0xd6, 0x51, 0xf6, 0xcc, 0x49, 0xe8, 0x8f, 0xdd, 0xbe, 0x35, + 0x71, 0x98, 0xd1, 0xb7, 0xe2, 0xc8, 0xca, 0xb0, 0x07, 0x14, 0xdc, 0x4e, 0x03, 0x10, 0xbd, 0xca, + 0xec, 0xce, 0x28, 0xdb, 0xee, 0x1c, 0xbc, 0x7d, 0x6b, 0x62, 0x98, 0x71, 0xf1, 0xfa, 0x64, 0x25, + 0x49, 0x1a, 0x45, 0xf2, 0xdb, 0xe7, 0xd9, 0x5f, 0x91, 0x00, 0x79, 0x29, 0x5f, 0xc1, 0xb6, 0x49, + 0xf6, 0x67, 0xa4, 0x10, 0xf7, 0x55, 0xcd, 0xd2, 0xee, 0x85, 0xb8, 0x47, 0x2f, 0x0a, 0x71, 0x5f, + 0xa4, 0x9c, 0xf7, 0xd2, 0x63, 0x84, 0xcf, 0x63, 0x9b, 0x0b, 0xb6, 0x53, 0xb3, 0x86, 0x26, 0xa8, + 0x5b, 0xf2, 0xe1, 0x01, 0xf9, 0x5f, 0x4b, 0x70, 0xb8, 0xc5, 0xa3, 0x5c, 0x61, 0xff, 0x12, 0x20, + 0xcb, 0xd7, 0xc9, 0xbf, 0x22, 0xc6, 0x84, 0xde, 0xb3, 0x83, 0x0e, 0x5b, 0x2d, 0x79, 0xf7, 0xce, + 0x65, 0x78, 0x76, 0x43, 0xf7, 0x9f, 0x4a, 0x30, 0xea, 0x1f, 0xde, 0x55, 0x64, 0x09, 0xd2, 0xfe, + 0xd1, 0xb9, 0x0a, 0xf7, 0xf5, 0xa2, 0x02, 0x97, 0x3e, 0x40, 0x8f, 0x9e, 0xf2, 0xc2, 0x95, 0x9d, + 0x86, 0x3d, 0xda, 0xb3, 0x35, 0x84, 0x4c, 0xe1, 0xb0, 0x8d, 0xd1, 0xf9, 0xf8, 0xbf, 0x12, 0xc4, + 0x56, 0x0c, 0xa3, 0x8e, 0x0c, 0x18, 0xd6, 0x0d, 0xa7, 0x4c, 0x3c, 0x0b, 0x57, 0xcb, 0x7c, 0xd3, + 0xcd, 0xf2, 0xe0, 0xec, 0xde, 0x8c, 0xf4, 0xdd, 0x5b, 0x13, 0xad, 0xac, 0x94, 0x21, 0xdd, 0x70, + 0x0a, 0x14, 0xb2, 0xc6, 0xb6, 0xe4, 0x1f, 0x85, 0x81, 0xe0, 0x60, 0x2c, 0x4b, 0x3e, 0xbd, 0xe7, + 0xc1, 0x82, 0x6c, 0x6e, 0xdf, 0x9a, 0x18, 0xf5, 0x22, 0xc6, 0x05, 0xcb, 0x4a, 0x7a, 0xc3, 0x37, + 0x3a, 0xbb, 0x10, 0xf7, 0xfd, 0x57, 0x27, 0xa4, 0x13, 0xdf, 0x90, 0x00, 0xbc, 0x93, 0x07, 0x74, + 0x12, 0x0e, 0x15, 0x96, 0x97, 0x8a, 0xe5, 0xd5, 0xb5, 0x99, 0xb5, 0xf5, 0xd5, 0xf2, 0xfa, 0xd2, + 0xea, 0x4a, 0x69, 0x76, 0xfe, 0xe2, 0x7c, 0xa9, 0xe8, 0x9d, 0xe4, 0xdb, 0x26, 0xae, 0x68, 0x9b, + 0x1a, 0xae, 0xa2, 0xfb, 0x61, 0x34, 0x88, 0x4d, 0x5a, 0xa5, 0x62, 0x46, 0xca, 0xa5, 0x5f, 0xba, + 0x39, 0x99, 0x60, 0xb5, 0x18, 0xae, 0xa2, 0xe3, 0x70, 0xb0, 0x15, 0x6f, 0x7e, 0x69, 0x2e, 0x13, + 0xc9, 0x0d, 0xbc, 0x74, 0x73, 0x32, 0xe9, 0x16, 0x6d, 0x48, 0x06, 0xe4, 0xc7, 0xe4, 0xfc, 0xa2, + 0x39, 0x78, 0xe9, 0xe6, 0x64, 0x1f, 0x33, 0x60, 0x2e, 0xf6, 0xa9, 0xaf, 0x8c, 0x1f, 0x28, 0x5c, + 0xec, 0x78, 0x56, 0x7f, 0x72, 0x57, 0xdb, 0x6d, 0xbb, 0x07, 0xce, 0xc1, 0x03, 0xfa, 0x6f, 0x0e, + 0xc1, 0x44, 0x87, 0x13, 0x69, 0x67, 0x7b, 0x5f, 0x87, 0xd1, 0x5d, 0x4e, 0x8b, 0x73, 0x3d, 0x1d, + 0x80, 0xcb, 0x37, 0x63, 0x80, 0x16, 0xed, 0xda, 0x2c, 0xa9, 0x7e, 0x7c, 0xb7, 0xcf, 0x42, 0x87, + 0x2b, 0xd2, 0x3b, 0x3a, 0x5c, 0x59, 0x0c, 0x1c, 0x57, 0x44, 0xf6, 0x76, 0xc8, 0xd9, 0xf3, 0x99, + 0x45, 0xf4, 0x5d, 0x39, 0xb3, 0x68, 0x5f, 0xd2, 0xc4, 0xee, 0xdc, 0xde, 0x27, 0xbe, 0xaf, 0xbd, + 0xcf, 0x18, 0xf4, 0xf1, 0xc3, 0x45, 0xf6, 0xc9, 0x77, 0xde, 0x42, 0x67, 0xc4, 0x07, 0xb0, 0xfb, + 0x7b, 0x5b, 0x54, 0x18, 0x76, 0x3e, 0xf1, 0x29, 0xb1, 0xa4, 0x7c, 0x2e, 0x0a, 0x99, 0x45, 0xbb, + 0x56, 0xaa, 0x6a, 0xce, 0x5d, 0xf2, 0x8e, 0x27, 0x3b, 0xef, 0x00, 0xd1, 0xed, 0x5b, 0x13, 0x83, + 0xcc, 0x0a, 0xbb, 0xe8, 0xde, 0x80, 0xa1, 0xd0, 0x49, 0x3a, 0xf7, 0x85, 0xe2, 0x7e, 0x0e, 0xf4, + 0x43, 0xac, 0x64, 0x5a, 0xb0, 0xfb, 0x3c, 0x12, 0x6d, 0xb7, 0x77, 0x3f, 0xe6, 0x02, 0x97, 0xee, + 0xe6, 0x71, 0x99, 0x37, 0x2b, 0x7f, 0x24, 0x41, 0x6a, 0xd1, 0x16, 0x9b, 0x50, 0xfc, 0x43, 0xba, + 0x21, 0x7f, 0xdc, 0x7d, 0x1b, 0x27, 0xda, 0x9b, 0xf7, 0x89, 0x37, 0x74, 0x3c, 0x45, 0x7f, 0x3b, + 0x42, 0xd3, 0x53, 0x01, 0xd7, 0x34, 0xdd, 0x5d, 0x7c, 0xf1, 0x9f, 0xd7, 0x7d, 0x85, 0x67, 0xd0, + 0xd8, 0x7e, 0x0d, 0xfa, 0x96, 0x04, 0x03, 0x8b, 0x76, 0x6d, 0x5d, 0xaf, 0xfe, 0xff, 0xee, 0x3b, + 0x77, 0x7c, 0x09, 0xff, 0x17, 0x11, 0x38, 0xe1, 0x5f, 0x73, 0x9f, 0x6f, 0x62, 0x6b, 0xc7, 0x5d, + 0x56, 0x4d, 0xb5, 0xa6, 0xe9, 0xfe, 0xe7, 0xed, 0x87, 0xfd, 0x02, 0x53, 0x5c, 0x21, 0xb6, 0xac, + 0x43, 0x6a, 0x45, 0xad, 0x61, 0x05, 0x3f, 0xdf, 0xc4, 0xb6, 0xd3, 0xe6, 0x2d, 0x9a, 0x31, 0xe8, + 0x33, 0x36, 0x37, 0xc5, 0x65, 0x9a, 0x98, 0xc2, 0x5b, 0x68, 0x14, 0xe2, 0x75, 0xad, 0xa1, 0x31, + 0xa3, 0xc4, 0x14, 0xd6, 0x40, 0x13, 0x90, 0xaa, 0x10, 0xdd, 0xcb, 0xec, 0xf6, 0x71, 0x4c, 0x7c, + 0x25, 0xa4, 0xa9, 0x3b, 0x6b, 0x04, 0x22, 0x3f, 0x09, 0x69, 0x36, 0x1e, 0x2f, 0xa0, 0x0f, 0x43, + 0x82, 0xde, 0x16, 0xf5, 0x46, 0xed, 0x27, 0xed, 0x2b, 0xec, 0x8d, 0x1b, 0xc6, 0x85, 0x0d, 0xcc, + 0x1a, 0x85, 0x42, 0x47, 0x53, 0x1e, 0xef, 0x9e, 0xec, 0x98, 0xa1, 0x5c, 0x33, 0xfe, 0x46, 0x1c, + 0x0e, 0xf2, 0x07, 0xe1, 0xaa, 0xa9, 0x4d, 0x6f, 0x39, 0x8e, 0x78, 0x95, 0x0d, 0xf8, 0xce, 0x55, + 0x35, 0x35, 0x79, 0x07, 0x62, 0x97, 0x1c, 0xc7, 0x44, 0x27, 0x20, 0x6e, 0x35, 0xeb, 0x58, 0x1c, + 0xe0, 0x8e, 0x4e, 0x79, 0x38, 0x53, 0x04, 0x41, 0x69, 0xd6, 0xb1, 0xc2, 0x50, 0x50, 0x09, 0x26, + 0x36, 0x9b, 0xf5, 0xfa, 0x4e, 0xb9, 0x8a, 0xe9, 0x3f, 0x78, 0x72, 0xff, 0x45, 0x02, 0xde, 0x36, + 0x55, 0xdd, 0x2d, 0x3e, 0x12, 0xca, 0x51, 0x8a, 0x56, 0xa4, 0x58, 0xe2, 0xdf, 0x23, 0x94, 0x04, + 0x8e, 0xfc, 0x7b, 0x11, 0x48, 0x08, 0xd6, 0xf4, 0x15, 0x18, 0x5c, 0xc7, 0x15, 0xc7, 0x10, 0x8f, + 0x34, 0xdd, 0x36, 0x42, 0x10, 0xad, 0xf1, 0x29, 0x4a, 0x5e, 0x3a, 0xa0, 0x90, 0x06, 0x81, 0xb9, + 0x2f, 0x26, 0x11, 0x98, 0xd9, 0x24, 0xb3, 0x16, 0x33, 0x0d, 0x71, 0xd2, 0x72, 0xe9, 0x80, 0x42, + 0x5b, 0x28, 0x0b, 0x7d, 0x24, 0x80, 0x1c, 0xf6, 0xf5, 0x4a, 0x02, 0xe7, 0x6d, 0x34, 0x06, 0x71, + 0x53, 0x75, 0x2a, 0xec, 0xc6, 0x30, 0xe9, 0x60, 0x4d, 0x12, 0x13, 0xec, 0xad, 0xe1, 0xf0, 0x7f, + 0x4f, 0x21, 0xc6, 0x60, 0x9f, 0x67, 0x23, 0x72, 0xaf, 0xa8, 0x8e, 0x83, 0x2d, 0x9d, 0x30, 0x64, + 0xe8, 0xf4, 0x6d, 0x37, 0xa3, 0xba, 0xc3, 0xff, 0xa3, 0x0b, 0xfd, 0xcd, 0xff, 0x85, 0x04, 0xf5, + 0x87, 0x32, 0xed, 0x64, 0xff, 0xc8, 0x2a, 0x2d, 0x80, 0x05, 0x82, 0x54, 0x82, 0x11, 0xb5, 0x5a, + 0xd5, 0xd8, 0x3f, 0x57, 0x29, 0x6f, 0x68, 0xb4, 0x8a, 0xb6, 0xe9, 0xbf, 0x29, 0xeb, 0x34, 0x17, + 0xc8, 0x23, 0x28, 0x70, 0xfc, 0x42, 0x12, 0xfa, 0x4d, 0x26, 0x94, 0x7c, 0x01, 0x86, 0x5b, 0x24, + 0x25, 0xf2, 0x5d, 0xd3, 0xf4, 0xaa, 0x78, 0x5b, 0x8b, 0xfc, 0x26, 0x30, 0xfa, 0x89, 0x45, 0xf6, + 0xb0, 0x98, 0xfe, 0x2e, 0xfc, 0x78, 0xe7, 0x5b, 0x27, 0x83, 0xbe, 0x5b, 0x27, 0xaa, 0xa9, 0x15, + 0x92, 0x94, 0x3f, 0xbf, 0x6c, 0x32, 0xc3, 0x3b, 0xd8, 0x45, 0x93, 0x29, 0xc3, 0xaa, 0x4d, 0xd7, + 0xb0, 0x2e, 0x2a, 0x6a, 0xd2, 0xa5, 0x9a, 0x9a, 0x4d, 0xdd, 0xd1, 0xfb, 0xe4, 0xa3, 0x7d, 0xc1, + 0xf7, 0x9b, 0xde, 0x41, 0x89, 0xcd, 0xcd, 0xac, 0xcc, 0xbb, 0x7e, 0xfc, 0xad, 0x08, 0x1c, 0xf5, + 0xf9, 0xb1, 0x0f, 0xb9, 0xd5, 0x9d, 0x73, 0xed, 0x3d, 0xbe, 0x87, 0x0f, 0x26, 0x5e, 0x81, 0x18, + 0xc1, 0x47, 0x5d, 0xfe, 0xc1, 0x43, 0xf6, 0x97, 0xff, 0xd5, 0x3f, 0x91, 0xa9, 0x53, 0xb4, 0x9f, + 0x15, 0xca, 0xa4, 0xf0, 0xc9, 0xde, 0xed, 0x97, 0xf1, 0xbe, 0x76, 0x69, 0xdf, 0x39, 0x33, 0x86, + 0x6d, 0xf8, 0xe6, 0x19, 0x90, 0x3b, 0x6c, 0x53, 0x58, 0xc6, 0xdc, 0x7d, 0x63, 0xb4, 0x87, 0x74, + 0xdc, 0xe9, 0x46, 0xcf, 0x6e, 0x33, 0xd8, 0xe3, 0x16, 0x6a, 0x1b, 0xc6, 0x9e, 0x22, 0x63, 0x7b, + 0xa7, 0x5e, 0x22, 0xb1, 0x8f, 0xb9, 0x0f, 0xe7, 0x25, 0xfe, 0x5f, 0xe2, 0xc4, 0x83, 0x77, 0xf0, + 0xe4, 0xe3, 0x1b, 0xa2, 0xfb, 0xa7, 0x3a, 0xae, 0x17, 0x53, 0xbe, 0xc5, 0x42, 0xf1, 0x51, 0xca, + 0xbf, 0x20, 0xc1, 0xa1, 0x96, 0xa1, 0x79, 0x8e, 0x9f, 0x6b, 0xf3, 0xae, 0x56, 0xcf, 0xb7, 0x7c, + 0xfc, 0xef, 0x6d, 0xcd, 0xb5, 0x11, 0xf6, 0x81, 0xae, 0xc2, 0x32, 0x29, 0x02, 0xd2, 0x3e, 0x01, + 0x07, 0x83, 0xc2, 0x0a, 0x33, 0xbd, 0x0f, 0x06, 0x83, 0x35, 0x01, 0x37, 0xd7, 0x40, 0xa0, 0x2a, + 0x90, 0xcb, 0x61, 0x3b, 0xbb, 0xba, 0x96, 0x20, 0xe9, 0xa2, 0xf2, 0xdd, 0x48, 0xcf, 0xaa, 0x7a, + 0x94, 0xf2, 0xcb, 0x12, 0x4c, 0x06, 0x47, 0xf0, 0x8a, 0x6f, 0x7b, 0x6f, 0xc2, 0xde, 0xb1, 0x29, + 0x7e, 0x4b, 0x82, 0x7b, 0x76, 0x91, 0x89, 0x1b, 0xe0, 0x05, 0x18, 0xf5, 0x1d, 0xec, 0x89, 0x14, + 0x2e, 0xa6, 0xfd, 0x44, 0xf7, 0x13, 0x49, 0xf7, 0x1c, 0xeb, 0x08, 0x31, 0xca, 0xd7, 0xfe, 0x60, + 0x62, 0xa4, 0xb5, 0xcf, 0x56, 0x46, 0x5a, 0x0f, 0xe3, 0xee, 0xa0, 0x7f, 0xbc, 0x22, 0xc1, 0x83, + 0x41, 0x55, 0xdb, 0x3c, 0x6d, 0x7b, 0xaf, 0xe6, 0xe1, 0xdf, 0x4b, 0x70, 0xa2, 0x17, 0xe1, 0xf8, + 0x84, 0x6c, 0xc0, 0x88, 0x77, 0xbc, 0x1e, 0x9e, 0x8f, 0x87, 0xf6, 0xf0, 0x5c, 0x92, 0x7b, 0x29, + 0x72, 0xb9, 0xdd, 0x05, 0xc3, 0x9b, 0x3c, 0xb0, 0xfc, 0x53, 0xee, 0x1a, 0x39, 0x58, 0xf8, 0x0b, + 0x23, 0x07, 0x4a, 0xff, 0x36, 0x73, 0x11, 0x69, 0x33, 0x17, 0xbe, 0x5d, 0xc8, 0x75, 0x9e, 0xb7, + 0xda, 0x1c, 0xa9, 0x7f, 0x18, 0x46, 0xda, 0xb8, 0x32, 0x8f, 0xea, 0x3d, 0x78, 0xb2, 0x82, 0x5a, + 0x9d, 0x55, 0xde, 0x81, 0x09, 0x3a, 0x6e, 0x1b, 0x43, 0xdf, 0x6d, 0x95, 0x1b, 0x3c, 0xb7, 0xb4, + 0x1d, 0x9a, 0xeb, 0x3e, 0x0f, 0x7d, 0x6c, 0x9e, 0xb9, 0xba, 0xfb, 0x70, 0x14, 0xce, 0x40, 0xfe, + 0x19, 0x91, 0xcb, 0x8a, 0x42, 0xec, 0xf6, 0x31, 0xd4, 0x8b, 0xae, 0x77, 0x28, 0x86, 0x7c, 0xc6, + 0x78, 0x5d, 0x64, 0xb5, 0xf6, 0xd2, 0x71, 0x73, 0x54, 0xee, 0x58, 0x56, 0x63, 0xb6, 0xb9, 0xbb, + 0xe9, 0xeb, 0xe7, 0x44, 0xfa, 0x72, 0x75, 0xea, 0x92, 0xbe, 0xde, 0x1b, 0xd3, 0xbb, 0x89, 0xac, + 0x8b, 0x98, 0x7f, 0x16, 0x13, 0xd9, 0xf7, 0x25, 0x38, 0x4c, 0x75, 0xf3, 0x3f, 0xa7, 0xd9, 0xab, + 0xc9, 0x4f, 0x02, 0xb2, 0xad, 0x4a, 0xb9, 0x6d, 0x74, 0x67, 0x6c, 0xab, 0x72, 0x35, 0xb0, 0xbe, + 0x9c, 0x04, 0x54, 0xb5, 0x9d, 0x30, 0x36, 0xbb, 0xc6, 0x9a, 0xa9, 0xda, 0xce, 0xd5, 0x5d, 0x56, + 0xa3, 0xd8, 0x1d, 0x98, 0xce, 0xd7, 0x24, 0xc8, 0xb5, 0x53, 0x99, 0x4f, 0x9f, 0x06, 0x63, 0x81, + 0x67, 0x7e, 0xe1, 0x19, 0x3c, 0xd9, 0xcb, 0x93, 0xae, 0x50, 0x18, 0x1d, 0xb4, 0xf0, 0xdd, 0xae, + 0x03, 0x26, 0x82, 0x1e, 0xda, 0x5a, 0x59, 0xbf, 0x67, 0xe1, 0xf3, 0x6b, 0x2d, 0x79, 0xf5, 0xcf, + 0x44, 0xed, 0xbd, 0x0d, 0xe3, 0x1d, 0xa4, 0xbe, 0xdb, 0xeb, 0xde, 0x56, 0xc7, 0xc9, 0xbc, 0xd3, + 0xe5, 0xfb, 0x69, 0x1e, 0x09, 0xc1, 0x57, 0x24, 0x7c, 0x7b, 0xb1, 0x76, 0x6f, 0xa3, 0xca, 0xcf, + 0xc2, 0x91, 0xb6, 0x54, 0x5c, 0xb6, 0x3c, 0xc4, 0xb6, 0x34, 0xdb, 0xe1, 0x62, 0xdd, 0xdf, 0x49, + 0xac, 0x10, 0x35, 0xa5, 0x91, 0x11, 0x64, 0x28, 0xeb, 0x15, 0xc3, 0xa8, 0x73, 0x31, 0xe4, 0x2b, + 0x30, 0xec, 0x83, 0xf1, 0x41, 0xce, 0x42, 0xcc, 0x34, 0xf8, 0xf7, 0x57, 0x52, 0xa7, 0x8e, 0x76, + 0x1a, 0x84, 0xd0, 0x70, 0xb5, 0x29, 0xbe, 0x3c, 0x0a, 0x88, 0x31, 0xa3, 0x57, 0x42, 0xc4, 0x10, + 0xab, 0x30, 0x12, 0x80, 0xf2, 0x41, 0xde, 0x0f, 0x7d, 0x26, 0x85, 0xb8, 0x6f, 0xf9, 0x75, 0x1a, + 0x86, 0x62, 0xb9, 0x5f, 0xbc, 0xa0, 0xad, 0x53, 0xdf, 0x3d, 0x08, 0x71, 0xca, 0x15, 0x7d, 0x41, + 0x02, 0xf0, 0x5d, 0xf0, 0x98, 0xea, 0xc4, 0xa6, 0xfd, 0x9e, 0x38, 0x37, 0xdd, 0x33, 0x3e, 0xaf, + 0xd9, 0x4e, 0xfc, 0xf8, 0xbf, 0x7d, 0xf3, 0x73, 0x91, 0xfb, 0x90, 0x3c, 0xdd, 0x61, 0x37, 0xee, + 0x8b, 0x97, 0xaf, 0x06, 0x3e, 0xfe, 0xf1, 0x70, 0x6f, 0x43, 0x09, 0xc9, 0xa6, 0x7a, 0x45, 0xe7, + 0x82, 0x5d, 0xa0, 0x82, 0x9d, 0x41, 0x8f, 0x75, 0x17, 0x6c, 0xfa, 0x23, 0xc1, 0xa0, 0xf9, 0x18, + 0xfa, 0x1d, 0x09, 0x46, 0xdb, 0x6d, 0xe9, 0xd0, 0xb9, 0xde, 0xa4, 0x68, 0x2d, 0x29, 0x72, 0xe7, + 0xf7, 0x41, 0xc9, 0x55, 0x99, 0xa3, 0xaa, 0xcc, 0xa0, 0x27, 0xf7, 0xa1, 0xca, 0xb4, 0x6f, 0xdd, + 0x41, 0xff, 0x5b, 0x82, 0x63, 0xbb, 0xee, 0x90, 0xd0, 0x4c, 0x6f, 0x52, 0xee, 0x52, 0x3b, 0xe5, + 0x0a, 0xef, 0x84, 0x05, 0xd7, 0xf8, 0x29, 0xaa, 0xf1, 0x15, 0x34, 0xbf, 0x1f, 0x8d, 0xbd, 0x8a, + 0xc8, 0xaf, 0xfb, 0x6f, 0x06, 0x2f, 0x0a, 0xef, 0xee, 0x4e, 0x2d, 0x1b, 0x8f, 0x2e, 0x81, 0xd1, + 0x5a, 0xd4, 0xca, 0xcf, 0x50, 0x15, 0x14, 0xb4, 0xf2, 0x0e, 0x27, 0x6d, 0xfa, 0x23, 0xc1, 0xc4, + 0xff, 0x31, 0xf4, 0xbf, 0xa4, 0xf6, 0xf7, 0x7e, 0x1f, 0xdf, 0x55, 0xc4, 0xce, 0x9b, 0xaa, 0xdc, + 0xb9, 0xbd, 0x13, 0x72, 0x25, 0x1b, 0x54, 0xc9, 0x1a, 0xc2, 0x77, 0x5a, 0xc9, 0xb6, 0x93, 0x88, + 0x7e, 0x4b, 0x82, 0xd1, 0x76, 0x7b, 0x92, 0x2e, 0x61, 0xb9, 0xcb, 0x26, 0xab, 0x4b, 0x58, 0xee, + 0xb6, 0x01, 0x92, 0xdf, 0x4f, 0x95, 0x3f, 0x8b, 0x4e, 0x77, 0x52, 0x7e, 0xd7, 0x59, 0x24, 0xb1, + 0xb8, 0x6b, 0x91, 0xdf, 0x25, 0x16, 0x7b, 0xd9, 0xc7, 0x74, 0x89, 0xc5, 0x9e, 0xf6, 0x18, 0xdd, + 0x63, 0xd1, 0xd5, 0xac, 0xc7, 0x69, 0xb4, 0xd1, 0xb7, 0x24, 0x18, 0x08, 0x54, 0xc4, 0xe8, 0xd1, + 0x5d, 0x05, 0x6d, 0xb7, 0x61, 0xc8, 0x9d, 0xda, 0x0b, 0x09, 0xd7, 0x65, 0x9e, 0xea, 0x32, 0x8b, + 0x66, 0xf6, 0xa3, 0x8b, 0x15, 0x90, 0xf8, 0x35, 0x09, 0x46, 0xda, 0x54, 0x99, 0x5d, 0xa2, 0xb0, + 0x73, 0xd1, 0x9c, 0x3b, 0xb7, 0x77, 0x42, 0xae, 0xd5, 0x45, 0xaa, 0xd5, 0x07, 0xd1, 0x13, 0xfb, + 0xd1, 0xca, 0xb7, 0x3e, 0xdf, 0xf2, 0xae, 0x51, 0xfa, 0xc6, 0x41, 0x67, 0xf7, 0x28, 0x98, 0x50, + 0xe8, 0xf1, 0x3d, 0xd3, 0x71, 0x7d, 0x9e, 0xa6, 0xfa, 0x3c, 0x85, 0x96, 0xdf, 0x99, 0x3e, 0xad, + 0xcb, 0xfa, 0xd7, 0x5b, 0x5f, 0xd1, 0xdd, 0xdd, 0x8b, 0xda, 0x16, 0xab, 0xb9, 0xc7, 0xf6, 0x44, + 0xc3, 0x95, 0x3a, 0x47, 0x95, 0x3a, 0x85, 0x1e, 0xe9, 0xa4, 0x94, 0xef, 0xae, 0xac, 0xa6, 0x6f, + 0x1a, 0xd3, 0x1f, 0x61, 0x25, 0xf0, 0xc7, 0xd0, 0x8f, 0x89, 0x7b, 0x8a, 0xc7, 0x77, 0x1d, 0xd7, + 0x57, 0xc7, 0xe6, 0x1e, 0xec, 0x01, 0x93, 0xcb, 0x75, 0x1f, 0x95, 0x6b, 0x1c, 0x1d, 0xed, 0x24, + 0x17, 0xa9, 0x65, 0xd1, 0xa7, 0x25, 0xf7, 0x6a, 0xf3, 0x89, 0xdd, 0x79, 0xfb, 0x8b, 0xdd, 0xdc, + 0x43, 0x3d, 0xe1, 0x72, 0x49, 0xee, 0xa7, 0x92, 0x4c, 0xa2, 0xf1, 0x8e, 0x92, 0xb0, 0xd2, 0xf7, + 0x4e, 0xdf, 0x1c, 0xf8, 0xe3, 0xfe, 0x8e, 0xaf, 0xa3, 0xd7, 0xb0, 0x8e, 0x6d, 0xcd, 0xde, 0xd7, + 0x0d, 0xc0, 0xde, 0x1e, 0x4f, 0xfd, 0x4e, 0x1c, 0xd2, 0x73, 0x6c, 0x94, 0x55, 0x47, 0x75, 0xde, + 0xe1, 0x46, 0x00, 0xd9, 0xfc, 0xcb, 0x56, 0xec, 0x93, 0x7c, 0xde, 0x47, 0xe6, 0xd2, 0x7b, 0x7a, + 0xd9, 0x93, 0xdd, 0x7f, 0xe2, 0xef, 0x55, 0x86, 0xf9, 0xc9, 0xec, 0x23, 0x59, 0xf4, 0xee, 0x02, + 0xfb, 0x98, 0xde, 0x27, 0x24, 0x38, 0x48, 0xb1, 0xbc, 0x78, 0xa3, 0x98, 0xe2, 0x4d, 0x9f, 0x8e, + 0x1e, 0xb3, 0xa0, 0xfa, 0x8e, 0x60, 0xd8, 0xe7, 0xef, 0xee, 0xe3, 0xb7, 0xe0, 0x8f, 0xfa, 0x06, + 0x0f, 0xb3, 0x95, 0x95, 0x91, 0x7a, 0x0b, 0xa5, 0x1d, 0xda, 0xd7, 0xc7, 0xf6, 0xbf, 0xaf, 0xbf, + 0x0c, 0x29, 0x5f, 0xa6, 0xcf, 0xc6, 0xbb, 0xbc, 0x9c, 0x16, 0x3e, 0x44, 0xf3, 0x13, 0xa3, 0x4f, + 0x4a, 0x70, 0xb0, 0xed, 0x22, 0x48, 0xff, 0x6f, 0xe2, 0x1e, 0x0f, 0xe9, 0x42, 0xc6, 0x69, 0xcb, + 0x57, 0x56, 0x46, 0x9b, 0xed, 0xaa, 0x89, 0x15, 0x18, 0x08, 0x2c, 0x60, 0x59, 0xf1, 0xdf, 0x4f, + 0x7b, 0xbf, 0x97, 0x1d, 0x64, 0x80, 0x72, 0x90, 0xc0, 0xdb, 0xa6, 0x61, 0x39, 0xb8, 0x4a, 0xaf, + 0x3c, 0x24, 0x14, 0xb7, 0x2d, 0x2f, 0x01, 0x6a, 0x9d, 0xdc, 0xf0, 0xf7, 0x1e, 0x93, 0xde, 0xf7, + 0x1e, 0x47, 0x21, 0xee, 0xff, 0x22, 0x22, 0x6b, 0xdc, 0xbd, 0xdb, 0x42, 0xff, 0x2f, 0x00, 0x00, + 0xff, 0xff, 0x2d, 0x40, 0x2b, 0xb4, 0xf6, 0x8e, 0x00, 0x00, } r := bytes.NewReader(gzipped) gzipr, err := compress_gzip.NewReader(r) From bd03ff3ce0d15db4a1a7a904aed0e22f188fea9d Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Mon, 12 Oct 2020 11:30:54 +0200 Subject: [PATCH 22/24] Remove buf version --- buf.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/buf.yaml b/buf.yaml index 89e406ec6653..adaef5ff18ef 100644 --- a/buf.yaml +++ b/buf.yaml @@ -1,4 +1,3 @@ -version: v1beta1 build: roots: - proto From 8ed1fdc9d0cd0ffced911195d13e302d05d2dc1e Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Mon, 12 Oct 2020 11:48:05 +0200 Subject: [PATCH 23/24] Fix tests --- CHANGELOG.md | 1 + x/staking/legacy/v040/migrate_test.go | 2 +- x/staking/simulation/genesis_test.go | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 094ffc042e8e..bd0e455be223 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -65,6 +65,7 @@ older clients. * (server) [\#5982](https://github.com/cosmos/cosmos-sdk/pull/5982) `--pruning` now must be set to `custom` if you want to customise the granular options. * (x/gov) [\#7000](https://github.com/cosmos/cosmos-sdk/pull/7000) [\#6859](https://github.com/cosmos/cosmos-sdk/pull/6859) `ProposalStatus` and `VoteOption` are now JSON serialized using its protobuf name, so expect names like `PROPOSAL_STATUS_DEPOSIT_PERIOD` as opposed to `DepositPeriod`. * (x/auth/vesting) [\#6859](https://github.com/cosmos/cosmos-sdk/pull/6859) Custom JSON marshaling of vesting accounts was removed. Vesting accounts are now marshaled using their default proto or amino JSON representation. +* (x/staking) [\#7499](https://github.com/cosmos/cosmos-sdk/pull/7499) `BondStatus` is now a protobuf `enum` instead of an `int32`, and JSON serialized using its protobuf name, so expect names like `BOND_STATUS_UNBONDING` as opposed to `Unbonding`. ### API Breaking Changes diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go index 1d593a6fc98a..626864a8ec26 100644 --- a/x/staking/legacy/v040/migrate_test.go +++ b/x/staking/legacy/v040/migrate_test.go @@ -81,7 +81,7 @@ func TestMigrate(t *testing.T) { "jailed": false, "min_self_delegation": "0", "operator_address": "", - "status": 1, + "status": "BOND_STATUS_UNBONDED", "tokens": "0", "unbonding_height": "0", "unbonding_time": "0001-01-01T00:00:00Z" diff --git a/x/staking/simulation/genesis_test.go b/x/staking/simulation/genesis_test.go index 171c68819ede..ace2f0acb555 100644 --- a/x/staking/simulation/genesis_test.go +++ b/x/staking/simulation/genesis_test.go @@ -55,7 +55,7 @@ func TestRandomizedGenState(t *testing.T) { require.Equal(t, "cosmosvaloper1ghekyjucln7y67ntx7cf27m9dpuxxemnsvnaes", stakingGenesis.Validators[2].GetOperator().String()) require.Equal(t, "cosmosvalconspub1zcjduepq280tm686ma80cva9z620dmknd9a858pd2zmq9ackfenfllecjxds0hg9n7", stakingGenesis.Validators[2].ConsensusPubkey) require.Equal(t, false, stakingGenesis.Validators[2].Jailed) - require.Equal(t, "Unbonded", stakingGenesis.Validators[2].Status.String()) + require.Equal(t, "BOND_STATUS_UNBONDED", stakingGenesis.Validators[2].Status.String()) require.Equal(t, "1000", stakingGenesis.Validators[2].Tokens.String()) require.Equal(t, "1000.000000000000000000", stakingGenesis.Validators[2].DelegatorShares.String()) require.Equal(t, "0.292059246265731326", stakingGenesis.Validators[2].Commission.CommissionRates.Rate.String()) From 8fa8bf02052cbf1666156ee644c335d571cb1e13 Mon Sep 17 00:00:00 2001 From: Amaury Martiny Date: Mon, 12 Oct 2020 11:53:00 +0200 Subject: [PATCH 24/24] Fix test --- x/staking/types/validator_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go index 075b0fe23419..00ad07ba58ef 100644 --- a/x/staking/types/validator_test.go +++ b/x/staking/types/validator_test.go @@ -328,7 +328,8 @@ func TestBondStatus(t *testing.T) { require.False(t, Unbonded == Bonded) require.False(t, Unbonded == Unbonding) require.False(t, Bonded == Unbonding) - require.Panicsf(t, func() { BondStatus(4).String() }, "invalid bond status") // nolint:govet + require.Equal(t, BondStatus(4).String(), "4") + require.Equal(t, BondStatusUnspecified, Unspecified.String()) require.Equal(t, BondStatusUnbonded, Unbonded.String()) require.Equal(t, BondStatusBonded, Bonded.String()) require.Equal(t, BondStatusUnbonding, Unbonding.String())