From fec543d4f8e72caf6543423c22ef94fa52a5fc05 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Tue, 26 Jan 2021 23:28:34 +1000
Subject: [PATCH 01/23] power reduction as on-chain param

---
 proto/cosmos/staking/v1beta1/staking.proto |    5 +
 x/staking/types/staking.pb.go              | 1494 ++++++++++----------
 2 files changed, 778 insertions(+), 721 deletions(-)

diff --git a/proto/cosmos/staking/v1beta1/staking.proto b/proto/cosmos/staking/v1beta1/staking.proto
index eadc86e9d13a..456655cb86ea 100644
--- a/proto/cosmos/staking/v1beta1/staking.proto
+++ b/proto/cosmos/staking/v1beta1/staking.proto
@@ -238,6 +238,11 @@ message Params {
   uint32 max_entries        = 3 [(gogoproto.moretags) = "yaml:\"max_entries\""];
   uint32 historical_entries = 4 [(gogoproto.moretags) = "yaml:\"historical_entries\""];
   string bond_denom         = 5 [(gogoproto.moretags) = "yaml:\"bond_denom\""];
+  string power_reduction    = 6 [
+    (gogoproto.moretags)   = "yaml:\"power_reduction\"",
+    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
+    (gogoproto.nullable)   = false
+  ];
 }
 
 // DelegationResponse is equivalent to Delegation except that it contains a
diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go
index b97e1224c45a..81c4caf82145 100644
--- a/x/staking/types/staking.pb.go
+++ b/x/staking/types/staking.pb.go
@@ -795,11 +795,12 @@ var xxx_messageInfo_Redelegation proto.InternalMessageInfo
 
 // Params defines the parameters for the staking module.
 type Params struct {
-	UnbondingTime     time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
-	MaxValidators     uint32        `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
-	MaxEntries        uint32        `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
-	HistoricalEntries uint32        `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
-	BondDenom         string        `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
+	UnbondingTime     time.Duration                          `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
+	MaxValidators     uint32                                 `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
+	MaxEntries        uint32                                 `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
+	HistoricalEntries uint32                                 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
+	BondDenom         string                                 `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
+	PowerReduction    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=power_reduction,json=powerReduction,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"power_reduction" yaml:"power_reduction"`
 }
 
 func (m *Params) Reset()      { *m = Params{} }
@@ -1094,120 +1095,121 @@ func init() {
 }
 
 var fileDescriptor_64c30c6cf92913c9 = []byte{
-	// 1796 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4d, 0x6c, 0x23, 0x49,
-	0x15, 0x76, 0x3b, 0x5e, 0xc7, 0x7e, 0x4e, 0xe2, 0xa4, 0x26, 0x33, 0xeb, 0x98, 0xc1, 0xed, 0x6d,
-	0x56, 0x4b, 0x40, 0xbb, 0x0e, 0x93, 0x45, 0x8b, 0xc8, 0x05, 0xc6, 0x71, 0x86, 0x58, 0xbb, 0x0c,
-	0xa1, 0x93, 0x09, 0x12, 0xac, 0xb0, 0xca, 0xdd, 0x15, 0xa7, 0x89, 0xbb, 0xdb, 0x74, 0x95, 0x87,
-	0x58, 0xda, 0x03, 0xc7, 0x65, 0x10, 0x62, 0xb9, 0xed, 0x65, 0xa4, 0x91, 0xf6, 0xba, 0x12, 0x17,
-	0xc4, 0x95, 0xeb, 0x02, 0x97, 0xe1, 0x86, 0x10, 0x32, 0x68, 0xe6, 0x82, 0x38, 0x21, 0x1f, 0x10,
-	0x37, 0x50, 0xfd, 0xf4, 0x4f, 0xda, 0xf1, 0xcc, 0x78, 0xb4, 0x87, 0x91, 0xd8, 0x4b, 0xe2, 0x7a,
-	0xf5, 0xde, 0xf7, 0xea, 0xfd, 0xd6, 0xab, 0x86, 0x57, 0x2d, 0x9f, 0xba, 0x3e, 0xdd, 0xa2, 0x0c,
-	0x9f, 0x39, 0x5e, 0x6f, 0xeb, 0xee, 0x8d, 0x2e, 0x61, 0xf8, 0x46, 0xb8, 0x6e, 0x0c, 0x02, 0x9f,
-	0xf9, 0xe8, 0x9a, 0xe4, 0x6a, 0x84, 0x54, 0xc5, 0x55, 0x5d, 0xef, 0xf9, 0x3d, 0x5f, 0xb0, 0x6c,
-	0xf1, 0x5f, 0x92, 0xbb, 0xba, 0xd1, 0xf3, 0xfd, 0x5e, 0x9f, 0x6c, 0x89, 0x55, 0x77, 0x78, 0xb2,
-	0x85, 0xbd, 0x91, 0xda, 0xaa, 0xa5, 0xb7, 0xec, 0x61, 0x80, 0x99, 0xe3, 0x7b, 0x6a, 0x5f, 0x4f,
-	0xef, 0x33, 0xc7, 0x25, 0x94, 0x61, 0x77, 0x10, 0x62, 0xcb, 0x93, 0x74, 0xa4, 0x52, 0x75, 0x2c,
-	0x85, 0xad, 0x4c, 0xe9, 0x62, 0x4a, 0x22, 0x3b, 0x2c, 0xdf, 0x09, 0xb1, 0xaf, 0x33, 0xe2, 0xd9,
-	0x24, 0x70, 0x1d, 0x8f, 0x6d, 0xb1, 0xd1, 0x80, 0x50, 0xf9, 0x57, 0xee, 0x1a, 0x3f, 0xd3, 0x60,
-	0x65, 0xdf, 0xa1, 0xcc, 0x0f, 0x1c, 0x0b, 0xf7, 0xdb, 0xde, 0x89, 0x8f, 0xde, 0x82, 0xfc, 0x29,
-	0xc1, 0x36, 0x09, 0x2a, 0x5a, 0x5d, 0xdb, 0x2c, 0x6d, 0x57, 0x1a, 0x31, 0x42, 0x43, 0xca, 0xee,
-	0x8b, 0xfd, 0x66, 0xee, 0x93, 0xb1, 0x9e, 0x31, 0x15, 0x37, 0xfa, 0x06, 0xe4, 0xef, 0xe2, 0x3e,
-	0x25, 0xac, 0x92, 0xad, 0x2f, 0x6c, 0x96, 0xb6, 0x5f, 0x69, 0x5c, 0xee, 0xbe, 0xc6, 0x31, 0xee,
-	0x3b, 0x36, 0x66, 0x7e, 0x04, 0x20, 0xc5, 0x8c, 0x5f, 0x67, 0xa1, 0xbc, 0xeb, 0xbb, 0xae, 0x43,
-	0xa9, 0xe3, 0x7b, 0x26, 0x66, 0x84, 0xa2, 0x26, 0xe4, 0x02, 0xcc, 0x88, 0x38, 0x4a, 0xb1, 0xd9,
-	0xe0, 0xfc, 0x7f, 0x19, 0xeb, 0xaf, 0xf5, 0x1c, 0x76, 0x3a, 0xec, 0x36, 0x2c, 0xdf, 0x55, 0xce,
-	0x50, 0xff, 0xde, 0xa0, 0xf6, 0x99, 0xb2, 0xaf, 0x45, 0x2c, 0x53, 0xc8, 0xa2, 0x77, 0xa1, 0xe0,
-	0xe2, 0xf3, 0x8e, 0xc0, 0xc9, 0x0a, 0x9c, 0x9b, 0xf3, 0xe1, 0x4c, 0xc6, 0x7a, 0x79, 0x84, 0xdd,
-	0xfe, 0x8e, 0x11, 0xe2, 0x18, 0xe6, 0xa2, 0x8b, 0xcf, 0xf9, 0x11, 0xd1, 0x00, 0xca, 0x9c, 0x6a,
-	0x9d, 0x62, 0xaf, 0x47, 0xa4, 0x92, 0x05, 0xa1, 0x64, 0x7f, 0x6e, 0x25, 0xd7, 0x62, 0x25, 0x09,
-	0x38, 0xc3, 0x5c, 0x76, 0xf1, 0xf9, 0xae, 0x20, 0x70, 0x8d, 0x3b, 0x85, 0x0f, 0x1f, 0xe8, 0x99,
-	0x7f, 0x3c, 0xd0, 0x35, 0xe3, 0x4f, 0x1a, 0x40, 0xec, 0x31, 0xf4, 0x2e, 0xac, 0x5a, 0xd1, 0x4a,
-	0xc8, 0x52, 0x15, 0xc3, 0x2f, 0xce, 0x8a, 0x45, 0xca, 0xdf, 0xcd, 0x02, 0x3f, 0xf4, 0xc3, 0xb1,
-	0xae, 0x99, 0x65, 0x2b, 0x15, 0x8a, 0x1f, 0x40, 0x69, 0x38, 0xb0, 0x31, 0x23, 0x1d, 0x9e, 0x9d,
-	0xc2, 0x93, 0xa5, 0xed, 0x6a, 0x43, 0xa6, 0x6e, 0x23, 0x4c, 0xdd, 0xc6, 0x51, 0x98, 0xba, 0xcd,
-	0x1a, 0xc7, 0x9a, 0x8c, 0x75, 0x24, 0xcd, 0x4a, 0x08, 0x1b, 0x1f, 0xfc, 0x4d, 0xd7, 0x4c, 0x90,
-	0x14, 0x2e, 0x90, 0xb0, 0xe9, 0xf7, 0x1a, 0x94, 0x5a, 0x84, 0x5a, 0x81, 0x33, 0xe0, 0x15, 0x82,
-	0x2a, 0xb0, 0xe8, 0xfa, 0x9e, 0x73, 0xa6, 0xf2, 0xb1, 0x68, 0x86, 0x4b, 0x54, 0x85, 0x82, 0x63,
-	0x13, 0x8f, 0x39, 0x6c, 0x24, 0xe3, 0x6a, 0x46, 0x6b, 0x2e, 0xf5, 0x13, 0xd2, 0xa5, 0x4e, 0x18,
-	0x0d, 0x33, 0x5c, 0xa2, 0x5b, 0xb0, 0x4a, 0x89, 0x35, 0x0c, 0x1c, 0x36, 0xea, 0x58, 0xbe, 0xc7,
-	0xb0, 0xc5, 0x2a, 0x39, 0x11, 0xb0, 0xcf, 0x4d, 0xc6, 0xfa, 0xcb, 0xf2, 0xac, 0x69, 0x0e, 0xc3,
-	0x2c, 0x87, 0xa4, 0x5d, 0x49, 0xe1, 0x1a, 0x6c, 0xc2, 0xb0, 0xd3, 0xa7, 0x95, 0x97, 0xa4, 0x06,
-	0xb5, 0x4c, 0xd8, 0xf2, 0xf1, 0x22, 0x14, 0xa3, 0x6c, 0xe7, 0x9a, 0xfd, 0x01, 0x09, 0xf8, 0xef,
-	0x0e, 0xb6, 0xed, 0x80, 0x50, 0xaa, 0xf2, 0x3a, 0xa1, 0x39, 0xcd, 0x61, 0x98, 0xe5, 0x90, 0x74,
-	0x53, 0x52, 0x10, 0xe3, 0x61, 0xf6, 0x28, 0xf1, 0xe8, 0x90, 0x76, 0x06, 0xc3, 0xee, 0x19, 0x19,
-	0xa9, 0x68, 0xac, 0x4f, 0x45, 0xe3, 0xa6, 0x37, 0x6a, 0xbe, 0x19, 0xa3, 0xa7, 0xe5, 0x8c, 0x3f,
-	0xfc, 0xe6, 0x8d, 0x75, 0x95, 0x1a, 0x56, 0x30, 0x1a, 0x30, 0xbf, 0x71, 0x30, 0xec, 0xbe, 0x4d,
-	0x46, 0x3c, 0xfc, 0x8a, 0xf5, 0x40, 0x70, 0xa2, 0x6b, 0x90, 0xff, 0x11, 0x76, 0xfa, 0xc4, 0x16,
-	0x0e, 0x2d, 0x98, 0x6a, 0x85, 0x76, 0x20, 0x4f, 0x19, 0x66, 0x43, 0x2a, 0xbc, 0xb8, 0xb2, 0x6d,
-	0xcc, 0x4a, 0xb5, 0xa6, 0xef, 0xd9, 0x87, 0x82, 0xd3, 0x54, 0x12, 0xe8, 0x16, 0xe4, 0x99, 0x7f,
-	0x46, 0x3c, 0xe5, 0xc2, 0xb9, 0xea, 0xbb, 0xed, 0x31, 0x53, 0x49, 0x73, 0x8f, 0xd8, 0xa4, 0x4f,
-	0x7a, 0xc2, 0x71, 0xf4, 0x14, 0x07, 0x84, 0x56, 0xf2, 0x02, 0xb1, 0x3d, 0x77, 0x11, 0x2a, 0x4f,
-	0xa5, 0xf1, 0x0c, 0xb3, 0x1c, 0x91, 0x0e, 0x05, 0x05, 0xbd, 0x0d, 0x25, 0x3b, 0x4e, 0xd4, 0xca,
-	0xa2, 0x08, 0xc1, 0x17, 0x66, 0x99, 0x9f, 0xc8, 0x69, 0xd5, 0xf7, 0x92, 0xd2, 0x3c, 0x39, 0x86,
-	0x5e, 0xd7, 0xf7, 0x6c, 0xc7, 0xeb, 0x75, 0x4e, 0x89, 0xd3, 0x3b, 0x65, 0x95, 0x42, 0x5d, 0xdb,
-	0x5c, 0x48, 0x26, 0x47, 0x9a, 0xc3, 0x30, 0xcb, 0x11, 0x69, 0x5f, 0x50, 0x90, 0x0d, 0x2b, 0x31,
-	0x97, 0x28, 0xd4, 0xe2, 0x53, 0x0b, 0xf5, 0x15, 0x55, 0xa8, 0x57, 0xd3, 0x5a, 0xe2, 0x5a, 0x5d,
-	0x8e, 0x88, 0x5c, 0x0c, 0xed, 0x03, 0xc4, 0xed, 0xa1, 0x02, 0x42, 0x83, 0xf1, 0xf4, 0x1e, 0xa3,
-	0x0c, 0x4f, 0xc8, 0xa2, 0xf7, 0xe0, 0x8a, 0xeb, 0x78, 0x1d, 0x4a, 0xfa, 0x27, 0x1d, 0xe5, 0x60,
-	0x0e, 0x59, 0x12, 0xd1, 0x7b, 0x67, 0xbe, 0x7c, 0x98, 0x8c, 0xf5, 0xaa, 0x6a, 0xa1, 0xd3, 0x90,
-	0x86, 0xb9, 0xe6, 0x3a, 0xde, 0x21, 0xe9, 0x9f, 0xb4, 0x22, 0xda, 0xce, 0xd2, 0xfb, 0x0f, 0xf4,
-	0x8c, 0x2a, 0xd7, 0x8c, 0xf1, 0x16, 0x2c, 0x1d, 0xe3, 0xbe, 0x2a, 0x33, 0x42, 0xd1, 0x75, 0x28,
-	0xe2, 0x70, 0x51, 0xd1, 0xea, 0x0b, 0x9b, 0x45, 0x33, 0x26, 0xc8, 0x32, 0xff, 0xe9, 0x5f, 0xeb,
-	0x9a, 0xf1, 0xb1, 0x06, 0xf9, 0xd6, 0xf1, 0x01, 0x76, 0x02, 0xd4, 0x86, 0xb5, 0x38, 0x73, 0x2e,
-	0x16, 0xf9, 0xf5, 0xc9, 0x58, 0xaf, 0xa4, 0x93, 0x2b, 0xaa, 0xf2, 0x38, 0x81, 0xc3, 0x32, 0x6f,
-	0xc3, 0xda, 0xdd, 0xb0, 0x77, 0x44, 0x50, 0xd9, 0x34, 0xd4, 0x14, 0x8b, 0x61, 0xae, 0x46, 0x34,
-	0x05, 0x95, 0x32, 0x73, 0x0f, 0x16, 0xe5, 0x69, 0x29, 0xda, 0x81, 0x97, 0x06, 0xfc, 0x87, 0xb0,
-	0xae, 0xb4, 0x5d, 0x9b, 0x99, 0xbc, 0x82, 0x5f, 0x85, 0x4f, 0x8a, 0x18, 0xbf, 0xca, 0x02, 0xb4,
-	0x8e, 0x8f, 0x8f, 0x02, 0x67, 0xd0, 0x27, 0xec, 0xd3, 0xb4, 0xfc, 0x08, 0xae, 0xc6, 0x66, 0xd1,
-	0xc0, 0x4a, 0x59, 0x5f, 0x9f, 0x8c, 0xf5, 0xeb, 0x69, 0xeb, 0x13, 0x6c, 0x86, 0x79, 0x25, 0xa2,
-	0x1f, 0x06, 0xd6, 0xa5, 0xa8, 0x36, 0x65, 0x11, 0xea, 0xc2, 0x6c, 0xd4, 0x04, 0x5b, 0x12, 0xb5,
-	0x45, 0xd9, 0xe5, 0xae, 0x3d, 0x84, 0x52, 0xec, 0x12, 0x8a, 0x5a, 0x50, 0x60, 0xea, 0xb7, 0xf2,
-	0xb0, 0x31, 0xdb, 0xc3, 0xa1, 0x98, 0xf2, 0x72, 0x24, 0x69, 0xfc, 0x47, 0x03, 0x88, 0x73, 0xf6,
-	0xc5, 0x4c, 0x31, 0xde, 0xca, 0x55, 0xe3, 0x5d, 0x78, 0xae, 0x51, 0x4d, 0x49, 0xa7, 0xfc, 0xf9,
-	0xf3, 0x2c, 0x5c, 0xb9, 0x13, 0x76, 0x9e, 0x17, 0xde, 0x07, 0x07, 0xb0, 0x48, 0x3c, 0x16, 0x38,
-	0xc2, 0x09, 0x3c, 0xda, 0x5f, 0x99, 0x15, 0xed, 0x4b, 0x6c, 0xda, 0xf3, 0x58, 0x30, 0x52, 0xb1,
-	0x0f, 0x61, 0x52, 0xde, 0xf8, 0xe5, 0x02, 0x54, 0x66, 0x49, 0xa2, 0x5d, 0x28, 0x5b, 0x01, 0x11,
-	0x84, 0xf0, 0xfe, 0xd0, 0xc4, 0xfd, 0x51, 0x8d, 0x27, 0xcb, 0x14, 0x83, 0x61, 0xae, 0x84, 0x14,
-	0x75, 0x7b, 0xf4, 0x80, 0x8f, 0x7d, 0x3c, 0xed, 0x38, 0xd7, 0x33, 0xce, 0x79, 0x86, 0xba, 0x3e,
-	0x42, 0x25, 0x17, 0x01, 0xe4, 0xfd, 0xb1, 0x12, 0x53, 0xc5, 0x05, 0xf2, 0x63, 0x28, 0x3b, 0x9e,
-	0xc3, 0x1c, 0xdc, 0xef, 0x74, 0x71, 0x1f, 0x7b, 0xd6, 0xf3, 0x4c, 0xcd, 0xb2, 0xe5, 0x2b, 0xb5,
-	0x29, 0x38, 0xc3, 0x5c, 0x51, 0x94, 0xa6, 0x24, 0xa0, 0x7d, 0x58, 0x0c, 0x55, 0xe5, 0x9e, 0x6b,
-	0xda, 0x08, 0xc5, 0x13, 0x03, 0xde, 0x2f, 0x16, 0x60, 0xcd, 0x24, 0xf6, 0x67, 0xa1, 0x98, 0x2f,
-	0x14, 0xdf, 0x06, 0x90, 0xe5, 0xce, 0x1b, 0xec, 0x73, 0x44, 0x83, 0x37, 0x8c, 0xa2, 0x44, 0x68,
-	0x51, 0x96, 0x88, 0xc7, 0x38, 0x0b, 0x4b, 0xc9, 0x78, 0xfc, 0x9f, 0xde, 0x4a, 0xa8, 0x1d, 0x77,
-	0xa2, 0x9c, 0xe8, 0x44, 0x5f, 0x9a, 0xd5, 0x89, 0xa6, 0xb2, 0xf7, 0xc9, 0x2d, 0xe8, 0xdf, 0x59,
-	0xc8, 0x1f, 0xe0, 0x00, 0xbb, 0x14, 0x59, 0x53, 0x93, 0xa6, 0x7c, 0x6b, 0x6e, 0x4c, 0xe5, 0x67,
-	0x4b, 0x7d, 0xed, 0x78, 0xca, 0xa0, 0xf9, 0xe1, 0x25, 0x83, 0xe6, 0x37, 0x61, 0x85, 0x3f, 0x87,
-	0x23, 0x1b, 0xa5, 0xb7, 0x97, 0x9b, 0x1b, 0x31, 0xca, 0xc5, 0x7d, 0xf9, 0x5a, 0x8e, 0x1e, 0x5d,
-	0x14, 0x7d, 0x0d, 0x4a, 0x9c, 0x23, 0x6e, 0xcc, 0x5c, 0xfc, 0x5a, 0xfc, 0x2c, 0x4d, 0x6c, 0x1a,
-	0x26, 0xb8, 0xf8, 0x7c, 0x4f, 0x2e, 0xd0, 0x3b, 0x80, 0x4e, 0xa3, 0x2f, 0x23, 0x9d, 0xd8, 0x9d,
-	0x5c, 0xfe, 0xf3, 0x93, 0xb1, 0xbe, 0x21, 0xe5, 0xa7, 0x79, 0x0c, 0x73, 0x2d, 0x26, 0x86, 0x68,
-	0x5f, 0x05, 0xe0, 0x76, 0x75, 0x6c, 0xe2, 0xf9, 0xae, 0x7a, 0xee, 0x5c, 0x9d, 0x8c, 0xf5, 0x35,
-	0x89, 0x12, 0xef, 0x19, 0x66, 0x91, 0x2f, 0x5a, 0xfc, 0x77, 0x22, 0xb3, 0x3f, 0xd2, 0x00, 0xc5,
-	0x2d, 0xdf, 0x24, 0x74, 0xc0, 0xdf, 0x67, 0x7c, 0x10, 0x4f, 0x4c, 0xcd, 0xda, 0x93, 0x07, 0xf1,
-	0x58, 0x3e, 0x1c, 0xc4, 0x13, 0x95, 0xf2, 0xf5, 0xb8, 0x3d, 0x66, 0x55, 0x1c, 0x15, 0x4c, 0x17,
-	0x53, 0x92, 0x18, 0xe6, 0x9d, 0x50, 0x7a, 0xaa, 0x1f, 0x66, 0x8c, 0x3f, 0x6a, 0xb0, 0x31, 0x95,
-	0x51, 0xd1, 0x61, 0x7f, 0x08, 0x28, 0x48, 0x6c, 0x0a, 0x7f, 0x8d, 0xd4, 0xa1, 0xe7, 0x4e, 0xd0,
-	0xb5, 0x60, 0xaa, 0xef, 0x7e, 0x7a, 0x1d, 0x3e, 0x27, 0x7c, 0xfe, 0x3b, 0x0d, 0xd6, 0x93, 0xea,
-	0x23, 0x43, 0x6e, 0xc3, 0x52, 0x52, 0xbb, 0x32, 0xe1, 0xd5, 0x67, 0x31, 0x41, 0x9d, 0xfe, 0x82,
-	0x3c, 0xfa, 0x6e, 0x5c, 0xae, 0xf2, 0xdb, 0xd9, 0x8d, 0x67, 0xf6, 0x46, 0x78, 0xa6, 0x74, 0xd9,
-	0xe6, 0x44, 0x3c, 0xfe, 0xab, 0x41, 0xee, 0xc0, 0xf7, 0xfb, 0xc8, 0x87, 0x35, 0xcf, 0x67, 0x1d,
-	0x9e, 0x59, 0xc4, 0xee, 0xa8, 0x47, 0xb7, 0xec, 0x83, 0xbb, 0xf3, 0x39, 0xe9, 0x9f, 0x63, 0x7d,
-	0x1a, 0xca, 0x2c, 0x7b, 0x3e, 0x6b, 0x0a, 0xca, 0x91, 0x7c, 0x92, 0xbf, 0x07, 0xcb, 0x17, 0x95,
-	0xc9, 0x2e, 0xf9, 0xbd, 0xb9, 0x95, 0x5d, 0x84, 0x99, 0x8c, 0xf5, 0xf5, 0xb8, 0x62, 0x22, 0xb2,
-	0x61, 0x2e, 0x75, 0x13, 0xda, 0x77, 0x0a, 0x3c, 0x7e, 0xff, 0x7a, 0xa0, 0x6b, 0x5f, 0xfe, 0xad,
-	0x06, 0x10, 0x7f, 0x79, 0x40, 0xaf, 0xc3, 0xcb, 0xcd, 0xef, 0xdc, 0x6e, 0x75, 0x0e, 0x8f, 0x6e,
-	0x1e, 0xdd, 0x39, 0xec, 0xdc, 0xb9, 0x7d, 0x78, 0xb0, 0xb7, 0xdb, 0xbe, 0xd5, 0xde, 0x6b, 0xad,
-	0x66, 0xaa, 0xe5, 0x7b, 0xf7, 0xeb, 0xa5, 0x3b, 0x1e, 0x1d, 0x10, 0xcb, 0x39, 0x71, 0x88, 0x8d,
-	0x5e, 0x83, 0xf5, 0x8b, 0xdc, 0x7c, 0xb5, 0xd7, 0x5a, 0xd5, 0xaa, 0x4b, 0xf7, 0xee, 0xd7, 0x0b,
-	0x72, 0x16, 0x23, 0x36, 0xda, 0x84, 0xab, 0xd3, 0x7c, 0xed, 0xdb, 0xdf, 0x5a, 0xcd, 0x56, 0x97,
-	0xef, 0xdd, 0xaf, 0x17, 0xa3, 0xa1, 0x0d, 0x19, 0x80, 0x92, 0x9c, 0x0a, 0x6f, 0xa1, 0x0a, 0xf7,
-	0xee, 0xd7, 0xf3, 0xd2, 0x81, 0xd5, 0xdc, 0xfb, 0x1f, 0xd5, 0x32, 0xcd, 0x5b, 0x9f, 0x3c, 0xaa,
-	0x69, 0x0f, 0x1f, 0xd5, 0xb4, 0xbf, 0x3f, 0xaa, 0x69, 0x1f, 0x3c, 0xae, 0x65, 0x1e, 0x3e, 0xae,
-	0x65, 0xfe, 0xfc, 0xb8, 0x96, 0xf9, 0xfe, 0xeb, 0x4f, 0xf4, 0xdd, 0x79, 0xf4, 0x51, 0x5b, 0x78,
-	0xb1, 0x9b, 0x17, 0x6d, 0xf8, 0xcd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x48, 0x4c, 0x86,
-	0xf3, 0x16, 0x00, 0x00,
+	// 1822 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4f, 0x6c, 0x23, 0x57,
+	0x19, 0xf7, 0xc4, 0xae, 0x63, 0x7f, 0x4e, 0xe2, 0xe4, 0x6d, 0x76, 0xeb, 0x98, 0xc5, 0xe3, 0x0e,
+	0x55, 0x09, 0xa8, 0x75, 0xd8, 0x14, 0x15, 0x91, 0x0b, 0xac, 0xe3, 0x2c, 0xb1, 0x5a, 0x96, 0x30,
+	0xc9, 0x06, 0x09, 0x2a, 0xac, 0xe7, 0x99, 0x17, 0x67, 0x88, 0x67, 0xc6, 0xcc, 0x7b, 0xde, 0xc6,
+	0x52, 0x0f, 0x1c, 0xcb, 0x22, 0x44, 0xb9, 0xf5, 0xb2, 0xd2, 0x4a, 0xbd, 0x56, 0xe2, 0x82, 0xb8,
+	0x72, 0x2d, 0x70, 0x59, 0x6e, 0x08, 0x21, 0x83, 0x76, 0x2f, 0xc0, 0x09, 0xf9, 0xc4, 0x0d, 0xf4,
+	0xfe, 0xcc, 0x9f, 0x8c, 0xe3, 0xdd, 0xf5, 0xd2, 0x43, 0x25, 0x7a, 0x49, 0xfc, 0xbe, 0xf7, 0x7d,
+	0xbf, 0xef, 0x7d, 0x7f, 0xdf, 0xf7, 0x06, 0x5e, 0xb6, 0x7c, 0xea, 0xfa, 0x74, 0x8b, 0x32, 0x7c,
+	0xe6, 0x78, 0xbd, 0xad, 0xbb, 0x37, 0xba, 0x84, 0xe1, 0x1b, 0xe1, 0xba, 0x31, 0x08, 0x7c, 0xe6,
+	0xa3, 0x6b, 0x92, 0xab, 0x11, 0x52, 0x15, 0x57, 0x75, 0xbd, 0xe7, 0xf7, 0x7c, 0xc1, 0xb2, 0xc5,
+	0x7f, 0x49, 0xee, 0xea, 0x46, 0xcf, 0xf7, 0x7b, 0x7d, 0xb2, 0x25, 0x56, 0xdd, 0xe1, 0xc9, 0x16,
+	0xf6, 0x46, 0x6a, 0xab, 0x96, 0xde, 0xb2, 0x87, 0x01, 0x66, 0x8e, 0xef, 0xa9, 0x7d, 0x3d, 0xbd,
+	0xcf, 0x1c, 0x97, 0x50, 0x86, 0xdd, 0x41, 0x88, 0x2d, 0x4f, 0xd2, 0x91, 0x4a, 0xd5, 0xb1, 0x14,
+	0xb6, 0x32, 0xa5, 0x8b, 0x29, 0x89, 0xec, 0xb0, 0x7c, 0x27, 0xc4, 0xbe, 0xce, 0x88, 0x67, 0x93,
+	0xc0, 0x75, 0x3c, 0xb6, 0xc5, 0x46, 0x03, 0x42, 0xe5, 0x5f, 0xb9, 0x6b, 0xfc, 0x54, 0x83, 0x95,
+	0x7d, 0x87, 0x32, 0x3f, 0x70, 0x2c, 0xdc, 0x6f, 0x7b, 0x27, 0x3e, 0x7a, 0x03, 0xf2, 0xa7, 0x04,
+	0xdb, 0x24, 0xa8, 0x68, 0x75, 0x6d, 0xb3, 0xb4, 0x5d, 0x69, 0xc4, 0x08, 0x0d, 0x29, 0xbb, 0x2f,
+	0xf6, 0x9b, 0xb9, 0x8f, 0xc7, 0x7a, 0xc6, 0x54, 0xdc, 0xe8, 0x1b, 0x90, 0xbf, 0x8b, 0xfb, 0x94,
+	0xb0, 0xca, 0x42, 0x3d, 0xbb, 0x59, 0xda, 0x7e, 0xa9, 0x71, 0xb9, 0xfb, 0x1a, 0xc7, 0xb8, 0xef,
+	0xd8, 0x98, 0xf9, 0x11, 0x80, 0x14, 0x33, 0x7e, 0xb5, 0x00, 0xe5, 0x5d, 0xdf, 0x75, 0x1d, 0x4a,
+	0x1d, 0xdf, 0x33, 0x31, 0x23, 0x14, 0x35, 0x21, 0x17, 0x60, 0x46, 0xc4, 0x51, 0x8a, 0xcd, 0x06,
+	0xe7, 0xff, 0xf3, 0x58, 0x7f, 0xa5, 0xe7, 0xb0, 0xd3, 0x61, 0xb7, 0x61, 0xf9, 0xae, 0x72, 0x86,
+	0xfa, 0xf7, 0x1a, 0xb5, 0xcf, 0x94, 0x7d, 0x2d, 0x62, 0x99, 0x42, 0x16, 0xbd, 0x0d, 0x05, 0x17,
+	0x9f, 0x77, 0x04, 0xce, 0x82, 0xc0, 0xb9, 0x39, 0x1f, 0xce, 0x64, 0xac, 0x97, 0x47, 0xd8, 0xed,
+	0xef, 0x18, 0x21, 0x8e, 0x61, 0x2e, 0xba, 0xf8, 0x9c, 0x1f, 0x11, 0x0d, 0xa0, 0xcc, 0xa9, 0xd6,
+	0x29, 0xf6, 0x7a, 0x44, 0x2a, 0xc9, 0x0a, 0x25, 0xfb, 0x73, 0x2b, 0xb9, 0x16, 0x2b, 0x49, 0xc0,
+	0x19, 0xe6, 0xb2, 0x8b, 0xcf, 0x77, 0x05, 0x81, 0x6b, 0xdc, 0x29, 0x7c, 0xf0, 0x40, 0xcf, 0xfc,
+	0xfd, 0x81, 0xae, 0x19, 0x7f, 0xd4, 0x00, 0x62, 0x8f, 0xa1, 0xb7, 0x61, 0xd5, 0x8a, 0x56, 0x42,
+	0x96, 0xaa, 0x18, 0x7e, 0x71, 0x56, 0x2c, 0x52, 0xfe, 0x6e, 0x16, 0xf8, 0xa1, 0x1f, 0x8e, 0x75,
+	0xcd, 0x2c, 0x5b, 0xa9, 0x50, 0xfc, 0x00, 0x4a, 0xc3, 0x81, 0x8d, 0x19, 0xe9, 0xf0, 0xec, 0x14,
+	0x9e, 0x2c, 0x6d, 0x57, 0x1b, 0x32, 0x75, 0x1b, 0x61, 0xea, 0x36, 0x8e, 0xc2, 0xd4, 0x6d, 0xd6,
+	0x38, 0xd6, 0x64, 0xac, 0x23, 0x69, 0x56, 0x42, 0xd8, 0x78, 0xff, 0xaf, 0xba, 0x66, 0x82, 0xa4,
+	0x70, 0x81, 0x84, 0x4d, 0xbf, 0xd3, 0xa0, 0xd4, 0x22, 0xd4, 0x0a, 0x9c, 0x01, 0xaf, 0x10, 0x54,
+	0x81, 0x45, 0xd7, 0xf7, 0x9c, 0x33, 0x95, 0x8f, 0x45, 0x33, 0x5c, 0xa2, 0x2a, 0x14, 0x1c, 0x9b,
+	0x78, 0xcc, 0x61, 0x23, 0x19, 0x57, 0x33, 0x5a, 0x73, 0xa9, 0x77, 0x48, 0x97, 0x3a, 0x61, 0x34,
+	0xcc, 0x70, 0x89, 0x6e, 0xc1, 0x2a, 0x25, 0xd6, 0x30, 0x70, 0xd8, 0xa8, 0x63, 0xf9, 0x1e, 0xc3,
+	0x16, 0xab, 0xe4, 0x44, 0xc0, 0x3e, 0x37, 0x19, 0xeb, 0x2f, 0xca, 0xb3, 0xa6, 0x39, 0x0c, 0xb3,
+	0x1c, 0x92, 0x76, 0x25, 0x85, 0x6b, 0xb0, 0x09, 0xc3, 0x4e, 0x9f, 0x56, 0x5e, 0x90, 0x1a, 0xd4,
+	0x32, 0x61, 0xcb, 0x47, 0x8b, 0x50, 0x8c, 0xb2, 0x9d, 0x6b, 0xf6, 0x07, 0x24, 0xe0, 0xbf, 0x3b,
+	0xd8, 0xb6, 0x03, 0x42, 0xa9, 0xca, 0xeb, 0x84, 0xe6, 0x34, 0x87, 0x61, 0x96, 0x43, 0xd2, 0x4d,
+	0x49, 0x41, 0x8c, 0x87, 0xd9, 0xa3, 0xc4, 0xa3, 0x43, 0xda, 0x19, 0x0c, 0xbb, 0x67, 0x64, 0xa4,
+	0xa2, 0xb1, 0x3e, 0x15, 0x8d, 0x9b, 0xde, 0xa8, 0xf9, 0x7a, 0x8c, 0x9e, 0x96, 0x33, 0x7e, 0xff,
+	0xeb, 0xd7, 0xd6, 0x55, 0x6a, 0x58, 0xc1, 0x68, 0xc0, 0xfc, 0xc6, 0xc1, 0xb0, 0xfb, 0x26, 0x19,
+	0xf1, 0xf0, 0x2b, 0xd6, 0x03, 0xc1, 0x89, 0xae, 0x41, 0xfe, 0x47, 0xd8, 0xe9, 0x13, 0x5b, 0x38,
+	0xb4, 0x60, 0xaa, 0x15, 0xda, 0x81, 0x3c, 0x65, 0x98, 0x0d, 0xa9, 0xf0, 0xe2, 0xca, 0xb6, 0x31,
+	0x2b, 0xd5, 0x9a, 0xbe, 0x67, 0x1f, 0x0a, 0x4e, 0x53, 0x49, 0xa0, 0x5b, 0x90, 0x67, 0xfe, 0x19,
+	0xf1, 0x94, 0x0b, 0xe7, 0xaa, 0xef, 0xb6, 0xc7, 0x4c, 0x25, 0xcd, 0x3d, 0x62, 0x93, 0x3e, 0xe9,
+	0x09, 0xc7, 0xd1, 0x53, 0x1c, 0x10, 0x5a, 0xc9, 0x0b, 0xc4, 0xf6, 0xdc, 0x45, 0xa8, 0x3c, 0x95,
+	0xc6, 0x33, 0xcc, 0x72, 0x44, 0x3a, 0x14, 0x14, 0xf4, 0x26, 0x94, 0xec, 0x38, 0x51, 0x2b, 0x8b,
+	0x22, 0x04, 0x5f, 0x98, 0x65, 0x7e, 0x22, 0xa7, 0x55, 0xdf, 0x4b, 0x4a, 0xf3, 0xe4, 0x18, 0x7a,
+	0x5d, 0xdf, 0xb3, 0x1d, 0xaf, 0xd7, 0x39, 0x25, 0x4e, 0xef, 0x94, 0x55, 0x0a, 0x75, 0x6d, 0x33,
+	0x9b, 0x4c, 0x8e, 0x34, 0x87, 0x61, 0x96, 0x23, 0xd2, 0xbe, 0xa0, 0x20, 0x1b, 0x56, 0x62, 0x2e,
+	0x51, 0xa8, 0xc5, 0xa7, 0x16, 0xea, 0x4b, 0xaa, 0x50, 0xaf, 0xa6, 0xb5, 0xc4, 0xb5, 0xba, 0x1c,
+	0x11, 0xb9, 0x18, 0xda, 0x07, 0x88, 0xdb, 0x43, 0x05, 0x84, 0x06, 0xe3, 0xe9, 0x3d, 0x46, 0x19,
+	0x9e, 0x90, 0x45, 0xef, 0xc2, 0x15, 0xd7, 0xf1, 0x3a, 0x94, 0xf4, 0x4f, 0x3a, 0xca, 0xc1, 0x1c,
+	0xb2, 0x24, 0xa2, 0xf7, 0xd6, 0x7c, 0xf9, 0x30, 0x19, 0xeb, 0x55, 0xd5, 0x42, 0xa7, 0x21, 0x0d,
+	0x73, 0xcd, 0x75, 0xbc, 0x43, 0xd2, 0x3f, 0x69, 0x45, 0xb4, 0x9d, 0xa5, 0xf7, 0x1e, 0xe8, 0x19,
+	0x55, 0xae, 0x19, 0xe3, 0x0d, 0x58, 0x3a, 0xc6, 0x7d, 0x55, 0x66, 0x84, 0xa2, 0xeb, 0x50, 0xc4,
+	0xe1, 0xa2, 0xa2, 0xd5, 0xb3, 0x9b, 0x45, 0x33, 0x26, 0xc8, 0x32, 0xff, 0xc9, 0x5f, 0xea, 0x9a,
+	0xf1, 0x91, 0x06, 0xf9, 0xd6, 0xf1, 0x01, 0x76, 0x02, 0xd4, 0x86, 0xb5, 0x38, 0x73, 0x2e, 0x16,
+	0xf9, 0xf5, 0xc9, 0x58, 0xaf, 0xa4, 0x93, 0x2b, 0xaa, 0xf2, 0x38, 0x81, 0xc3, 0x32, 0x6f, 0xc3,
+	0xda, 0xdd, 0xb0, 0x77, 0x44, 0x50, 0x0b, 0x69, 0xa8, 0x29, 0x16, 0xc3, 0x5c, 0x8d, 0x68, 0x0a,
+	0x2a, 0x65, 0xe6, 0x1e, 0x2c, 0xca, 0xd3, 0x52, 0xb4, 0x03, 0x2f, 0x0c, 0xf8, 0x0f, 0x61, 0x5d,
+	0x69, 0xbb, 0x36, 0x33, 0x79, 0x05, 0xbf, 0x0a, 0x9f, 0x14, 0x31, 0x7e, 0xb9, 0x00, 0xd0, 0x3a,
+	0x3e, 0x3e, 0x0a, 0x9c, 0x41, 0x9f, 0xb0, 0x4f, 0xd2, 0xf2, 0x23, 0xb8, 0x1a, 0x9b, 0x45, 0x03,
+	0x2b, 0x65, 0x7d, 0x7d, 0x32, 0xd6, 0xaf, 0xa7, 0xad, 0x4f, 0xb0, 0x19, 0xe6, 0x95, 0x88, 0x7e,
+	0x18, 0x58, 0x97, 0xa2, 0xda, 0x94, 0x45, 0xa8, 0xd9, 0xd9, 0xa8, 0x09, 0xb6, 0x24, 0x6a, 0x8b,
+	0xb2, 0xcb, 0x5d, 0x7b, 0x08, 0xa5, 0xd8, 0x25, 0x14, 0xb5, 0xa0, 0xc0, 0xd4, 0x6f, 0xe5, 0x61,
+	0x63, 0xb6, 0x87, 0x43, 0x31, 0xe5, 0xe5, 0x48, 0xd2, 0xf8, 0xb7, 0x06, 0x10, 0xe7, 0xec, 0xa7,
+	0x33, 0xc5, 0x78, 0x2b, 0x57, 0x8d, 0x37, 0xfb, 0x5c, 0xa3, 0x9a, 0x92, 0x4e, 0xf9, 0xf3, 0x67,
+	0x0b, 0x70, 0xe5, 0x4e, 0xd8, 0x79, 0x3e, 0xf5, 0x3e, 0x38, 0x80, 0x45, 0xe2, 0xb1, 0xc0, 0x11,
+	0x4e, 0xe0, 0xd1, 0xfe, 0xca, 0xac, 0x68, 0x5f, 0x62, 0xd3, 0x9e, 0xc7, 0x82, 0x91, 0x8a, 0x7d,
+	0x08, 0x93, 0xf2, 0xc6, 0x2f, 0xb2, 0x50, 0x99, 0x25, 0x89, 0x76, 0xa1, 0x6c, 0x05, 0x44, 0x10,
+	0xc2, 0xfb, 0x43, 0x13, 0xf7, 0x47, 0x35, 0x9e, 0x2c, 0x53, 0x0c, 0x86, 0xb9, 0x12, 0x52, 0xd4,
+	0xed, 0xd1, 0x03, 0x3e, 0xf6, 0xf1, 0xb4, 0xe3, 0x5c, 0xcf, 0x38, 0xe7, 0x19, 0xea, 0xfa, 0x08,
+	0x95, 0x5c, 0x04, 0x90, 0xf7, 0xc7, 0x4a, 0x4c, 0x15, 0x17, 0xc8, 0x8f, 0xa1, 0xec, 0x78, 0x0e,
+	0x73, 0x70, 0xbf, 0xd3, 0xc5, 0x7d, 0xec, 0x59, 0xcf, 0x33, 0x35, 0xcb, 0x96, 0xaf, 0xd4, 0xa6,
+	0xe0, 0x0c, 0x73, 0x45, 0x51, 0x9a, 0x92, 0x80, 0xf6, 0x61, 0x31, 0x54, 0x95, 0x7b, 0xae, 0x69,
+	0x23, 0x14, 0x4f, 0x0c, 0x78, 0x3f, 0xcf, 0xc2, 0x9a, 0x49, 0xec, 0xcf, 0x42, 0x31, 0x5f, 0x28,
+	0xbe, 0x0d, 0x20, 0xcb, 0x9d, 0x37, 0xd8, 0xe7, 0x88, 0x06, 0x6f, 0x18, 0x45, 0x89, 0xd0, 0xa2,
+	0x2c, 0x11, 0x8f, 0xf1, 0x02, 0x2c, 0x25, 0xe3, 0xf1, 0x7f, 0x7a, 0x2b, 0xa1, 0x76, 0xdc, 0x89,
+	0x72, 0xa2, 0x13, 0x7d, 0x69, 0x56, 0x27, 0x9a, 0xca, 0xde, 0x27, 0xb7, 0xa0, 0x7f, 0x64, 0x21,
+	0x7f, 0x80, 0x03, 0xec, 0x52, 0x64, 0x4d, 0x4d, 0x9a, 0xf2, 0xad, 0xb9, 0x31, 0x95, 0x9f, 0x2d,
+	0xf5, 0xb5, 0xe3, 0x29, 0x83, 0xe6, 0x07, 0x97, 0x0c, 0x9a, 0xdf, 0x84, 0x15, 0xfe, 0x1c, 0x8e,
+	0x6c, 0x94, 0xde, 0x5e, 0x6e, 0x6e, 0xc4, 0x28, 0x17, 0xf7, 0xe5, 0x6b, 0x39, 0x7a, 0x74, 0x51,
+	0xf4, 0x35, 0x28, 0x71, 0x8e, 0xb8, 0x31, 0x73, 0xf1, 0x6b, 0xf1, 0xb3, 0x34, 0xb1, 0x69, 0x98,
+	0xe0, 0xe2, 0xf3, 0x3d, 0xb9, 0x40, 0x6f, 0x01, 0x3a, 0x8d, 0xbe, 0x8c, 0x74, 0x62, 0x77, 0x72,
+	0xf9, 0xcf, 0x4f, 0xc6, 0xfa, 0x86, 0x94, 0x9f, 0xe6, 0x31, 0xcc, 0xb5, 0x98, 0x18, 0xa2, 0x7d,
+	0x15, 0x80, 0xdb, 0xd5, 0xb1, 0x89, 0xe7, 0xbb, 0xea, 0xb9, 0x73, 0x75, 0x32, 0xd6, 0xd7, 0x24,
+	0x4a, 0xbc, 0x67, 0x98, 0x45, 0xbe, 0x68, 0xf1, 0xdf, 0xbc, 0x36, 0x07, 0xfe, 0x3b, 0x24, 0xe8,
+	0x04, 0xc4, 0x1e, 0x5a, 0x62, 0x32, 0xce, 0xff, 0x6f, 0xb5, 0x99, 0x82, 0x33, 0xcc, 0x15, 0x41,
+	0x31, 0x43, 0x42, 0xa2, 0x98, 0x3e, 0xd4, 0x00, 0xc5, 0xb7, 0x8c, 0x49, 0xe8, 0x80, 0x3f, 0x09,
+	0xf9, 0xec, 0x9f, 0x18, 0xd4, 0xb5, 0x27, 0xcf, 0xfe, 0xb1, 0x7c, 0x38, 0xfb, 0x27, 0x8a, 0xf3,
+	0xeb, 0x71, 0x47, 0x5e, 0x50, 0xa9, 0xa3, 0x60, 0xba, 0x98, 0x92, 0xc4, 0xfb, 0xc1, 0x09, 0xa5,
+	0xa7, 0x5a, 0x70, 0xc6, 0xf8, 0x83, 0x06, 0x1b, 0x53, 0x49, 0x1c, 0x1d, 0xf6, 0x87, 0x80, 0x82,
+	0xc4, 0xa6, 0x08, 0xd1, 0x48, 0x1d, 0x7a, 0xee, 0x9a, 0x58, 0x0b, 0xa6, 0x5a, 0xfd, 0x27, 0x77,
+	0xa9, 0xe4, 0x84, 0xcf, 0x7f, 0xab, 0xc1, 0x7a, 0x52, 0x7d, 0x64, 0xc8, 0x6d, 0x58, 0x4a, 0x6a,
+	0x57, 0x26, 0xbc, 0xfc, 0x2c, 0x26, 0xa8, 0xd3, 0x5f, 0x90, 0x47, 0xdf, 0x8d, 0x3b, 0x84, 0xfc,
+	0x5c, 0x77, 0xe3, 0x99, 0xbd, 0x11, 0x9e, 0x29, 0xdd, 0x29, 0x72, 0x22, 0x1e, 0xff, 0xd1, 0x20,
+	0x77, 0xe0, 0xfb, 0x7d, 0xe4, 0xc3, 0x9a, 0xe7, 0xb3, 0x0e, 0x4f, 0x66, 0x62, 0x77, 0xd4, 0x3b,
+	0x5f, 0xb6, 0xde, 0xdd, 0xf9, 0x9c, 0xf4, 0xcf, 0xb1, 0x3e, 0x0d, 0x65, 0x96, 0x3d, 0x9f, 0x35,
+	0x05, 0xe5, 0x48, 0x7e, 0x05, 0x78, 0x17, 0x96, 0x2f, 0x2a, 0x93, 0x8d, 0xf9, 0x7b, 0x73, 0x2b,
+	0xbb, 0x08, 0x33, 0x19, 0xeb, 0xeb, 0x71, 0x91, 0x46, 0x64, 0xc3, 0x5c, 0xea, 0x26, 0xb4, 0xef,
+	0x14, 0x78, 0xfc, 0xfe, 0xf5, 0x40, 0xd7, 0xbe, 0xfc, 0x1b, 0x0d, 0x20, 0xfe, 0xd8, 0x81, 0x5e,
+	0x85, 0x17, 0x9b, 0xdf, 0xb9, 0xdd, 0xea, 0x1c, 0x1e, 0xdd, 0x3c, 0xba, 0x73, 0xd8, 0xb9, 0x73,
+	0xfb, 0xf0, 0x60, 0x6f, 0xb7, 0x7d, 0xab, 0xbd, 0xd7, 0x5a, 0xcd, 0x54, 0xcb, 0xf7, 0xee, 0xd7,
+	0x4b, 0x77, 0x3c, 0x3a, 0x20, 0x96, 0x73, 0xe2, 0x10, 0x1b, 0xbd, 0x02, 0xeb, 0x17, 0xb9, 0xf9,
+	0x6a, 0xaf, 0xb5, 0xaa, 0x55, 0x97, 0xee, 0xdd, 0xaf, 0x17, 0xe4, 0xf8, 0x47, 0x6c, 0xb4, 0x09,
+	0x57, 0xa7, 0xf9, 0xda, 0xb7, 0xbf, 0xb5, 0xba, 0x50, 0x5d, 0xbe, 0x77, 0xbf, 0x5e, 0x8c, 0xe6,
+	0x44, 0x64, 0x00, 0x4a, 0x72, 0x2a, 0xbc, 0x6c, 0x15, 0xee, 0xdd, 0xaf, 0xe7, 0xa5, 0x03, 0xab,
+	0xb9, 0xf7, 0x3e, 0xac, 0x65, 0x9a, 0xb7, 0x3e, 0x7e, 0x54, 0xd3, 0x1e, 0x3e, 0xaa, 0x69, 0x7f,
+	0x7b, 0x54, 0xd3, 0xde, 0x7f, 0x5c, 0xcb, 0x3c, 0x7c, 0x5c, 0xcb, 0xfc, 0xe9, 0x71, 0x2d, 0xf3,
+	0xfd, 0x57, 0x9f, 0xe8, 0xbb, 0xf3, 0xe8, 0x3b, 0xba, 0xf0, 0x62, 0x37, 0x2f, 0x3a, 0xff, 0xeb,
+	0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x90, 0x8f, 0x24, 0x66, 0x17, 0x00, 0x00,
 }
 
 func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
@@ -1216,608 +1218,609 @@ 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{
-		// 9603 bytes of a gzipped FileDescriptorSet
-		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x24, 0xd7,
-		0x71, 0xd8, 0xcd, 0xee, 0x02, 0xd8, 0x6d, 0x2c, 0x80, 0xc5, 0x03, 0xee, 0x6e, 0x6f, 0x79, 0x04,
-		0xc0, 0xe1, 0xd7, 0xf1, 0x48, 0x02, 0xe4, 0x91, 0x77, 0x24, 0xf7, 0x24, 0xd2, 0x58, 0x60, 0x0f,
-		0x07, 0x1e, 0xbe, 0x38, 0x00, 0x8e, 0xd4, 0x87, 0xb3, 0x35, 0x98, 0x7d, 0x58, 0x0c, 0xb1, 0x3b,
-		0x33, 0x9c, 0x99, 0xbd, 0x3b, 0x50, 0x52, 0x15, 0x2d, 0x29, 0x8a, 0x44, 0xc7, 0x91, 0x14, 0xb9,
-		0x1c, 0x89, 0xd6, 0x29, 0x92, 0xe5, 0x44, 0x8e, 0xac, 0xc4, 0x1f, 0x52, 0x94, 0x38, 0x49, 0x55,
-		0xa4, 0x24, 0x8e, 0x25, 0xa5, 0xe2, 0x92, 0x2a, 0xae, 0xc4, 0x71, 0x25, 0x67, 0x87, 0x52, 0x39,
-		0x8c, 0xa2, 0xc4, 0xf2, 0x59, 0x4e, 0x9c, 0x52, 0xa5, 0x92, 0x7a, 0x5f, 0xf3, 0xb5, 0x1f, 0xb3,
-		0x0b, 0xdd, 0x49, 0x72, 0x9c, 0x5f, 0xd8, 0xd7, 0xaf, 0xbb, 0x5f, 0xbf, 0x7e, 0xfd, 0xba, 0xfb,
-		0x7d, 0x0d, 0xe0, 0x9f, 0x9f, 0x87, 0x99, 0x9a, 0x69, 0xd6, 0xea, 0x78, 0xce, 0xb2, 0x4d, 0xd7,
-		0xdc, 0x69, 0xee, 0xce, 0x55, 0xb1, 0xa3, 0xd9, 0xba, 0xe5, 0x9a, 0xf6, 0x2c, 0x85, 0xa1, 0x31,
-		0x86, 0x31, 0x2b, 0x30, 0xe4, 0x55, 0x18, 0xbf, 0xa0, 0xd7, 0xf1, 0xa2, 0x87, 0xb8, 0x89, 0x5d,
-		0xf4, 0x24, 0xa4, 0x76, 0xf5, 0x3a, 0xce, 0x4b, 0x33, 0xc9, 0x53, 0xc3, 0x67, 0xee, 0x99, 0x8d,
-		0x10, 0xcd, 0x86, 0x29, 0x36, 0x08, 0x58, 0xa1, 0x14, 0xf2, 0xb7, 0x52, 0x30, 0xd1, 0xa6, 0x16,
-		0x21, 0x48, 0x19, 0x6a, 0x83, 0x70, 0x94, 0x4e, 0x65, 0x14, 0xfa, 0x1b, 0xe5, 0x61, 0xc8, 0x52,
-		0xb5, 0x7d, 0xb5, 0x86, 0xf3, 0x09, 0x0a, 0x16, 0x45, 0x34, 0x05, 0x50, 0xc5, 0x16, 0x36, 0xaa,
-		0xd8, 0xd0, 0x0e, 0xf2, 0xc9, 0x99, 0xe4, 0xa9, 0x8c, 0x12, 0x80, 0xa0, 0x07, 0x61, 0xdc, 0x6a,
-		0xee, 0xd4, 0x75, 0xad, 0x12, 0x40, 0x83, 0x99, 0xe4, 0xa9, 0x01, 0x25, 0xc7, 0x2a, 0x16, 0x7d,
-		0xe4, 0xfb, 0x61, 0xec, 0x2a, 0x56, 0xf7, 0x83, 0xa8, 0xc3, 0x14, 0x75, 0x94, 0x80, 0x03, 0x88,
-		0x0b, 0x90, 0x6d, 0x60, 0xc7, 0x51, 0x6b, 0xb8, 0xe2, 0x1e, 0x58, 0x38, 0x9f, 0xa2, 0xbd, 0x9f,
-		0x69, 0xe9, 0x7d, 0xb4, 0xe7, 0xc3, 0x9c, 0x6a, 0xeb, 0xc0, 0xc2, 0x68, 0x1e, 0x32, 0xd8, 0x68,
-		0x36, 0x18, 0x87, 0x81, 0x0e, 0xfa, 0x2b, 0x1b, 0xcd, 0x46, 0x94, 0x4b, 0x9a, 0x90, 0x71, 0x16,
-		0x43, 0x0e, 0xb6, 0xaf, 0xe8, 0x1a, 0xce, 0x0f, 0x52, 0x06, 0xf7, 0xb7, 0x30, 0xd8, 0x64, 0xf5,
-		0x51, 0x1e, 0x82, 0x0e, 0x2d, 0x40, 0x06, 0x5f, 0x73, 0xb1, 0xe1, 0xe8, 0xa6, 0x91, 0x1f, 0xa2,
-		0x4c, 0xee, 0x6d, 0x33, 0x8a, 0xb8, 0x5e, 0x8d, 0xb2, 0xf0, 0xe9, 0xd0, 0x39, 0x18, 0x32, 0x2d,
-		0x57, 0x37, 0x0d, 0x27, 0x9f, 0x9e, 0x91, 0x4e, 0x0d, 0x9f, 0x39, 0xd9, 0xd6, 0x10, 0xd6, 0x19,
-		0x8e, 0x22, 0x90, 0xd1, 0x32, 0xe4, 0x1c, 0xb3, 0x69, 0x6b, 0xb8, 0xa2, 0x99, 0x55, 0x5c, 0xd1,
-		0x8d, 0x5d, 0x33, 0x9f, 0xa1, 0x0c, 0xa6, 0x5b, 0x3b, 0x42, 0x11, 0x17, 0xcc, 0x2a, 0x5e, 0x36,
-		0x76, 0x4d, 0x65, 0xd4, 0x09, 0x95, 0xd1, 0x31, 0x18, 0x74, 0x0e, 0x0c, 0x57, 0xbd, 0x96, 0xcf,
-		0x52, 0x0b, 0xe1, 0x25, 0xf9, 0x37, 0x06, 0x61, 0xac, 0x17, 0x13, 0x3b, 0x0f, 0x03, 0xbb, 0xa4,
-		0x97, 0xf9, 0x44, 0x3f, 0x3a, 0x60, 0x34, 0x61, 0x25, 0x0e, 0x1e, 0x52, 0x89, 0xf3, 0x30, 0x6c,
-		0x60, 0xc7, 0xc5, 0x55, 0x66, 0x11, 0xc9, 0x1e, 0x6d, 0x0a, 0x18, 0x51, 0xab, 0x49, 0xa5, 0x0e,
-		0x65, 0x52, 0x2f, 0xc0, 0x98, 0x27, 0x52, 0xc5, 0x56, 0x8d, 0x9a, 0xb0, 0xcd, 0xb9, 0x38, 0x49,
-		0x66, 0xcb, 0x82, 0x4e, 0x21, 0x64, 0xca, 0x28, 0x0e, 0x95, 0xd1, 0x22, 0x80, 0x69, 0x60, 0x73,
-		0xb7, 0x52, 0xc5, 0x5a, 0x3d, 0x9f, 0xee, 0xa0, 0xa5, 0x75, 0x82, 0xd2, 0xa2, 0x25, 0x93, 0x41,
-		0xb5, 0x3a, 0x7a, 0xca, 0x37, 0xb5, 0xa1, 0x0e, 0x96, 0xb2, 0xca, 0x26, 0x59, 0x8b, 0xb5, 0x6d,
-		0xc3, 0xa8, 0x8d, 0x89, 0xdd, 0xe3, 0x2a, 0xef, 0x59, 0x86, 0x0a, 0x31, 0x1b, 0xdb, 0x33, 0x85,
-		0x93, 0xb1, 0x8e, 0x8d, 0xd8, 0xc1, 0x22, 0xba, 0x1b, 0x3c, 0x40, 0x85, 0x9a, 0x15, 0x50, 0x2f,
-		0x94, 0x15, 0xc0, 0x35, 0xb5, 0x81, 0x0b, 0x2f, 0xc3, 0x68, 0x58, 0x3d, 0x68, 0x12, 0x06, 0x1c,
-		0x57, 0xb5, 0x5d, 0x6a, 0x85, 0x03, 0x0a, 0x2b, 0xa0, 0x1c, 0x24, 0xb1, 0x51, 0xa5, 0x5e, 0x6e,
-		0x40, 0x21, 0x3f, 0xd1, 0x4f, 0xf8, 0x1d, 0x4e, 0xd2, 0x0e, 0xdf, 0xd7, 0x3a, 0xa2, 0x21, 0xce,
-		0xd1, 0x7e, 0x17, 0x9e, 0x80, 0x91, 0x50, 0x07, 0x7a, 0x6d, 0x5a, 0x7e, 0x27, 0x1c, 0x6d, 0xcb,
-		0x1a, 0xbd, 0x00, 0x93, 0x4d, 0x43, 0x37, 0x5c, 0x6c, 0x5b, 0x36, 0x26, 0x16, 0xcb, 0x9a, 0xca,
-		0xff, 0xe7, 0xa1, 0x0e, 0x36, 0xb7, 0x1d, 0xc4, 0x66, 0x5c, 0x94, 0x89, 0x66, 0x2b, 0xf0, 0x74,
-		0x26, 0xfd, 0xc6, 0x50, 0xee, 0x95, 0x57, 0x5e, 0x79, 0x25, 0x21, 0x7f, 0x79, 0x10, 0x26, 0xdb,
-		0xcd, 0x99, 0xb6, 0xd3, 0xf7, 0x18, 0x0c, 0x1a, 0xcd, 0xc6, 0x0e, 0xb6, 0xa9, 0x92, 0x06, 0x14,
-		0x5e, 0x42, 0xf3, 0x30, 0x50, 0x57, 0x77, 0x70, 0x3d, 0x9f, 0x9a, 0x91, 0x4e, 0x8d, 0x9e, 0x79,
-		0xb0, 0xa7, 0x59, 0x39, 0xbb, 0x42, 0x48, 0x14, 0x46, 0x89, 0x9e, 0x86, 0x14, 0x77, 0xd1, 0x84,
-		0xc3, 0xe9, 0xde, 0x38, 0x90, 0xb9, 0xa4, 0x50, 0x3a, 0x74, 0x07, 0x64, 0xc8, 0x5f, 0x66, 0x1b,
-		0x83, 0x54, 0xe6, 0x34, 0x01, 0x10, 0xbb, 0x40, 0x05, 0x48, 0xd3, 0x69, 0x52, 0xc5, 0x22, 0xb4,
-		0x79, 0x65, 0x62, 0x58, 0x55, 0xbc, 0xab, 0x36, 0xeb, 0x6e, 0xe5, 0x8a, 0x5a, 0x6f, 0x62, 0x6a,
-		0xf0, 0x19, 0x25, 0xcb, 0x81, 0x97, 0x09, 0x0c, 0x4d, 0xc3, 0x30, 0x9b, 0x55, 0xba, 0x51, 0xc5,
-		0xd7, 0xa8, 0xf7, 0x1c, 0x50, 0xd8, 0x44, 0x5b, 0x26, 0x10, 0xd2, 0xfc, 0x8b, 0x8e, 0x69, 0x08,
-		0xd3, 0xa4, 0x4d, 0x10, 0x00, 0x6d, 0xfe, 0x89, 0xa8, 0xe3, 0xbe, 0xb3, 0x7d, 0xf7, 0x5a, 0xe6,
-		0xd2, 0xfd, 0x30, 0x46, 0x31, 0x1e, 0xe3, 0x43, 0xaf, 0xd6, 0xf3, 0xe3, 0x33, 0xd2, 0xa9, 0xb4,
-		0x32, 0xca, 0xc0, 0xeb, 0x1c, 0x2a, 0x7f, 0x31, 0x01, 0x29, 0xea, 0x58, 0xc6, 0x60, 0x78, 0xeb,
-		0x2d, 0x1b, 0xe5, 0xca, 0xe2, 0xfa, 0x76, 0x69, 0xa5, 0x9c, 0x93, 0xd0, 0x28, 0x00, 0x05, 0x5c,
-		0x58, 0x59, 0x9f, 0xdf, 0xca, 0x25, 0xbc, 0xf2, 0xf2, 0xda, 0xd6, 0xb9, 0xc7, 0x73, 0x49, 0x8f,
-		0x60, 0x9b, 0x01, 0x52, 0x41, 0x84, 0xc7, 0xce, 0xe4, 0x06, 0x50, 0x0e, 0xb2, 0x8c, 0xc1, 0xf2,
-		0x0b, 0xe5, 0xc5, 0x73, 0x8f, 0xe7, 0x06, 0xc3, 0x90, 0xc7, 0xce, 0xe4, 0x86, 0xd0, 0x08, 0x64,
-		0x28, 0xa4, 0xb4, 0xbe, 0xbe, 0x92, 0x4b, 0x7b, 0x3c, 0x37, 0xb7, 0x94, 0xe5, 0xb5, 0xa5, 0x5c,
-		0xc6, 0xe3, 0xb9, 0xa4, 0xac, 0x6f, 0x6f, 0xe4, 0xc0, 0xe3, 0xb0, 0x5a, 0xde, 0xdc, 0x9c, 0x5f,
-		0x2a, 0xe7, 0x86, 0x3d, 0x8c, 0xd2, 0x5b, 0xb6, 0xca, 0x9b, 0xb9, 0x6c, 0x48, 0xac, 0xc7, 0xce,
-		0xe4, 0x46, 0xbc, 0x26, 0xca, 0x6b, 0xdb, 0xab, 0xb9, 0x51, 0x34, 0x0e, 0x23, 0xac, 0x09, 0x21,
-		0xc4, 0x58, 0x04, 0x74, 0xee, 0xf1, 0x5c, 0xce, 0x17, 0x84, 0x71, 0x19, 0x0f, 0x01, 0xce, 0x3d,
-		0x9e, 0x43, 0xf2, 0x02, 0x0c, 0x50, 0x33, 0x44, 0x08, 0x46, 0x57, 0xe6, 0x4b, 0xe5, 0x95, 0xca,
-		0xfa, 0xc6, 0xd6, 0xf2, 0xfa, 0xda, 0xfc, 0x4a, 0x4e, 0xf2, 0x61, 0x4a, 0xf9, 0xb9, 0xed, 0x65,
-		0xa5, 0xbc, 0x98, 0x4b, 0x04, 0x61, 0x1b, 0xe5, 0xf9, 0xad, 0xf2, 0x62, 0x2e, 0x29, 0x6b, 0x30,
-		0xd9, 0xce, 0xa1, 0xb6, 0x9d, 0x42, 0x01, 0x5b, 0x48, 0x74, 0xb0, 0x05, 0xca, 0x2b, 0x6a, 0x0b,
-		0xf2, 0x37, 0x13, 0x30, 0xd1, 0x26, 0xa8, 0xb4, 0x6d, 0xe4, 0x19, 0x18, 0x60, 0xb6, 0xcc, 0xc2,
-		0xec, 0x03, 0x6d, 0xa3, 0x13, 0xb5, 0xec, 0x96, 0x50, 0x4b, 0xe9, 0x82, 0xa9, 0x46, 0xb2, 0x43,
-		0xaa, 0x41, 0x58, 0xb4, 0x18, 0xec, 0x4f, 0xb6, 0x38, 0x7f, 0x16, 0x1f, 0xcf, 0xf5, 0x12, 0x1f,
-		0x29, 0xac, 0xbf, 0x20, 0x30, 0xd0, 0x26, 0x08, 0x9c, 0x87, 0xf1, 0x16, 0x46, 0x3d, 0x3b, 0xe3,
-		0xf7, 0x48, 0x90, 0xef, 0xa4, 0x9c, 0x18, 0x97, 0x98, 0x08, 0xb9, 0xc4, 0xf3, 0x51, 0x0d, 0xde,
-		0xd5, 0x79, 0x10, 0x5a, 0xc6, 0xfa, 0x33, 0x12, 0x1c, 0x6b, 0x9f, 0x52, 0xb6, 0x95, 0xe1, 0x69,
-		0x18, 0x6c, 0x60, 0x77, 0xcf, 0x14, 0x69, 0xd5, 0x7d, 0x6d, 0x82, 0x35, 0xa9, 0x8e, 0x0e, 0x36,
-		0xa7, 0x0a, 0x46, 0xfb, 0x64, 0xa7, 0xbc, 0x90, 0x49, 0xd3, 0x22, 0xe9, 0x07, 0x12, 0x70, 0xb4,
-		0x2d, 0xf3, 0xb6, 0x82, 0xde, 0x09, 0xa0, 0x1b, 0x56, 0xd3, 0x65, 0xa9, 0x13, 0xf3, 0xc4, 0x19,
-		0x0a, 0xa1, 0xce, 0x8b, 0x78, 0xd9, 0xa6, 0xeb, 0xd5, 0x27, 0x69, 0x3d, 0x30, 0x10, 0x45, 0x78,
-		0xd2, 0x17, 0x34, 0x45, 0x05, 0x9d, 0xea, 0xd0, 0xd3, 0x16, 0xc3, 0x7c, 0x04, 0x72, 0x5a, 0x5d,
-		0xc7, 0x86, 0x5b, 0x71, 0x5c, 0x1b, 0xab, 0x0d, 0xdd, 0xa8, 0xd1, 0x50, 0x93, 0x2e, 0x0e, 0xec,
-		0xaa, 0x75, 0x07, 0x2b, 0x63, 0xac, 0x7a, 0x53, 0xd4, 0x12, 0x0a, 0x6a, 0x40, 0x76, 0x80, 0x62,
-		0x30, 0x44, 0xc1, 0xaa, 0x3d, 0x0a, 0xf9, 0xc3, 0x19, 0x18, 0x0e, 0x24, 0xe0, 0xe8, 0x2e, 0xc8,
-		0xbe, 0xa8, 0x5e, 0x51, 0x2b, 0x62, 0x51, 0xc5, 0x34, 0x31, 0x4c, 0x60, 0x1b, 0x7c, 0x61, 0xf5,
-		0x08, 0x4c, 0x52, 0x14, 0xb3, 0xe9, 0x62, 0xbb, 0xa2, 0xd5, 0x55, 0xc7, 0xa1, 0x4a, 0x4b, 0x53,
-		0x54, 0x44, 0xea, 0xd6, 0x49, 0xd5, 0x82, 0xa8, 0x41, 0x67, 0x61, 0x82, 0x52, 0x34, 0x9a, 0x75,
-		0x57, 0xb7, 0xea, 0xb8, 0x42, 0x96, 0x79, 0x0e, 0x0d, 0x39, 0x9e, 0x64, 0xe3, 0x04, 0x63, 0x95,
-		0x23, 0x10, 0x89, 0x1c, 0xb4, 0x08, 0x77, 0x52, 0xb2, 0x1a, 0x36, 0xb0, 0xad, 0xba, 0xb8, 0x82,
-		0x5f, 0x6a, 0xaa, 0x75, 0xa7, 0xa2, 0x1a, 0xd5, 0xca, 0x9e, 0xea, 0xec, 0xe5, 0x27, 0x09, 0x83,
-		0x52, 0x22, 0x2f, 0x29, 0x27, 0x08, 0xe2, 0x12, 0xc7, 0x2b, 0x53, 0xb4, 0x79, 0xa3, 0x7a, 0x51,
-		0x75, 0xf6, 0x50, 0x11, 0x8e, 0x51, 0x2e, 0x8e, 0x6b, 0xeb, 0x46, 0xad, 0xa2, 0xed, 0x61, 0x6d,
-		0xbf, 0xd2, 0x74, 0x77, 0x9f, 0xcc, 0xdf, 0x11, 0x6c, 0x9f, 0x4a, 0xb8, 0x49, 0x71, 0x16, 0x08,
-		0xca, 0xb6, 0xbb, 0xfb, 0x24, 0xda, 0x84, 0x2c, 0x19, 0x8c, 0x86, 0xfe, 0x32, 0xae, 0xec, 0x9a,
-		0x36, 0x8d, 0xa1, 0xa3, 0x6d, 0x5c, 0x53, 0x40, 0x83, 0xb3, 0xeb, 0x9c, 0x60, 0xd5, 0xac, 0xe2,
-		0xe2, 0xc0, 0xe6, 0x46, 0xb9, 0xbc, 0xa8, 0x0c, 0x0b, 0x2e, 0x17, 0x4c, 0x9b, 0x18, 0x54, 0xcd,
-		0xf4, 0x14, 0x3c, 0xcc, 0x0c, 0xaa, 0x66, 0x0a, 0xf5, 0x9e, 0x85, 0x09, 0x4d, 0x63, 0x7d, 0xd6,
-		0xb5, 0x0a, 0x5f, 0x8c, 0x39, 0xf9, 0x5c, 0x48, 0x59, 0x9a, 0xb6, 0xc4, 0x10, 0xb8, 0x8d, 0x3b,
-		0xe8, 0x29, 0x38, 0xea, 0x2b, 0x2b, 0x48, 0x38, 0xde, 0xd2, 0xcb, 0x28, 0xe9, 0x59, 0x98, 0xb0,
-		0x0e, 0x5a, 0x09, 0x51, 0xa8, 0x45, 0xeb, 0x20, 0x4a, 0xf6, 0x04, 0x4c, 0x5a, 0x7b, 0x56, 0x2b,
-		0xdd, 0xe9, 0x20, 0x1d, 0xb2, 0xf6, 0xac, 0x28, 0xe1, 0xbd, 0x74, 0x65, 0x6e, 0x63, 0x4d, 0x75,
-		0x71, 0x35, 0x7f, 0x3c, 0x88, 0x1e, 0xa8, 0x40, 0xb3, 0x90, 0xd3, 0xb4, 0x0a, 0x36, 0xd4, 0x9d,
-		0x3a, 0xae, 0xa8, 0x36, 0x36, 0x54, 0x27, 0x3f, 0x4d, 0x91, 0x53, 0xae, 0xdd, 0xc4, 0xca, 0xa8,
-		0xa6, 0x95, 0x69, 0xe5, 0x3c, 0xad, 0x43, 0xa7, 0x61, 0xdc, 0xdc, 0x79, 0x51, 0x63, 0x16, 0x59,
-		0xb1, 0x6c, 0xbc, 0xab, 0x5f, 0xcb, 0xdf, 0x43, 0xd5, 0x3b, 0x46, 0x2a, 0xa8, 0x3d, 0x6e, 0x50,
-		0x30, 0x7a, 0x00, 0x72, 0x9a, 0xb3, 0xa7, 0xda, 0x16, 0x75, 0xc9, 0x8e, 0xa5, 0x6a, 0x38, 0x7f,
-		0x2f, 0x43, 0x65, 0xf0, 0x35, 0x01, 0x26, 0x33, 0xc2, 0xb9, 0xaa, 0xef, 0xba, 0x82, 0xe3, 0xfd,
-		0x6c, 0x46, 0x50, 0x18, 0xe7, 0x76, 0x0a, 0x72, 0x44, 0x13, 0xa1, 0x86, 0x4f, 0x51, 0xb4, 0x51,
-		0x6b, 0xcf, 0x0a, 0xb6, 0x7b, 0x37, 0x8c, 0x10, 0x4c, 0xbf, 0xd1, 0x07, 0x58, 0xe2, 0x66, 0xed,
-		0x05, 0x5a, 0x7c, 0x1c, 0x8e, 0x11, 0xa4, 0x06, 0x76, 0xd5, 0xaa, 0xea, 0xaa, 0x01, 0xec, 0x87,
-		0x28, 0x36, 0x51, 0xfb, 0x2a, 0xaf, 0x0c, 0xc9, 0x69, 0x37, 0x77, 0x0e, 0x3c, 0xc3, 0x7a, 0x98,
-		0xc9, 0x49, 0x60, 0xc2, 0xb4, 0x6e, 0x5b, 0x72, 0x2e, 0x17, 0x21, 0x1b, 0xb4, 0x7b, 0x94, 0x01,
-		0x66, 0xf9, 0x39, 0x89, 0x24, 0x41, 0x0b, 0xeb, 0x8b, 0x24, 0x7d, 0x79, 0x6b, 0x39, 0x97, 0x20,
-		0x69, 0xd4, 0xca, 0xf2, 0x56, 0xb9, 0xa2, 0x6c, 0xaf, 0x6d, 0x2d, 0xaf, 0x96, 0x73, 0xc9, 0x40,
-		0x62, 0xff, 0x6c, 0x2a, 0x7d, 0x5f, 0xee, 0x7e, 0xf9, 0x1b, 0x09, 0x18, 0x0d, 0xaf, 0xd4, 0xd0,
-		0x9b, 0xe0, 0xb8, 0xd8, 0x56, 0x71, 0xb0, 0x5b, 0xb9, 0xaa, 0xdb, 0x74, 0x42, 0x36, 0x54, 0x16,
-		0x1c, 0x3d, 0xfb, 0x99, 0xe4, 0x58, 0x9b, 0xd8, 0x7d, 0x5e, 0xb7, 0xc9, 0x74, 0x6b, 0xa8, 0x2e,
-		0x5a, 0x81, 0x69, 0xc3, 0xac, 0x38, 0xae, 0x6a, 0x54, 0x55, 0xbb, 0x5a, 0xf1, 0x37, 0xb4, 0x2a,
-		0xaa, 0xa6, 0x61, 0xc7, 0x31, 0x59, 0x20, 0xf4, 0xb8, 0x9c, 0x34, 0xcc, 0x4d, 0x8e, 0xec, 0x47,
-		0x88, 0x79, 0x8e, 0x1a, 0x31, 0xdf, 0x64, 0x27, 0xf3, 0xbd, 0x03, 0x32, 0x0d, 0xd5, 0xaa, 0x60,
-		0xc3, 0xb5, 0x0f, 0x68, 0x7e, 0x9e, 0x56, 0xd2, 0x0d, 0xd5, 0x2a, 0x93, 0xf2, 0x0f, 0x65, 0x99,
-		0xf4, 0x6c, 0x2a, 0x9d, 0xce, 0x65, 0x9e, 0x4d, 0xa5, 0x33, 0x39, 0x90, 0x5f, 0x4f, 0x42, 0x36,
-		0x98, 0xaf, 0x93, 0xe5, 0x8f, 0x46, 0x23, 0x96, 0x44, 0x7d, 0xda, 0xdd, 0x5d, 0xb3, 0xfb, 0xd9,
-		0x05, 0x12, 0xca, 0x8a, 0x83, 0x2c, 0x39, 0x56, 0x18, 0x25, 0x49, 0x23, 0x88, 0xb1, 0x61, 0x96,
-		0x8c, 0xa4, 0x15, 0x5e, 0x42, 0x4b, 0x30, 0xf8, 0xa2, 0x43, 0x79, 0x0f, 0x52, 0xde, 0xf7, 0x74,
-		0xe7, 0xfd, 0xec, 0x26, 0x65, 0x9e, 0x79, 0x76, 0xb3, 0xb2, 0xb6, 0xae, 0xac, 0xce, 0xaf, 0x28,
-		0x9c, 0x1c, 0x9d, 0x80, 0x54, 0x5d, 0x7d, 0xf9, 0x20, 0x1c, 0xf4, 0x28, 0xa8, 0xd7, 0x41, 0x38,
-		0x01, 0xa9, 0xab, 0x58, 0xdd, 0x0f, 0x87, 0x1a, 0x0a, 0xba, 0x8d, 0x93, 0x61, 0x0e, 0x06, 0xa8,
-		0xbe, 0x10, 0x00, 0xd7, 0x58, 0xee, 0x08, 0x4a, 0x43, 0x6a, 0x61, 0x5d, 0x21, 0x13, 0x22, 0x07,
-		0x59, 0x06, 0xad, 0x6c, 0x2c, 0x97, 0x17, 0xca, 0xb9, 0x84, 0x7c, 0x16, 0x06, 0x99, 0x12, 0xc8,
-		0x64, 0xf1, 0xd4, 0x90, 0x3b, 0xc2, 0x8b, 0x9c, 0x87, 0x24, 0x6a, 0xb7, 0x57, 0x4b, 0x65, 0x25,
-		0x97, 0x08, 0x0f, 0x75, 0x2a, 0x37, 0x20, 0x3b, 0x90, 0x0d, 0xe6, 0xe1, 0x3f, 0x9c, 0xc5, 0xf8,
-		0x97, 0x24, 0x18, 0x0e, 0xe4, 0xd5, 0x24, 0x21, 0x52, 0xeb, 0x75, 0xf3, 0x6a, 0x45, 0xad, 0xeb,
-		0xaa, 0xc3, 0x4d, 0x03, 0x28, 0x68, 0x9e, 0x40, 0x7a, 0x1d, 0xba, 0x1f, 0xd2, 0x14, 0x19, 0xc8,
-		0x0d, 0xca, 0x9f, 0x90, 0x20, 0x17, 0x4d, 0x6c, 0x23, 0x62, 0x4a, 0x3f, 0x4a, 0x31, 0xe5, 0x8f,
-		0x4b, 0x30, 0x1a, 0xce, 0x66, 0x23, 0xe2, 0xdd, 0xf5, 0x23, 0x15, 0xef, 0x0f, 0x12, 0x30, 0x12,
-		0xca, 0x61, 0x7b, 0x95, 0xee, 0x25, 0x18, 0xd7, 0xab, 0xb8, 0x61, 0x99, 0x2e, 0x36, 0xb4, 0x83,
-		0x4a, 0x1d, 0x5f, 0xc1, 0xf5, 0xbc, 0x4c, 0x9d, 0xc6, 0x5c, 0xf7, 0x2c, 0x79, 0x76, 0xd9, 0xa7,
-		0x5b, 0x21, 0x64, 0xc5, 0x89, 0xe5, 0xc5, 0xf2, 0xea, 0xc6, 0xfa, 0x56, 0x79, 0x6d, 0xe1, 0x2d,
-		0x95, 0xed, 0xb5, 0x4b, 0x6b, 0xeb, 0xcf, 0xaf, 0x29, 0x39, 0x3d, 0x82, 0x76, 0x1b, 0xa7, 0xfd,
-		0x06, 0xe4, 0xa2, 0x42, 0xa1, 0xe3, 0xd0, 0x4e, 0xac, 0xdc, 0x11, 0x34, 0x01, 0x63, 0x6b, 0xeb,
-		0x95, 0xcd, 0xe5, 0xc5, 0x72, 0xa5, 0x7c, 0xe1, 0x42, 0x79, 0x61, 0x6b, 0x93, 0xed, 0x7b, 0x78,
-		0xd8, 0x5b, 0xa1, 0x09, 0x2e, 0xbf, 0x96, 0x84, 0x89, 0x36, 0x92, 0xa0, 0x79, 0xbe, 0x62, 0x61,
-		0x8b, 0xa8, 0x87, 0x7b, 0x91, 0x7e, 0x96, 0xe4, 0x0c, 0x1b, 0xaa, 0xed, 0xf2, 0x05, 0xce, 0x03,
-		0x40, 0xb4, 0x64, 0xb8, 0xfa, 0xae, 0x8e, 0x6d, 0xbe, 0x9f, 0xc4, 0x96, 0x31, 0x63, 0x3e, 0x9c,
-		0x6d, 0x29, 0x3d, 0x04, 0xc8, 0x32, 0x1d, 0xdd, 0xd5, 0xaf, 0xe0, 0x8a, 0x6e, 0x88, 0xcd, 0x27,
-		0xb2, 0xac, 0x49, 0x29, 0x39, 0x51, 0xb3, 0x6c, 0xb8, 0x1e, 0xb6, 0x81, 0x6b, 0x6a, 0x04, 0x9b,
-		0x38, 0xf3, 0xa4, 0x92, 0x13, 0x35, 0x1e, 0xf6, 0x5d, 0x90, 0xad, 0x9a, 0x4d, 0x92, 0xeb, 0x31,
-		0x3c, 0x12, 0x3b, 0x24, 0x65, 0x98, 0xc1, 0x3c, 0x14, 0x9e, 0xc5, 0xfb, 0xbb, 0x5e, 0x59, 0x65,
-		0x98, 0xc1, 0x18, 0xca, 0xfd, 0x30, 0xa6, 0xd6, 0x6a, 0x36, 0x61, 0x2e, 0x18, 0xb1, 0x75, 0xc9,
-		0xa8, 0x07, 0xa6, 0x88, 0x85, 0x67, 0x21, 0x2d, 0xf4, 0x40, 0x42, 0x35, 0xd1, 0x44, 0xc5, 0x62,
-		0x8b, 0xed, 0xc4, 0xa9, 0x8c, 0x92, 0x36, 0x44, 0xe5, 0x5d, 0x90, 0xd5, 0x9d, 0x8a, 0xbf, 0x89,
-		0x9f, 0x98, 0x49, 0x9c, 0x4a, 0x2b, 0xc3, 0xba, 0xe3, 0x6d, 0x80, 0xca, 0x9f, 0x49, 0xc0, 0x68,
-		0xf8, 0x10, 0x02, 0x2d, 0x42, 0xba, 0x6e, 0x6a, 0x2a, 0x35, 0x2d, 0x76, 0x02, 0x76, 0x2a, 0xe6,
-		0xdc, 0x62, 0x76, 0x85, 0xe3, 0x2b, 0x1e, 0x65, 0xe1, 0xb7, 0x25, 0x48, 0x0b, 0x30, 0x3a, 0x06,
-		0x29, 0x4b, 0x75, 0xf7, 0x28, 0xbb, 0x81, 0x52, 0x22, 0x27, 0x29, 0xb4, 0x4c, 0xe0, 0x8e, 0xa5,
-		0x1a, 0xd4, 0x04, 0x38, 0x9c, 0x94, 0xc9, 0xb8, 0xd6, 0xb1, 0x5a, 0xa5, 0x8b, 0x1e, 0xb3, 0xd1,
-		0xc0, 0x86, 0xeb, 0x88, 0x71, 0xe5, 0xf0, 0x05, 0x0e, 0x46, 0x0f, 0xc2, 0xb8, 0x6b, 0xab, 0x7a,
-		0x3d, 0x84, 0x9b, 0xa2, 0xb8, 0x39, 0x51, 0xe1, 0x21, 0x17, 0xe1, 0x84, 0xe0, 0x5b, 0xc5, 0xae,
-		0xaa, 0xed, 0xe1, 0xaa, 0x4f, 0x34, 0x48, 0x37, 0x37, 0x8e, 0x73, 0x84, 0x45, 0x5e, 0x2f, 0x68,
-		0xe5, 0x6f, 0x48, 0x30, 0x2e, 0x96, 0x69, 0x55, 0x4f, 0x59, 0xab, 0x00, 0xaa, 0x61, 0x98, 0x6e,
-		0x50, 0x5d, 0xad, 0xa6, 0xdc, 0x42, 0x37, 0x3b, 0xef, 0x11, 0x29, 0x01, 0x06, 0x85, 0x06, 0x80,
-		0x5f, 0xd3, 0x51, 0x6d, 0xd3, 0x30, 0xcc, 0x4f, 0x98, 0xe8, 0x31, 0x25, 0x5b, 0xd8, 0x03, 0x03,
-		0x91, 0xf5, 0x1c, 0x9a, 0x84, 0x81, 0x1d, 0x5c, 0xd3, 0x0d, 0xbe, 0x6f, 0xcc, 0x0a, 0x62, 0xfb,
-		0x25, 0xe5, 0x6d, 0xbf, 0x94, 0x3e, 0x28, 0xc1, 0x84, 0x66, 0x36, 0xa2, 0xf2, 0x96, 0x72, 0x91,
-		0xdd, 0x05, 0xe7, 0xa2, 0xf4, 0xd6, 0xa7, 0x6b, 0xba, 0xbb, 0xd7, 0xdc, 0x99, 0xd5, 0xcc, 0xc6,
-		0x5c, 0xcd, 0xac, 0xab, 0x46, 0xcd, 0x3f, 0x67, 0xa5, 0x3f, 0xb4, 0x87, 0x6b, 0xd8, 0x78, 0xb8,
-		0x66, 0x06, 0x4e, 0x5d, 0xcf, 0xfb, 0x3f, 0xff, 0x4c, 0x92, 0x7e, 0x21, 0x91, 0x5c, 0xda, 0x28,
-		0x7d, 0x36, 0x51, 0x58, 0x62, 0xcd, 0x6d, 0x08, 0xf5, 0x28, 0x78, 0xb7, 0x8e, 0x35, 0xd2, 0x65,
-		0xf8, 0xf6, 0x83, 0x30, 0x59, 0x33, 0x6b, 0x26, 0xe5, 0x38, 0x47, 0x7e, 0xf1, 0x93, 0xdb, 0x8c,
-		0x07, 0x2d, 0xc4, 0x1e, 0xf3, 0x16, 0xd7, 0x60, 0x82, 0x23, 0x57, 0xe8, 0xd1, 0x11, 0x5b, 0xd8,
-		0xa0, 0xae, 0xbb, 0x6a, 0xf9, 0x5f, 0xfb, 0x16, 0x0d, 0xe8, 0xca, 0x38, 0x27, 0x25, 0x75, 0x6c,
-		0xed, 0x53, 0x54, 0xe0, 0x68, 0x88, 0x1f, 0x9b, 0xb6, 0xd8, 0x8e, 0xe1, 0xf8, 0x9b, 0x9c, 0xe3,
-		0x44, 0x80, 0xe3, 0x26, 0x27, 0x2d, 0x2e, 0xc0, 0x48, 0x3f, 0xbc, 0xfe, 0x25, 0xe7, 0x95, 0xc5,
-		0x41, 0x26, 0x4b, 0x30, 0x46, 0x99, 0x68, 0x4d, 0xc7, 0x35, 0x1b, 0xd4, 0x27, 0x76, 0x67, 0xf3,
-		0x5b, 0xdf, 0x62, 0xf3, 0x68, 0x94, 0x90, 0x2d, 0x78, 0x54, 0xc5, 0x22, 0xd0, 0xd3, 0xb2, 0x2a,
-		0xd6, 0xea, 0x31, 0x1c, 0xbe, 0xc2, 0x05, 0xf1, 0xf0, 0x8b, 0x97, 0x61, 0x92, 0xfc, 0xa6, 0x2e,
-		0x2b, 0x28, 0x49, 0xfc, 0x16, 0x5c, 0xfe, 0x1b, 0xef, 0x61, 0x53, 0x75, 0xc2, 0x63, 0x10, 0x90,
-		0x29, 0x30, 0x8a, 0x35, 0xec, 0xba, 0xd8, 0x76, 0x2a, 0x6a, 0xbd, 0x9d, 0x78, 0x81, 0x3d, 0x8c,
-		0xfc, 0xc7, 0xbe, 0x13, 0x1e, 0xc5, 0x25, 0x46, 0x39, 0x5f, 0xaf, 0x17, 0xb7, 0xe1, 0x78, 0x1b,
-		0xab, 0xe8, 0x81, 0xe7, 0x6b, 0x9c, 0xe7, 0x64, 0x8b, 0x65, 0x10, 0xb6, 0x1b, 0x20, 0xe0, 0xde,
-		0x58, 0xf6, 0xc0, 0xf3, 0xe7, 0x39, 0x4f, 0xc4, 0x69, 0xc5, 0x90, 0x12, 0x8e, 0xcf, 0xc2, 0xf8,
-		0x15, 0x6c, 0xef, 0x98, 0x0e, 0xdf, 0x37, 0xea, 0x81, 0xdd, 0xc7, 0x39, 0xbb, 0x31, 0x4e, 0x48,
-		0x37, 0x92, 0x08, 0xaf, 0xa7, 0x20, 0xbd, 0xab, 0x6a, 0xb8, 0x07, 0x16, 0xd7, 0x39, 0x8b, 0x21,
-		0x82, 0x4f, 0x48, 0xe7, 0x21, 0x5b, 0x33, 0x79, 0xd4, 0x8a, 0x27, 0xff, 0x04, 0x27, 0x1f, 0x16,
-		0x34, 0x9c, 0x85, 0x65, 0x5a, 0xcd, 0x3a, 0x09, 0x69, 0xf1, 0x2c, 0xfe, 0xa6, 0x60, 0x21, 0x68,
-		0x38, 0x8b, 0x3e, 0xd4, 0xfa, 0x49, 0xc1, 0xc2, 0x09, 0xe8, 0xf3, 0x19, 0x18, 0x36, 0x8d, 0xfa,
-		0x81, 0x69, 0xf4, 0x22, 0xc4, 0xa7, 0x38, 0x07, 0xe0, 0x24, 0x84, 0xc1, 0x79, 0xc8, 0xf4, 0x3a,
-		0x10, 0x7f, 0xeb, 0x3b, 0x62, 0x7a, 0x88, 0x11, 0x58, 0x82, 0x31, 0xe1, 0xa0, 0x74, 0xd3, 0xe8,
-		0x81, 0xc5, 0xdf, 0xe6, 0x2c, 0x46, 0x03, 0x64, 0xbc, 0x1b, 0x2e, 0x76, 0xdc, 0x1a, 0xee, 0x85,
-		0xc9, 0x67, 0x44, 0x37, 0x38, 0x09, 0x57, 0xe5, 0x0e, 0x36, 0xb4, 0xbd, 0xde, 0x38, 0xfc, 0x92,
-		0x50, 0xa5, 0xa0, 0x21, 0x2c, 0x16, 0x60, 0xa4, 0xa1, 0xda, 0xce, 0x9e, 0x5a, 0xef, 0x69, 0x38,
-		0xfe, 0x0e, 0xe7, 0x91, 0xf5, 0x88, 0xb8, 0x46, 0x9a, 0x46, 0x3f, 0x6c, 0x3e, 0x2b, 0x34, 0x12,
-		0x20, 0xe3, 0x53, 0xcf, 0x71, 0xe9, 0x26, 0x5b, 0x3f, 0xdc, 0x7e, 0x59, 0x4c, 0x3d, 0x46, 0xbb,
-		0x1a, 0xe4, 0x78, 0x1e, 0x32, 0x8e, 0xfe, 0x72, 0x4f, 0x6c, 0x3e, 0x27, 0x46, 0x9a, 0x12, 0x10,
-		0xe2, 0xb7, 0xc0, 0x89, 0xb6, 0x61, 0xa2, 0x07, 0x66, 0x7f, 0x97, 0x33, 0x3b, 0xd6, 0x26, 0x54,
-		0x70, 0x97, 0xd0, 0x2f, 0xcb, 0xbf, 0x27, 0x5c, 0x02, 0x8e, 0xf0, 0xda, 0x20, 0xeb, 0x08, 0x47,
-		0xdd, 0xed, 0x4f, 0x6b, 0xbf, 0x22, 0xb4, 0xc6, 0x68, 0x43, 0x5a, 0xdb, 0x82, 0x63, 0x9c, 0x63,
-		0x7f, 0xe3, 0xfa, 0xab, 0xc2, 0xb1, 0x32, 0xea, 0xed, 0xf0, 0xe8, 0xbe, 0x0d, 0x0a, 0x9e, 0x3a,
-		0x45, 0xc2, 0xea, 0x54, 0x1a, 0xaa, 0xd5, 0x03, 0xe7, 0x5f, 0xe3, 0x9c, 0x85, 0xc7, 0xf7, 0x32,
-		0x5e, 0x67, 0x55, 0xb5, 0x08, 0xf3, 0x17, 0x20, 0x2f, 0x98, 0x37, 0x0d, 0x1b, 0x6b, 0x66, 0xcd,
-		0xd0, 0x5f, 0xc6, 0xd5, 0x1e, 0x58, 0xff, 0x7a, 0x64, 0xa8, 0xb6, 0x03, 0xe4, 0x84, 0xf3, 0x32,
-		0xe4, 0xbc, 0x5c, 0xa5, 0xa2, 0x37, 0x2c, 0xd3, 0x76, 0x63, 0x38, 0x7e, 0x5e, 0x8c, 0x94, 0x47,
-		0xb7, 0x4c, 0xc9, 0x8a, 0x65, 0x60, 0x27, 0xcf, 0xbd, 0x9a, 0xe4, 0x17, 0x38, 0xa3, 0x11, 0x9f,
-		0x8a, 0x3b, 0x0e, 0xcd, 0x6c, 0x58, 0xaa, 0xdd, 0x8b, 0xff, 0xfb, 0xfb, 0xc2, 0x71, 0x70, 0x12,
-		0xee, 0x38, 0xdc, 0x03, 0x0b, 0x93, 0x68, 0xdf, 0x03, 0x87, 0x2f, 0x0a, 0xc7, 0x21, 0x68, 0x38,
-		0x0b, 0x91, 0x30, 0xf4, 0xc0, 0xe2, 0x1f, 0x08, 0x16, 0x82, 0x86, 0xb0, 0x78, 0xce, 0x0f, 0xb4,
-		0x36, 0xae, 0xe9, 0x8e, 0x6b, 0xb3, 0x34, 0xb9, 0x3b, 0xab, 0x7f, 0xf8, 0x9d, 0x70, 0x12, 0xa6,
-		0x04, 0x48, 0x89, 0x27, 0xe2, 0xdb, 0xae, 0x74, 0x15, 0x15, 0x2f, 0xd8, 0x6f, 0x08, 0x4f, 0x14,
-		0x20, 0x23, 0xb2, 0x05, 0x32, 0x44, 0xa2, 0x76, 0x8d, 0xac, 0x1d, 0x7a, 0x60, 0xf7, 0x8f, 0x22,
-		0xc2, 0x6d, 0x0a, 0x5a, 0xc2, 0x33, 0x90, 0xff, 0x34, 0x8d, 0x7d, 0x7c, 0xd0, 0x93, 0x75, 0xfe,
-		0xe3, 0x48, 0xfe, 0xb3, 0xcd, 0x28, 0x99, 0x0f, 0x19, 0x8b, 0xe4, 0x53, 0x28, 0xee, 0x9e, 0x51,
-		0xfe, 0xa7, 0xbe, 0xc7, 0xfb, 0x1b, 0x4e, 0xa7, 0x8a, 0x2b, 0xc4, 0xc8, 0xc3, 0x49, 0x4f, 0x3c,
-		0xb3, 0xf7, 0x7c, 0xcf, 0xb3, 0xf3, 0x50, 0xce, 0x53, 0xbc, 0x00, 0x23, 0xa1, 0x84, 0x27, 0x9e,
-		0xd5, 0x7b, 0x39, 0xab, 0x6c, 0x30, 0xdf, 0x29, 0x9e, 0x85, 0x14, 0x49, 0x5e, 0xe2, 0xc9, 0xff,
-		0x32, 0x27, 0xa7, 0xe8, 0xc5, 0x37, 0x43, 0x5a, 0x24, 0x2d, 0xf1, 0xa4, 0xef, 0xe3, 0xa4, 0x1e,
-		0x09, 0x21, 0x17, 0x09, 0x4b, 0x3c, 0xf9, 0x5f, 0x11, 0xe4, 0x82, 0x84, 0x90, 0xf7, 0xae, 0xc2,
-		0x2f, 0xfd, 0x74, 0x8a, 0x07, 0x1d, 0xa1, 0xbb, 0xf3, 0x30, 0xc4, 0x33, 0x95, 0x78, 0xea, 0x0f,
-		0xf0, 0xc6, 0x05, 0x45, 0xf1, 0x09, 0x18, 0xe8, 0x51, 0xe1, 0x3f, 0xc3, 0x49, 0x19, 0x7e, 0x71,
-		0x01, 0x86, 0x03, 0xd9, 0x49, 0x3c, 0xf9, 0x5f, 0xe3, 0xe4, 0x41, 0x2a, 0x22, 0x3a, 0xcf, 0x4e,
-		0xe2, 0x19, 0x7c, 0x50, 0x88, 0xce, 0x29, 0x88, 0xda, 0x44, 0x62, 0x12, 0x4f, 0xfd, 0x21, 0xa1,
-		0x75, 0x41, 0x52, 0x7c, 0x06, 0x32, 0x5e, 0xb0, 0x89, 0xa7, 0xff, 0x30, 0xa7, 0xf7, 0x69, 0x88,
-		0x06, 0x02, 0xc1, 0x2e, 0x9e, 0xc5, 0x5f, 0x17, 0x1a, 0x08, 0x50, 0x91, 0x69, 0x14, 0x4d, 0x60,
-		0xe2, 0x39, 0x7d, 0x44, 0x4c, 0xa3, 0x48, 0xfe, 0x42, 0x46, 0x93, 0xfa, 0xfc, 0x78, 0x16, 0x3f,
-		0x2b, 0x46, 0x93, 0xe2, 0x13, 0x31, 0xa2, 0x19, 0x41, 0x3c, 0x8f, 0xbf, 0x21, 0xc4, 0x88, 0x24,
-		0x04, 0xc5, 0x0d, 0x40, 0xad, 0xd9, 0x40, 0x3c, 0xbf, 0x8f, 0x72, 0x7e, 0xe3, 0x2d, 0xc9, 0x40,
-		0xf1, 0x79, 0x38, 0xd6, 0x3e, 0x13, 0x88, 0xe7, 0xfa, 0xb1, 0xef, 0x45, 0xd6, 0x6e, 0xc1, 0x44,
-		0xa0, 0xb8, 0xe5, 0x87, 0x94, 0x60, 0x16, 0x10, 0xcf, 0xf6, 0xb5, 0xef, 0x85, 0x1d, 0x77, 0x30,
-		0x09, 0x28, 0xce, 0x03, 0xf8, 0x01, 0x38, 0x9e, 0xd7, 0xc7, 0x39, 0xaf, 0x00, 0x11, 0x99, 0x1a,
-		0x3c, 0xfe, 0xc6, 0xd3, 0x5f, 0x17, 0x53, 0x83, 0x53, 0x90, 0xa9, 0x21, 0x42, 0x6f, 0x3c, 0xf5,
-		0x27, 0xc4, 0xd4, 0x10, 0x24, 0xc4, 0xb2, 0x03, 0xd1, 0x2d, 0x9e, 0xc3, 0xa7, 0x84, 0x65, 0x07,
-		0xa8, 0x8a, 0x6b, 0x30, 0xde, 0x12, 0x10, 0xe3, 0x59, 0xfd, 0x02, 0x67, 0x95, 0x8b, 0xc6, 0xc3,
-		0x60, 0xf0, 0xe2, 0xc1, 0x30, 0x9e, 0xdb, 0xa7, 0x23, 0xc1, 0x8b, 0xc7, 0xc2, 0xe2, 0x79, 0x48,
-		0x1b, 0xcd, 0x7a, 0x9d, 0x4c, 0x1e, 0xd4, 0xfd, 0x6e, 0x60, 0xfe, 0xbf, 0x7c, 0x9f, 0x6b, 0x47,
-		0x10, 0x14, 0xcf, 0xc2, 0x00, 0x6e, 0xec, 0xe0, 0x6a, 0x1c, 0xe5, 0xb7, 0xbf, 0x2f, 0x1c, 0x26,
-		0xc1, 0x2e, 0x3e, 0x03, 0xc0, 0xb6, 0x46, 0xe8, 0xf1, 0x60, 0x0c, 0xed, 0x7f, 0xfd, 0x3e, 0xbf,
-		0x8c, 0xe3, 0x93, 0xf8, 0x0c, 0xd8, 0xd5, 0x9e, 0xee, 0x0c, 0xbe, 0x13, 0x66, 0x40, 0x47, 0xe4,
-		0x29, 0x18, 0x7a, 0xd1, 0x31, 0x0d, 0x57, 0xad, 0xc5, 0x51, 0xff, 0x37, 0x4e, 0x2d, 0xf0, 0x89,
-		0xc2, 0x1a, 0xa6, 0x8d, 0x5d, 0xb5, 0xe6, 0xc4, 0xd1, 0xfe, 0x77, 0x4e, 0xeb, 0x11, 0x10, 0x62,
-		0x4d, 0x75, 0xdc, 0x5e, 0xfa, 0xfd, 0x47, 0x82, 0x58, 0x10, 0x10, 0xa1, 0xc9, 0xef, 0x7d, 0x7c,
-		0x10, 0x47, 0xfb, 0x5d, 0x21, 0x34, 0xc7, 0x2f, 0xbe, 0x19, 0x32, 0xe4, 0x27, 0xbb, 0x61, 0x17,
-		0x43, 0xfc, 0xc7, 0x9c, 0xd8, 0xa7, 0x20, 0x2d, 0x3b, 0x6e, 0xd5, 0xd5, 0xe3, 0x95, 0x7d, 0x93,
-		0x8f, 0xb4, 0xc0, 0x2f, 0xce, 0xc3, 0xb0, 0xe3, 0x56, 0xab, 0x4d, 0x9e, 0x9f, 0xc6, 0x90, 0xff,
-		0xc9, 0xf7, 0xbd, 0x2d, 0x0b, 0x8f, 0x86, 0x8c, 0xf6, 0xd5, 0x7d, 0xd7, 0x32, 0xe9, 0x11, 0x48,
-		0x1c, 0x87, 0xef, 0x71, 0x0e, 0x01, 0x92, 0xe2, 0x02, 0x64, 0x49, 0x5f, 0x6c, 0x6c, 0x61, 0x7a,
-		0x5e, 0x15, 0xc3, 0xe2, 0x4f, 0xb9, 0x02, 0x42, 0x44, 0xa5, 0x9f, 0xfc, 0xca, 0xeb, 0x53, 0xd2,
-		0xd7, 0x5f, 0x9f, 0x92, 0xfe, 0xe0, 0xf5, 0x29, 0xe9, 0x43, 0xdf, 0x9c, 0x3a, 0xf2, 0xf5, 0x6f,
-		0x4e, 0x1d, 0xf9, 0xdd, 0x6f, 0x4e, 0x1d, 0x69, 0xbf, 0x6d, 0x0c, 0x4b, 0xe6, 0x92, 0xc9, 0x36,
-		0x8c, 0xdf, 0x2a, 0x87, 0xb6, 0x8b, 0x6b, 0xa6, 0xbf, 0x5b, 0xeb, 0x2d, 0x72, 0xe0, 0x4f, 0x25,
-		0xb2, 0x60, 0x0e, 0xef, 0xe5, 0xaa, 0xc6, 0x41, 0x87, 0xb7, 0x3a, 0x85, 0xb6, 0x1b, 0xc3, 0xf2,
-		0x9b, 0x20, 0x39, 0x6f, 0x1c, 0xa0, 0x13, 0xcc, 0xe7, 0x55, 0x9a, 0x76, 0x9d, 0xdf, 0xfc, 0x1a,
-		0x22, 0xe5, 0x6d, 0xbb, 0x8e, 0x26, 0xfd, 0xeb, 0x99, 0xd2, 0xa9, 0x2c, 0xbf, 0x73, 0x59, 0x4c,
-		0x7d, 0xf7, 0x53, 0xd3, 0x47, 0x4a, 0xfb, 0xd1, 0x1e, 0x7e, 0x29, 0xb6, 0x97, 0xe9, 0x79, 0xe3,
-		0x80, 0x76, 0x72, 0x43, 0x7a, 0xeb, 0x00, 0x69, 0xc3, 0x11, 0x1b, 0xdb, 0x53, 0xd1, 0x8d, 0xed,
-		0xe7, 0x71, 0xbd, 0x7e, 0xc9, 0x30, 0xaf, 0x1a, 0x5b, 0x04, 0x6d, 0x67, 0x90, 0x5d, 0x23, 0x86,
-		0xbf, 0x9a, 0x80, 0xa9, 0x96, 0x3d, 0x6c, 0x3e, 0xf2, 0x9d, 0x1e, 0x2a, 0x15, 0x21, 0xbd, 0x28,
-		0x0c, 0x2a, 0x0f, 0x43, 0x0e, 0xd6, 0x4c, 0xa3, 0xea, 0xd0, 0xae, 0x26, 0x15, 0x51, 0x24, 0x5d,
-		0x35, 0x54, 0xc3, 0x74, 0xf8, 0xed, 0x48, 0x56, 0x28, 0xfd, 0xac, 0xd4, 0xdf, 0x38, 0x8e, 0x88,
-		0x96, 0x44, 0x37, 0x4f, 0x77, 0xdb, 0xfb, 0xa7, 0x2a, 0xf0, 0xe4, 0x0f, 0xec, 0xf3, 0xf7, 0xaa,
-		0x8e, 0x0f, 0x25, 0x60, 0x3a, 0xaa, 0x0e, 0x32, 0x8f, 0x1c, 0x57, 0x6d, 0x58, 0x9d, 0xf4, 0x71,
-		0x1e, 0x32, 0x5b, 0x02, 0xa7, 0x6f, 0x85, 0xfc, 0x5c, 0x9f, 0x0a, 0x19, 0xf5, 0x9a, 0x12, 0x1a,
-		0x79, 0x30, 0x5e, 0x23, 0x5e, 0x17, 0x0e, 0xa1, 0x92, 0x77, 0x27, 0xe1, 0x84, 0x66, 0x3a, 0x0d,
-		0xd3, 0xa9, 0x30, 0x83, 0x67, 0x05, 0xae, 0x8c, 0x6c, 0xb0, 0xaa, 0x87, 0xe3, 0x90, 0x8b, 0x30,
-		0x4a, 0x9d, 0x02, 0xdd, 0x08, 0xa6, 0x7e, 0x38, 0x36, 0x74, 0x7e, 0xf5, 0xdf, 0x0e, 0xd0, 0x49,
-		0x34, 0xe2, 0x11, 0xd2, 0x9b, 0x2e, 0x5b, 0x30, 0xa9, 0x37, 0xac, 0x3a, 0xa6, 0x47, 0x62, 0x15,
-		0xaf, 0x2e, 0x9e, 0xdf, 0xd7, 0x38, 0xbf, 0x09, 0x9f, 0x7c, 0x59, 0x50, 0x17, 0x57, 0x60, 0x5c,
-		0xd5, 0x34, 0x6c, 0x85, 0x58, 0xc6, 0x38, 0x2c, 0x21, 0x60, 0x8e, 0x53, 0x7a, 0xdc, 0x4a, 0xcf,
-		0x74, 0x1a, 0xdb, 0xb7, 0xde, 0x1b, 0x18, 0x34, 0x1b, 0xd7, 0xb0, 0xf1, 0xb0, 0x81, 0xdd, 0xab,
-		0xa6, 0xbd, 0xcf, 0xd5, 0xfb, 0x30, 0x6b, 0x4a, 0x0c, 0xc2, 0x7b, 0x93, 0x30, 0xc5, 0x2a, 0xe6,
-		0x76, 0x54, 0x07, 0xcf, 0x5d, 0x79, 0x74, 0x07, 0xbb, 0xea, 0xa3, 0x73, 0x9a, 0xa9, 0x8b, 0x69,
-		0x3a, 0xc1, 0xc7, 0x85, 0xd4, 0xcf, 0xf2, 0xfa, 0x0e, 0x7e, 0x6a, 0x09, 0x52, 0x0b, 0xa6, 0x6e,
-		0x10, 0x8b, 0xac, 0x62, 0xc3, 0x6c, 0x70, 0x2f, 0xc5, 0x0a, 0xe8, 0x6e, 0x18, 0x54, 0x1b, 0x66,
-		0xd3, 0x70, 0xd9, 0x69, 0x5e, 0x69, 0xf8, 0x2b, 0x37, 0xa6, 0x8f, 0xfc, 0xde, 0x8d, 0xe9, 0xe4,
-		0xb2, 0xe1, 0x2a, 0xbc, 0xaa, 0x98, 0x7a, 0xe3, 0x93, 0xd3, 0x92, 0xfc, 0x2c, 0x0c, 0x2d, 0x62,
-		0xed, 0x30, 0xbc, 0x16, 0xb1, 0x16, 0xe1, 0xf5, 0x00, 0xa4, 0x97, 0x0d, 0x97, 0xdd, 0x20, 0xbe,
-		0x13, 0x92, 0xba, 0xc1, 0x2e, 0xa5, 0x45, 0xda, 0x27, 0x70, 0x82, 0xba, 0x88, 0x35, 0x0f, 0xb5,
-		0x8a, 0xb5, 0x28, 0x2a, 0x61, 0x4f, 0xe0, 0xa5, 0xc5, 0xdf, 0xfd, 0x4f, 0x53, 0x47, 0x5e, 0x79,
-		0x7d, 0xea, 0x48, 0xc7, 0x91, 0x08, 0x46, 0x07, 0xae, 0x62, 0x3e, 0x04, 0x4e, 0x75, 0x7f, 0xce,
-		0x0d, 0xcd, 0x85, 0xcf, 0xa6, 0xe0, 0x4e, 0xfa, 0x78, 0xc4, 0x6e, 0xe8, 0x86, 0x3b, 0xa7, 0xd9,
-		0x07, 0x96, 0x4b, 0xc3, 0x89, 0xb9, 0xcb, 0x47, 0x61, 0xdc, 0xaf, 0x9e, 0x65, 0xd5, 0x1d, 0xc6,
-		0x60, 0x17, 0x06, 0x36, 0x08, 0x1d, 0x51, 0x9c, 0x6b, 0xba, 0x6a, 0x9d, 0xbb, 0x0b, 0x56, 0x20,
-		0x50, 0xf6, 0xe0, 0x24, 0xc1, 0xa0, 0xba, 0x78, 0x6b, 0x52, 0xc7, 0xea, 0x2e, 0xbb, 0xb7, 0x9b,
-		0xa4, 0x21, 0x24, 0x4d, 0x00, 0xf4, 0x8a, 0xee, 0x24, 0x0c, 0xa8, 0x4d, 0x76, 0xe4, 0x9c, 0x24,
-		0xb1, 0x85, 0x16, 0xe4, 0x4b, 0x30, 0xc4, 0x8f, 0xb9, 0x50, 0x0e, 0x92, 0xfb, 0xf8, 0x80, 0xb6,
-		0x93, 0x55, 0xc8, 0x4f, 0x34, 0x0b, 0x03, 0x54, 0x78, 0xfe, 0x20, 0x21, 0x3f, 0xdb, 0x22, 0xfd,
-		0x2c, 0x15, 0x52, 0x61, 0x68, 0xf2, 0xb3, 0x90, 0x5e, 0x34, 0x1b, 0xba, 0x61, 0x86, 0xb9, 0x65,
-		0x18, 0x37, 0x2a, 0xb3, 0xd5, 0xe4, 0x63, 0xad, 0xb0, 0x02, 0x3a, 0x06, 0x83, 0xec, 0x1e, 0x37,
-		0x3f, 0x36, 0xe7, 0x25, 0x79, 0x01, 0x86, 0x28, 0xef, 0x75, 0x0b, 0x21, 0xfe, 0x02, 0x88, 0x5f,
-		0x18, 0xa7, 0x6e, 0x81, 0xb3, 0x4f, 0xf8, 0xc2, 0x22, 0x48, 0x55, 0x55, 0x57, 0xe5, 0xfd, 0xa6,
-		0xbf, 0xe5, 0xa7, 0x21, 0xcd, 0x99, 0x38, 0xe8, 0x0c, 0x24, 0x4d, 0xcb, 0xe1, 0x07, 0xdf, 0x85,
-		0x4e, 0x5d, 0x59, 0xb7, 0x4a, 0x29, 0x62, 0x25, 0x0a, 0x41, 0x2e, 0x29, 0x1d, 0xcd, 0xe2, 0xc9,
-		0x80, 0x59, 0x04, 0x86, 0x3c, 0xf0, 0x93, 0x0d, 0x69, 0x8b, 0x39, 0x78, 0xc6, 0xf2, 0xa9, 0x04,
-		0x4c, 0x05, 0x6a, 0xaf, 0x60, 0x9b, 0xac, 0xf5, 0x98, 0x45, 0x71, 0x6b, 0x41, 0x01, 0x21, 0x79,
-		0x7d, 0x07, 0x73, 0x79, 0x33, 0x24, 0xe7, 0x2d, 0x0b, 0x15, 0x20, 0xcd, 0x0e, 0xb8, 0x4d, 0x66,
-		0x2f, 0x29, 0xc5, 0x2b, 0x93, 0x3a, 0xc7, 0xdc, 0x75, 0xaf, 0xaa, 0xb6, 0xf7, 0xd4, 0x49, 0x94,
-		0xe5, 0xa7, 0x20, 0xb3, 0x60, 0x1a, 0x0e, 0x36, 0x9c, 0x26, 0x0d, 0x44, 0x3b, 0x75, 0x53, 0xdb,
-		0xe7, 0x1c, 0x58, 0x81, 0x28, 0x5c, 0xb5, 0x2c, 0x4a, 0x99, 0x52, 0xc8, 0x4f, 0x36, 0x2f, 0x4b,
-		0x9b, 0x1d, 0x55, 0xf4, 0x54, 0xff, 0x2a, 0xe2, 0x9d, 0xf4, 0x74, 0xf4, 0xbf, 0x25, 0x38, 0xd9,
-		0x3a, 0xa1, 0xf6, 0xf1, 0x81, 0xd3, 0xef, 0x7c, 0x7a, 0x01, 0x32, 0x1b, 0xf4, 0xbd, 0xf1, 0x25,
-		0x7c, 0x80, 0x0a, 0x30, 0x84, 0xab, 0x67, 0xce, 0x9e, 0x7d, 0xf4, 0x29, 0x66, 0xed, 0x17, 0x8f,
-		0x28, 0x02, 0x80, 0xa6, 0x20, 0xe3, 0x60, 0xcd, 0x3a, 0x73, 0xf6, 0xdc, 0xfe, 0xa3, 0xcc, 0xbc,
-		0x2e, 0x1e, 0x51, 0x7c, 0x50, 0x31, 0x4d, 0x7a, 0xfd, 0xc6, 0xa7, 0xa6, 0xa5, 0xd2, 0x00, 0x24,
-		0x9d, 0x66, 0xe3, 0xb6, 0xda, 0xc8, 0x6b, 0x03, 0x30, 0x13, 0xa4, 0xa4, 0xd1, 0xfa, 0x8a, 0x5a,
-		0xd7, 0xab, 0xaa, 0xff, 0x52, 0x3c, 0x17, 0xd0, 0x01, 0xc5, 0x68, 0xaf, 0x82, 0x42, 0x57, 0x4d,
-		0xca, 0xbf, 0x2e, 0x41, 0xf6, 0xb2, 0xe0, 0xbc, 0x89, 0x5d, 0x74, 0x1e, 0xc0, 0x6b, 0x49, 0x4c,
-		0x9b, 0x3b, 0x66, 0xa3, 0x6d, 0xcd, 0x7a, 0x34, 0x4a, 0x00, 0x1d, 0x3d, 0x41, 0x0d, 0xd1, 0x32,
-		0x1d, 0xfe, 0xfc, 0x25, 0x86, 0xd4, 0x43, 0x46, 0x0f, 0x01, 0xa2, 0x1e, 0xae, 0x72, 0xc5, 0x74,
-		0x75, 0xa3, 0x56, 0xb1, 0xcc, 0xab, 0xfc, 0x51, 0x61, 0x52, 0xc9, 0xd1, 0x9a, 0xcb, 0xb4, 0x62,
-		0x83, 0xc0, 0x89, 0xd0, 0x19, 0x8f, 0x0b, 0xc9, 0xad, 0xd4, 0x6a, 0xd5, 0xc6, 0x8e, 0xc3, 0x9d,
-		0x98, 0x28, 0xa2, 0xf3, 0x30, 0x64, 0x35, 0x77, 0x2a, 0xc2, 0x63, 0x0c, 0x9f, 0x39, 0xd9, 0x6e,
-		0xfe, 0x0b, 0xfb, 0xe0, 0x1e, 0x60, 0xd0, 0x6a, 0xee, 0x10, 0x6b, 0xb9, 0x0b, 0xb2, 0x6d, 0x84,
-		0x19, 0xbe, 0xe2, 0xcb, 0x41, 0x9f, 0xb9, 0xf3, 0x1e, 0x54, 0x2c, 0x5b, 0x37, 0x6d, 0xdd, 0x3d,
-		0xa0, 0xb7, 0x57, 0x92, 0x4a, 0x4e, 0x54, 0x6c, 0x70, 0xb8, 0xbc, 0x0f, 0x63, 0x9b, 0x34, 0xb7,
-		0xf0, 0x25, 0x3f, 0xeb, 0xcb, 0x27, 0xc5, 0xcb, 0xd7, 0x51, 0xb2, 0x44, 0x8b, 0x64, 0xa5, 0xe7,
-		0x3a, 0x5a, 0xe7, 0x13, 0xfd, 0x5b, 0x67, 0x38, 0xda, 0xfd, 0xd1, 0x89, 0xd0, 0xe4, 0xe4, 0xa9,
-		0x64, 0xc0, 0x7d, 0xf5, 0x6a, 0x98, 0x71, 0x29, 0x75, 0xa1, 0x7b, 0x50, 0x2d, 0xc4, 0xb8, 0xd1,
-		0x42, 0xec, 0x14, 0x92, 0x9f, 0x82, 0x91, 0x0d, 0xd5, 0x76, 0x37, 0xb1, 0x7b, 0x11, 0xab, 0x55,
-		0x6c, 0x87, 0xa3, 0xee, 0x88, 0x88, 0xba, 0x08, 0x52, 0x34, 0xb4, 0xb2, 0xa8, 0x43, 0x7f, 0xcb,
-		0x7b, 0x90, 0xa2, 0x37, 0xd8, 0xbc, 0x88, 0xcc, 0x29, 0x58, 0x44, 0x26, 0xbe, 0xf4, 0xc0, 0xc5,
-		0x8e, 0x58, 0xd0, 0xd1, 0x02, 0x7a, 0x5c, 0xc4, 0xd5, 0x64, 0xf7, 0xb8, 0xca, 0x0d, 0x91, 0x47,
-		0xd7, 0x3a, 0x0c, 0x95, 0x88, 0x2b, 0x5e, 0x5e, 0xf4, 0x04, 0x91, 0x7c, 0x41, 0xd0, 0x2a, 0x8c,
-		0x59, 0xaa, 0xed, 0xd2, 0xab, 0xfb, 0x7b, 0xb4, 0x17, 0xdc, 0xd6, 0xa7, 0x5b, 0x67, 0x5e, 0xa8,
-		0xb3, 0xbc, 0x95, 0x11, 0x2b, 0x08, 0x94, 0xff, 0x30, 0x05, 0x83, 0x5c, 0x19, 0x6f, 0x86, 0x21,
-		0xae, 0x56, 0x6e, 0x9d, 0x77, 0xce, 0xb6, 0x06, 0xa6, 0x59, 0x2f, 0x80, 0x70, 0x7e, 0x82, 0x06,
-		0xdd, 0x07, 0x69, 0x6d, 0x4f, 0xd5, 0x8d, 0x8a, 0x5e, 0x15, 0x69, 0xde, 0xeb, 0x37, 0xa6, 0x87,
-		0x16, 0x08, 0x6c, 0x79, 0x51, 0x19, 0xa2, 0x95, 0xcb, 0x55, 0x92, 0x09, 0xec, 0x61, 0xbd, 0xb6,
-		0xe7, 0xf2, 0x19, 0xc6, 0x4b, 0xe8, 0x49, 0x48, 0x11, 0x83, 0xe0, 0x0f, 0xbb, 0x0a, 0x2d, 0xc9,
-		0xb6, 0xb7, 0xe2, 0x29, 0xa5, 0x49, 0xc3, 0x1f, 0xfa, 0xfd, 0x69, 0x49, 0xa1, 0x14, 0x68, 0x01,
-		0x46, 0xea, 0xaa, 0xe3, 0x56, 0x68, 0x04, 0x23, 0xcd, 0x0f, 0x50, 0x16, 0x27, 0x5a, 0x15, 0xc2,
-		0x15, 0xcb, 0x45, 0x1f, 0x26, 0x54, 0x0c, 0x54, 0x45, 0xa7, 0x20, 0x47, 0x99, 0x68, 0x66, 0xa3,
-		0xa1, 0xbb, 0x2c, 0xb7, 0x1a, 0xa4, 0x7a, 0x1f, 0x25, 0xf0, 0x05, 0x0a, 0xa6, 0x19, 0xd6, 0x1d,
-		0x90, 0xa1, 0x4f, 0x49, 0x28, 0x0a, 0xbb, 0x36, 0x99, 0x26, 0x00, 0x5a, 0x79, 0x3f, 0x8c, 0xf9,
-		0xfe, 0x91, 0xa1, 0xa4, 0x19, 0x17, 0x1f, 0x4c, 0x11, 0x1f, 0x81, 0x49, 0x03, 0x5f, 0xa3, 0x17,
-		0x39, 0x43, 0xd8, 0x19, 0x8a, 0x8d, 0x48, 0xdd, 0xe5, 0x30, 0xc5, 0xbd, 0x30, 0xaa, 0x09, 0xe5,
-		0x33, 0x5c, 0xa0, 0xb8, 0x23, 0x1e, 0x94, 0xa2, 0x9d, 0x80, 0xb4, 0x6a, 0x59, 0x0c, 0x61, 0x98,
-		0xfb, 0x47, 0xcb, 0xa2, 0x55, 0xa7, 0x61, 0x9c, 0xf6, 0xd1, 0xc6, 0x4e, 0xb3, 0xee, 0x72, 0x26,
-		0x59, 0x8a, 0x33, 0x46, 0x2a, 0x14, 0x06, 0xa7, 0xb8, 0x77, 0xc3, 0x08, 0xbe, 0xa2, 0x57, 0xb1,
-		0xa1, 0x61, 0x86, 0x37, 0x42, 0xf1, 0xb2, 0x02, 0x48, 0x91, 0x1e, 0x00, 0xcf, 0xef, 0x55, 0x84,
-		0x4f, 0x1e, 0x65, 0xfc, 0x04, 0x7c, 0x9e, 0x81, 0xe5, 0x3c, 0xa4, 0x16, 0x55, 0x57, 0x25, 0x09,
-		0x86, 0x7b, 0x8d, 0x05, 0x9a, 0xac, 0x42, 0x7e, 0xca, 0x6f, 0x24, 0x20, 0x75, 0xd9, 0x74, 0x31,
-		0x7a, 0x2c, 0x90, 0x00, 0x8e, 0xb6, 0xb3, 0xe7, 0x4d, 0xbd, 0x66, 0xe0, 0xea, 0xaa, 0x53, 0x0b,
-		0xbc, 0xfb, 0xf6, 0xcd, 0x29, 0x11, 0x32, 0xa7, 0x49, 0x18, 0xb0, 0xcd, 0xa6, 0x51, 0x15, 0x37,
-		0x0e, 0x69, 0x01, 0x95, 0x21, 0xed, 0x59, 0x49, 0x2a, 0xce, 0x4a, 0xc6, 0x88, 0x95, 0x10, 0x1b,
-		0xe6, 0x00, 0x65, 0x68, 0x87, 0x1b, 0x4b, 0x09, 0x32, 0x9e, 0xf3, 0xe2, 0xd6, 0xd6, 0x9b, 0xc1,
-		0xfa, 0x64, 0x24, 0x98, 0x78, 0x63, 0xef, 0x29, 0x8f, 0x59, 0x5c, 0xce, 0xab, 0xe0, 0xda, 0x0b,
-		0x99, 0x15, 0x7f, 0x83, 0x3e, 0x44, 0xfb, 0xe5, 0x9b, 0x15, 0x7b, 0x87, 0x7e, 0x12, 0x32, 0x8e,
-		0x5e, 0x33, 0x54, 0xb7, 0x69, 0x63, 0x6e, 0x79, 0x3e, 0x40, 0xfe, 0x92, 0x04, 0x83, 0xcc, 0x92,
-		0x03, 0x7a, 0x93, 0xda, 0xeb, 0x2d, 0xd1, 0x49, 0x6f, 0xc9, 0xc3, 0xeb, 0x6d, 0x1e, 0xc0, 0x13,
-		0xc6, 0xe1, 0x4f, 0x83, 0xdb, 0x64, 0x0c, 0x4c, 0xc4, 0x4d, 0xbd, 0xc6, 0x27, 0x6a, 0x80, 0x48,
-		0xfe, 0x8f, 0x12, 0x49, 0x62, 0x79, 0x3d, 0x9a, 0x87, 0x11, 0x21, 0x57, 0x65, 0xb7, 0xae, 0xd6,
-		0xb8, 0xed, 0xdc, 0xd9, 0x51, 0xb8, 0x0b, 0x75, 0xb5, 0xa6, 0x0c, 0x73, 0x79, 0x48, 0xa1, 0xfd,
-		0x38, 0x24, 0x3a, 0x8c, 0x43, 0x68, 0xe0, 0x93, 0x87, 0x1b, 0xf8, 0xd0, 0x10, 0xa5, 0xa2, 0x43,
-		0xf4, 0xf9, 0x04, 0x5d, 0xcc, 0x58, 0xa6, 0xa3, 0xd6, 0x7f, 0x18, 0x33, 0xe2, 0x0e, 0xc8, 0x58,
-		0x66, 0xbd, 0xc2, 0x6a, 0xd8, 0x4d, 0xdc, 0xb4, 0x65, 0xd6, 0x95, 0x96, 0x61, 0x1f, 0xb8, 0x45,
-		0xd3, 0x65, 0xf0, 0x16, 0x68, 0x6d, 0x28, 0xaa, 0x35, 0x1b, 0xb2, 0x4c, 0x15, 0x3c, 0x96, 0x3d,
-		0x42, 0x74, 0x40, 0x83, 0xa3, 0xd4, 0x1a, 0x7b, 0x99, 0xd8, 0x0c, 0x53, 0xe1, 0x78, 0x84, 0x82,
-		0xb9, 0xfe, 0x76, 0xab, 0xe0, 0xa0, 0x59, 0x2a, 0x1c, 0x4f, 0xfe, 0x39, 0x09, 0x60, 0x85, 0x68,
-		0x96, 0xf6, 0x97, 0x44, 0x21, 0x87, 0x8a, 0x50, 0x09, 0xb5, 0x3c, 0xd5, 0x69, 0xd0, 0x78, 0xfb,
-		0x59, 0x27, 0x28, 0xf7, 0x02, 0x8c, 0xf8, 0xc6, 0xe8, 0x60, 0x21, 0xcc, 0x54, 0x97, 0xac, 0x7a,
-		0x13, 0xbb, 0x4a, 0xf6, 0x4a, 0xa0, 0x24, 0xff, 0x33, 0x09, 0x32, 0x54, 0xa6, 0x55, 0xec, 0xaa,
-		0xa1, 0x31, 0x94, 0x0e, 0x3f, 0x86, 0x77, 0x02, 0x30, 0x36, 0x8e, 0xfe, 0x32, 0xe6, 0x96, 0x95,
-		0xa1, 0x90, 0x4d, 0xfd, 0x65, 0x8c, 0xce, 0x79, 0x0a, 0x4f, 0x76, 0x57, 0xb8, 0xc8, 0xba, 0xb9,
-		0xda, 0x8f, 0xc3, 0x10, 0xfd, 0x94, 0xce, 0x35, 0x87, 0x27, 0xd2, 0x83, 0x46, 0xb3, 0xb1, 0x75,
-		0xcd, 0x91, 0x5f, 0x84, 0xa1, 0xad, 0x6b, 0x6c, 0x6f, 0xe4, 0x0e, 0xc8, 0xd8, 0xa6, 0xc9, 0x63,
-		0x32, 0xcb, 0x85, 0xd2, 0x04, 0x40, 0x43, 0x90, 0xd8, 0x0f, 0x48, 0xf8, 0xfb, 0x01, 0xfe, 0x86,
-		0x46, 0xb2, 0xa7, 0x0d, 0x8d, 0xd3, 0xff, 0x4e, 0x82, 0xe1, 0x80, 0x7f, 0x40, 0x8f, 0xc2, 0xd1,
-		0xd2, 0xca, 0xfa, 0xc2, 0xa5, 0xca, 0xf2, 0x62, 0xe5, 0xc2, 0xca, 0xfc, 0x92, 0xff, 0xd6, 0xa4,
-		0x70, 0xec, 0xd5, 0xeb, 0x33, 0x28, 0x80, 0xbb, 0x6d, 0xec, 0x1b, 0xe6, 0x55, 0x03, 0xcd, 0xc1,
-		0x64, 0x98, 0x64, 0xbe, 0xb4, 0x59, 0x5e, 0xdb, 0xca, 0x49, 0x85, 0xa3, 0xaf, 0x5e, 0x9f, 0x19,
-		0x0f, 0x50, 0xcc, 0xef, 0x38, 0xd8, 0x70, 0x5b, 0x09, 0x16, 0xd6, 0x57, 0x57, 0x97, 0xb7, 0x72,
-		0x89, 0x16, 0x02, 0xee, 0xb0, 0x1f, 0x80, 0xf1, 0x30, 0xc1, 0xda, 0xf2, 0x4a, 0x2e, 0x59, 0x40,
-		0xaf, 0x5e, 0x9f, 0x19, 0x0d, 0x60, 0xaf, 0xe9, 0xf5, 0x42, 0xfa, 0xfd, 0x9f, 0x9e, 0x3a, 0xf2,
-		0x4b, 0xbf, 0x38, 0x25, 0x91, 0x9e, 0x8d, 0x84, 0x7c, 0x04, 0x7a, 0x08, 0x8e, 0x6f, 0x2e, 0x2f,
-		0xad, 0x95, 0x17, 0x2b, 0xab, 0x9b, 0x4b, 0x15, 0xf6, 0x8d, 0x0d, 0xaf, 0x77, 0x63, 0xaf, 0x5e,
-		0x9f, 0x19, 0xe6, 0x5d, 0xea, 0x84, 0xbd, 0xa1, 0x94, 0x2f, 0xaf, 0x6f, 0x95, 0x73, 0x12, 0xc3,
-		0xde, 0xb0, 0xf1, 0x15, 0xd3, 0x65, 0xdf, 0xda, 0x7a, 0x04, 0x4e, 0xb4, 0xc1, 0xf6, 0x3a, 0x36,
-		0xfe, 0xea, 0xf5, 0x99, 0x91, 0x0d, 0x1b, 0xb3, 0xf9, 0x43, 0x29, 0x66, 0x21, 0xdf, 0x4a, 0xb1,
-		0xbe, 0xb1, 0xbe, 0x39, 0xbf, 0x92, 0x9b, 0x29, 0xe4, 0x5e, 0xbd, 0x3e, 0x93, 0x15, 0xce, 0x90,
-		0xe0, 0xfb, 0x3d, 0xbb, 0x9d, 0x2b, 0x9e, 0x3f, 0x79, 0x18, 0xee, 0xe1, 0x7b, 0x80, 0x8e, 0xab,
-		0xee, 0xeb, 0x46, 0xcd, 0xdb, 0x69, 0xe5, 0x65, 0xbe, 0xf2, 0x39, 0xc6, 0x37, 0x5b, 0x05, 0xb4,
-		0xeb, 0x7e, 0x6b, 0xa1, 0xf3, 0xc9, 0x52, 0x21, 0xe6, 0xf0, 0x25, 0x7e, 0xe9, 0xd4, 0x79, 0x6f,
-		0xbe, 0x10, 0xb3, 0x63, 0x5c, 0xe8, 0xba, 0xb8, 0x93, 0x3f, 0x20, 0xc1, 0xe8, 0x45, 0xdd, 0x71,
-		0x4d, 0x5b, 0xd7, 0xd4, 0x3a, 0x7d, 0x61, 0x72, 0xae, 0x57, 0xdf, 0x1a, 0x99, 0xea, 0xcf, 0xc0,
-		0xe0, 0x15, 0xb5, 0xce, 0x9c, 0x5a, 0x92, 0x7e, 0x10, 0xa3, 0xbd, 0xfa, 0x7c, 0xd7, 0x26, 0x18,
-		0x30, 0x32, 0xf9, 0x57, 0x12, 0x30, 0x46, 0x27, 0x83, 0xc3, 0x3e, 0x95, 0x44, 0xd6, 0x58, 0x25,
-		0x48, 0xd9, 0xaa, 0xcb, 0x37, 0x0d, 0x4b, 0xb3, 0x7c, 0xe7, 0xf7, 0xbe, 0xf8, 0xdd, 0xdc, 0xd9,
-		0x45, 0xac, 0x29, 0x94, 0x16, 0xbd, 0x1d, 0xd2, 0x0d, 0xf5, 0x5a, 0x85, 0xf2, 0x61, 0x2b, 0x97,
-		0xf9, 0xfe, 0xf8, 0xdc, 0xbc, 0x31, 0x3d, 0x76, 0xa0, 0x36, 0xea, 0x45, 0x59, 0xf0, 0x91, 0x95,
-		0xa1, 0x86, 0x7a, 0x8d, 0x88, 0x88, 0x2c, 0x18, 0x23, 0x50, 0x6d, 0x4f, 0x35, 0x6a, 0x98, 0x35,
-		0x42, 0xb7, 0x40, 0x4b, 0x17, 0xfb, 0x6e, 0xe4, 0x98, 0xdf, 0x48, 0x80, 0x9d, 0xac, 0x8c, 0x34,
-		0xd4, 0x6b, 0x0b, 0x14, 0x40, 0x5a, 0x2c, 0xa6, 0x3f, 0xfa, 0xc9, 0xe9, 0x23, 0x74, 0x37, 0xfd,
-		0x1b, 0x12, 0x80, 0xaf, 0x31, 0xf4, 0x76, 0xc8, 0x69, 0x5e, 0x89, 0xd2, 0x3a, 0x7c, 0x0c, 0xef,
-		0xef, 0x34, 0x16, 0x11, 0x7d, 0xb3, 0xd8, 0xfc, 0xf5, 0x1b, 0xd3, 0x92, 0x32, 0xa6, 0x45, 0x86,
-		0xe2, 0x6d, 0x30, 0xdc, 0xb4, 0xaa, 0xaa, 0x8b, 0x2b, 0x74, 0x1d, 0x97, 0x88, 0x8d, 0xf3, 0x53,
-		0x84, 0xd7, 0xcd, 0x1b, 0xd3, 0x88, 0x75, 0x2b, 0x40, 0x2c, 0xd3, 0xe8, 0x0f, 0x0c, 0x42, 0x08,
-		0x02, 0x7d, 0xfa, 0xaa, 0x04, 0xc3, 0x8b, 0x81, 0x9b, 0x5e, 0x79, 0x18, 0x6a, 0x98, 0x86, 0xbe,
-		0xcf, 0xed, 0x31, 0xa3, 0x88, 0x22, 0x2a, 0x40, 0x9a, 0x3d, 0xba, 0x73, 0x0f, 0xc4, 0x56, 0xa8,
-		0x28, 0x13, 0xaa, 0xab, 0x78, 0xc7, 0xd1, 0xc5, 0x68, 0x28, 0xa2, 0x88, 0x2e, 0x40, 0xce, 0xc1,
-		0x5a, 0xd3, 0xd6, 0xdd, 0x83, 0x8a, 0x66, 0x1a, 0xae, 0xaa, 0xb9, 0xec, 0xf9, 0x56, 0xe9, 0x8e,
-		0x9b, 0x37, 0xa6, 0x8f, 0x33, 0x59, 0xa3, 0x18, 0xb2, 0x32, 0x26, 0x40, 0x0b, 0x0c, 0x42, 0x5a,
-		0xa8, 0x62, 0x57, 0xd5, 0xeb, 0x4e, 0x9e, 0x1d, 0x0c, 0x89, 0x62, 0xa0, 0x2f, 0x9f, 0x1b, 0x0a,
-		0x6e, 0x6c, 0x5d, 0x80, 0x9c, 0x69, 0x61, 0x3b, 0x94, 0x88, 0x4a, 0xd1, 0x96, 0xa3, 0x18, 0xb2,
-		0x32, 0x26, 0x40, 0x22, 0x49, 0x75, 0xc9, 0x30, 0x8b, 0x85, 0xa2, 0xd5, 0xdc, 0xf1, 0xf7, 0xc3,
-		0x26, 0x5b, 0x46, 0x63, 0xde, 0x38, 0x28, 0x3d, 0xe6, 0x73, 0x8f, 0xd2, 0xc9, 0x5f, 0xfb, 0xc2,
-		0xc3, 0x93, 0xdc, 0x34, 0xfc, 0xfd, 0xa9, 0x4b, 0xf8, 0x80, 0x0c, 0x3f, 0x47, 0xdd, 0xa0, 0x98,
-		0x24, 0xed, 0x7c, 0x51, 0xd5, 0xeb, 0xe2, 0x19, 0xb2, 0xc2, 0x4b, 0xa8, 0x08, 0x83, 0x8e, 0xab,
-		0xba, 0x4d, 0x87, 0x7f, 0x1c, 0x4c, 0xee, 0x64, 0x6a, 0x25, 0xd3, 0xa8, 0x6e, 0x52, 0x4c, 0x85,
-		0x53, 0xa0, 0x0b, 0x30, 0xe8, 0x9a, 0xfb, 0xd8, 0xe0, 0x2a, 0xec, 0x6b, 0x7e, 0xd3, 0x73, 0x2a,
-		0x46, 0x4d, 0x34, 0x52, 0xc5, 0x75, 0x5c, 0x63, 0x69, 0xd5, 0x9e, 0x4a, 0x56, 0x1f, 0xf4, 0x1b,
-		0x61, 0xa5, 0xe5, 0xbe, 0x27, 0x21, 0xd7, 0x54, 0x94, 0x9f, 0xac, 0x8c, 0x79, 0xa0, 0x4d, 0x0a,
-		0x41, 0x97, 0x42, 0x57, 0x12, 0xf9, 0x87, 0xf4, 0xee, 0xee, 0xd4, 0xfd, 0x80, 0x4d, 0x8b, 0xfd,
-		0x89, 0xe0, 0x85, 0xc6, 0x0b, 0x90, 0x6b, 0x1a, 0x3b, 0xa6, 0x41, 0xdf, 0x0a, 0xf2, 0xfc, 0x9e,
-		0xac, 0xef, 0x92, 0x41, 0xe3, 0x88, 0x62, 0xc8, 0xca, 0x98, 0x07, 0xba, 0xc8, 0x56, 0x01, 0x55,
-		0x18, 0xf5, 0xb1, 0xe8, 0x44, 0xcd, 0xc4, 0x4e, 0xd4, 0xbb, 0xf8, 0x44, 0x3d, 0x1a, 0x6d, 0xc5,
-		0x9f, 0xab, 0x23, 0x1e, 0x90, 0x90, 0xa1, 0x8b, 0x00, 0xbe, 0x7b, 0xa0, 0xfb, 0x14, 0xc3, 0x9d,
-		0x07, 0xde, 0xf7, 0x31, 0x62, 0xbd, 0xe7, 0xd3, 0xa2, 0x77, 0xc2, 0x44, 0x43, 0x37, 0x2a, 0x0e,
-		0xae, 0xef, 0x56, 0xb8, 0x82, 0x09, 0x4b, 0xfa, 0xa9, 0x97, 0xd2, 0x4a, 0x7f, 0xf6, 0x70, 0xf3,
-		0xc6, 0x74, 0x81, 0xbb, 0xd0, 0x56, 0x96, 0xb2, 0x32, 0xde, 0xd0, 0x8d, 0x4d, 0x5c, 0xdf, 0x5d,
-		0xf4, 0x60, 0xc5, 0xec, 0xfb, 0x3f, 0x39, 0x7d, 0x84, 0x4f, 0xd7, 0x23, 0xf2, 0x39, 0xba, 0x77,
-		0xce, 0xa7, 0x19, 0x76, 0xc8, 0x9a, 0x44, 0x15, 0x05, 0xba, 0xa3, 0x91, 0x51, 0x7c, 0x00, 0x9b,
-		0xe6, 0xaf, 0xfc, 0x87, 0x19, 0x49, 0xfe, 0x9c, 0x04, 0x83, 0x8b, 0x97, 0x37, 0x54, 0xdd, 0x46,
-		0xcb, 0x30, 0xee, 0x5b, 0x4e, 0x78, 0x92, 0x9f, 0xbc, 0x79, 0x63, 0x3a, 0x1f, 0x35, 0x2e, 0x6f,
-		0x96, 0xfb, 0x06, 0x2c, 0xa6, 0xf9, 0x72, 0xa7, 0x85, 0x6b, 0x88, 0x55, 0x0b, 0x8a, 0xdc, 0xba,
-		0xac, 0x8d, 0x74, 0xb3, 0x0c, 0x43, 0x4c, 0x5a, 0x07, 0x15, 0x61, 0xc0, 0x22, 0x3f, 0xf8, 0xc1,
-		0xc0, 0x54, 0x47, 0xe3, 0xa5, 0xf8, 0xde, 0x46, 0x26, 0x21, 0x91, 0x3f, 0x9c, 0x00, 0x58, 0xbc,
-		0x7c, 0x79, 0xcb, 0xd6, 0xad, 0x3a, 0x76, 0x6f, 0x65, 0xcf, 0xb7, 0xe0, 0x68, 0x60, 0x95, 0x64,
-		0x6b, 0x91, 0xde, 0xcf, 0xdc, 0xbc, 0x31, 0x7d, 0x32, 0xda, 0xfb, 0x00, 0x9a, 0xac, 0x4c, 0xf8,
-		0xeb, 0x25, 0x5b, 0x6b, 0xcb, 0xb5, 0xea, 0xb8, 0x1e, 0xd7, 0x64, 0x67, 0xae, 0x01, 0xb4, 0x20,
-		0xd7, 0x45, 0xc7, 0x6d, 0xaf, 0xda, 0x4d, 0x18, 0xf6, 0x55, 0xe2, 0xa0, 0x45, 0x48, 0xbb, 0xfc,
-		0x37, 0xd7, 0xb0, 0xdc, 0x59, 0xc3, 0x82, 0x8c, 0x6b, 0xd9, 0xa3, 0x94, 0xff, 0x4c, 0x02, 0xf0,
-		0x6d, 0xf6, 0xc7, 0xd3, 0xc4, 0x88, 0x2b, 0xe7, 0x8e, 0x37, 0x79, 0xa8, 0x54, 0x8d, 0x53, 0x47,
-		0xf4, 0xf9, 0xd3, 0x09, 0x98, 0xd8, 0x16, 0x9e, 0xe7, 0xc7, 0x5e, 0x07, 0x1b, 0x30, 0x84, 0x0d,
-		0xd7, 0xd6, 0xa9, 0x12, 0xc8, 0x68, 0x3f, 0xd2, 0x69, 0xb4, 0xdb, 0xf4, 0x89, 0x7e, 0xec, 0x46,
-		0x6c, 0xba, 0x73, 0x36, 0x11, 0x6d, 0x7c, 0x30, 0x09, 0xf9, 0x4e, 0x94, 0x68, 0x01, 0xc6, 0x34,
-		0x1b, 0x53, 0x40, 0x25, 0xb8, 0xf3, 0x57, 0x2a, 0xf8, 0x99, 0x65, 0x04, 0x41, 0x56, 0x46, 0x05,
-		0x84, 0x47, 0x8f, 0x1a, 0x90, 0xb4, 0x8f, 0x98, 0x1d, 0xc1, 0xea, 0x31, 0xcf, 0x93, 0x79, 0xf8,
-		0x10, 0x8d, 0x84, 0x19, 0xb0, 0xf8, 0x31, 0xea, 0x43, 0x69, 0x00, 0x79, 0x09, 0xc6, 0x74, 0x43,
-		0x77, 0x75, 0xb5, 0x5e, 0xd9, 0x51, 0xeb, 0xaa, 0xa1, 0x1d, 0x26, 0x6b, 0x66, 0x2e, 0x9f, 0x37,
-		0x1b, 0x61, 0x27, 0x2b, 0xa3, 0x1c, 0x52, 0x62, 0x00, 0x74, 0x11, 0x86, 0x44, 0x53, 0xa9, 0x43,
-		0x65, 0x1b, 0x82, 0x3c, 0x90, 0xe0, 0xfd, 0x4c, 0x12, 0xc6, 0x15, 0x5c, 0xfd, 0xff, 0x43, 0xd1,
-		0xdf, 0x50, 0xac, 0x02, 0xb0, 0xe9, 0x4e, 0x1c, 0xec, 0x21, 0x46, 0x83, 0x38, 0x8c, 0x0c, 0xe3,
-		0xb0, 0xe8, 0xb8, 0x81, 0xf1, 0xb8, 0x91, 0x80, 0x6c, 0x70, 0x3c, 0xfe, 0x82, 0x46, 0x25, 0xb4,
-		0xec, 0x7b, 0xa2, 0x14, 0xff, 0x44, 0x68, 0x07, 0x4f, 0xd4, 0x62, 0xbd, 0xdd, 0x5d, 0xd0, 0xff,
-		0x48, 0xc0, 0xe0, 0x86, 0x6a, 0xab, 0x0d, 0x07, 0x69, 0x2d, 0x99, 0xa6, 0xd8, 0x7e, 0x6c, 0xf9,
-		0x10, 0x34, 0xdf, 0xed, 0x88, 0x49, 0x34, 0x3f, 0xda, 0x26, 0xd1, 0xfc, 0x09, 0x18, 0x25, 0xcb,
-		0xe1, 0xc0, 0x15, 0x06, 0xa2, 0xed, 0x91, 0xd2, 0x09, 0x9f, 0x4b, 0xb8, 0x9e, 0xad, 0x96, 0x2f,
-		0x07, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0xdf, 0x31, 0x13, 0xf2, 0x63, 0xfe, 0xb2, 0x34, 0x50, 0x29,
-		0x2b, 0xd0, 0x50, 0xaf, 0x95, 0x59, 0x01, 0xad, 0x00, 0xda, 0xf3, 0x76, 0x46, 0x2a, 0xbe, 0x3a,
-		0x09, 0xfd, 0x9d, 0x37, 0x6f, 0x4c, 0x9f, 0x60, 0xf4, 0xad, 0x38, 0xb2, 0x32, 0xee, 0x03, 0x05,
-		0xb7, 0xc7, 0x01, 0x48, 0xbf, 0x2a, 0xec, 0xfa, 0x1c, 0x5b, 0xee, 0x1c, 0xbd, 0x79, 0x63, 0x7a,
-		0x9c, 0x71, 0xf1, 0xeb, 0x64, 0x25, 0x43, 0x0a, 0x8b, 0xe4, 0x77, 0xc0, 0xb2, 0x3f, 0x2d, 0x01,
-		0xf2, 0x5d, 0xbe, 0x82, 0x1d, 0x8b, 0xac, 0xcf, 0x48, 0x22, 0x1e, 0xc8, 0x9a, 0xa5, 0xee, 0x89,
-		0xb8, 0x4f, 0x2f, 0x12, 0xf1, 0xc0, 0x4c, 0x79, 0xca, 0x77, 0x8f, 0x09, 0x3e, 0x8e, 0x6d, 0xee,
-		0x1a, 0xce, 0x2e, 0x98, 0xba, 0xa0, 0x6e, 0xf1, 0x87, 0x47, 0xe4, 0x7f, 0x25, 0xc1, 0x89, 0x16,
-		0x8b, 0xf2, 0x84, 0xfd, 0x4b, 0x80, 0xec, 0x40, 0x25, 0xff, 0xde, 0x1b, 0x13, 0xba, 0x6f, 0x03,
-		0x1d, 0xb7, 0x5b, 0xfc, 0xee, 0xad, 0xf3, 0xf0, 0xec, 0xb2, 0xe2, 0x3f, 0x95, 0x60, 0x32, 0xd8,
-		0xbc, 0xd7, 0x91, 0x35, 0xc8, 0x06, 0x5b, 0xe7, 0x5d, 0xb8, 0xa7, 0x97, 0x2e, 0x70, 0xe9, 0x43,
-		0xf4, 0xe8, 0x39, 0x7f, 0xba, 0xb2, 0xbd, 0xb3, 0x47, 0x7b, 0xd6, 0x86, 0x90, 0x29, 0x3a, 0x6d,
-		0x53, 0x74, 0x3c, 0xfe, 0x8f, 0x04, 0xa9, 0x0d, 0xd3, 0xac, 0x23, 0x13, 0xc6, 0x0d, 0xd3, 0xad,
-		0x10, 0xcb, 0xc2, 0xd5, 0x0a, 0x5f, 0x74, 0x33, 0x3f, 0xb8, 0xd0, 0x9f, 0x92, 0xbe, 0x7d, 0x63,
-		0xba, 0x95, 0x95, 0x32, 0x66, 0x98, 0x6e, 0x89, 0x42, 0xb6, 0xd8, 0x92, 0xfc, 0x9d, 0x30, 0x12,
-		0x6e, 0x8c, 0x79, 0xc9, 0xe7, 0xfb, 0x6e, 0x2c, 0xcc, 0xe6, 0xe6, 0x8d, 0xe9, 0x49, 0x7f, 0xc6,
-		0x78, 0x60, 0x59, 0xc9, 0xee, 0x04, 0x5a, 0x67, 0xd7, 0xbb, 0xbe, 0xfb, 0xc9, 0x69, 0xe9, 0xf4,
-		0x17, 0x25, 0x00, 0x7f, 0xe7, 0x01, 0x3d, 0x04, 0xc7, 0x4b, 0xeb, 0x6b, 0x8b, 0x95, 0xcd, 0xad,
-		0xf9, 0xad, 0xed, 0xcd, 0xca, 0xf6, 0xda, 0xe6, 0x46, 0x79, 0x61, 0xf9, 0xc2, 0x72, 0x79, 0xd1,
-		0xdf, 0x1e, 0x77, 0x2c, 0xac, 0xe9, 0xbb, 0x3a, 0xae, 0xa2, 0xfb, 0x60, 0x32, 0x8c, 0x4d, 0x4a,
-		0xe5, 0xc5, 0x9c, 0x54, 0xc8, 0xbe, 0x7a, 0x7d, 0x26, 0xcd, 0x72, 0x31, 0x5c, 0x45, 0xa7, 0xe0,
-		0x68, 0x2b, 0xde, 0xf2, 0xda, 0x52, 0x2e, 0x51, 0x18, 0x79, 0xf5, 0xfa, 0x4c, 0xc6, 0x4b, 0xda,
-		0x90, 0x0c, 0x28, 0x88, 0xc9, 0xf9, 0x25, 0x0b, 0xf0, 0xea, 0xf5, 0x99, 0x41, 0xa6, 0xc0, 0x42,
-		0xea, 0xfd, 0x9f, 0x9e, 0x3a, 0x52, 0xba, 0xd0, 0x71, 0x03, 0xfc, 0xa1, 0xae, 0xba, 0xbb, 0xe6,
-		0x6d, 0x6a, 0x87, 0x77, 0xbd, 0xff, 0x78, 0xa8, 0xe3, 0xae, 0x77, 0x0d, 0x1b, 0xd8, 0xd1, 0x9d,
-		0x43, 0xed, 0x7a, 0xf7, 0xb4, 0x93, 0x2e, 0xff, 0xce, 0x00, 0x64, 0x97, 0x58, 0x2b, 0x64, 0x20,
-		0x30, 0x7a, 0x13, 0x0c, 0x5a, 0x34, 0x8c, 0x78, 0xc7, 0x68, 0x1d, 0x0c, 0x9e, 0x05, 0x1b, 0xef,
-		0x2e, 0x17, 0x0b, 0x3d, 0x0e, 0xbf, 0xcc, 0xc1, 0xee, 0x98, 0xf9, 0xb7, 0xa6, 0xb2, 0x7d, 0xed,
-		0xf7, 0xb0, 0x9c, 0x85, 0x6f, 0xad, 0x44, 0xf9, 0xc9, 0xec, 0x5e, 0xc8, 0x16, 0x81, 0xb0, 0xdb,
-		0x61, 0xef, 0x95, 0xe0, 0x28, 0xc5, 0xf2, 0x03, 0x31, 0xc5, 0x14, 0xc9, 0xfe, 0xe9, 0x4e, 0x5d,
-		0x58, 0x51, 0x1d, 0xff, 0xae, 0x07, 0xbb, 0xcf, 0x75, 0x0f, 0x0f, 0x84, 0x27, 0x03, 0x8d, 0x47,
-		0xd9, 0xca, 0xca, 0x44, 0xbd, 0x85, 0xd2, 0x41, 0x4b, 0xa1, 0x0b, 0x7d, 0xa9, 0xfe, 0xb6, 0xda,
-		0x83, 0x97, 0xfb, 0x9e, 0x85, 0x61, 0xdf, 0x97, 0x38, 0xfc, 0xff, 0x53, 0xf4, 0x1e, 0x3b, 0x82,
-		0xc4, 0xe8, 0x7d, 0x12, 0x1c, 0xf5, 0xa3, 0x79, 0x90, 0x2d, 0xfb, 0x3f, 0x1e, 0x0f, 0xf6, 0xb1,
-		0x10, 0x8a, 0x2a, 0xa7, 0x2d, 0x5f, 0x59, 0x99, 0x6c, 0xb6, 0x92, 0x92, 0x25, 0xd8, 0x48, 0xd0,
-		0xb3, 0x3a, 0x79, 0xf1, 0xa9, 0xba, 0xde, 0x5d, 0x73, 0x98, 0x01, 0xfb, 0xdf, 0x02, 0x96, 0x69,
-		0xbb, 0xb8, 0x4a, 0x37, 0xe4, 0xd2, 0x8a, 0x57, 0x96, 0xd7, 0x00, 0xb5, 0x0e, 0x6e, 0xf4, 0x02,
-		0x63, 0xc6, 0xbf, 0xc0, 0x38, 0x09, 0x03, 0xc1, 0x2b, 0x7e, 0xac, 0x50, 0x4c, 0xbf, 0x9f, 0x87,
-		0xcf, 0x5b, 0x3e, 0xe7, 0xff, 0x45, 0x02, 0x4e, 0x07, 0x8f, 0x87, 0x5e, 0x6a, 0x62, 0xfb, 0xc0,
-		0x9b, 0xa2, 0x96, 0x5a, 0xd3, 0x8d, 0xe0, 0x1b, 0xa0, 0x13, 0xc1, 0x80, 0x4f, 0x71, 0x85, 0x9e,
-		0x64, 0x03, 0x86, 0x37, 0xd4, 0x1a, 0x56, 0xf0, 0x4b, 0x4d, 0xec, 0xb8, 0x6d, 0x2e, 0x99, 0x1f,
-		0x83, 0x41, 0x73, 0x77, 0x57, 0x1c, 0x69, 0xa7, 0x14, 0x5e, 0x22, 0x5d, 0xae, 0xeb, 0x0d, 0x9d,
-		0xdd, 0x06, 0x4b, 0x29, 0xac, 0x80, 0xa6, 0x61, 0x58, 0x33, 0x9b, 0x06, 0x9f, 0x71, 0xf9, 0x94,
-		0xf8, 0x00, 0x44, 0xd3, 0x60, 0x33, 0x4e, 0x7e, 0x06, 0xb2, 0xac, 0x3d, 0x1e, 0x71, 0x4f, 0x40,
-		0x9a, 0x5e, 0xa7, 0xf2, 0x5b, 0x1d, 0x22, 0xe5, 0x4b, 0xec, 0x42, 0x3a, 0xe3, 0xc2, 0x1a, 0x66,
-		0x85, 0x52, 0xa9, 0xa3, 0x2a, 0x4f, 0xc5, 0xbb, 0x06, 0xa6, 0x28, 0x4f, 0x8d, 0xbf, 0x39, 0x00,
-		0x47, 0xf9, 0x09, 0x9d, 0x6a, 0xe9, 0x73, 0x7b, 0xae, 0x2b, 0x5e, 0x09, 0x01, 0x4f, 0x75, 0x55,
-		0x4b, 0x97, 0x0f, 0x20, 0x75, 0xd1, 0x75, 0x2d, 0x74, 0x1a, 0x06, 0xec, 0x66, 0x1d, 0x8b, 0x1d,
-		0x1f, 0x6f, 0x4f, 0x5e, 0xb5, 0xf4, 0x59, 0x82, 0xa0, 0x34, 0xeb, 0x58, 0x61, 0x28, 0xa8, 0x0c,
-		0xd3, 0xbb, 0xcd, 0x7a, 0xfd, 0xa0, 0x52, 0xc5, 0xf4, 0x7f, 0xf7, 0x78, 0x5f, 0xbf, 0xc7, 0xd7,
-		0x2c, 0x55, 0x7c, 0x43, 0x8f, 0xe8, 0xe6, 0x24, 0x45, 0x5b, 0xa4, 0x58, 0xe2, 0xcb, 0xf7, 0x65,
-		0x81, 0x23, 0xff, 0x5e, 0x02, 0xd2, 0x82, 0x35, 0xbd, 0x21, 0x8e, 0xeb, 0x58, 0x73, 0x4d, 0x71,
-		0x62, 0xe2, 0x95, 0x11, 0x82, 0x64, 0x8d, 0x0f, 0x51, 0xe6, 0xe2, 0x11, 0x85, 0x14, 0x08, 0xcc,
-		0xbb, 0xb7, 0x4f, 0x60, 0x56, 0x93, 0x8c, 0x5a, 0xca, 0x32, 0xc5, 0xd2, 0xec, 0xe2, 0x11, 0x85,
-		0x96, 0x50, 0x1e, 0x06, 0xc9, 0xcc, 0x70, 0xd9, 0x87, 0x09, 0x09, 0x9c, 0x97, 0xd1, 0x31, 0x18,
-		0xb0, 0x54, 0x57, 0x63, 0x57, 0xea, 0x48, 0x05, 0x2b, 0xa2, 0x27, 0x60, 0x90, 0x3d, 0x08, 0x8d,
-		0xfe, 0x63, 0x0c, 0xa2, 0x0c, 0xf6, 0xe5, 0x2d, 0x22, 0xf7, 0x86, 0xea, 0xba, 0xd8, 0x36, 0x08,
-		0x43, 0x86, 0x8e, 0x10, 0xa4, 0x76, 0xcc, 0xea, 0x01, 0xff, 0x67, 0x1d, 0xf4, 0x37, 0xff, 0xef,
-		0x00, 0xd4, 0x1e, 0x2a, 0xb4, 0x92, 0xfd, 0x8f, 0xa2, 0xac, 0x00, 0x96, 0x08, 0x52, 0x19, 0x26,
-		0xd4, 0x6a, 0x55, 0x67, 0xff, 0x37, 0xa3, 0xb2, 0xa3, 0x53, 0x0f, 0xe1, 0xd0, 0xff, 0x40, 0xd5,
-		0x69, 0x2c, 0x90, 0x4f, 0x50, 0xe2, 0xf8, 0xa5, 0x0c, 0x0c, 0x59, 0x4c, 0x28, 0xf9, 0x3c, 0x8c,
-		0xb7, 0x48, 0x4a, 0xe4, 0xdb, 0xd7, 0x8d, 0xaa, 0x78, 0xcc, 0x40, 0x7e, 0x13, 0x18, 0xfd, 0x7a,
-		0x1e, 0x3b, 0x8b, 0xa2, 0xbf, 0x4b, 0xef, 0xee, 0xfc, 0xf0, 0x6b, 0x34, 0xf0, 0xf0, 0x4b, 0xb5,
-		0xf4, 0x52, 0x86, 0xf2, 0xe7, 0xcf, 0xbd, 0xe6, 0x79, 0x05, 0x7b, 0xea, 0x35, 0x6b, 0xda, 0x35,
-		0x12, 0xa5, 0x45, 0xf4, 0x25, 0x55, 0xaa, 0xa5, 0x3b, 0xd4, 0x1c, 0xfd, 0xaf, 0xf9, 0x39, 0xe7,
-		0x03, 0xbf, 0xe9, 0x23, 0xb0, 0xd4, 0xd2, 0xfc, 0xc6, 0xb2, 0x67, 0xc7, 0x5f, 0x4e, 0xc0, 0xc9,
-		0x80, 0x1d, 0x07, 0x90, 0x5b, 0xcd, 0xb9, 0xd0, 0xde, 0xe2, 0x7b, 0x78, 0xfc, 0x75, 0x09, 0x52,
-		0x04, 0x1f, 0xc5, 0x7c, 0xbb, 0x3f, 0xff, 0xab, 0x5f, 0xfb, 0x27, 0x72, 0xf8, 0xd4, 0x2a, 0x34,
-		0x2a, 0x94, 0x49, 0xe9, 0x7d, 0xbd, 0xeb, 0x2f, 0xe7, 0x7f, 0xc8, 0xd0, 0xb9, 0x75, 0x6a, 0x8c,
-		0xea, 0xf0, 0x5b, 0x67, 0x41, 0xee, 0x90, 0xf2, 0x30, 0x8f, 0xd9, 0x3d, 0x89, 0xea, 0xc3, 0x1d,
-		0x77, 0xba, 0xff, 0xdf, 0x6d, 0x04, 0x7b, 0x4c, 0xc7, 0xae, 0xc1, 0xb1, 0xe7, 0x48, 0xdb, 0xfe,
-		0x32, 0x59, 0x38, 0xf6, 0x63, 0xde, 0x69, 0x9e, 0xc4, 0xff, 0x01, 0x98, 0x38, 0xa9, 0x03, 0x5f,
-		0x3e, 0xbe, 0x40, 0xbc, 0x6f, 0xb6, 0x63, 0xbc, 0x98, 0x0d, 0x04, 0x0b, 0x25, 0x40, 0x29, 0xff,
-		0xb2, 0x04, 0xc7, 0x5b, 0x9a, 0xe6, 0x3e, 0x7e, 0xa9, 0xcd, 0x53, 0x85, 0x43, 0x65, 0x36, 0x4b,
-		0x6d, 0x84, 0xbd, 0x3f, 0x56, 0x58, 0x26, 0x45, 0x48, 0xda, 0xa7, 0xe1, 0x68, 0x58, 0x58, 0xa1,
-		0xa6, 0x7b, 0x61, 0x34, 0xbc, 0x23, 0xcc, 0xd5, 0x35, 0x12, 0xda, 0x13, 0x96, 0x2b, 0x51, 0x3d,
-		0x7b, 0x7d, 0x2d, 0x43, 0xc6, 0x43, 0xe5, 0x29, 0x70, 0xcf, 0x5d, 0xf5, 0x29, 0xe5, 0x0f, 0x4b,
-		0x30, 0x13, 0x6e, 0x21, 0x90, 0x0c, 0xf5, 0x27, 0xec, 0x2d, 0x1b, 0xe2, 0x37, 0x24, 0xb8, 0xab,
-		0x8b, 0x4c, 0x5c, 0x01, 0x2f, 0xc3, 0x64, 0x60, 0x27, 0x40, 0xb8, 0x70, 0x31, 0xec, 0xa7, 0xe3,
-		0xd3, 0x50, 0x6f, 0xe1, 0x7b, 0x07, 0x51, 0xca, 0x67, 0x7f, 0x7f, 0x7a, 0xa2, 0xb5, 0xce, 0x51,
-		0x26, 0x5a, 0x57, 0xef, 0xb7, 0xd0, 0x3e, 0x5e, 0x93, 0xe0, 0x81, 0x70, 0x57, 0xdb, 0xe4, 0xb3,
-		0x3f, 0xaa, 0x71, 0xf8, 0xf7, 0x12, 0x9c, 0xee, 0x45, 0x38, 0x3e, 0x20, 0x3b, 0x30, 0xe1, 0x67,
-		0xda, 0xd1, 0xf1, 0xe8, 0x2b, 0x7f, 0x67, 0x56, 0x8a, 0x3c, 0x6e, 0xb7, 0x41, 0xf1, 0x16, 0x9f,
-		0x58, 0xc1, 0x21, 0xf7, 0x94, 0x1c, 0xde, 0xcd, 0x15, 0x4a, 0x0e, 0xed, 0xe7, 0xb6, 0x19, 0x8b,
-		0x44, 0x9b, 0xb1, 0xf0, 0x53, 0x73, 0xf9, 0x0a, 0xf7, 0x5b, 0x6d, 0xf6, 0xe0, 0xde, 0x06, 0x13,
-		0x6d, 0x4c, 0x99, 0xcf, 0xea, 0x3e, 0x2c, 0x59, 0x41, 0xad, 0xc6, 0x2a, 0x1f, 0xc0, 0x34, 0x6d,
-		0xb7, 0x8d, 0xa2, 0x6f, 0x77, 0x97, 0x1b, 0xdc, 0xb7, 0xb4, 0x6d, 0x9a, 0xf7, 0x7d, 0x19, 0x06,
-		0xd9, 0x38, 0xf3, 0xee, 0x1e, 0xc2, 0x50, 0x38, 0x03, 0xf9, 0xe7, 0x85, 0x2f, 0x5b, 0x14, 0x62,
-		0xb7, 0x9f, 0x43, 0xbd, 0xf4, 0xf5, 0x16, 0xcd, 0xa1, 0x80, 0x32, 0xbe, 0x21, 0xbc, 0x5a, 0x7b,
-		0xe9, 0xb8, 0x3a, 0xb4, 0x5b, 0xe6, 0xd5, 0x98, 0x6e, 0x6e, 0xaf, 0xfb, 0xfa, 0x45, 0xe1, 0xbe,
-		0xbc, 0x3e, 0xc5, 0xb8, 0xaf, 0x1f, 0x8d, 0xea, 0x3d, 0x47, 0x16, 0x23, 0xe6, 0x9f, 0x47, 0x47,
-		0xf6, 0x5d, 0x09, 0x4e, 0xd0, 0xbe, 0x05, 0x37, 0x22, 0xfa, 0x55, 0xf9, 0x43, 0x80, 0x1c, 0x5b,
-		0xab, 0xb4, 0x9d, 0xdd, 0x39, 0xc7, 0xd6, 0x2e, 0x87, 0xe2, 0xcb, 0x43, 0x80, 0xaa, 0xa1, 0xed,
-		0x26, 0x8a, 0xcd, 0x6e, 0xc9, 0xe5, 0xaa, 0x81, 0xdd, 0x8c, 0x36, 0xc3, 0x99, 0xba, 0x05, 0xc3,
-		0xf9, 0x75, 0x09, 0x0a, 0xed, 0xba, 0xcc, 0x87, 0x4f, 0x87, 0x63, 0xa1, 0x43, 0x82, 0xe8, 0x08,
-		0x3e, 0xd4, 0xcb, 0x56, 0x4e, 0x64, 0x1a, 0x1d, 0xb5, 0xf1, 0xed, 0xce, 0x03, 0xa6, 0xc3, 0x16,
-		0xda, 0x9a, 0x59, 0xff, 0xc8, 0xa6, 0xcf, 0x17, 0x5a, 0xfc, 0xea, 0x9f, 0x8b, 0xdc, 0xfb, 0x1a,
-		0x4c, 0x75, 0x90, 0xfa, 0x76, 0xc7, 0xbd, 0xbd, 0x8e, 0x83, 0x79, 0xab, 0xd3, 0xf7, 0xc7, 0xf9,
-		0x4c, 0x08, 0xdf, 0xc0, 0x0e, 0xac, 0xc5, 0xda, 0x3d, 0xe1, 0x92, 0xdf, 0x02, 0x77, 0xb4, 0xa5,
-		0xe2, 0xb2, 0x15, 0x21, 0xb5, 0xa7, 0x3b, 0x2e, 0x17, 0xeb, 0xbe, 0x4e, 0x62, 0x45, 0xa8, 0x29,
-		0x8d, 0x8c, 0x20, 0x47, 0x59, 0x6f, 0x98, 0x66, 0x9d, 0x8b, 0x21, 0x5f, 0x82, 0xf1, 0x00, 0x8c,
-		0x37, 0x72, 0x0e, 0x52, 0x96, 0xc9, 0x3f, 0x4f, 0x30, 0x7c, 0xe6, 0x64, 0xc7, 0xdd, 0x7b, 0xd3,
-		0xac, 0xf3, 0x6e, 0x53, 0x7c, 0x79, 0x12, 0x10, 0x63, 0x46, 0x37, 0xf2, 0x45, 0x13, 0x9b, 0x30,
-		0x11, 0x82, 0xf2, 0x46, 0x7e, 0xa0, 0x43, 0x82, 0x33, 0xdf, 0x3e, 0x0a, 0x03, 0x94, 0x2b, 0xfa,
-		0x98, 0x04, 0x10, 0x38, 0x11, 0x9e, 0xed, 0xc4, 0xa6, 0xfd, 0x9a, 0xb8, 0x30, 0xd7, 0x33, 0x3e,
-		0xcf, 0xd9, 0x4e, 0xbf, 0xfb, 0xdf, 0x7c, 0xeb, 0x23, 0x89, 0x7b, 0x90, 0x3c, 0xd7, 0x61, 0x35,
-		0x1e, 0x98, 0x2f, 0x9f, 0x09, 0xbd, 0x7d, 0x7f, 0xb8, 0xb7, 0xa6, 0x84, 0x64, 0xb3, 0xbd, 0xa2,
-		0x73, 0xc1, 0xce, 0x53, 0xc1, 0xce, 0xa2, 0xc7, 0xe2, 0x05, 0x9b, 0x7b, 0x47, 0x78, 0xd2, 0xbc,
-		0x0b, 0xfd, 0x8e, 0x04, 0x93, 0xed, 0x96, 0x74, 0xe8, 0xc9, 0xde, 0xa4, 0x68, 0x4d, 0x29, 0x0a,
-		0x4f, 0x1d, 0x82, 0x92, 0x77, 0x65, 0x89, 0x76, 0x65, 0x1e, 0x3d, 0x73, 0x88, 0xae, 0xcc, 0x05,
-		0xf7, 0xf7, 0xff, 0x97, 0x04, 0x77, 0x76, 0x5d, 0x21, 0xa1, 0xf9, 0xde, 0xa4, 0xec, 0x92, 0x3b,
-		0x15, 0x4a, 0x3f, 0x08, 0x0b, 0xde, 0xe3, 0xe7, 0x68, 0x8f, 0x2f, 0xa1, 0xe5, 0xc3, 0xf4, 0xb8,
-		0xed, 0x21, 0x0a, 0xfa, 0xad, 0xf0, 0xcd, 0xc2, 0xee, 0xe6, 0xd4, 0xb2, 0xf0, 0x88, 0x99, 0x18,
-		0xad, 0x49, 0xad, 0xfc, 0x02, 0xed, 0x82, 0x82, 0x36, 0x7e, 0xc0, 0x41, 0x9b, 0x7b, 0x47, 0xd8,
-		0xf1, 0xbf, 0x0b, 0xfd, 0x4f, 0xa9, 0xfd, 0x45, 0xc1, 0x27, 0xba, 0x8a, 0xd8, 0x79, 0x51, 0x55,
-		0x78, 0xb2, 0x7f, 0x42, 0xde, 0xc9, 0x06, 0xed, 0x64, 0x0d, 0xe1, 0x5b, 0xdd, 0xc9, 0xb6, 0x83,
-		0x88, 0xbe, 0x2a, 0xc1, 0x64, 0xbb, 0x35, 0x49, 0xcc, 0xb4, 0xec, 0xb2, 0xc8, 0x8a, 0x99, 0x96,
-		0xdd, 0x16, 0x40, 0xf2, 0x9b, 0x68, 0xe7, 0xcf, 0xa1, 0xc7, 0x3b, 0x75, 0xbe, 0xeb, 0x28, 0x92,
-		0xb9, 0xd8, 0x35, 0xc9, 0x8f, 0x99, 0x8b, 0xbd, 0xac, 0x63, 0x62, 0xe6, 0x62, 0x4f, 0x6b, 0x8c,
-		0xf8, 0xb9, 0xe8, 0xf5, 0xac, 0xc7, 0x61, 0x74, 0xd0, 0x97, 0x25, 0x18, 0x09, 0x65, 0xc4, 0xe8,
-		0xd1, 0xae, 0x82, 0xb6, 0x5b, 0x30, 0x14, 0xce, 0xf4, 0x43, 0xc2, 0xfb, 0xb2, 0x4c, 0xfb, 0xb2,
-		0x80, 0xe6, 0x0f, 0xd3, 0x97, 0xf0, 0x59, 0xe9, 0xd7, 0x25, 0x98, 0x68, 0x93, 0x65, 0xc6, 0xcc,
-		0xc2, 0xce, 0x49, 0x73, 0xe1, 0xc9, 0xfe, 0x09, 0x79, 0xaf, 0x2e, 0xd0, 0x5e, 0xfd, 0x04, 0x7a,
-		0xfa, 0x30, 0xbd, 0x0a, 0xc4, 0xe7, 0x1b, 0xfe, 0xbd, 0xab, 0x40, 0x3b, 0xe8, 0x5c, 0x9f, 0x82,
-		0x89, 0x0e, 0x3d, 0xd1, 0x37, 0x1d, 0xef, 0xcf, 0xf3, 0xb4, 0x3f, 0xcf, 0xa1, 0xf5, 0x1f, 0xac,
-		0x3f, 0xad, 0x61, 0xfd, 0xf3, 0xad, 0x2f, 0x00, 0xbb, 0x5b, 0x51, 0xdb, 0x64, 0xb5, 0xf0, 0x58,
-		0x5f, 0x34, 0xbc, 0x53, 0x4f, 0xd2, 0x4e, 0x9d, 0x41, 0x8f, 0x74, 0xea, 0x54, 0xe0, 0x72, 0x9d,
-		0x6e, 0xec, 0x9a, 0x73, 0xef, 0x60, 0x29, 0xf0, 0xbb, 0xd0, 0x4f, 0x89, 0x8b, 0x4d, 0xa7, 0xba,
-		0xb6, 0x1b, 0xc8, 0x63, 0x0b, 0x0f, 0xf4, 0x80, 0xc9, 0xe5, 0xba, 0x87, 0xca, 0x35, 0x85, 0x4e,
-		0x76, 0x92, 0x8b, 0xe4, 0xb2, 0xe8, 0x03, 0x92, 0x77, 0x17, 0xf2, 0x74, 0x77, 0xde, 0xc1, 0x64,
-		0xb7, 0xf0, 0x60, 0x4f, 0xb8, 0x5c, 0x92, 0xfb, 0xa8, 0x24, 0x33, 0x68, 0xaa, 0xa3, 0x24, 0x2c,
-		0xf5, 0xbd, 0xd5, 0x37, 0x07, 0x5e, 0x3d, 0x0e, 0xd3, 0x1d, 0x5a, 0x74, 0xaf, 0xc5, 0x9c, 0x71,
-		0x75, 0x79, 0x08, 0x1b, 0xfb, 0xd0, 0xb5, 0xc3, 0xd3, 0xda, 0xc3, 0x3f, 0x7f, 0xed, 0xed, 0x40,
-		0xec, 0x5f, 0xa7, 0x00, 0xad, 0x3a, 0xb5, 0x05, 0x1b, 0xb3, 0x7f, 0x7a, 0xc7, 0x67, 0x79, 0xe4,
-		0x85, 0x97, 0xf4, 0x03, 0xbd, 0xf0, 0x5a, 0x0d, 0xbd, 0x99, 0x4a, 0xf4, 0xf7, 0x2e, 0xb3, 0xe7,
-		0x87, 0x53, 0xc9, 0x1f, 0xca, 0xc3, 0xa9, 0xf6, 0xf7, 0xaa, 0x53, 0xb7, 0xee, 0x01, 0xc6, 0xc0,
-		0x61, 0x1f, 0xa1, 0xf0, 0xf7, 0x90, 0x83, 0x5d, 0xde, 0x43, 0xe6, 0x3b, 0x3e, 0x7a, 0xe4, 0xd4,
-		0xe8, 0xac, 0xf8, 0x80, 0xef, 0x50, 0x6f, 0x37, 0x61, 0xf9, 0x17, 0x7e, 0xfd, 0x2d, 0x84, 0x93,
-		0x50, 0x68, 0x35, 0x27, 0x6f, 0x52, 0x7f, 0x24, 0x09, 0xb9, 0x55, 0xa7, 0x56, 0xae, 0xea, 0xee,
-		0x6d, 0xb2, 0xb5, 0x67, 0x3a, 0x3f, 0x6a, 0x41, 0x37, 0x6f, 0x4c, 0x8f, 0x32, 0x9d, 0x76, 0xd1,
-		0x64, 0x03, 0xc6, 0x22, 0x4f, 0x89, 0xb9, 0x65, 0x2d, 0x1e, 0xe6, 0x45, 0x73, 0x84, 0x95, 0x4c,
-		0xdf, 0x20, 0x04, 0xec, 0x1b, 0x5d, 0x6b, 0x6f, 0xcc, 0xcc, 0xa0, 0x2e, 0xde, 0xce, 0x17, 0x80,
-		0xfe, 0x98, 0x15, 0x20, 0x1f, 0x1d, 0x14, 0x6f, 0xc4, 0xfe, 0x50, 0x82, 0xe1, 0x55, 0x47, 0xa4,
-		0x82, 0xf8, 0xc7, 0xf4, 0xfd, 0xd1, 0x13, 0xde, 0x77, 0x58, 0x93, 0xbd, 0xd9, 0xad, 0xf8, 0x36,
-		0xab, 0xaf, 0x84, 0xa3, 0x30, 0x11, 0xe8, 0xa7, 0xd7, 0xff, 0xdf, 0x4e, 0x50, 0xff, 0x58, 0xc2,
-		0x35, 0xdd, 0xf0, 0xb2, 0x48, 0xfc, 0x17, 0xf5, 0x75, 0x85, 0xaf, 0xe7, 0xd4, 0x61, 0xf5, 0xbc,
-		0x4f, 0x1d, 0x44, 0x44, 0x9f, 0xde, 0xc6, 0xd7, 0x6a, 0xeb, 0xdb, 0x1f, 0xa9, 0x8f, 0xcf, 0xea,
-		0x44, 0x5e, 0xf8, 0xc8, 0x6f, 0x48, 0x30, 0xb2, 0xea, 0xd4, 0xb6, 0x8d, 0xea, 0xff, 0xf3, 0xf6,
-		0xbb, 0x0b, 0x47, 0x43, 0x3d, 0xbd, 0x4d, 0x2a, 0x3d, 0xf3, 0x5a, 0x0a, 0x92, 0xab, 0x4e, 0x0d,
-		0xbd, 0x04, 0x63, 0xd1, 0xa4, 0xa1, 0x63, 0x2e, 0xd8, 0x1a, 0x11, 0x3a, 0xaf, 0xd7, 0x3a, 0x47,
-		0x0f, 0xb4, 0x0f, 0x23, 0xe1, 0xc8, 0x71, 0xaa, 0x0b, 0x93, 0x10, 0x66, 0xe1, 0x91, 0x5e, 0x31,
-		0xbd, 0xc6, 0xde, 0x0e, 0x69, 0xcf, 0xe9, 0xdd, 0xdd, 0x85, 0x5a, 0x20, 0x75, 0xce, 0x6e, 0xdb,
-		0xb8, 0x15, 0xa2, 0xbd, 0xa8, 0x4b, 0xe9, 0xa6, 0xbd, 0x08, 0x6e, 0x57, 0xed, 0x75, 0x9a, 0x5a,
-		0x3b, 0x00, 0x81, 0x79, 0x70, 0x6f, 0x17, 0x0e, 0x3e, 0x5a, 0xe1, 0xe1, 0x9e, 0xd0, 0xbc, 0x43,
-		0xa7, 0x5b, 0x9c, 0x8c, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xca, 0x34, 0x9e, 0x6a,
-		0x94, 0x00, 0x00,
+		// 9630 bytes of a gzipped FileDescriptorSet
+		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x5c, 0xd7,
+		0x75, 0x18, 0xdf, 0xee, 0x02, 0xd8, 0x3d, 0x58, 0x00, 0x8b, 0x0b, 0x90, 0x5c, 0xae, 0x28, 0x00,
+		0x7a, 0xfa, 0xa2, 0x28, 0x09, 0x94, 0x28, 0x91, 0x92, 0x96, 0xb6, 0x64, 0x2c, 0xb0, 0x04, 0x21,
+		0xe2, 0x4b, 0x0f, 0x00, 0x25, 0x7f, 0xa4, 0x3b, 0x0f, 0x6f, 0x2f, 0x16, 0x4f, 0xd8, 0x7d, 0xef,
+		0xe9, 0xbd, 0xb7, 0x24, 0x21, 0xdb, 0x33, 0x8a, 0xed, 0xba, 0x36, 0xd3, 0xd4, 0x76, 0x9d, 0x49,
+		0x6d, 0xc5, 0x74, 0xed, 0x38, 0xad, 0x53, 0xc7, 0x6d, 0x3e, 0xec, 0xba, 0x4d, 0xdb, 0x99, 0xda,
+		0x6d, 0xd3, 0xd8, 0xee, 0x34, 0x63, 0x4f, 0x33, 0x6d, 0x9a, 0x69, 0x99, 0x54, 0xf6, 0xb8, 0x8a,
+		0xeb, 0x36, 0x0e, 0xeb, 0x4c, 0xd3, 0xf1, 0x74, 0xda, 0xb9, 0x5f, 0xef, 0x6b, 0x3f, 0xde, 0x2e,
+		0x4c, 0x5a, 0x4e, 0x93, 0x5f, 0xd8, 0x7b, 0xee, 0x39, 0xe7, 0x9e, 0x7b, 0xee, 0xb9, 0xe7, 0x9c,
+		0xfb, 0xf5, 0x00, 0xff, 0xf2, 0x1c, 0xcc, 0xd4, 0x4c, 0xb3, 0x56, 0xc7, 0xa7, 0x2c, 0xdb, 0x74,
+		0xcd, 0xed, 0xe6, 0xce, 0xa9, 0x2a, 0x76, 0x34, 0x5b, 0xb7, 0x5c, 0xd3, 0x9e, 0xa5, 0x30, 0x34,
+		0xc6, 0x30, 0x66, 0x05, 0x86, 0xbc, 0x02, 0xe3, 0xe7, 0xf5, 0x3a, 0x5e, 0xf0, 0x10, 0x37, 0xb0,
+		0x8b, 0x9e, 0x84, 0xd4, 0x8e, 0x5e, 0xc7, 0x79, 0x69, 0x26, 0x79, 0x62, 0xf8, 0xf4, 0x3d, 0xb3,
+		0x11, 0xa2, 0xd9, 0x30, 0xc5, 0x3a, 0x01, 0x2b, 0x94, 0x42, 0xfe, 0x76, 0x0a, 0x26, 0xda, 0xd4,
+		0x22, 0x04, 0x29, 0x43, 0x6d, 0x10, 0x8e, 0xd2, 0x89, 0x8c, 0x42, 0x7f, 0xa3, 0x3c, 0x0c, 0x59,
+		0xaa, 0xb6, 0xa7, 0xd6, 0x70, 0x3e, 0x41, 0xc1, 0xa2, 0x88, 0xa6, 0x00, 0xaa, 0xd8, 0xc2, 0x46,
+		0x15, 0x1b, 0xda, 0x7e, 0x3e, 0x39, 0x93, 0x3c, 0x91, 0x51, 0x02, 0x10, 0xf4, 0x20, 0x8c, 0x5b,
+		0xcd, 0xed, 0xba, 0xae, 0x55, 0x02, 0x68, 0x30, 0x93, 0x3c, 0x31, 0xa0, 0xe4, 0x58, 0xc5, 0x82,
+		0x8f, 0x7c, 0x3f, 0x8c, 0x5d, 0xc1, 0xea, 0x5e, 0x10, 0x75, 0x98, 0xa2, 0x8e, 0x12, 0x70, 0x00,
+		0x71, 0x1e, 0xb2, 0x0d, 0xec, 0x38, 0x6a, 0x0d, 0x57, 0xdc, 0x7d, 0x0b, 0xe7, 0x53, 0xb4, 0xf7,
+		0x33, 0x2d, 0xbd, 0x8f, 0xf6, 0x7c, 0x98, 0x53, 0x6d, 0xee, 0x5b, 0x18, 0xcd, 0x41, 0x06, 0x1b,
+		0xcd, 0x06, 0xe3, 0x30, 0xd0, 0x41, 0x7f, 0x65, 0xa3, 0xd9, 0x88, 0x72, 0x49, 0x13, 0x32, 0xce,
+		0x62, 0xc8, 0xc1, 0xf6, 0x65, 0x5d, 0xc3, 0xf9, 0x41, 0xca, 0xe0, 0xfe, 0x16, 0x06, 0x1b, 0xac,
+		0x3e, 0xca, 0x43, 0xd0, 0xa1, 0x79, 0xc8, 0xe0, 0xab, 0x2e, 0x36, 0x1c, 0xdd, 0x34, 0xf2, 0x43,
+		0x94, 0xc9, 0xbd, 0x6d, 0x46, 0x11, 0xd7, 0xab, 0x51, 0x16, 0x3e, 0x1d, 0x3a, 0x0b, 0x43, 0xa6,
+		0xe5, 0xea, 0xa6, 0xe1, 0xe4, 0xd3, 0x33, 0xd2, 0x89, 0xe1, 0xd3, 0xc7, 0xdb, 0x1a, 0xc2, 0x1a,
+		0xc3, 0x51, 0x04, 0x32, 0x5a, 0x82, 0x9c, 0x63, 0x36, 0x6d, 0x0d, 0x57, 0x34, 0xb3, 0x8a, 0x2b,
+		0xba, 0xb1, 0x63, 0xe6, 0x33, 0x94, 0xc1, 0x74, 0x6b, 0x47, 0x28, 0xe2, 0xbc, 0x59, 0xc5, 0x4b,
+		0xc6, 0x8e, 0xa9, 0x8c, 0x3a, 0xa1, 0x32, 0x3a, 0x02, 0x83, 0xce, 0xbe, 0xe1, 0xaa, 0x57, 0xf3,
+		0x59, 0x6a, 0x21, 0xbc, 0x24, 0xff, 0xe6, 0x20, 0x8c, 0xf5, 0x62, 0x62, 0xe7, 0x60, 0x60, 0x87,
+		0xf4, 0x32, 0x9f, 0xe8, 0x47, 0x07, 0x8c, 0x26, 0xac, 0xc4, 0xc1, 0x03, 0x2a, 0x71, 0x0e, 0x86,
+		0x0d, 0xec, 0xb8, 0xb8, 0xca, 0x2c, 0x22, 0xd9, 0xa3, 0x4d, 0x01, 0x23, 0x6a, 0x35, 0xa9, 0xd4,
+		0x81, 0x4c, 0xea, 0x05, 0x18, 0xf3, 0x44, 0xaa, 0xd8, 0xaa, 0x51, 0x13, 0xb6, 0x79, 0x2a, 0x4e,
+		0x92, 0xd9, 0xb2, 0xa0, 0x53, 0x08, 0x99, 0x32, 0x8a, 0x43, 0x65, 0xb4, 0x00, 0x60, 0x1a, 0xd8,
+		0xdc, 0xa9, 0x54, 0xb1, 0x56, 0xcf, 0xa7, 0x3b, 0x68, 0x69, 0x8d, 0xa0, 0xb4, 0x68, 0xc9, 0x64,
+		0x50, 0xad, 0x8e, 0x9e, 0xf2, 0x4d, 0x6d, 0xa8, 0x83, 0xa5, 0xac, 0xb0, 0x49, 0xd6, 0x62, 0x6d,
+		0x5b, 0x30, 0x6a, 0x63, 0x62, 0xf7, 0xb8, 0xca, 0x7b, 0x96, 0xa1, 0x42, 0xcc, 0xc6, 0xf6, 0x4c,
+		0xe1, 0x64, 0xac, 0x63, 0x23, 0x76, 0xb0, 0x88, 0xee, 0x06, 0x0f, 0x50, 0xa1, 0x66, 0x05, 0xd4,
+		0x0b, 0x65, 0x05, 0x70, 0x55, 0x6d, 0xe0, 0xc2, 0xcb, 0x30, 0x1a, 0x56, 0x0f, 0x9a, 0x84, 0x01,
+		0xc7, 0x55, 0x6d, 0x97, 0x5a, 0xe1, 0x80, 0xc2, 0x0a, 0x28, 0x07, 0x49, 0x6c, 0x54, 0xa9, 0x97,
+		0x1b, 0x50, 0xc8, 0x4f, 0xf4, 0x16, 0xbf, 0xc3, 0x49, 0xda, 0xe1, 0xfb, 0x5a, 0x47, 0x34, 0xc4,
+		0x39, 0xda, 0xef, 0xc2, 0x13, 0x30, 0x12, 0xea, 0x40, 0xaf, 0x4d, 0xcb, 0xef, 0x82, 0xc3, 0x6d,
+		0x59, 0xa3, 0x17, 0x60, 0xb2, 0x69, 0xe8, 0x86, 0x8b, 0x6d, 0xcb, 0xc6, 0xc4, 0x62, 0x59, 0x53,
+		0xf9, 0xff, 0x3a, 0xd4, 0xc1, 0xe6, 0xb6, 0x82, 0xd8, 0x8c, 0x8b, 0x32, 0xd1, 0x6c, 0x05, 0x9e,
+		0xcc, 0xa4, 0x5f, 0x1f, 0xca, 0xbd, 0xf2, 0xca, 0x2b, 0xaf, 0x24, 0xe4, 0xaf, 0x0c, 0xc2, 0x64,
+		0xbb, 0x39, 0xd3, 0x76, 0xfa, 0x1e, 0x81, 0x41, 0xa3, 0xd9, 0xd8, 0xc6, 0x36, 0x55, 0xd2, 0x80,
+		0xc2, 0x4b, 0x68, 0x0e, 0x06, 0xea, 0xea, 0x36, 0xae, 0xe7, 0x53, 0x33, 0xd2, 0x89, 0xd1, 0xd3,
+		0x0f, 0xf6, 0x34, 0x2b, 0x67, 0x97, 0x09, 0x89, 0xc2, 0x28, 0xd1, 0xd3, 0x90, 0xe2, 0x2e, 0x9a,
+		0x70, 0x38, 0xd9, 0x1b, 0x07, 0x32, 0x97, 0x14, 0x4a, 0x87, 0xee, 0x80, 0x0c, 0xf9, 0xcb, 0x6c,
+		0x63, 0x90, 0xca, 0x9c, 0x26, 0x00, 0x62, 0x17, 0xa8, 0x00, 0x69, 0x3a, 0x4d, 0xaa, 0x58, 0x84,
+		0x36, 0xaf, 0x4c, 0x0c, 0xab, 0x8a, 0x77, 0xd4, 0x66, 0xdd, 0xad, 0x5c, 0x56, 0xeb, 0x4d, 0x4c,
+		0x0d, 0x3e, 0xa3, 0x64, 0x39, 0xf0, 0x12, 0x81, 0xa1, 0x69, 0x18, 0x66, 0xb3, 0x4a, 0x37, 0xaa,
+		0xf8, 0x2a, 0xf5, 0x9e, 0x03, 0x0a, 0x9b, 0x68, 0x4b, 0x04, 0x42, 0x9a, 0x7f, 0xd1, 0x31, 0x0d,
+		0x61, 0x9a, 0xb4, 0x09, 0x02, 0xa0, 0xcd, 0x3f, 0x11, 0x75, 0xdc, 0x77, 0xb6, 0xef, 0x5e, 0xcb,
+		0x5c, 0xba, 0x1f, 0xc6, 0x28, 0xc6, 0x63, 0x7c, 0xe8, 0xd5, 0x7a, 0x7e, 0x7c, 0x46, 0x3a, 0x91,
+		0x56, 0x46, 0x19, 0x78, 0x8d, 0x43, 0xe5, 0x2f, 0x25, 0x20, 0x45, 0x1d, 0xcb, 0x18, 0x0c, 0x6f,
+		0xbe, 0x75, 0xbd, 0x5c, 0x59, 0x58, 0xdb, 0x2a, 0x2d, 0x97, 0x73, 0x12, 0x1a, 0x05, 0xa0, 0x80,
+		0xf3, 0xcb, 0x6b, 0x73, 0x9b, 0xb9, 0x84, 0x57, 0x5e, 0x5a, 0xdd, 0x3c, 0xfb, 0x78, 0x2e, 0xe9,
+		0x11, 0x6c, 0x31, 0x40, 0x2a, 0x88, 0xf0, 0xd8, 0xe9, 0xdc, 0x00, 0xca, 0x41, 0x96, 0x31, 0x58,
+		0x7a, 0xa1, 0xbc, 0x70, 0xf6, 0xf1, 0xdc, 0x60, 0x18, 0xf2, 0xd8, 0xe9, 0xdc, 0x10, 0x1a, 0x81,
+		0x0c, 0x85, 0x94, 0xd6, 0xd6, 0x96, 0x73, 0x69, 0x8f, 0xe7, 0xc6, 0xa6, 0xb2, 0xb4, 0xba, 0x98,
+		0xcb, 0x78, 0x3c, 0x17, 0x95, 0xb5, 0xad, 0xf5, 0x1c, 0x78, 0x1c, 0x56, 0xca, 0x1b, 0x1b, 0x73,
+		0x8b, 0xe5, 0xdc, 0xb0, 0x87, 0x51, 0x7a, 0xeb, 0x66, 0x79, 0x23, 0x97, 0x0d, 0x89, 0xf5, 0xd8,
+		0xe9, 0xdc, 0x88, 0xd7, 0x44, 0x79, 0x75, 0x6b, 0x25, 0x37, 0x8a, 0xc6, 0x61, 0x84, 0x35, 0x21,
+		0x84, 0x18, 0x8b, 0x80, 0xce, 0x3e, 0x9e, 0xcb, 0xf9, 0x82, 0x30, 0x2e, 0xe3, 0x21, 0xc0, 0xd9,
+		0xc7, 0x73, 0x48, 0x9e, 0x87, 0x01, 0x6a, 0x86, 0x08, 0xc1, 0xe8, 0xf2, 0x5c, 0xa9, 0xbc, 0x5c,
+		0x59, 0x5b, 0xdf, 0x5c, 0x5a, 0x5b, 0x9d, 0x5b, 0xce, 0x49, 0x3e, 0x4c, 0x29, 0x3f, 0xb7, 0xb5,
+		0xa4, 0x94, 0x17, 0x72, 0x89, 0x20, 0x6c, 0xbd, 0x3c, 0xb7, 0x59, 0x5e, 0xc8, 0x25, 0x65, 0x0d,
+		0x26, 0xdb, 0x39, 0xd4, 0xb6, 0x53, 0x28, 0x60, 0x0b, 0x89, 0x0e, 0xb6, 0x40, 0x79, 0x45, 0x6d,
+		0x41, 0xfe, 0x56, 0x02, 0x26, 0xda, 0x04, 0x95, 0xb6, 0x8d, 0x3c, 0x03, 0x03, 0xcc, 0x96, 0x59,
+		0x98, 0x7d, 0xa0, 0x6d, 0x74, 0xa2, 0x96, 0xdd, 0x12, 0x6a, 0x29, 0x5d, 0x30, 0xd5, 0x48, 0x76,
+		0x48, 0x35, 0x08, 0x8b, 0x16, 0x83, 0xfd, 0xa9, 0x16, 0xe7, 0xcf, 0xe2, 0xe3, 0xd9, 0x5e, 0xe2,
+		0x23, 0x85, 0xf5, 0x17, 0x04, 0x06, 0xda, 0x04, 0x81, 0x73, 0x30, 0xde, 0xc2, 0xa8, 0x67, 0x67,
+		0xfc, 0x5e, 0x09, 0xf2, 0x9d, 0x94, 0x13, 0xe3, 0x12, 0x13, 0x21, 0x97, 0x78, 0x2e, 0xaa, 0xc1,
+		0xbb, 0x3a, 0x0f, 0x42, 0xcb, 0x58, 0x7f, 0x56, 0x82, 0x23, 0xed, 0x53, 0xca, 0xb6, 0x32, 0x3c,
+		0x0d, 0x83, 0x0d, 0xec, 0xee, 0x9a, 0x22, 0xad, 0xba, 0xaf, 0x4d, 0xb0, 0x26, 0xd5, 0xd1, 0xc1,
+		0xe6, 0x54, 0xc1, 0x68, 0x9f, 0xec, 0x94, 0x17, 0x32, 0x69, 0x5a, 0x24, 0xfd, 0x60, 0x02, 0x0e,
+		0xb7, 0x65, 0xde, 0x56, 0xd0, 0x3b, 0x01, 0x74, 0xc3, 0x6a, 0xba, 0x2c, 0x75, 0x62, 0x9e, 0x38,
+		0x43, 0x21, 0xd4, 0x79, 0x11, 0x2f, 0xdb, 0x74, 0xbd, 0xfa, 0x24, 0xad, 0x07, 0x06, 0xa2, 0x08,
+		0x4f, 0xfa, 0x82, 0xa6, 0xa8, 0xa0, 0x53, 0x1d, 0x7a, 0xda, 0x62, 0x98, 0x8f, 0x40, 0x4e, 0xab,
+		0xeb, 0xd8, 0x70, 0x2b, 0x8e, 0x6b, 0x63, 0xb5, 0xa1, 0x1b, 0x35, 0x1a, 0x6a, 0xd2, 0xc5, 0x81,
+		0x1d, 0xb5, 0xee, 0x60, 0x65, 0x8c, 0x55, 0x6f, 0x88, 0x5a, 0x42, 0x41, 0x0d, 0xc8, 0x0e, 0x50,
+		0x0c, 0x86, 0x28, 0x58, 0xb5, 0x47, 0x21, 0x7f, 0x24, 0x03, 0xc3, 0x81, 0x04, 0x1c, 0xdd, 0x05,
+		0xd9, 0x17, 0xd5, 0xcb, 0x6a, 0x45, 0x2c, 0xaa, 0x98, 0x26, 0x86, 0x09, 0x6c, 0x9d, 0x2f, 0xac,
+		0x1e, 0x81, 0x49, 0x8a, 0x62, 0x36, 0x5d, 0x6c, 0x57, 0xb4, 0xba, 0xea, 0x38, 0x54, 0x69, 0x69,
+		0x8a, 0x8a, 0x48, 0xdd, 0x1a, 0xa9, 0x9a, 0x17, 0x35, 0xe8, 0x0c, 0x4c, 0x50, 0x8a, 0x46, 0xb3,
+		0xee, 0xea, 0x56, 0x1d, 0x57, 0xc8, 0x32, 0xcf, 0xa1, 0x21, 0xc7, 0x93, 0x6c, 0x9c, 0x60, 0xac,
+		0x70, 0x04, 0x22, 0x91, 0x83, 0x16, 0xe0, 0x4e, 0x4a, 0x56, 0xc3, 0x06, 0xb6, 0x55, 0x17, 0x57,
+		0xf0, 0x4b, 0x4d, 0xb5, 0xee, 0x54, 0x54, 0xa3, 0x5a, 0xd9, 0x55, 0x9d, 0xdd, 0xfc, 0x24, 0x61,
+		0x50, 0x4a, 0xe4, 0x25, 0xe5, 0x18, 0x41, 0x5c, 0xe4, 0x78, 0x65, 0x8a, 0x36, 0x67, 0x54, 0x2f,
+		0xa8, 0xce, 0x2e, 0x2a, 0xc2, 0x11, 0xca, 0xc5, 0x71, 0x6d, 0xdd, 0xa8, 0x55, 0xb4, 0x5d, 0xac,
+		0xed, 0x55, 0x9a, 0xee, 0xce, 0x93, 0xf9, 0x3b, 0x82, 0xed, 0x53, 0x09, 0x37, 0x28, 0xce, 0x3c,
+		0x41, 0xd9, 0x72, 0x77, 0x9e, 0x44, 0x1b, 0x90, 0x25, 0x83, 0xd1, 0xd0, 0x5f, 0xc6, 0x95, 0x1d,
+		0xd3, 0xa6, 0x31, 0x74, 0xb4, 0x8d, 0x6b, 0x0a, 0x68, 0x70, 0x76, 0x8d, 0x13, 0xac, 0x98, 0x55,
+		0x5c, 0x1c, 0xd8, 0x58, 0x2f, 0x97, 0x17, 0x94, 0x61, 0xc1, 0xe5, 0xbc, 0x69, 0x13, 0x83, 0xaa,
+		0x99, 0x9e, 0x82, 0x87, 0x99, 0x41, 0xd5, 0x4c, 0xa1, 0xde, 0x33, 0x30, 0xa1, 0x69, 0xac, 0xcf,
+		0xba, 0x56, 0xe1, 0x8b, 0x31, 0x27, 0x9f, 0x0b, 0x29, 0x4b, 0xd3, 0x16, 0x19, 0x02, 0xb7, 0x71,
+		0x07, 0x3d, 0x05, 0x87, 0x7d, 0x65, 0x05, 0x09, 0xc7, 0x5b, 0x7a, 0x19, 0x25, 0x3d, 0x03, 0x13,
+		0xd6, 0x7e, 0x2b, 0x21, 0x0a, 0xb5, 0x68, 0xed, 0x47, 0xc9, 0x9e, 0x80, 0x49, 0x6b, 0xd7, 0x6a,
+		0xa5, 0x3b, 0x19, 0xa4, 0x43, 0xd6, 0xae, 0x15, 0x25, 0xbc, 0x97, 0xae, 0xcc, 0x6d, 0xac, 0xa9,
+		0x2e, 0xae, 0xe6, 0x8f, 0x06, 0xd1, 0x03, 0x15, 0x68, 0x16, 0x72, 0x9a, 0x56, 0xc1, 0x86, 0xba,
+		0x5d, 0xc7, 0x15, 0xd5, 0xc6, 0x86, 0xea, 0xe4, 0xa7, 0x29, 0x72, 0xca, 0xb5, 0x9b, 0x58, 0x19,
+		0xd5, 0xb4, 0x32, 0xad, 0x9c, 0xa3, 0x75, 0xe8, 0x24, 0x8c, 0x9b, 0xdb, 0x2f, 0x6a, 0xcc, 0x22,
+		0x2b, 0x96, 0x8d, 0x77, 0xf4, 0xab, 0xf9, 0x7b, 0xa8, 0x7a, 0xc7, 0x48, 0x05, 0xb5, 0xc7, 0x75,
+		0x0a, 0x46, 0x0f, 0x40, 0x4e, 0x73, 0x76, 0x55, 0xdb, 0xa2, 0x2e, 0xd9, 0xb1, 0x54, 0x0d, 0xe7,
+		0xef, 0x65, 0xa8, 0x0c, 0xbe, 0x2a, 0xc0, 0x64, 0x46, 0x38, 0x57, 0xf4, 0x1d, 0x57, 0x70, 0xbc,
+		0x9f, 0xcd, 0x08, 0x0a, 0xe3, 0xdc, 0x4e, 0x40, 0x8e, 0x68, 0x22, 0xd4, 0xf0, 0x09, 0x8a, 0x36,
+		0x6a, 0xed, 0x5a, 0xc1, 0x76, 0xef, 0x86, 0x11, 0x82, 0xe9, 0x37, 0xfa, 0x00, 0x4b, 0xdc, 0xac,
+		0xdd, 0x40, 0x8b, 0x8f, 0xc3, 0x11, 0x82, 0xd4, 0xc0, 0xae, 0x5a, 0x55, 0x5d, 0x35, 0x80, 0xfd,
+		0x10, 0xc5, 0x26, 0x6a, 0x5f, 0xe1, 0x95, 0x21, 0x39, 0xed, 0xe6, 0xf6, 0xbe, 0x67, 0x58, 0x0f,
+		0x33, 0x39, 0x09, 0x4c, 0x98, 0xd6, 0x6d, 0x4b, 0xce, 0xe5, 0x22, 0x64, 0x83, 0x76, 0x8f, 0x32,
+		0xc0, 0x2c, 0x3f, 0x27, 0x91, 0x24, 0x68, 0x7e, 0x6d, 0x81, 0xa4, 0x2f, 0x6f, 0x2b, 0xe7, 0x12,
+		0x24, 0x8d, 0x5a, 0x5e, 0xda, 0x2c, 0x57, 0x94, 0xad, 0xd5, 0xcd, 0xa5, 0x95, 0x72, 0x2e, 0x19,
+		0x48, 0xec, 0x9f, 0x4d, 0xa5, 0xef, 0xcb, 0xdd, 0x2f, 0x7f, 0x33, 0x01, 0xa3, 0xe1, 0x95, 0x1a,
+		0x7a, 0x13, 0x1c, 0x15, 0xdb, 0x2a, 0x0e, 0x76, 0x2b, 0x57, 0x74, 0x9b, 0x4e, 0xc8, 0x86, 0xca,
+		0x82, 0xa3, 0x67, 0x3f, 0x93, 0x1c, 0x6b, 0x03, 0xbb, 0xcf, 0xeb, 0x36, 0x99, 0x6e, 0x0d, 0xd5,
+		0x45, 0xcb, 0x30, 0x6d, 0x98, 0x15, 0xc7, 0x55, 0x8d, 0xaa, 0x6a, 0x57, 0x2b, 0xfe, 0x86, 0x56,
+		0x45, 0xd5, 0x34, 0xec, 0x38, 0x26, 0x0b, 0x84, 0x1e, 0x97, 0xe3, 0x86, 0xb9, 0xc1, 0x91, 0xfd,
+		0x08, 0x31, 0xc7, 0x51, 0x23, 0xe6, 0x9b, 0xec, 0x64, 0xbe, 0x77, 0x40, 0xa6, 0xa1, 0x5a, 0x15,
+		0x6c, 0xb8, 0xf6, 0x3e, 0xcd, 0xcf, 0xd3, 0x4a, 0xba, 0xa1, 0x5a, 0x65, 0x52, 0xfe, 0xb1, 0x2c,
+		0x93, 0x9e, 0x4d, 0xa5, 0xd3, 0xb9, 0xcc, 0xb3, 0xa9, 0x74, 0x26, 0x07, 0xf2, 0x6b, 0x49, 0xc8,
+		0x06, 0xf3, 0x75, 0xb2, 0xfc, 0xd1, 0x68, 0xc4, 0x92, 0xa8, 0x4f, 0xbb, 0xbb, 0x6b, 0x76, 0x3f,
+		0x3b, 0x4f, 0x42, 0x59, 0x71, 0x90, 0x25, 0xc7, 0x0a, 0xa3, 0x24, 0x69, 0x04, 0x31, 0x36, 0xcc,
+		0x92, 0x91, 0xb4, 0xc2, 0x4b, 0x68, 0x11, 0x06, 0x5f, 0x74, 0x28, 0xef, 0x41, 0xca, 0xfb, 0x9e,
+		0xee, 0xbc, 0x9f, 0xdd, 0xa0, 0xcc, 0x33, 0xcf, 0x6e, 0x54, 0x56, 0xd7, 0x94, 0x95, 0xb9, 0x65,
+		0x85, 0x93, 0xa3, 0x63, 0x90, 0xaa, 0xab, 0x2f, 0xef, 0x87, 0x83, 0x1e, 0x05, 0xf5, 0x3a, 0x08,
+		0xc7, 0x20, 0x75, 0x05, 0xab, 0x7b, 0xe1, 0x50, 0x43, 0x41, 0xb7, 0x71, 0x32, 0x9c, 0x82, 0x01,
+		0xaa, 0x2f, 0x04, 0xc0, 0x35, 0x96, 0x3b, 0x84, 0xd2, 0x90, 0x9a, 0x5f, 0x53, 0xc8, 0x84, 0xc8,
+		0x41, 0x96, 0x41, 0x2b, 0xeb, 0x4b, 0xe5, 0xf9, 0x72, 0x2e, 0x21, 0x9f, 0x81, 0x41, 0xa6, 0x04,
+		0x32, 0x59, 0x3c, 0x35, 0xe4, 0x0e, 0xf1, 0x22, 0xe7, 0x21, 0x89, 0xda, 0xad, 0x95, 0x52, 0x59,
+		0xc9, 0x25, 0xc2, 0x43, 0x9d, 0xca, 0x0d, 0xc8, 0x0e, 0x64, 0x83, 0x79, 0xf8, 0x8f, 0x67, 0x31,
+		0xfe, 0x65, 0x09, 0x86, 0x03, 0x79, 0x35, 0x49, 0x88, 0xd4, 0x7a, 0xdd, 0xbc, 0x52, 0x51, 0xeb,
+		0xba, 0xea, 0x70, 0xd3, 0x00, 0x0a, 0x9a, 0x23, 0x90, 0x5e, 0x87, 0xee, 0xc7, 0x34, 0x45, 0x06,
+		0x72, 0x83, 0xf2, 0x27, 0x25, 0xc8, 0x45, 0x13, 0xdb, 0x88, 0x98, 0xd2, 0x1b, 0x29, 0xa6, 0xfc,
+		0x09, 0x09, 0x46, 0xc3, 0xd9, 0x6c, 0x44, 0xbc, 0xbb, 0xde, 0x50, 0xf1, 0xfe, 0x30, 0x01, 0x23,
+		0xa1, 0x1c, 0xb6, 0x57, 0xe9, 0x5e, 0x82, 0x71, 0xbd, 0x8a, 0x1b, 0x96, 0xe9, 0x62, 0x43, 0xdb,
+		0xaf, 0xd4, 0xf1, 0x65, 0x5c, 0xcf, 0xcb, 0xd4, 0x69, 0x9c, 0xea, 0x9e, 0x25, 0xcf, 0x2e, 0xf9,
+		0x74, 0xcb, 0x84, 0xac, 0x38, 0xb1, 0xb4, 0x50, 0x5e, 0x59, 0x5f, 0xdb, 0x2c, 0xaf, 0xce, 0xbf,
+		0xb5, 0xb2, 0xb5, 0x7a, 0x71, 0x75, 0xed, 0xf9, 0x55, 0x25, 0xa7, 0x47, 0xd0, 0x6e, 0xe3, 0xb4,
+		0x5f, 0x87, 0x5c, 0x54, 0x28, 0x74, 0x14, 0xda, 0x89, 0x95, 0x3b, 0x84, 0x26, 0x60, 0x6c, 0x75,
+		0xad, 0xb2, 0xb1, 0xb4, 0x50, 0xae, 0x94, 0xcf, 0x9f, 0x2f, 0xcf, 0x6f, 0x6e, 0xb0, 0x7d, 0x0f,
+		0x0f, 0x7b, 0x33, 0x34, 0xc1, 0xe5, 0x57, 0x93, 0x30, 0xd1, 0x46, 0x12, 0x34, 0xc7, 0x57, 0x2c,
+		0x6c, 0x11, 0xf5, 0x70, 0x2f, 0xd2, 0xcf, 0x92, 0x9c, 0x61, 0x5d, 0xb5, 0x5d, 0xbe, 0xc0, 0x79,
+		0x00, 0x88, 0x96, 0x0c, 0x57, 0xdf, 0xd1, 0xb1, 0xcd, 0xf7, 0x93, 0xd8, 0x32, 0x66, 0xcc, 0x87,
+		0xb3, 0x2d, 0xa5, 0x87, 0x00, 0x59, 0xa6, 0xa3, 0xbb, 0xfa, 0x65, 0x5c, 0xd1, 0x0d, 0xb1, 0xf9,
+		0x44, 0x96, 0x35, 0x29, 0x25, 0x27, 0x6a, 0x96, 0x0c, 0xd7, 0xc3, 0x36, 0x70, 0x4d, 0x8d, 0x60,
+		0x13, 0x67, 0x9e, 0x54, 0x72, 0xa2, 0xc6, 0xc3, 0xbe, 0x0b, 0xb2, 0x55, 0xb3, 0x49, 0x72, 0x3d,
+		0x86, 0x47, 0x62, 0x87, 0xa4, 0x0c, 0x33, 0x98, 0x87, 0xc2, 0xb3, 0x78, 0x7f, 0xd7, 0x2b, 0xab,
+		0x0c, 0x33, 0x18, 0x43, 0xb9, 0x1f, 0xc6, 0xd4, 0x5a, 0xcd, 0x26, 0xcc, 0x05, 0x23, 0xb6, 0x2e,
+		0x19, 0xf5, 0xc0, 0x14, 0xb1, 0xf0, 0x2c, 0xa4, 0x85, 0x1e, 0x48, 0xa8, 0x26, 0x9a, 0xa8, 0x58,
+		0x6c, 0xb1, 0x9d, 0x38, 0x91, 0x51, 0xd2, 0x86, 0xa8, 0xbc, 0x0b, 0xb2, 0xba, 0x53, 0xf1, 0x37,
+		0xf1, 0x13, 0x33, 0x89, 0x13, 0x69, 0x65, 0x58, 0x77, 0xbc, 0x0d, 0x50, 0xf9, 0xb3, 0x09, 0x18,
+		0x0d, 0x1f, 0x42, 0xa0, 0x05, 0x48, 0xd7, 0x4d, 0x4d, 0xa5, 0xa6, 0xc5, 0x4e, 0xc0, 0x4e, 0xc4,
+		0x9c, 0x5b, 0xcc, 0x2e, 0x73, 0x7c, 0xc5, 0xa3, 0x2c, 0xfc, 0x8e, 0x04, 0x69, 0x01, 0x46, 0x47,
+		0x20, 0x65, 0xa9, 0xee, 0x2e, 0x65, 0x37, 0x50, 0x4a, 0xe4, 0x24, 0x85, 0x96, 0x09, 0xdc, 0xb1,
+		0x54, 0x83, 0x9a, 0x00, 0x87, 0x93, 0x32, 0x19, 0xd7, 0x3a, 0x56, 0xab, 0x74, 0xd1, 0x63, 0x36,
+		0x1a, 0xd8, 0x70, 0x1d, 0x31, 0xae, 0x1c, 0x3e, 0xcf, 0xc1, 0xe8, 0x41, 0x18, 0x77, 0x6d, 0x55,
+		0xaf, 0x87, 0x70, 0x53, 0x14, 0x37, 0x27, 0x2a, 0x3c, 0xe4, 0x22, 0x1c, 0x13, 0x7c, 0xab, 0xd8,
+		0x55, 0xb5, 0x5d, 0x5c, 0xf5, 0x89, 0x06, 0xe9, 0xe6, 0xc6, 0x51, 0x8e, 0xb0, 0xc0, 0xeb, 0x05,
+		0xad, 0xfc, 0x4d, 0x09, 0xc6, 0xc5, 0x32, 0xad, 0xea, 0x29, 0x6b, 0x05, 0x40, 0x35, 0x0c, 0xd3,
+		0x0d, 0xaa, 0xab, 0xd5, 0x94, 0x5b, 0xe8, 0x66, 0xe7, 0x3c, 0x22, 0x25, 0xc0, 0xa0, 0xd0, 0x00,
+		0xf0, 0x6b, 0x3a, 0xaa, 0x6d, 0x1a, 0x86, 0xf9, 0x09, 0x13, 0x3d, 0xa6, 0x64, 0x0b, 0x7b, 0x60,
+		0x20, 0xb2, 0x9e, 0x43, 0x93, 0x30, 0xb0, 0x8d, 0x6b, 0xba, 0xc1, 0xf7, 0x8d, 0x59, 0x41, 0x6c,
+		0xbf, 0xa4, 0xbc, 0xed, 0x97, 0xd2, 0x87, 0x24, 0x98, 0xd0, 0xcc, 0x46, 0x54, 0xde, 0x52, 0x2e,
+		0xb2, 0xbb, 0xe0, 0x5c, 0x90, 0xde, 0xf6, 0x74, 0x4d, 0x77, 0x77, 0x9b, 0xdb, 0xb3, 0x9a, 0xd9,
+		0x38, 0x55, 0x33, 0xeb, 0xaa, 0x51, 0xf3, 0xcf, 0x59, 0xe9, 0x0f, 0xed, 0xe1, 0x1a, 0x36, 0x1e,
+		0xae, 0x99, 0x81, 0x53, 0xd7, 0x73, 0xfe, 0xcf, 0x3f, 0x93, 0xa4, 0x5f, 0x4c, 0x24, 0x17, 0xd7,
+		0x4b, 0x9f, 0x4b, 0x14, 0x16, 0x59, 0x73, 0xeb, 0x42, 0x3d, 0x0a, 0xde, 0xa9, 0x63, 0x8d, 0x74,
+		0x19, 0xbe, 0xfb, 0x20, 0x4c, 0xd6, 0xcc, 0x9a, 0x49, 0x39, 0x9e, 0x22, 0xbf, 0xf8, 0xc9, 0x6d,
+		0xc6, 0x83, 0x16, 0x62, 0x8f, 0x79, 0x8b, 0xab, 0x30, 0xc1, 0x91, 0x2b, 0xf4, 0xe8, 0x88, 0x2d,
+		0x6c, 0x50, 0xd7, 0x5d, 0xb5, 0xfc, 0xaf, 0x7f, 0x9b, 0x06, 0x74, 0x65, 0x9c, 0x93, 0x92, 0x3a,
+		0xb6, 0xf6, 0x29, 0x2a, 0x70, 0x38, 0xc4, 0x8f, 0x4d, 0x5b, 0x6c, 0xc7, 0x70, 0xfc, 0x2d, 0xce,
+		0x71, 0x22, 0xc0, 0x71, 0x83, 0x93, 0x16, 0xe7, 0x61, 0xa4, 0x1f, 0x5e, 0xff, 0x9a, 0xf3, 0xca,
+		0xe2, 0x20, 0x93, 0x45, 0x18, 0xa3, 0x4c, 0xb4, 0xa6, 0xe3, 0x9a, 0x0d, 0xea, 0x13, 0xbb, 0xb3,
+		0xf9, 0xed, 0x6f, 0xb3, 0x79, 0x34, 0x4a, 0xc8, 0xe6, 0x3d, 0xaa, 0x62, 0x11, 0xe8, 0x69, 0x59,
+		0x15, 0x6b, 0xf5, 0x18, 0x0e, 0x5f, 0xe5, 0x82, 0x78, 0xf8, 0xc5, 0x4b, 0x30, 0x49, 0x7e, 0x53,
+		0x97, 0x15, 0x94, 0x24, 0x7e, 0x0b, 0x2e, 0xff, 0xcd, 0xf7, 0xb2, 0xa9, 0x3a, 0xe1, 0x31, 0x08,
+		0xc8, 0x14, 0x18, 0xc5, 0x1a, 0x76, 0x5d, 0x6c, 0x3b, 0x15, 0xb5, 0xde, 0x4e, 0xbc, 0xc0, 0x1e,
+		0x46, 0xfe, 0xe3, 0xdf, 0x0b, 0x8f, 0xe2, 0x22, 0xa3, 0x9c, 0xab, 0xd7, 0x8b, 0x5b, 0x70, 0xb4,
+		0x8d, 0x55, 0xf4, 0xc0, 0xf3, 0x55, 0xce, 0x73, 0xb2, 0xc5, 0x32, 0x08, 0xdb, 0x75, 0x10, 0x70,
+		0x6f, 0x2c, 0x7b, 0xe0, 0xf9, 0x0b, 0x9c, 0x27, 0xe2, 0xb4, 0x62, 0x48, 0x09, 0xc7, 0x67, 0x61,
+		0xfc, 0x32, 0xb6, 0xb7, 0x4d, 0x87, 0xef, 0x1b, 0xf5, 0xc0, 0xee, 0x13, 0x9c, 0xdd, 0x18, 0x27,
+		0xa4, 0x1b, 0x49, 0x84, 0xd7, 0x53, 0x90, 0xde, 0x51, 0x35, 0xdc, 0x03, 0x8b, 0xeb, 0x9c, 0xc5,
+		0x10, 0xc1, 0x27, 0xa4, 0x73, 0x90, 0xad, 0x99, 0x3c, 0x6a, 0xc5, 0x93, 0x7f, 0x92, 0x93, 0x0f,
+		0x0b, 0x1a, 0xce, 0xc2, 0x32, 0xad, 0x66, 0x9d, 0x84, 0xb4, 0x78, 0x16, 0x7f, 0x5b, 0xb0, 0x10,
+		0x34, 0x9c, 0x45, 0x1f, 0x6a, 0xfd, 0x94, 0x60, 0xe1, 0x04, 0xf4, 0xf9, 0x0c, 0x0c, 0x9b, 0x46,
+		0x7d, 0xdf, 0x34, 0x7a, 0x11, 0xe2, 0xd3, 0x9c, 0x03, 0x70, 0x12, 0xc2, 0xe0, 0x1c, 0x64, 0x7a,
+		0x1d, 0x88, 0xbf, 0xf3, 0x3d, 0x31, 0x3d, 0xc4, 0x08, 0x2c, 0xc2, 0x98, 0x70, 0x50, 0xba, 0x69,
+		0xf4, 0xc0, 0xe2, 0xef, 0x72, 0x16, 0xa3, 0x01, 0x32, 0xde, 0x0d, 0x17, 0x3b, 0x6e, 0x0d, 0xf7,
+		0xc2, 0xe4, 0xb3, 0xa2, 0x1b, 0x9c, 0x84, 0xab, 0x72, 0x1b, 0x1b, 0xda, 0x6e, 0x6f, 0x1c, 0x7e,
+		0x59, 0xa8, 0x52, 0xd0, 0x10, 0x16, 0xf3, 0x30, 0xd2, 0x50, 0x6d, 0x67, 0x57, 0xad, 0xf7, 0x34,
+		0x1c, 0x7f, 0x8f, 0xf3, 0xc8, 0x7a, 0x44, 0x5c, 0x23, 0x4d, 0xa3, 0x1f, 0x36, 0x9f, 0x13, 0x1a,
+		0x09, 0x90, 0xf1, 0xa9, 0xe7, 0xb8, 0x74, 0x93, 0xad, 0x1f, 0x6e, 0xbf, 0x22, 0xa6, 0x1e, 0xa3,
+		0x5d, 0x09, 0x72, 0x3c, 0x07, 0x19, 0x47, 0x7f, 0xb9, 0x27, 0x36, 0x9f, 0x17, 0x23, 0x4d, 0x09,
+		0x08, 0xf1, 0x5b, 0xe1, 0x58, 0xdb, 0x30, 0xd1, 0x03, 0xb3, 0xbf, 0xcf, 0x99, 0x1d, 0x69, 0x13,
+		0x2a, 0xb8, 0x4b, 0xe8, 0x97, 0xe5, 0x3f, 0x10, 0x2e, 0x01, 0x47, 0x78, 0xad, 0x93, 0x75, 0x84,
+		0xa3, 0xee, 0xf4, 0xa7, 0xb5, 0x5f, 0x15, 0x5a, 0x63, 0xb4, 0x21, 0xad, 0x6d, 0xc2, 0x11, 0xce,
+		0xb1, 0xbf, 0x71, 0xfd, 0x35, 0xe1, 0x58, 0x19, 0xf5, 0x56, 0x78, 0x74, 0xdf, 0x0e, 0x05, 0x4f,
+		0x9d, 0x22, 0x61, 0x75, 0x2a, 0x0d, 0xd5, 0xea, 0x81, 0xf3, 0xaf, 0x73, 0xce, 0xc2, 0xe3, 0x7b,
+		0x19, 0xaf, 0xb3, 0xa2, 0x5a, 0x84, 0xf9, 0x0b, 0x90, 0x17, 0xcc, 0x9b, 0x86, 0x8d, 0x35, 0xb3,
+		0x66, 0xe8, 0x2f, 0xe3, 0x6a, 0x0f, 0xac, 0x7f, 0x23, 0x32, 0x54, 0x5b, 0x01, 0x72, 0xc2, 0x79,
+		0x09, 0x72, 0x5e, 0xae, 0x52, 0xd1, 0x1b, 0x96, 0x69, 0xbb, 0x31, 0x1c, 0xbf, 0x20, 0x46, 0xca,
+		0xa3, 0x5b, 0xa2, 0x64, 0xc5, 0x32, 0xb0, 0x93, 0xe7, 0x5e, 0x4d, 0xf2, 0x8b, 0x9c, 0xd1, 0x88,
+		0x4f, 0xc5, 0x1d, 0x87, 0x66, 0x36, 0x2c, 0xd5, 0xee, 0xc5, 0xff, 0xfd, 0x43, 0xe1, 0x38, 0x38,
+		0x09, 0x77, 0x1c, 0xee, 0xbe, 0x85, 0x49, 0xb4, 0xef, 0x81, 0xc3, 0x97, 0x84, 0xe3, 0x10, 0x34,
+		0x9c, 0x85, 0x48, 0x18, 0x7a, 0x60, 0xf1, 0x8f, 0x04, 0x0b, 0x41, 0x43, 0x58, 0x3c, 0xe7, 0x07,
+		0x5a, 0x1b, 0xd7, 0x74, 0xc7, 0xb5, 0x59, 0x9a, 0xdc, 0x9d, 0xd5, 0x3f, 0xfe, 0x5e, 0x38, 0x09,
+		0x53, 0x02, 0xa4, 0xc4, 0x13, 0xf1, 0x6d, 0x57, 0xba, 0x8a, 0x8a, 0x17, 0xec, 0x37, 0x85, 0x27,
+		0x0a, 0x90, 0x11, 0xd9, 0x02, 0x19, 0x22, 0x51, 0xbb, 0x46, 0xd6, 0x0e, 0x3d, 0xb0, 0xfb, 0x27,
+		0x11, 0xe1, 0x36, 0x04, 0x2d, 0xe1, 0x19, 0xc8, 0x7f, 0x9a, 0xc6, 0x1e, 0xde, 0xef, 0xc9, 0x3a,
+		0xff, 0x69, 0x24, 0xff, 0xd9, 0x62, 0x94, 0xcc, 0x87, 0x8c, 0x45, 0xf2, 0x29, 0x14, 0x77, 0xcf,
+		0x28, 0xff, 0xd3, 0x3f, 0xe0, 0xfd, 0x0d, 0xa7, 0x53, 0xc5, 0x65, 0x62, 0xe4, 0xe1, 0xa4, 0x27,
+		0x9e, 0xd9, 0x7b, 0x7f, 0xe0, 0xd9, 0x79, 0x28, 0xe7, 0x29, 0x9e, 0x87, 0x91, 0x50, 0xc2, 0x13,
+		0xcf, 0xea, 0x7d, 0x9c, 0x55, 0x36, 0x98, 0xef, 0x14, 0xcf, 0x40, 0x8a, 0x24, 0x2f, 0xf1, 0xe4,
+		0x7f, 0x95, 0x93, 0x53, 0xf4, 0xe2, 0x9b, 0x21, 0x2d, 0x92, 0x96, 0x78, 0xd2, 0xf7, 0x73, 0x52,
+		0x8f, 0x84, 0x90, 0x8b, 0x84, 0x25, 0x9e, 0xfc, 0xaf, 0x09, 0x72, 0x41, 0x42, 0xc8, 0x7b, 0x57,
+		0xe1, 0x97, 0x7f, 0x26, 0xc5, 0x83, 0x8e, 0xd0, 0xdd, 0x39, 0x18, 0xe2, 0x99, 0x4a, 0x3c, 0xf5,
+		0x07, 0x79, 0xe3, 0x82, 0xa2, 0xf8, 0x04, 0x0c, 0xf4, 0xa8, 0xf0, 0x9f, 0xe5, 0xa4, 0x0c, 0xbf,
+		0x38, 0x0f, 0xc3, 0x81, 0xec, 0x24, 0x9e, 0xfc, 0x6f, 0x70, 0xf2, 0x20, 0x15, 0x11, 0x9d, 0x67,
+		0x27, 0xf1, 0x0c, 0x3e, 0x24, 0x44, 0xe7, 0x14, 0x44, 0x6d, 0x22, 0x31, 0x89, 0xa7, 0xfe, 0xb0,
+		0xd0, 0xba, 0x20, 0x29, 0x3e, 0x03, 0x19, 0x2f, 0xd8, 0xc4, 0xd3, 0x7f, 0x84, 0xd3, 0xfb, 0x34,
+		0x44, 0x03, 0x81, 0x60, 0x17, 0xcf, 0xe2, 0x6f, 0x0a, 0x0d, 0x04, 0xa8, 0xc8, 0x34, 0x8a, 0x26,
+		0x30, 0xf1, 0x9c, 0x3e, 0x2a, 0xa6, 0x51, 0x24, 0x7f, 0x21, 0xa3, 0x49, 0x7d, 0x7e, 0x3c, 0x8b,
+		0x9f, 0x13, 0xa3, 0x49, 0xf1, 0x89, 0x18, 0xd1, 0x8c, 0x20, 0x9e, 0xc7, 0xdf, 0x12, 0x62, 0x44,
+		0x12, 0x82, 0xe2, 0x3a, 0xa0, 0xd6, 0x6c, 0x20, 0x9e, 0xdf, 0xc7, 0x38, 0xbf, 0xf1, 0x96, 0x64,
+		0xa0, 0xf8, 0x3c, 0x1c, 0x69, 0x9f, 0x09, 0xc4, 0x73, 0xfd, 0xf8, 0x0f, 0x22, 0x6b, 0xb7, 0x60,
+		0x22, 0x50, 0xdc, 0xf4, 0x43, 0x4a, 0x30, 0x0b, 0x88, 0x67, 0xfb, 0xea, 0x0f, 0xc2, 0x8e, 0x3b,
+		0x98, 0x04, 0x14, 0xe7, 0x00, 0xfc, 0x00, 0x1c, 0xcf, 0xeb, 0x13, 0x9c, 0x57, 0x80, 0x88, 0x4c,
+		0x0d, 0x1e, 0x7f, 0xe3, 0xe9, 0xaf, 0x8b, 0xa9, 0xc1, 0x29, 0xc8, 0xd4, 0x10, 0xa1, 0x37, 0x9e,
+		0xfa, 0x93, 0x62, 0x6a, 0x08, 0x12, 0x62, 0xd9, 0x81, 0xe8, 0x16, 0xcf, 0xe1, 0xd3, 0xc2, 0xb2,
+		0x03, 0x54, 0xc5, 0x55, 0x18, 0x6f, 0x09, 0x88, 0xf1, 0xac, 0x7e, 0x91, 0xb3, 0xca, 0x45, 0xe3,
+		0x61, 0x30, 0x78, 0xf1, 0x60, 0x18, 0xcf, 0xed, 0x33, 0x91, 0xe0, 0xc5, 0x63, 0x61, 0xf1, 0x1c,
+		0xa4, 0x8d, 0x66, 0xbd, 0x4e, 0x26, 0x0f, 0xea, 0x7e, 0x37, 0x30, 0xff, 0x47, 0x3f, 0xe4, 0xda,
+		0x11, 0x04, 0xc5, 0x33, 0x30, 0x80, 0x1b, 0xdb, 0xb8, 0x1a, 0x47, 0xf9, 0xdd, 0x1f, 0x0a, 0x87,
+		0x49, 0xb0, 0x8b, 0xcf, 0x00, 0xb0, 0xad, 0x11, 0x7a, 0x3c, 0x18, 0x43, 0xfb, 0xdf, 0x7e, 0xc8,
+		0x2f, 0xe3, 0xf8, 0x24, 0x3e, 0x03, 0x76, 0xb5, 0xa7, 0x3b, 0x83, 0xef, 0x85, 0x19, 0xd0, 0x11,
+		0x79, 0x0a, 0x86, 0x5e, 0x74, 0x4c, 0xc3, 0x55, 0x6b, 0x71, 0xd4, 0xff, 0x9d, 0x53, 0x0b, 0x7c,
+		0xa2, 0xb0, 0x86, 0x69, 0x63, 0x57, 0xad, 0x39, 0x71, 0xb4, 0xff, 0x83, 0xd3, 0x7a, 0x04, 0x84,
+		0x58, 0x53, 0x1d, 0xb7, 0x97, 0x7e, 0xff, 0xb1, 0x20, 0x16, 0x04, 0x44, 0x68, 0xf2, 0x7b, 0x0f,
+		0xef, 0xc7, 0xd1, 0x7e, 0x5f, 0x08, 0xcd, 0xf1, 0x8b, 0x6f, 0x86, 0x0c, 0xf9, 0xc9, 0x6e, 0xd8,
+		0xc5, 0x10, 0xff, 0x09, 0x27, 0xf6, 0x29, 0x48, 0xcb, 0x8e, 0x5b, 0x75, 0xf5, 0x78, 0x65, 0xdf,
+		0xe4, 0x23, 0x2d, 0xf0, 0x8b, 0x73, 0x30, 0xec, 0xb8, 0xd5, 0x6a, 0x93, 0xe7, 0xa7, 0x31, 0xe4,
+		0xff, 0xf3, 0x87, 0xde, 0x96, 0x85, 0x47, 0x43, 0x46, 0xfb, 0xca, 0x9e, 0x6b, 0x99, 0xf4, 0x08,
+		0x24, 0x8e, 0xc3, 0x0f, 0x38, 0x87, 0x00, 0x49, 0x71, 0x1e, 0xb2, 0xa4, 0x2f, 0x36, 0xb6, 0x30,
+		0x3d, 0xaf, 0x8a, 0x61, 0xf1, 0xa7, 0x5c, 0x01, 0x21, 0xa2, 0xd2, 0x4f, 0x7d, 0xf5, 0xb5, 0x29,
+		0xe9, 0x1b, 0xaf, 0x4d, 0x49, 0x7f, 0xf8, 0xda, 0x94, 0xf4, 0xe1, 0x6f, 0x4d, 0x1d, 0xfa, 0xc6,
+		0xb7, 0xa6, 0x0e, 0xfd, 0xde, 0xb7, 0xa6, 0x0e, 0xb5, 0xdf, 0x36, 0x86, 0x45, 0x73, 0xd1, 0x64,
+		0x1b, 0xc6, 0x6f, 0x93, 0x43, 0xdb, 0xc5, 0x35, 0xd3, 0xdf, 0xad, 0xf5, 0x16, 0x39, 0xf0, 0xa7,
+		0x12, 0x59, 0x30, 0x87, 0xf7, 0x72, 0x55, 0x63, 0xbf, 0xc3, 0x5b, 0x9d, 0x42, 0xdb, 0x8d, 0x61,
+		0xf9, 0x4d, 0x90, 0x9c, 0x33, 0xf6, 0xd1, 0x31, 0xe6, 0xf3, 0x2a, 0x4d, 0xbb, 0xce, 0x6f, 0x7e,
+		0x0d, 0x91, 0xf2, 0x96, 0x5d, 0x47, 0x93, 0xfe, 0xf5, 0x4c, 0xe9, 0x44, 0x96, 0xdf, 0xb9, 0x2c,
+		0xa6, 0xbe, 0xff, 0xe9, 0xe9, 0x43, 0xa5, 0xbd, 0x68, 0x0f, 0xbf, 0x1c, 0xdb, 0xcb, 0xf4, 0x9c,
+		0xb1, 0x4f, 0x3b, 0xb9, 0x2e, 0xbd, 0x6d, 0x80, 0xb4, 0xe1, 0x88, 0x8d, 0xed, 0xa9, 0xe8, 0xc6,
+		0xf6, 0xf3, 0xb8, 0x5e, 0xbf, 0x68, 0x98, 0x57, 0x8c, 0x4d, 0x82, 0xb6, 0x3d, 0xc8, 0xae, 0x11,
+		0xc3, 0x5f, 0x4f, 0xc0, 0x54, 0xcb, 0x1e, 0x36, 0x1f, 0xf9, 0x4e, 0x0f, 0x95, 0x8a, 0x90, 0x5e,
+		0x10, 0x06, 0x95, 0x87, 0x21, 0x07, 0x6b, 0xa6, 0x51, 0x75, 0x68, 0x57, 0x93, 0x8a, 0x28, 0x92,
+		0xae, 0x1a, 0xaa, 0x61, 0x3a, 0xfc, 0x76, 0x24, 0x2b, 0x94, 0x7e, 0x4e, 0xea, 0x6f, 0x1c, 0x47,
+		0x44, 0x4b, 0xa2, 0x9b, 0x27, 0xbb, 0xed, 0xfd, 0x53, 0x15, 0x78, 0xf2, 0x07, 0xf6, 0xf9, 0x7b,
+		0x55, 0xc7, 0x87, 0x13, 0x30, 0x1d, 0x55, 0x07, 0x99, 0x47, 0x8e, 0xab, 0x36, 0xac, 0x4e, 0xfa,
+		0x38, 0x07, 0x99, 0x4d, 0x81, 0xd3, 0xb7, 0x42, 0x7e, 0xbe, 0x4f, 0x85, 0x8c, 0x7a, 0x4d, 0x09,
+		0x8d, 0x3c, 0x18, 0xaf, 0x11, 0xaf, 0x0b, 0x07, 0x50, 0xc9, 0x7b, 0x92, 0x70, 0x4c, 0x33, 0x9d,
+		0x86, 0xe9, 0x54, 0x98, 0xc1, 0xb3, 0x02, 0x57, 0x46, 0x36, 0x58, 0xd5, 0xc3, 0x71, 0xc8, 0x05,
+		0x18, 0xa5, 0x4e, 0x81, 0x6e, 0x04, 0x53, 0x3f, 0x1c, 0x1b, 0x3a, 0xbf, 0xf6, 0xef, 0x07, 0xe8,
+		0x24, 0x1a, 0xf1, 0x08, 0xe9, 0x4d, 0x97, 0x4d, 0x98, 0xd4, 0x1b, 0x56, 0x1d, 0xd3, 0x23, 0xb1,
+		0x8a, 0x57, 0x17, 0xcf, 0xef, 0xeb, 0x9c, 0xdf, 0x84, 0x4f, 0xbe, 0x24, 0xa8, 0x8b, 0xcb, 0x30,
+		0xae, 0x6a, 0x1a, 0xb6, 0x42, 0x2c, 0x63, 0x1c, 0x96, 0x10, 0x30, 0xc7, 0x29, 0x3d, 0x6e, 0xa5,
+		0x67, 0x3a, 0x8d, 0xed, 0xdb, 0xee, 0x0d, 0x0c, 0x9a, 0x8d, 0x6b, 0xd8, 0x78, 0xd8, 0xc0, 0xee,
+		0x15, 0xd3, 0xde, 0xe3, 0xea, 0x7d, 0x98, 0x35, 0x25, 0x06, 0xe1, 0x7d, 0x49, 0x98, 0x62, 0x15,
+		0xa7, 0xb6, 0x55, 0x07, 0x9f, 0xba, 0xfc, 0xe8, 0x36, 0x76, 0xd5, 0x47, 0x4f, 0x69, 0xa6, 0x2e,
+		0xa6, 0xe9, 0x04, 0x1f, 0x17, 0x52, 0x3f, 0xcb, 0xeb, 0x3b, 0xf8, 0xa9, 0x45, 0x48, 0xcd, 0x9b,
+		0xba, 0x41, 0x2c, 0xb2, 0x8a, 0x0d, 0xb3, 0xc1, 0xbd, 0x14, 0x2b, 0xa0, 0xbb, 0x61, 0x50, 0x6d,
+		0x98, 0x4d, 0xc3, 0x65, 0xa7, 0x79, 0xa5, 0xe1, 0xaf, 0xde, 0x98, 0x3e, 0xf4, 0xfb, 0x37, 0xa6,
+		0x93, 0x4b, 0x86, 0xab, 0xf0, 0xaa, 0x62, 0xea, 0xf5, 0x4f, 0x4d, 0x4b, 0xf2, 0xb3, 0x30, 0xb4,
+		0x80, 0xb5, 0x83, 0xf0, 0x5a, 0xc0, 0x5a, 0x84, 0xd7, 0x03, 0x90, 0x5e, 0x32, 0x5c, 0x76, 0x83,
+		0xf8, 0x4e, 0x48, 0xea, 0x06, 0xbb, 0x94, 0x16, 0x69, 0x9f, 0xc0, 0x09, 0xea, 0x02, 0xd6, 0x3c,
+		0xd4, 0x2a, 0xd6, 0xa2, 0xa8, 0x84, 0x3d, 0x81, 0x97, 0x16, 0x7e, 0xef, 0xbf, 0x4c, 0x1d, 0x7a,
+		0xe5, 0xb5, 0xa9, 0x43, 0x1d, 0x47, 0x22, 0x18, 0x1d, 0xb8, 0x8a, 0xf9, 0x10, 0x38, 0xd5, 0xbd,
+		0x53, 0x6e, 0x68, 0x2e, 0x7c, 0x2e, 0x05, 0x77, 0xd2, 0xc7, 0x23, 0x76, 0x43, 0x37, 0xdc, 0x53,
+		0x9a, 0xbd, 0x6f, 0xb9, 0x34, 0x9c, 0x98, 0x3b, 0x7c, 0x14, 0xc6, 0xfd, 0xea, 0x59, 0x56, 0xdd,
+		0x61, 0x0c, 0x76, 0x60, 0x60, 0x9d, 0xd0, 0x11, 0xc5, 0xb9, 0xa6, 0xab, 0xd6, 0xb9, 0xbb, 0x60,
+		0x05, 0x02, 0x65, 0x0f, 0x4e, 0x12, 0x0c, 0xaa, 0x8b, 0xb7, 0x26, 0x75, 0xac, 0xee, 0xb0, 0x7b,
+		0xbb, 0x49, 0x1a, 0x42, 0xd2, 0x04, 0x40, 0xaf, 0xe8, 0x4e, 0xc2, 0x80, 0xda, 0x64, 0x47, 0xce,
+		0x49, 0x12, 0x5b, 0x68, 0x41, 0xbe, 0x08, 0x43, 0xfc, 0x98, 0x0b, 0xe5, 0x20, 0xb9, 0x87, 0xf7,
+		0x69, 0x3b, 0x59, 0x85, 0xfc, 0x44, 0xb3, 0x30, 0x40, 0x85, 0xe7, 0x0f, 0x12, 0xf2, 0xb3, 0x2d,
+		0xd2, 0xcf, 0x52, 0x21, 0x15, 0x86, 0x26, 0x3f, 0x0b, 0xe9, 0x05, 0xb3, 0xa1, 0x1b, 0x66, 0x98,
+		0x5b, 0x86, 0x71, 0xa3, 0x32, 0x5b, 0x4d, 0x3e, 0xd6, 0x0a, 0x2b, 0xa0, 0x23, 0x30, 0xc8, 0xee,
+		0x71, 0xf3, 0x63, 0x73, 0x5e, 0x92, 0xe7, 0x61, 0x88, 0xf2, 0x5e, 0xb3, 0x10, 0xe2, 0x2f, 0x80,
+		0xf8, 0x85, 0x71, 0xea, 0x16, 0x38, 0xfb, 0x84, 0x2f, 0x2c, 0x82, 0x54, 0x55, 0x75, 0x55, 0xde,
+		0x6f, 0xfa, 0x5b, 0x7e, 0x1a, 0xd2, 0x9c, 0x89, 0x83, 0x4e, 0x43, 0xd2, 0xb4, 0x1c, 0x7e, 0xf0,
+		0x5d, 0xe8, 0xd4, 0x95, 0x35, 0xab, 0x94, 0x22, 0x56, 0xa2, 0x10, 0xe4, 0x92, 0xd2, 0xd1, 0x2c,
+		0x9e, 0x0c, 0x98, 0x45, 0x60, 0xc8, 0x03, 0x3f, 0xd9, 0x90, 0xb6, 0x98, 0x83, 0x67, 0x2c, 0x9f,
+		0x4e, 0xc0, 0x54, 0xa0, 0xf6, 0x32, 0xb6, 0xc9, 0x5a, 0x8f, 0x59, 0x14, 0xb7, 0x16, 0x14, 0x10,
+		0x92, 0xd7, 0x77, 0x30, 0x97, 0x37, 0x43, 0x72, 0xce, 0xb2, 0x50, 0x01, 0xd2, 0xec, 0x80, 0xdb,
+		0x64, 0xf6, 0x92, 0x52, 0xbc, 0x32, 0xa9, 0x73, 0xcc, 0x1d, 0xf7, 0x8a, 0x6a, 0x7b, 0x4f, 0x9d,
+		0x44, 0x59, 0x7e, 0x0a, 0x32, 0xf3, 0xa6, 0xe1, 0x60, 0xc3, 0x69, 0xd2, 0x40, 0xb4, 0x5d, 0x37,
+		0xb5, 0x3d, 0xce, 0x81, 0x15, 0x88, 0xc2, 0x55, 0xcb, 0xa2, 0x94, 0x29, 0x85, 0xfc, 0x64, 0xf3,
+		0xb2, 0xb4, 0xd1, 0x51, 0x45, 0x4f, 0xf5, 0xaf, 0x22, 0xde, 0x49, 0x4f, 0x47, 0xff, 0x47, 0x82,
+		0xe3, 0xad, 0x13, 0x6a, 0x0f, 0xef, 0x3b, 0xfd, 0xce, 0xa7, 0x17, 0x20, 0xb3, 0x4e, 0xdf, 0x1b,
+		0x5f, 0xc4, 0xfb, 0xa8, 0x00, 0x43, 0xb8, 0x7a, 0xfa, 0xcc, 0x99, 0x47, 0x9f, 0x62, 0xd6, 0x7e,
+		0xe1, 0x90, 0x22, 0x00, 0x68, 0x0a, 0x32, 0x0e, 0xd6, 0xac, 0xd3, 0x67, 0xce, 0xee, 0x3d, 0xca,
+		0xcc, 0xeb, 0xc2, 0x21, 0xc5, 0x07, 0x15, 0xd3, 0xa4, 0xd7, 0xaf, 0x7f, 0x7a, 0x5a, 0x2a, 0x0d,
+		0x40, 0xd2, 0x69, 0x36, 0x6e, 0xab, 0x8d, 0xbc, 0x3a, 0x00, 0x33, 0x41, 0x4a, 0x1a, 0xad, 0x2f,
+		0xab, 0x75, 0xbd, 0xaa, 0xfa, 0x2f, 0xc5, 0x73, 0x01, 0x1d, 0x50, 0x8c, 0xf6, 0x2a, 0x28, 0x74,
+		0xd5, 0xa4, 0xfc, 0x1b, 0x12, 0x64, 0x2f, 0x09, 0xce, 0x1b, 0xd8, 0x45, 0xe7, 0x00, 0xbc, 0x96,
+		0xc4, 0xb4, 0xb9, 0x63, 0x36, 0xda, 0xd6, 0xac, 0x47, 0xa3, 0x04, 0xd0, 0xd1, 0x13, 0xd4, 0x10,
+		0x2d, 0xd3, 0xe1, 0xcf, 0x5f, 0x62, 0x48, 0x3d, 0x64, 0xf4, 0x10, 0x20, 0xea, 0xe1, 0x2a, 0x97,
+		0x4d, 0x57, 0x37, 0x6a, 0x15, 0xcb, 0xbc, 0xc2, 0x1f, 0x15, 0x26, 0x95, 0x1c, 0xad, 0xb9, 0x44,
+		0x2b, 0xd6, 0x09, 0x9c, 0x08, 0x9d, 0xf1, 0xb8, 0x90, 0xdc, 0x4a, 0xad, 0x56, 0x6d, 0xec, 0x38,
+		0xdc, 0x89, 0x89, 0x22, 0x3a, 0x07, 0x43, 0x56, 0x73, 0xbb, 0x22, 0x3c, 0xc6, 0xf0, 0xe9, 0xe3,
+		0xed, 0xe6, 0xbf, 0xb0, 0x0f, 0xee, 0x01, 0x06, 0xad, 0xe6, 0x36, 0xb1, 0x96, 0xbb, 0x20, 0xdb,
+		0x46, 0x98, 0xe1, 0xcb, 0xbe, 0x1c, 0xf4, 0x99, 0x3b, 0xef, 0x41, 0xc5, 0xb2, 0x75, 0xd3, 0xd6,
+		0xdd, 0x7d, 0x7a, 0x7b, 0x25, 0xa9, 0xe4, 0x44, 0xc5, 0x3a, 0x87, 0xcb, 0x7b, 0x30, 0xb6, 0x41,
+		0x73, 0x0b, 0x5f, 0xf2, 0x33, 0xbe, 0x7c, 0x52, 0xbc, 0x7c, 0x1d, 0x25, 0x4b, 0xb4, 0x48, 0x56,
+		0x7a, 0xae, 0xa3, 0x75, 0x3e, 0xd1, 0xbf, 0x75, 0x86, 0xa3, 0xdd, 0x1f, 0x1f, 0x0b, 0x4d, 0x4e,
+		0x9e, 0x4a, 0x06, 0xdc, 0x57, 0xaf, 0x86, 0x19, 0x97, 0x52, 0x17, 0xba, 0x07, 0xd5, 0x42, 0x8c,
+		0x1b, 0x2d, 0xc4, 0x4e, 0x21, 0xf9, 0x29, 0x18, 0x59, 0x57, 0x6d, 0x77, 0x03, 0xbb, 0x17, 0xb0,
+		0x5a, 0xc5, 0x76, 0x38, 0xea, 0x8e, 0x88, 0xa8, 0x8b, 0x20, 0x45, 0x43, 0x2b, 0x8b, 0x3a, 0xf4,
+		0xb7, 0xbc, 0x0b, 0x29, 0x7a, 0x83, 0xcd, 0x8b, 0xc8, 0x9c, 0x82, 0x45, 0x64, 0xe2, 0x4b, 0xf7,
+		0x5d, 0xec, 0x88, 0x05, 0x1d, 0x2d, 0xa0, 0xc7, 0x45, 0x5c, 0x4d, 0x76, 0x8f, 0xab, 0xdc, 0x10,
+		0x79, 0x74, 0xad, 0xc3, 0x50, 0x89, 0xb8, 0xe2, 0xa5, 0x05, 0x4f, 0x10, 0xc9, 0x17, 0x04, 0xad,
+		0xc0, 0x98, 0xa5, 0xda, 0x2e, 0xbd, 0xba, 0xbf, 0x4b, 0x7b, 0xc1, 0x6d, 0x7d, 0xba, 0x75, 0xe6,
+		0x85, 0x3a, 0xcb, 0x5b, 0x19, 0xb1, 0x82, 0x40, 0xf9, 0x3b, 0x29, 0x18, 0xe4, 0xca, 0x78, 0x33,
+		0x0c, 0x71, 0xb5, 0x72, 0xeb, 0xbc, 0x73, 0xb6, 0x35, 0x30, 0xcd, 0x7a, 0x01, 0x84, 0xf3, 0x13,
+		0x34, 0xe8, 0x3e, 0x48, 0x6b, 0xbb, 0xaa, 0x6e, 0x54, 0xf4, 0xaa, 0x48, 0xf3, 0x5e, 0xbb, 0x31,
+		0x3d, 0x34, 0x4f, 0x60, 0x4b, 0x0b, 0xca, 0x10, 0xad, 0x5c, 0xaa, 0x92, 0x4c, 0x60, 0x17, 0xeb,
+		0xb5, 0x5d, 0x97, 0xcf, 0x30, 0x5e, 0x42, 0x4f, 0x42, 0x8a, 0x18, 0x04, 0x7f, 0xd8, 0x55, 0x68,
+		0x49, 0xb6, 0xbd, 0x15, 0x4f, 0x29, 0x4d, 0x1a, 0xfe, 0xf0, 0x1f, 0x4c, 0x4b, 0x0a, 0xa5, 0x40,
+		0xf3, 0x30, 0x52, 0x57, 0x1d, 0xb7, 0x42, 0x23, 0x18, 0x69, 0x7e, 0x80, 0xb2, 0x38, 0xd6, 0xaa,
+		0x10, 0xae, 0x58, 0x2e, 0xfa, 0x30, 0xa1, 0x62, 0xa0, 0x2a, 0x3a, 0x01, 0x39, 0xca, 0x44, 0x33,
+		0x1b, 0x0d, 0xdd, 0x65, 0xb9, 0xd5, 0x20, 0xd5, 0xfb, 0x28, 0x81, 0xcf, 0x53, 0x30, 0xcd, 0xb0,
+		0xee, 0x80, 0x0c, 0x7d, 0x4a, 0x42, 0x51, 0xd8, 0xb5, 0xc9, 0x34, 0x01, 0xd0, 0xca, 0xfb, 0x61,
+		0xcc, 0xf7, 0x8f, 0x0c, 0x25, 0xcd, 0xb8, 0xf8, 0x60, 0x8a, 0xf8, 0x08, 0x4c, 0x1a, 0xf8, 0x2a,
+		0xbd, 0xc8, 0x19, 0xc2, 0xce, 0x50, 0x6c, 0x44, 0xea, 0x2e, 0x85, 0x29, 0xee, 0x85, 0x51, 0x4d,
+		0x28, 0x9f, 0xe1, 0x02, 0xc5, 0x1d, 0xf1, 0xa0, 0x14, 0xed, 0x18, 0xa4, 0x55, 0xcb, 0x62, 0x08,
+		0xc3, 0xdc, 0x3f, 0x5a, 0x16, 0xad, 0x3a, 0x09, 0xe3, 0xb4, 0x8f, 0x36, 0x76, 0x9a, 0x75, 0x97,
+		0x33, 0xc9, 0x52, 0x9c, 0x31, 0x52, 0xa1, 0x30, 0x38, 0xc5, 0xbd, 0x1b, 0x46, 0xf0, 0x65, 0xbd,
+		0x8a, 0x0d, 0x0d, 0x33, 0xbc, 0x11, 0x8a, 0x97, 0x15, 0x40, 0x8a, 0xf4, 0x00, 0x78, 0x7e, 0xaf,
+		0x22, 0x7c, 0xf2, 0x28, 0xe3, 0x27, 0xe0, 0x73, 0x0c, 0x2c, 0xe7, 0x21, 0xb5, 0xa0, 0xba, 0x2a,
+		0x49, 0x30, 0xdc, 0xab, 0x2c, 0xd0, 0x64, 0x15, 0xf2, 0x53, 0x7e, 0x3d, 0x01, 0xa9, 0x4b, 0xa6,
+		0x8b, 0xd1, 0x63, 0x81, 0x04, 0x70, 0xb4, 0x9d, 0x3d, 0x6f, 0xe8, 0x35, 0x03, 0x57, 0x57, 0x9c,
+		0x5a, 0xe0, 0xdd, 0xb7, 0x6f, 0x4e, 0x89, 0x90, 0x39, 0x4d, 0xc2, 0x80, 0x6d, 0x36, 0x8d, 0xaa,
+		0xb8, 0x71, 0x48, 0x0b, 0xa8, 0x0c, 0x69, 0xcf, 0x4a, 0x52, 0x71, 0x56, 0x32, 0x46, 0xac, 0x84,
+		0xd8, 0x30, 0x07, 0x28, 0x43, 0xdb, 0xdc, 0x58, 0x4a, 0x90, 0xf1, 0x9c, 0x17, 0xb7, 0xb6, 0xde,
+		0x0c, 0xd6, 0x27, 0x23, 0xc1, 0xc4, 0x1b, 0x7b, 0x4f, 0x79, 0xcc, 0xe2, 0x72, 0x5e, 0x05, 0xd7,
+		0x5e, 0xc8, 0xac, 0xf8, 0x1b, 0xf4, 0x21, 0xda, 0x2f, 0xdf, 0xac, 0xd8, 0x3b, 0xf4, 0xe3, 0x90,
+		0x71, 0xf4, 0x9a, 0xa1, 0xba, 0x4d, 0x1b, 0x73, 0xcb, 0xf3, 0x01, 0xf2, 0x97, 0x25, 0x18, 0x64,
+		0x96, 0x1c, 0xd0, 0x9b, 0xd4, 0x5e, 0x6f, 0x89, 0x4e, 0x7a, 0x4b, 0x1e, 0x5c, 0x6f, 0x73, 0x00,
+		0x9e, 0x30, 0x0e, 0x7f, 0x1a, 0xdc, 0x26, 0x63, 0x60, 0x22, 0x6e, 0xe8, 0x35, 0x3e, 0x51, 0x03,
+		0x44, 0xf2, 0x7f, 0x96, 0x48, 0x12, 0xcb, 0xeb, 0xd1, 0x1c, 0x8c, 0x08, 0xb9, 0x2a, 0x3b, 0x75,
+		0xb5, 0xc6, 0x6d, 0xe7, 0xce, 0x8e, 0xc2, 0x9d, 0xaf, 0xab, 0x35, 0x65, 0x98, 0xcb, 0x43, 0x0a,
+		0xed, 0xc7, 0x21, 0xd1, 0x61, 0x1c, 0x42, 0x03, 0x9f, 0x3c, 0xd8, 0xc0, 0x87, 0x86, 0x28, 0x15,
+		0x1d, 0xa2, 0x2f, 0x24, 0xe8, 0x62, 0xc6, 0x32, 0x1d, 0xb5, 0xfe, 0xe3, 0x98, 0x11, 0x77, 0x40,
+		0xc6, 0x32, 0xeb, 0x15, 0x56, 0xc3, 0x6e, 0xe2, 0xa6, 0x2d, 0xb3, 0xae, 0xb4, 0x0c, 0xfb, 0xc0,
+		0x2d, 0x9a, 0x2e, 0x83, 0xb7, 0x40, 0x6b, 0x43, 0x51, 0xad, 0xd9, 0x90, 0x65, 0xaa, 0xe0, 0xb1,
+		0xec, 0x11, 0xa2, 0x03, 0x1a, 0x1c, 0xa5, 0xd6, 0xd8, 0xcb, 0xc4, 0x66, 0x98, 0x0a, 0xc7, 0x23,
+		0x14, 0xcc, 0xf5, 0xb7, 0x5b, 0x05, 0x07, 0xcd, 0x52, 0xe1, 0x78, 0xf2, 0xcf, 0x4b, 0x00, 0xcb,
+		0x44, 0xb3, 0xb4, 0xbf, 0x24, 0x0a, 0x39, 0x54, 0x84, 0x4a, 0xa8, 0xe5, 0xa9, 0x4e, 0x83, 0xc6,
+		0xdb, 0xcf, 0x3a, 0x41, 0xb9, 0xe7, 0x61, 0xc4, 0x37, 0x46, 0x07, 0x0b, 0x61, 0xa6, 0xba, 0x64,
+		0xd5, 0x1b, 0xd8, 0x55, 0xb2, 0x97, 0x03, 0x25, 0xf9, 0x5f, 0x48, 0x90, 0xa1, 0x32, 0xad, 0x60,
+		0x57, 0x0d, 0x8d, 0xa1, 0x74, 0xf0, 0x31, 0xbc, 0x13, 0x80, 0xb1, 0x71, 0xf4, 0x97, 0x31, 0xb7,
+		0xac, 0x0c, 0x85, 0x6c, 0xe8, 0x2f, 0x63, 0x74, 0xd6, 0x53, 0x78, 0xb2, 0xbb, 0xc2, 0x45, 0xd6,
+		0xcd, 0xd5, 0x7e, 0x14, 0x86, 0xe8, 0xa7, 0x74, 0xae, 0x3a, 0x3c, 0x91, 0x1e, 0x34, 0x9a, 0x8d,
+		0xcd, 0xab, 0x8e, 0xfc, 0x22, 0x0c, 0x6d, 0x5e, 0x65, 0x7b, 0x23, 0x77, 0x40, 0xc6, 0x36, 0x4d,
+		0x1e, 0x93, 0x59, 0x2e, 0x94, 0x26, 0x00, 0x1a, 0x82, 0xc4, 0x7e, 0x40, 0xc2, 0xdf, 0x0f, 0xf0,
+		0x37, 0x34, 0x92, 0x3d, 0x6d, 0x68, 0x9c, 0xfc, 0x0f, 0x12, 0x0c, 0x07, 0xfc, 0x03, 0x7a, 0x14,
+		0x0e, 0x97, 0x96, 0xd7, 0xe6, 0x2f, 0x56, 0x96, 0x16, 0x2a, 0xe7, 0x97, 0xe7, 0x16, 0xfd, 0xb7,
+		0x26, 0x85, 0x23, 0xd7, 0xae, 0xcf, 0xa0, 0x00, 0xee, 0x96, 0xb1, 0x67, 0x98, 0x57, 0x0c, 0x74,
+		0x0a, 0x26, 0xc3, 0x24, 0x73, 0xa5, 0x8d, 0xf2, 0xea, 0x66, 0x4e, 0x2a, 0x1c, 0xbe, 0x76, 0x7d,
+		0x66, 0x3c, 0x40, 0x31, 0xb7, 0xed, 0x60, 0xc3, 0x6d, 0x25, 0x98, 0x5f, 0x5b, 0x59, 0x59, 0xda,
+		0xcc, 0x25, 0x5a, 0x08, 0xb8, 0xc3, 0x7e, 0x00, 0xc6, 0xc3, 0x04, 0xab, 0x4b, 0xcb, 0xb9, 0x64,
+		0x01, 0x5d, 0xbb, 0x3e, 0x33, 0x1a, 0xc0, 0x5e, 0xd5, 0xeb, 0x85, 0xf4, 0x07, 0x3e, 0x33, 0x75,
+		0xe8, 0x97, 0x7f, 0x69, 0x4a, 0x22, 0x3d, 0x1b, 0x09, 0xf9, 0x08, 0xf4, 0x10, 0x1c, 0xdd, 0x58,
+		0x5a, 0x5c, 0x2d, 0x2f, 0x54, 0x56, 0x36, 0x16, 0x2b, 0xec, 0x1b, 0x1b, 0x5e, 0xef, 0xc6, 0xae,
+		0x5d, 0x9f, 0x19, 0xe6, 0x5d, 0xea, 0x84, 0xbd, 0xae, 0x94, 0x2f, 0xad, 0x6d, 0x96, 0x73, 0x12,
+		0xc3, 0x5e, 0xb7, 0xf1, 0x65, 0xd3, 0x65, 0xdf, 0xda, 0x7a, 0x04, 0x8e, 0xb5, 0xc1, 0xf6, 0x3a,
+		0x36, 0x7e, 0xed, 0xfa, 0xcc, 0xc8, 0xba, 0x8d, 0xd9, 0xfc, 0xa1, 0x14, 0xb3, 0x90, 0x6f, 0xa5,
+		0x58, 0x5b, 0x5f, 0xdb, 0x98, 0x5b, 0xce, 0xcd, 0x14, 0x72, 0xd7, 0xae, 0xcf, 0x64, 0x85, 0x33,
+		0x24, 0xf8, 0x7e, 0xcf, 0x6e, 0xe7, 0x8a, 0xe7, 0x3b, 0xb3, 0x70, 0x0f, 0xdf, 0x03, 0x74, 0x5c,
+		0x75, 0x4f, 0x37, 0x6a, 0xde, 0x4e, 0x2b, 0x2f, 0xf3, 0x95, 0xcf, 0x11, 0xbe, 0xd9, 0x2a, 0xa0,
+		0x5d, 0xf7, 0x5b, 0x0b, 0x9d, 0x4f, 0x96, 0x0a, 0x31, 0x87, 0x2f, 0xf1, 0x4b, 0xa7, 0xce, 0x7b,
+		0xf3, 0x85, 0x98, 0x1d, 0xe3, 0x42, 0xd7, 0xc5, 0x9d, 0xfc, 0x41, 0x09, 0x46, 0x2f, 0xe8, 0x8e,
+		0x6b, 0xda, 0xba, 0xa6, 0xd6, 0xe9, 0x0b, 0x93, 0xb3, 0xbd, 0xfa, 0xd6, 0xc8, 0x54, 0x7f, 0x06,
+		0x06, 0x2f, 0xab, 0x75, 0xe6, 0xd4, 0x92, 0xf4, 0x83, 0x18, 0xed, 0xd5, 0xe7, 0xbb, 0x36, 0xc1,
+		0x80, 0x91, 0xc9, 0xbf, 0x9a, 0x80, 0x31, 0x3a, 0x19, 0x1c, 0xf6, 0xa9, 0x24, 0xb2, 0xc6, 0x2a,
+		0x41, 0xca, 0x56, 0x5d, 0xbe, 0x69, 0x58, 0x9a, 0xe5, 0x3b, 0xbf, 0xf7, 0xc5, 0xef, 0xe6, 0xce,
+		0x2e, 0x60, 0x4d, 0xa1, 0xb4, 0xe8, 0x1d, 0x90, 0x6e, 0xa8, 0x57, 0x2b, 0x94, 0x0f, 0x5b, 0xb9,
+		0xcc, 0xf5, 0xc7, 0xe7, 0xe6, 0x8d, 0xe9, 0xb1, 0x7d, 0xb5, 0x51, 0x2f, 0xca, 0x82, 0x8f, 0xac,
+		0x0c, 0x35, 0xd4, 0xab, 0x44, 0x44, 0x64, 0xc1, 0x18, 0x81, 0x6a, 0xbb, 0xaa, 0x51, 0xc3, 0xac,
+		0x11, 0xba, 0x05, 0x5a, 0xba, 0xd0, 0x77, 0x23, 0x47, 0xfc, 0x46, 0x02, 0xec, 0x64, 0x65, 0xa4,
+		0xa1, 0x5e, 0x9d, 0xa7, 0x00, 0xd2, 0x62, 0x31, 0xfd, 0xb1, 0x4f, 0x4d, 0x1f, 0xa2, 0xbb, 0xe9,
+		0xdf, 0x94, 0x00, 0x7c, 0x8d, 0xa1, 0x77, 0x40, 0x4e, 0xf3, 0x4a, 0x94, 0xd6, 0xe1, 0x63, 0x78,
+		0x7f, 0xa7, 0xb1, 0x88, 0xe8, 0x9b, 0xc5, 0xe6, 0x6f, 0xdc, 0x98, 0x96, 0x94, 0x31, 0x2d, 0x32,
+		0x14, 0x6f, 0x87, 0xe1, 0xa6, 0x55, 0x55, 0x5d, 0x5c, 0xa1, 0xeb, 0xb8, 0x44, 0x6c, 0x9c, 0x9f,
+		0x22, 0xbc, 0x6e, 0xde, 0x98, 0x46, 0xac, 0x5b, 0x01, 0x62, 0x99, 0x46, 0x7f, 0x60, 0x10, 0x42,
+		0x10, 0xe8, 0xd3, 0xd7, 0x24, 0x18, 0x5e, 0x08, 0xdc, 0xf4, 0xca, 0xc3, 0x50, 0xc3, 0x34, 0xf4,
+		0x3d, 0x6e, 0x8f, 0x19, 0x45, 0x14, 0x51, 0x01, 0xd2, 0xec, 0xd1, 0x9d, 0xbb, 0x2f, 0xb6, 0x42,
+		0x45, 0x99, 0x50, 0x5d, 0xc1, 0xdb, 0x8e, 0x2e, 0x46, 0x43, 0x11, 0x45, 0x74, 0x1e, 0x72, 0x0e,
+		0xd6, 0x9a, 0xb6, 0xee, 0xee, 0x57, 0x34, 0xd3, 0x70, 0x55, 0xcd, 0x65, 0xcf, 0xb7, 0x4a, 0x77,
+		0xdc, 0xbc, 0x31, 0x7d, 0x94, 0xc9, 0x1a, 0xc5, 0x90, 0x95, 0x31, 0x01, 0x9a, 0x67, 0x10, 0xd2,
+		0x42, 0x15, 0xbb, 0xaa, 0x5e, 0x77, 0xf2, 0xec, 0x60, 0x48, 0x14, 0x03, 0x7d, 0xf9, 0xfc, 0x50,
+		0x70, 0x63, 0xeb, 0x3c, 0xe4, 0x4c, 0x0b, 0xdb, 0xa1, 0x44, 0x54, 0x8a, 0xb6, 0x1c, 0xc5, 0x90,
+		0x95, 0x31, 0x01, 0x12, 0x49, 0xaa, 0x4b, 0x86, 0x59, 0x2c, 0x14, 0xad, 0xe6, 0xb6, 0xbf, 0x1f,
+		0x36, 0xd9, 0x32, 0x1a, 0x73, 0xc6, 0x7e, 0xe9, 0x31, 0x9f, 0x7b, 0x94, 0x4e, 0xfe, 0xfa, 0x17,
+		0x1f, 0x9e, 0xe4, 0xa6, 0xe1, 0xef, 0x4f, 0x5d, 0xc4, 0xfb, 0x64, 0xf8, 0x39, 0xea, 0x3a, 0xc5,
+		0x24, 0x69, 0xe7, 0x8b, 0xaa, 0x5e, 0x17, 0xcf, 0x90, 0x15, 0x5e, 0x42, 0x45, 0x18, 0x74, 0x5c,
+		0xd5, 0x6d, 0x3a, 0xfc, 0xe3, 0x60, 0x72, 0x27, 0x53, 0x2b, 0x99, 0x46, 0x75, 0x83, 0x62, 0x2a,
+		0x9c, 0x02, 0x9d, 0x87, 0x41, 0xd7, 0xdc, 0xc3, 0x06, 0x57, 0x61, 0x5f, 0xf3, 0x9b, 0x9e, 0x53,
+		0x31, 0x6a, 0xa2, 0x91, 0x2a, 0xae, 0xe3, 0x1a, 0x4b, 0xab, 0x76, 0x55, 0xb2, 0xfa, 0xa0, 0xdf,
+		0x08, 0x2b, 0x2d, 0xf5, 0x3d, 0x09, 0xb9, 0xa6, 0xa2, 0xfc, 0x64, 0x65, 0xcc, 0x03, 0x6d, 0x50,
+		0x08, 0xba, 0x18, 0xba, 0x92, 0xc8, 0x3f, 0xa4, 0x77, 0x77, 0xa7, 0xee, 0x07, 0x6c, 0x5a, 0xec,
+		0x4f, 0x04, 0x2f, 0x34, 0x9e, 0x87, 0x5c, 0xd3, 0xd8, 0x36, 0x0d, 0xfa, 0x56, 0x90, 0xe7, 0xf7,
+		0x64, 0x7d, 0x97, 0x0c, 0x1a, 0x47, 0x14, 0x43, 0x56, 0xc6, 0x3c, 0xd0, 0x05, 0xb6, 0x0a, 0xa8,
+		0xc2, 0xa8, 0x8f, 0x45, 0x27, 0x6a, 0x26, 0x76, 0xa2, 0xde, 0xc5, 0x27, 0xea, 0xe1, 0x68, 0x2b,
+		0xfe, 0x5c, 0x1d, 0xf1, 0x80, 0x84, 0x0c, 0x5d, 0x00, 0xf0, 0xdd, 0x03, 0xdd, 0xa7, 0x18, 0xee,
+		0x3c, 0xf0, 0xbe, 0x8f, 0x11, 0xeb, 0x3d, 0x9f, 0x16, 0xbd, 0x0b, 0x26, 0x1a, 0xba, 0x51, 0x71,
+		0x70, 0x7d, 0xa7, 0xc2, 0x15, 0x4c, 0x58, 0xd2, 0x4f, 0xbd, 0x94, 0x96, 0xfb, 0xb3, 0x87, 0x9b,
+		0x37, 0xa6, 0x0b, 0xdc, 0x85, 0xb6, 0xb2, 0x94, 0x95, 0xf1, 0x86, 0x6e, 0x6c, 0xe0, 0xfa, 0xce,
+		0x82, 0x07, 0x2b, 0x66, 0x3f, 0xf0, 0xa9, 0xe9, 0x43, 0x7c, 0xba, 0x1e, 0x92, 0xcf, 0xd2, 0xbd,
+		0x73, 0x3e, 0xcd, 0xb0, 0x43, 0xd6, 0x24, 0xaa, 0x28, 0xd0, 0x1d, 0x8d, 0x8c, 0xe2, 0x03, 0xd8,
+		0x34, 0x7f, 0xe5, 0x3f, 0xcd, 0x48, 0xf2, 0xe7, 0x25, 0x18, 0x5c, 0xb8, 0xb4, 0xae, 0xea, 0x36,
+		0x5a, 0x82, 0x71, 0xdf, 0x72, 0xc2, 0x93, 0xfc, 0xf8, 0xcd, 0x1b, 0xd3, 0xf9, 0xa8, 0x71, 0x79,
+		0xb3, 0xdc, 0x37, 0x60, 0x31, 0xcd, 0x97, 0x3a, 0x2d, 0x5c, 0x43, 0xac, 0x5a, 0x50, 0xe4, 0xd6,
+		0x65, 0x6d, 0xa4, 0x9b, 0x65, 0x18, 0x62, 0xd2, 0x3a, 0xa8, 0x08, 0x03, 0x16, 0xf9, 0xc1, 0x0f,
+		0x06, 0xa6, 0x3a, 0x1a, 0x2f, 0xc5, 0xf7, 0x36, 0x32, 0x09, 0x89, 0xfc, 0x91, 0x04, 0xc0, 0xc2,
+		0xa5, 0x4b, 0x9b, 0xb6, 0x6e, 0xd5, 0xb1, 0x7b, 0x2b, 0x7b, 0xbe, 0x09, 0x87, 0x03, 0xab, 0x24,
+		0x5b, 0x8b, 0xf4, 0x7e, 0xe6, 0xe6, 0x8d, 0xe9, 0xe3, 0xd1, 0xde, 0x07, 0xd0, 0x64, 0x65, 0xc2,
+		0x5f, 0x2f, 0xd9, 0x5a, 0x5b, 0xae, 0x55, 0xc7, 0xf5, 0xb8, 0x26, 0x3b, 0x73, 0x0d, 0xa0, 0x05,
+		0xb9, 0x2e, 0x38, 0x6e, 0x7b, 0xd5, 0x6e, 0xc0, 0xb0, 0xaf, 0x12, 0x07, 0x2d, 0x40, 0xda, 0xe5,
+		0xbf, 0xb9, 0x86, 0xe5, 0xce, 0x1a, 0x16, 0x64, 0x5c, 0xcb, 0x1e, 0xa5, 0xfc, 0x67, 0x12, 0x80,
+		0x6f, 0xb3, 0x3f, 0x99, 0x26, 0x46, 0x5c, 0x39, 0x77, 0xbc, 0xc9, 0x03, 0xa5, 0x6a, 0x9c, 0x3a,
+		0xa2, 0xcf, 0x9f, 0x49, 0xc0, 0xc4, 0x96, 0xf0, 0x3c, 0x3f, 0xf1, 0x3a, 0x58, 0x87, 0x21, 0x6c,
+		0xb8, 0xb6, 0x4e, 0x95, 0x40, 0x46, 0xfb, 0x91, 0x4e, 0xa3, 0xdd, 0xa6, 0x4f, 0xf4, 0x63, 0x37,
+		0x62, 0xd3, 0x9d, 0xb3, 0x89, 0x68, 0xe3, 0x43, 0x49, 0xc8, 0x77, 0xa2, 0x44, 0xf3, 0x30, 0xa6,
+		0xd9, 0x98, 0x02, 0x2a, 0xc1, 0x9d, 0xbf, 0x52, 0xc1, 0xcf, 0x2c, 0x23, 0x08, 0xb2, 0x32, 0x2a,
+		0x20, 0x3c, 0x7a, 0xd4, 0x80, 0xa4, 0x7d, 0xc4, 0xec, 0x08, 0x56, 0x8f, 0x79, 0x9e, 0xcc, 0xc3,
+		0x87, 0x68, 0x24, 0xcc, 0x80, 0xc5, 0x8f, 0x51, 0x1f, 0x4a, 0x03, 0xc8, 0x4b, 0x30, 0xa6, 0x1b,
+		0xba, 0xab, 0xab, 0xf5, 0xca, 0xb6, 0x5a, 0x57, 0x0d, 0xed, 0x20, 0x59, 0x33, 0x73, 0xf9, 0xbc,
+		0xd9, 0x08, 0x3b, 0x59, 0x19, 0xe5, 0x90, 0x12, 0x03, 0xa0, 0x0b, 0x30, 0x24, 0x9a, 0x4a, 0x1d,
+		0x28, 0xdb, 0x10, 0xe4, 0x81, 0x04, 0xef, 0x67, 0x93, 0x30, 0xae, 0xe0, 0xea, 0x5f, 0x0e, 0x45,
+		0x7f, 0x43, 0xb1, 0x02, 0xc0, 0xa6, 0x3b, 0x71, 0xb0, 0x07, 0x18, 0x0d, 0xe2, 0x30, 0x32, 0x8c,
+		0xc3, 0x82, 0xe3, 0x06, 0xc6, 0xe3, 0x46, 0x02, 0xb2, 0xc1, 0xf1, 0xf8, 0x0b, 0x1a, 0x95, 0xd0,
+		0x92, 0xef, 0x89, 0x52, 0xfc, 0x13, 0xa1, 0x1d, 0x3c, 0x51, 0x8b, 0xf5, 0x76, 0x77, 0x41, 0x7f,
+		0x94, 0x84, 0xc1, 0x75, 0xd5, 0x56, 0x1b, 0x0e, 0xd2, 0x5a, 0x32, 0x4d, 0xb1, 0xfd, 0xd8, 0xf2,
+		0x21, 0x68, 0xbe, 0xdb, 0x11, 0x93, 0x68, 0x7e, 0xac, 0x4d, 0xa2, 0xf9, 0x16, 0x18, 0x25, 0xcb,
+		0xe1, 0xc0, 0x15, 0x06, 0xa2, 0xed, 0x91, 0xd2, 0x31, 0x9f, 0x4b, 0xb8, 0x9e, 0xad, 0x96, 0x2f,
+		0x05, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0xdf, 0x31, 0x13, 0xf2, 0x23, 0xfe, 0xb2, 0x34, 0x50, 0x29,
+		0x2b, 0xd0, 0x50, 0xaf, 0x96, 0x59, 0x01, 0x2d, 0x03, 0xda, 0xf5, 0x76, 0x46, 0x2a, 0xbe, 0x3a,
+		0x09, 0xfd, 0x9d, 0x37, 0x6f, 0x4c, 0x1f, 0x63, 0xf4, 0xad, 0x38, 0xb2, 0x32, 0xee, 0x03, 0x05,
+		0xb7, 0xc7, 0x01, 0x48, 0xbf, 0x2a, 0xec, 0xfa, 0x1c, 0x5b, 0xee, 0x1c, 0xbe, 0x79, 0x63, 0x7a,
+		0x9c, 0x71, 0xf1, 0xeb, 0x64, 0x25, 0x43, 0x0a, 0x0b, 0xf4, 0x66, 0xdd, 0x4b, 0x30, 0x46, 0xef,
+		0x04, 0x54, 0x6c, 0x5c, 0x6d, 0xd2, 0x0f, 0x56, 0xf0, 0x75, 0xcd, 0x81, 0xe7, 0x66, 0x84, 0x9d,
+		0xac, 0x8c, 0x52, 0x88, 0x22, 0x00, 0x81, 0xc9, 0xf4, 0x19, 0x09, 0x90, 0x1f, 0x65, 0x14, 0xec,
+		0x58, 0x64, 0x49, 0x48, 0x72, 0xff, 0x40, 0xa2, 0x2e, 0x75, 0xcf, 0xfd, 0x7d, 0x7a, 0x91, 0xfb,
+		0x07, 0x26, 0xe7, 0x53, 0xbe, 0x47, 0x4e, 0x70, 0xd3, 0x69, 0x73, 0xbd, 0x71, 0x76, 0xde, 0xd4,
+		0x05, 0x75, 0x8b, 0x0b, 0x3e, 0x24, 0xff, 0x1b, 0x09, 0x8e, 0xb5, 0x18, 0xb1, 0x27, 0xec, 0x5f,
+		0x01, 0x64, 0x07, 0x2a, 0xf9, 0x27, 0xe6, 0x98, 0xd0, 0x7d, 0xcf, 0x89, 0x71, 0xbb, 0xc5, 0xd5,
+		0xdf, 0xba, 0xa0, 0xc2, 0xee, 0x47, 0xfe, 0x73, 0x09, 0x26, 0x83, 0xcd, 0x7b, 0x1d, 0x59, 0x85,
+		0x6c, 0xb0, 0x75, 0xde, 0x85, 0x7b, 0x7a, 0xe9, 0x02, 0x97, 0x3e, 0x44, 0x8f, 0x9e, 0xf3, 0x3d,
+		0x04, 0xdb, 0xae, 0x7b, 0xb4, 0x67, 0x6d, 0x08, 0x99, 0xa2, 0x9e, 0x22, 0x45, 0xc7, 0xe3, 0xff,
+		0x4a, 0x90, 0x5a, 0x37, 0xcd, 0x3a, 0x32, 0x61, 0xdc, 0x30, 0xdd, 0x0a, 0x31, 0x66, 0x5c, 0xad,
+		0xf0, 0x75, 0x3e, 0x73, 0xbd, 0xf3, 0xfd, 0x29, 0xe9, 0xbb, 0x37, 0xa6, 0x5b, 0x59, 0x29, 0x63,
+		0x86, 0xe9, 0x96, 0x28, 0x64, 0x93, 0xed, 0x02, 0xbc, 0x0b, 0x46, 0xc2, 0x8d, 0x31, 0xc7, 0xfc,
+		0x7c, 0xdf, 0x8d, 0x85, 0xd9, 0xdc, 0xbc, 0x31, 0x3d, 0xe9, 0x4f, 0x52, 0x0f, 0x2c, 0x2b, 0xd9,
+		0xed, 0x40, 0xeb, 0xec, 0x46, 0xd9, 0xf7, 0x3f, 0x35, 0x2d, 0x9d, 0xfc, 0x92, 0x04, 0xe0, 0x6f,
+		0x76, 0xa0, 0x87, 0xe0, 0x68, 0x69, 0x6d, 0x75, 0xa1, 0xb2, 0xb1, 0x39, 0xb7, 0xb9, 0xb5, 0x51,
+		0xd9, 0x5a, 0xdd, 0x58, 0x2f, 0xcf, 0x2f, 0x9d, 0x5f, 0x2a, 0x2f, 0xf8, 0x3b, 0xf2, 0x8e, 0x85,
+		0x35, 0x7d, 0x47, 0xc7, 0x55, 0x74, 0x1f, 0x4c, 0x86, 0xb1, 0x49, 0xa9, 0xbc, 0x90, 0x93, 0x0a,
+		0xd9, 0x6b, 0xd7, 0x67, 0xd2, 0x2c, 0xfd, 0xc3, 0x55, 0x74, 0x02, 0x0e, 0xb7, 0xe2, 0x2d, 0xad,
+		0x2e, 0xe6, 0x12, 0x85, 0x91, 0x6b, 0xd7, 0x67, 0x32, 0x5e, 0x9e, 0x88, 0x64, 0x40, 0x41, 0x4c,
+		0xce, 0x2f, 0x59, 0x80, 0x6b, 0xd7, 0x67, 0x06, 0x99, 0x02, 0x0b, 0xa9, 0x0f, 0x7c, 0x66, 0xea,
+		0x50, 0xe9, 0x7c, 0xc7, 0x3d, 0xf7, 0x87, 0xba, 0xea, 0xee, 0xaa, 0xb7, 0x8f, 0x1e, 0xde, 0x68,
+		0xff, 0x93, 0xa1, 0x8e, 0x1b, 0xed, 0x35, 0x6c, 0x60, 0x47, 0x77, 0x0e, 0xb4, 0xd1, 0xde, 0xd3,
+		0xe6, 0xbd, 0xfc, 0xbb, 0x03, 0x90, 0x5d, 0x64, 0xad, 0x90, 0x81, 0xc0, 0xe8, 0x4d, 0x30, 0x68,
+		0xd1, 0xc8, 0xe5, 0x9d, 0xdc, 0x75, 0x30, 0x78, 0x16, 0xdf, 0xbc, 0xeb, 0x63, 0x2c, 0xda, 0x39,
+		0xfc, 0xfe, 0x08, 0xbb, 0xd6, 0xe6, 0x5f, 0xd4, 0xca, 0xf6, 0xb5, 0xc5, 0xc4, 0x5c, 0x31, 0xdf,
+		0xcd, 0x89, 0xf2, 0x93, 0xd9, 0x55, 0x94, 0x4d, 0x02, 0x61, 0x17, 0xd2, 0xde, 0x27, 0xc1, 0x61,
+		0x8a, 0xe5, 0xc7, 0x7e, 0x8a, 0x29, 0xd6, 0x17, 0x27, 0x3b, 0x75, 0x61, 0x59, 0x75, 0xfc, 0xeb,
+		0x25, 0xec, 0x0a, 0xd9, 0x3d, 0x3c, 0xf6, 0x1e, 0x0f, 0x34, 0x1e, 0x65, 0x2b, 0x2b, 0x13, 0xf5,
+		0x16, 0x4a, 0x07, 0x2d, 0x86, 0xee, 0x10, 0xa6, 0xfa, 0xdb, 0xdd, 0x0f, 0xde, 0x27, 0x7c, 0x16,
+		0x86, 0x7d, 0x5f, 0xe2, 0xf0, 0x7f, 0x89, 0xd1, 0x7b, 0xec, 0x08, 0x12, 0xa3, 0xf7, 0x4b, 0x70,
+		0xd8, 0x4f, 0x20, 0x82, 0x6c, 0xd9, 0xbf, 0x0e, 0x79, 0xb0, 0x8f, 0xb5, 0x57, 0x54, 0x39, 0x6d,
+		0xf9, 0xca, 0xca, 0x64, 0xb3, 0x95, 0x94, 0xac, 0xfa, 0x46, 0x82, 0x9e, 0xd5, 0xc9, 0x8b, 0xaf,
+		0xe3, 0xf5, 0xee, 0x9a, 0xc3, 0x0c, 0xd8, 0xbf, 0x33, 0xb0, 0x4c, 0xdb, 0xc5, 0x55, 0xba, 0x07,
+		0x98, 0x56, 0xbc, 0xb2, 0xbc, 0x0a, 0xa8, 0x75, 0x70, 0xa3, 0x77, 0x26, 0x33, 0xfe, 0x9d, 0xc9,
+		0x49, 0x18, 0x08, 0xde, 0x2a, 0x64, 0x85, 0x62, 0xfa, 0x03, 0x3c, 0x7c, 0xde, 0xf2, 0x39, 0xff,
+		0xaf, 0x12, 0x70, 0x32, 0x78, 0x22, 0xf5, 0x52, 0x13, 0xdb, 0xfb, 0xde, 0x14, 0xb5, 0xd4, 0x9a,
+		0x6e, 0x04, 0x9f, 0x1d, 0x1d, 0x0b, 0x06, 0x7c, 0x8a, 0x2b, 0xf4, 0x24, 0x1b, 0x30, 0xbc, 0xae,
+		0xd6, 0xb0, 0x82, 0x5f, 0x6a, 0x62, 0xc7, 0x6d, 0x73, 0xaf, 0xfd, 0x08, 0x0c, 0x9a, 0x3b, 0x3b,
+		0xe2, 0x14, 0x3d, 0xa5, 0xf0, 0x12, 0xe9, 0x72, 0x5d, 0x6f, 0xe8, 0xec, 0x02, 0x5a, 0x4a, 0x61,
+		0x05, 0x34, 0x0d, 0xc3, 0x9a, 0xd9, 0x34, 0xf8, 0x8c, 0xcb, 0xa7, 0xc4, 0x37, 0x27, 0x9a, 0x06,
+		0x9b, 0x71, 0xf2, 0x33, 0x90, 0x65, 0xed, 0xf1, 0x88, 0x7b, 0x0c, 0xd2, 0xf4, 0x06, 0x97, 0xdf,
+		0xea, 0x10, 0x29, 0x5f, 0x64, 0x77, 0xe0, 0x19, 0x17, 0xd6, 0x30, 0x2b, 0x94, 0x4a, 0x1d, 0x55,
+		0x79, 0x22, 0xde, 0x35, 0x30, 0x45, 0x79, 0x6a, 0xfc, 0xad, 0x01, 0x38, 0xcc, 0x0f, 0x05, 0x55,
+		0x4b, 0x3f, 0xb5, 0xeb, 0xba, 0xe2, 0x61, 0x12, 0xf0, 0xec, 0x5a, 0xb5, 0x74, 0x79, 0x1f, 0x52,
+		0x17, 0x5c, 0xd7, 0x42, 0x27, 0x61, 0xc0, 0x6e, 0xd6, 0xb1, 0xd8, 0x64, 0xf2, 0x8e, 0x01, 0x54,
+		0x4b, 0x9f, 0x25, 0x08, 0x4a, 0xb3, 0x8e, 0x15, 0x86, 0x82, 0xca, 0x30, 0xbd, 0xd3, 0xac, 0xd7,
+		0xf7, 0x2b, 0x55, 0x4c, 0xff, 0x5d, 0x90, 0xf7, 0xc1, 0x7d, 0x7c, 0xd5, 0x52, 0xc5, 0x67, 0xfb,
+		0x88, 0x6e, 0x8e, 0x53, 0xb4, 0x05, 0x8a, 0x25, 0x3e, 0xb6, 0x5f, 0x16, 0x38, 0xf2, 0xef, 0x27,
+		0x20, 0x2d, 0x58, 0xd3, 0x4b, 0xe9, 0xb8, 0x8e, 0x35, 0xd7, 0x14, 0x87, 0x34, 0x5e, 0x19, 0x21,
+		0x48, 0xd6, 0xf8, 0x10, 0x65, 0x2e, 0x1c, 0x52, 0x48, 0x81, 0xc0, 0xbc, 0xa7, 0x02, 0x04, 0x66,
+		0x35, 0xc9, 0xa8, 0xa5, 0x2c, 0x53, 0xac, 0x06, 0x2f, 0x1c, 0x52, 0x68, 0x09, 0xe5, 0x61, 0x90,
+		0xcc, 0x0c, 0x97, 0x7d, 0x0b, 0x91, 0xc0, 0x79, 0x19, 0x1d, 0x81, 0x01, 0x4b, 0x75, 0x35, 0x76,
+		0x8b, 0x8f, 0x54, 0xb0, 0x22, 0x7a, 0x02, 0x06, 0xd9, 0x1b, 0xd4, 0xe8, 0xff, 0xe2, 0x20, 0xca,
+		0x60, 0x1f, 0xfb, 0x22, 0x72, 0xaf, 0xab, 0xae, 0x8b, 0x6d, 0x83, 0x30, 0x64, 0xe8, 0x08, 0x41,
+		0x6a, 0xdb, 0xac, 0xee, 0xf3, 0xff, 0x0f, 0x42, 0x7f, 0xf3, 0x7f, 0x48, 0x40, 0xed, 0xa1, 0x42,
+		0x2b, 0xd9, 0xbf, 0x45, 0xca, 0x0a, 0x60, 0x89, 0x20, 0x95, 0x61, 0x42, 0xad, 0x56, 0x75, 0xf6,
+		0xaf, 0x3a, 0x2a, 0xdb, 0x3a, 0xf5, 0x10, 0x0e, 0xfd, 0xa7, 0x57, 0x9d, 0xc6, 0x02, 0xf9, 0x04,
+		0x25, 0x8e, 0x5f, 0xca, 0xc0, 0x90, 0xc5, 0x84, 0x92, 0xcf, 0xc1, 0x78, 0x8b, 0xa4, 0x44, 0xbe,
+		0x3d, 0xdd, 0xa8, 0x8a, 0xf7, 0x13, 0xe4, 0x37, 0x81, 0xd1, 0x0f, 0xf6, 0xb1, 0xe3, 0x2f, 0xfa,
+		0xbb, 0xf4, 0x9e, 0xce, 0x6f, 0xcd, 0x46, 0x03, 0x6f, 0xcd, 0x54, 0x4b, 0x2f, 0x65, 0x28, 0x7f,
+		0xfe, 0xc2, 0x6c, 0x8e, 0x57, 0xb0, 0xd7, 0x65, 0xb3, 0xa6, 0x5d, 0x23, 0x51, 0x5a, 0x44, 0x5f,
+		0x52, 0xa5, 0x5a, 0xba, 0x43, 0xcd, 0xd1, 0xff, 0x80, 0xa0, 0x73, 0x2e, 0xf0, 0x9b, 0xbe, 0x3b,
+		0x4b, 0x2d, 0xce, 0xad, 0x2f, 0x79, 0x76, 0xfc, 0x95, 0x04, 0x1c, 0x0f, 0xd8, 0x71, 0x00, 0xb9,
+		0xd5, 0x9c, 0x0b, 0xed, 0x2d, 0xbe, 0x87, 0xf7, 0x66, 0x17, 0x21, 0x45, 0xf0, 0x51, 0xcc, 0xbf,
+		0x0b, 0xc8, 0xff, 0xda, 0xd7, 0xff, 0x99, 0x1c, 0x3e, 0x28, 0x0b, 0x8d, 0x0a, 0x65, 0x52, 0x7a,
+		0x7f, 0xef, 0xfa, 0xcb, 0xf9, 0xdf, 0x4e, 0x74, 0x6e, 0x9d, 0x1a, 0xa3, 0x3a, 0xfc, 0xf6, 0x19,
+		0x90, 0x3b, 0xa4, 0x3c, 0xcc, 0x63, 0x76, 0x4f, 0xa2, 0xfa, 0x70, 0xc7, 0x9d, 0x9e, 0x1c, 0x74,
+		0x1b, 0xc1, 0x1e, 0xd3, 0xb1, 0xab, 0x70, 0xe4, 0x39, 0xd2, 0xb6, 0xbf, 0x32, 0x17, 0x8e, 0xfd,
+		0x88, 0x77, 0x80, 0x28, 0xf1, 0xff, 0x39, 0x26, 0x0e, 0x07, 0xc1, 0x97, 0x8f, 0x2f, 0x10, 0xef,
+		0x9b, 0xed, 0x18, 0x2f, 0x66, 0x03, 0xc1, 0x42, 0x09, 0x50, 0xca, 0xbf, 0x22, 0xc1, 0xd1, 0x96,
+		0xa6, 0xb9, 0x8f, 0x5f, 0x6c, 0xf3, 0x3a, 0xe2, 0x40, 0x99, 0xcd, 0x62, 0x1b, 0x61, 0xef, 0x8f,
+		0x15, 0x96, 0x49, 0x11, 0x92, 0xf6, 0x69, 0x38, 0x1c, 0x16, 0x56, 0xa8, 0xe9, 0x5e, 0x18, 0x0d,
+		0x6f, 0x42, 0x73, 0x75, 0x8d, 0x84, 0xb6, 0xa1, 0xe5, 0x4a, 0x54, 0xcf, 0x5e, 0x5f, 0xcb, 0x90,
+		0xf1, 0x50, 0x79, 0x0a, 0xdc, 0x73, 0x57, 0x7d, 0x4a, 0xf9, 0x23, 0x12, 0xcc, 0x84, 0x5b, 0x08,
+		0x24, 0x43, 0xfd, 0x09, 0x7b, 0xcb, 0x86, 0xf8, 0x75, 0x09, 0xee, 0xea, 0x22, 0x13, 0x57, 0xc0,
+		0xcb, 0x30, 0x19, 0xd8, 0x09, 0x10, 0x2e, 0x5c, 0x0c, 0xfb, 0xc9, 0xf8, 0x34, 0xd4, 0x5b, 0xf8,
+		0xde, 0x41, 0x94, 0xf2, 0xb9, 0x3f, 0x98, 0x9e, 0x68, 0xad, 0x73, 0x94, 0x89, 0xd6, 0xd5, 0xfb,
+		0x2d, 0xb4, 0x8f, 0x57, 0x25, 0x78, 0x20, 0xdc, 0xd5, 0x36, 0xf9, 0xec, 0x1b, 0x35, 0x0e, 0xff,
+		0x51, 0x82, 0x93, 0xbd, 0x08, 0xc7, 0x07, 0x64, 0x1b, 0x26, 0xfc, 0x4c, 0x3b, 0x3a, 0x1e, 0x7d,
+		0xe5, 0xef, 0xcc, 0x4a, 0x91, 0xc7, 0xed, 0x36, 0x28, 0xde, 0xe2, 0x13, 0x2b, 0x38, 0xe4, 0x9e,
+		0x92, 0xc3, 0x1b, 0xc8, 0x42, 0xc9, 0xa1, 0x2d, 0xe4, 0x36, 0x63, 0x91, 0x68, 0x33, 0x16, 0x7e,
+		0x6a, 0x2e, 0x5f, 0xe6, 0x7e, 0xab, 0xcd, 0x1e, 0xdc, 0xdb, 0x61, 0xa2, 0x8d, 0x29, 0xf3, 0x59,
+		0xdd, 0x87, 0x25, 0x2b, 0xa8, 0xd5, 0x58, 0xe5, 0x7d, 0x98, 0xa6, 0xed, 0xb6, 0x51, 0xf4, 0xed,
+		0xee, 0x72, 0x83, 0xfb, 0x96, 0xb6, 0x4d, 0xf3, 0xbe, 0x2f, 0xc1, 0x20, 0x1b, 0x67, 0xde, 0xdd,
+		0x03, 0x18, 0x0a, 0x67, 0x20, 0xff, 0x82, 0xf0, 0x65, 0x0b, 0x42, 0xec, 0xf6, 0x73, 0xa8, 0x97,
+		0xbe, 0xde, 0xa2, 0x39, 0x14, 0x50, 0xc6, 0x37, 0x85, 0x57, 0x6b, 0x2f, 0x1d, 0x57, 0x87, 0x76,
+		0xcb, 0xbc, 0x1a, 0xd3, 0xcd, 0xed, 0x75, 0x5f, 0xbf, 0x24, 0xdc, 0x97, 0xd7, 0xa7, 0x18, 0xf7,
+		0xf5, 0xc6, 0xa8, 0xde, 0x73, 0x64, 0x31, 0x62, 0xfe, 0x79, 0x74, 0x64, 0xdf, 0x97, 0xe0, 0x18,
+		0xed, 0x5b, 0x70, 0x23, 0xa2, 0x5f, 0x95, 0x3f, 0x04, 0xc8, 0xb1, 0xb5, 0x4a, 0xdb, 0xd9, 0x9d,
+		0x73, 0x6c, 0xed, 0x52, 0x28, 0xbe, 0x3c, 0x04, 0xa8, 0x1a, 0xda, 0x6e, 0xa2, 0xd8, 0xec, 0x62,
+		0x5e, 0xae, 0x1a, 0xd8, 0xcd, 0x68, 0x33, 0x9c, 0xa9, 0x5b, 0x30, 0x9c, 0xdf, 0x90, 0xa0, 0xd0,
+		0xae, 0xcb, 0x7c, 0xf8, 0x74, 0x38, 0x12, 0x3a, 0x24, 0x88, 0x8e, 0xe0, 0x43, 0xbd, 0x6c, 0xe5,
+		0x44, 0xa6, 0xd1, 0x61, 0x1b, 0xdf, 0xee, 0x3c, 0x60, 0x3a, 0x6c, 0xa1, 0xad, 0x99, 0xf5, 0x1b,
+		0x36, 0x7d, 0xbe, 0xd8, 0xe2, 0x57, 0xff, 0x5c, 0xe4, 0xde, 0x57, 0x61, 0xaa, 0x83, 0xd4, 0xb7,
+		0x3b, 0xee, 0xed, 0x76, 0x1c, 0xcc, 0x5b, 0x9d, 0xbe, 0x3f, 0xce, 0x67, 0x42, 0xf8, 0xd2, 0x77,
+		0x60, 0x2d, 0xd6, 0xee, 0xd5, 0x98, 0xfc, 0x56, 0xb8, 0xa3, 0x2d, 0x15, 0x97, 0xad, 0x08, 0xa9,
+		0x5d, 0xdd, 0x71, 0xb9, 0x58, 0xf7, 0x75, 0x12, 0x2b, 0x42, 0x4d, 0x69, 0x64, 0x04, 0x39, 0xca,
+		0x7a, 0xdd, 0x34, 0xeb, 0x5c, 0x0c, 0xf9, 0x22, 0x8c, 0x07, 0x60, 0xbc, 0x91, 0xb3, 0x90, 0xb2,
+		0x4c, 0xfe, 0x45, 0x84, 0xe1, 0xd3, 0xc7, 0x3b, 0xee, 0xde, 0x9b, 0x66, 0x9d, 0x77, 0x9b, 0xe2,
+		0xcb, 0x93, 0x80, 0x18, 0x33, 0xba, 0x91, 0x2f, 0x9a, 0xd8, 0x80, 0x89, 0x10, 0x94, 0x37, 0xf2,
+		0x23, 0x1d, 0x12, 0x9c, 0xfe, 0xee, 0x61, 0x18, 0xa0, 0x5c, 0xd1, 0xc7, 0x25, 0x80, 0xc0, 0x21,
+		0xf4, 0x6c, 0x27, 0x36, 0xed, 0xd7, 0xc4, 0x85, 0x53, 0x3d, 0xe3, 0xf3, 0x9c, 0xed, 0xe4, 0x7b,
+		0xfe, 0xdd, 0xb7, 0x3f, 0x9a, 0xb8, 0x07, 0xc9, 0xa7, 0x3a, 0xac, 0xc6, 0x03, 0xf3, 0xe5, 0xb3,
+		0xa1, 0xe7, 0xf6, 0x0f, 0xf7, 0xd6, 0x94, 0x90, 0x6c, 0xb6, 0x57, 0x74, 0x2e, 0xd8, 0x39, 0x2a,
+		0xd8, 0x19, 0xf4, 0x58, 0xbc, 0x60, 0xa7, 0xde, 0x19, 0x9e, 0x34, 0xef, 0x46, 0xbf, 0x2b, 0xc1,
+		0x64, 0xbb, 0x25, 0x1d, 0x7a, 0xb2, 0x37, 0x29, 0x5a, 0x53, 0x8a, 0xc2, 0x53, 0x07, 0xa0, 0xe4,
+		0x5d, 0x59, 0xa4, 0x5d, 0x99, 0x43, 0xcf, 0x1c, 0xa0, 0x2b, 0xa7, 0x82, 0xfb, 0xfb, 0xff, 0x5b,
+		0x82, 0x3b, 0xbb, 0xae, 0x90, 0xd0, 0x5c, 0x6f, 0x52, 0x76, 0xc9, 0x9d, 0x0a, 0xa5, 0x1f, 0x85,
+		0x05, 0xef, 0xf1, 0x73, 0xb4, 0xc7, 0x17, 0xd1, 0xd2, 0x41, 0x7a, 0xdc, 0xf6, 0x10, 0x05, 0xfd,
+		0x76, 0xf8, 0x32, 0x63, 0x77, 0x73, 0x6a, 0x59, 0x78, 0xc4, 0x4c, 0x8c, 0xd6, 0xa4, 0x56, 0x7e,
+		0x81, 0x76, 0x41, 0x41, 0xeb, 0x3f, 0xe2, 0xa0, 0x9d, 0x7a, 0x67, 0xd8, 0xf1, 0xbf, 0x1b, 0xfd,
+		0x2f, 0xa9, 0xfd, 0xdd, 0xc4, 0x27, 0xba, 0x8a, 0xd8, 0x79, 0x51, 0x55, 0x78, 0xb2, 0x7f, 0x42,
+		0xde, 0xc9, 0x06, 0xed, 0x64, 0x0d, 0xe1, 0x5b, 0xdd, 0xc9, 0xb6, 0x83, 0x88, 0xbe, 0x26, 0xc1,
+		0x64, 0xbb, 0x35, 0x49, 0xcc, 0xb4, 0xec, 0xb2, 0xc8, 0x8a, 0x99, 0x96, 0xdd, 0x16, 0x40, 0xf2,
+		0x9b, 0x68, 0xe7, 0xcf, 0xa2, 0xc7, 0x3b, 0x75, 0xbe, 0xeb, 0x28, 0x92, 0xb9, 0xd8, 0x35, 0xc9,
+		0x8f, 0x99, 0x8b, 0xbd, 0xac, 0x63, 0x62, 0xe6, 0x62, 0x4f, 0x6b, 0x8c, 0xf8, 0xb9, 0xe8, 0xf5,
+		0xac, 0xc7, 0x61, 0x74, 0xd0, 0x57, 0x24, 0x18, 0x09, 0x65, 0xc4, 0xe8, 0xd1, 0xae, 0x82, 0xb6,
+		0x5b, 0x30, 0x14, 0x4e, 0xf7, 0x43, 0xc2, 0xfb, 0xb2, 0x44, 0xfb, 0x32, 0x8f, 0xe6, 0x0e, 0xd2,
+		0x97, 0xf0, 0x59, 0xe9, 0x37, 0x24, 0x98, 0x68, 0x93, 0x65, 0xc6, 0xcc, 0xc2, 0xce, 0x49, 0x73,
+		0xe1, 0xc9, 0xfe, 0x09, 0x79, 0xaf, 0xce, 0xd3, 0x5e, 0xbd, 0x05, 0x3d, 0x7d, 0x90, 0x5e, 0x05,
+		0xe2, 0xf3, 0x0d, 0xff, 0xde, 0x55, 0xa0, 0x1d, 0x74, 0xb6, 0x4f, 0xc1, 0x44, 0x87, 0x9e, 0xe8,
+		0x9b, 0x8e, 0xf7, 0xe7, 0x79, 0xda, 0x9f, 0xe7, 0xd0, 0xda, 0x8f, 0xd6, 0x9f, 0xd6, 0xb0, 0xfe,
+		0x85, 0xd6, 0x47, 0x87, 0xdd, 0xad, 0xa8, 0x6d, 0xb2, 0x5a, 0x78, 0xac, 0x2f, 0x1a, 0xde, 0xa9,
+		0x27, 0x69, 0xa7, 0x4e, 0xa3, 0x47, 0x3a, 0x75, 0x2a, 0x70, 0x9f, 0x4f, 0x37, 0x76, 0xcc, 0x53,
+		0xef, 0x64, 0x29, 0xf0, 0xbb, 0xd1, 0x4f, 0x8b, 0x8b, 0x4d, 0x27, 0xba, 0xb6, 0x1b, 0xc8, 0x63,
+		0x0b, 0x0f, 0xf4, 0x80, 0xc9, 0xe5, 0xba, 0x87, 0xca, 0x35, 0x85, 0x8e, 0x77, 0x92, 0x8b, 0xe4,
+		0xb2, 0xe8, 0x83, 0x92, 0x77, 0xfd, 0xf2, 0x64, 0x77, 0xde, 0xc1, 0x64, 0xb7, 0xf0, 0x60, 0x4f,
+		0xb8, 0x5c, 0x92, 0xfb, 0xa8, 0x24, 0x33, 0x68, 0xaa, 0xa3, 0x24, 0x2c, 0xf5, 0xbd, 0xd5, 0x37,
+		0x07, 0xae, 0x1d, 0x85, 0xe9, 0x0e, 0x2d, 0xba, 0x57, 0x63, 0xce, 0xb8, 0xba, 0xbc, 0xbd, 0x8d,
+		0x7d, 0x5b, 0xdb, 0xe1, 0x35, 0xef, 0xc1, 0x5f, 0xdc, 0xf6, 0x76, 0x20, 0xf6, 0x6f, 0x53, 0x80,
+		0x56, 0x9c, 0xda, 0xbc, 0x8d, 0xd9, 0xff, 0xd9, 0xe3, 0xb3, 0x3c, 0xf2, 0xa8, 0x4c, 0xfa, 0x91,
+		0x1e, 0x95, 0xad, 0x84, 0x9e, 0x69, 0x25, 0xfa, 0x7b, 0x0a, 0xda, 0xf3, 0x5b, 0xad, 0xe4, 0x8f,
+		0xe5, 0xad, 0x56, 0xfb, 0xab, 0xdc, 0xa9, 0x5b, 0xf7, 0xe6, 0x63, 0xe0, 0xa0, 0xef, 0x5e, 0xf8,
+		0x13, 0xcc, 0xc1, 0x2e, 0x4f, 0x30, 0xf3, 0x1d, 0xdf, 0x59, 0x72, 0x6a, 0x74, 0x46, 0x7c, 0x33,
+		0x78, 0xa8, 0xb7, 0x9b, 0xb0, 0xfc, 0xa3, 0xc2, 0xfe, 0x16, 0xc2, 0x71, 0x28, 0xb4, 0x9a, 0x93,
+		0x37, 0xa9, 0x3f, 0x9a, 0x84, 0xdc, 0x8a, 0x53, 0x2b, 0x57, 0x75, 0xf7, 0x36, 0xd9, 0xda, 0x33,
+		0x9d, 0xdf, 0xd1, 0xa0, 0x9b, 0x37, 0xa6, 0x47, 0x99, 0x4e, 0xbb, 0x68, 0xb2, 0x01, 0x63, 0x91,
+		0xd7, 0xcb, 0xdc, 0xb2, 0x16, 0x0e, 0xf2, 0x88, 0x3a, 0xc2, 0x4a, 0xa6, 0xcf, 0x1e, 0x02, 0xf6,
+		0x8d, 0xae, 0xb6, 0x37, 0x66, 0x66, 0x50, 0x17, 0x6e, 0xe7, 0xa3, 0x43, 0x7f, 0xcc, 0x0a, 0x90,
+		0x8f, 0x0e, 0x8a, 0x37, 0x62, 0xdf, 0x91, 0x60, 0x78, 0xc5, 0x11, 0xa9, 0x20, 0xfe, 0x09, 0x7d,
+		0xf2, 0xf4, 0x84, 0xf7, 0xe9, 0xd7, 0x64, 0x6f, 0x76, 0x2b, 0x3e, 0x07, 0xeb, 0x2b, 0xe1, 0x30,
+		0x4c, 0x04, 0xfa, 0xe9, 0xf5, 0xff, 0x77, 0x12, 0xd4, 0x3f, 0x96, 0x70, 0x4d, 0x37, 0xbc, 0x2c,
+		0x12, 0xff, 0x45, 0x7d, 0xd0, 0xe1, 0xeb, 0x39, 0x75, 0x50, 0x3d, 0xef, 0x51, 0x07, 0x11, 0xd1,
+		0xa7, 0xb7, 0xf1, 0xb5, 0xd2, 0xfa, 0xdc, 0x48, 0xea, 0xe3, 0x4b, 0x3e, 0x91, 0x47, 0x45, 0xf2,
+		0xeb, 0x12, 0x8c, 0xac, 0x38, 0xb5, 0x2d, 0xa3, 0xfa, 0xff, 0xbd, 0xfd, 0xee, 0xc0, 0xe1, 0x50,
+		0x4f, 0x6f, 0x93, 0x4a, 0x4f, 0xbf, 0x9a, 0x82, 0xe4, 0x8a, 0x53, 0x43, 0x2f, 0xc1, 0x58, 0x34,
+		0x69, 0xe8, 0x98, 0x0b, 0xb6, 0x46, 0x84, 0xce, 0xeb, 0xb5, 0xce, 0xd1, 0x03, 0xed, 0xc1, 0x48,
+		0x38, 0x72, 0x9c, 0xe8, 0xc2, 0x24, 0x84, 0x59, 0x78, 0xa4, 0x57, 0x4c, 0xaf, 0xb1, 0x77, 0x40,
+		0xda, 0x73, 0x7a, 0x77, 0x77, 0xa1, 0x16, 0x48, 0x9d, 0xb3, 0xdb, 0x36, 0x6e, 0x85, 0x68, 0x2f,
+		0xea, 0x52, 0xba, 0x69, 0x2f, 0x82, 0xdb, 0x55, 0x7b, 0x9d, 0xa6, 0xd6, 0x36, 0x40, 0x60, 0x1e,
+		0xdc, 0xdb, 0x85, 0x83, 0x8f, 0x56, 0x78, 0xb8, 0x27, 0x34, 0xef, 0xd0, 0xe9, 0x16, 0x27, 0xe3,
+		0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x2a, 0x2c, 0x38, 0xdd, 0x94, 0x00, 0x00,
 	}
 	r := bytes.NewReader(gzipped)
 	gzipr, err := compress_gzip.NewReader(r)
@@ -2026,6 +2029,9 @@ func (this *Params) Equal(that interface{}) bool {
 	if this.BondDenom != that1.BondDenom {
 		return false
 	}
+	if !this.PowerReduction.Equal(that1.PowerReduction) {
+		return false
+	}
 	return true
 }
 func (this *RedelegationEntryResponse) Equal(that interface{}) bool {
@@ -2876,6 +2882,16 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	{
+		size := m.PowerReduction.Size()
+		i -= size
+		if _, err := m.PowerReduction.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x32
 	if len(m.BondDenom) > 0 {
 		i -= len(m.BondDenom)
 		copy(dAtA[i:], m.BondDenom)
@@ -3417,6 +3433,8 @@ func (m *Params) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovStaking(uint64(l))
 	}
+	l = m.PowerReduction.Size()
+	n += 1 + l + sovStaking(uint64(l))
 	return n
 }
 
@@ -5949,6 +5967,40 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			}
 			m.BondDenom = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PowerReduction", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PowerReduction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStaking(dAtA[iNdEx:])

From 4f476d6890404db0b331c313827eabde9b04b3cf Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 27 Jan 2021 20:24:00 +1000
Subject: [PATCH 02/23] on-chain power reduction param conversion basic work

---
 simapp/simd/cmd/testnet.go                   |   6 +-
 testutil/network/network.go                  |   6 +-
 types/staking.go                             |  12 +-
 types/staking_test.go                        |   4 +-
 x/auth/client/cli/cli_test.go                |   4 +-
 x/authz/simulation/operations_test.go        |   6 +-
 x/bank/client/rest/tx_test.go                |   3 +-
 x/bank/keeper/keeper_test.go                 |   4 +-
 x/bank/simulation/operations_test.go         |   2 +-
 x/distribution/keeper/delegation_test.go     |  12 +-
 x/distribution/keeper/keeper_test.go         |   2 +-
 x/distribution/simulation/operations_test.go |   4 +-
 x/evidence/keeper/keeper_test.go             |   2 +-
 x/gov/abci_test.go                           |   6 +-
 x/gov/common_test.go                         |   4 +-
 x/gov/keeper/common_test.go                  |   6 +-
 x/gov/keeper/deposit_test.go                 |   4 +-
 x/gov/keeper/grpc_query_test.go              |   8 +-
 x/gov/keeper/querier_test.go                 |   2 +-
 x/gov/keeper/tally_test.go                   |  20 +-
 x/gov/simulation/operations_test.go          |   2 +-
 x/gov/types/params.go                        |   2 +-
 x/ibc/core/02-client/keeper/keeper_test.go   |   2 +-
 x/ibc/testing/chain.go                       |   2 +-
 x/slashing/abci_test.go                      |   2 +-
 x/slashing/app_test.go                       |   4 +-
 x/slashing/genesis_test.go                   |   2 +-
 x/slashing/handler_test.go                   |  10 +-
 x/slashing/init_test.go                      |   2 +-
 x/slashing/keeper/common_test.go             |   2 +-
 x/slashing/keeper/grpc_query_test.go         |   2 +-
 x/slashing/keeper/keeper_test.go             |  16 +-
 x/slashing/keeper/signing_info_test.go       |   8 +-
 x/slashing/simulation/operations_test.go     |   4 +-
 x/staking/app_test.go                        |   4 +-
 x/staking/client/cli/tx.go                   |   2 +-
 x/staking/common_test.go                     |   2 +-
 x/staking/genesis.go                         |   4 +-
 x/staking/genesis_test.go                    |  12 +-
 x/staking/handler_test.go                    |  74 ++++----
 x/staking/keeper/common_test.go              |   2 +-
 x/staking/keeper/delegation_test.go          |  52 ++---
 x/staking/keeper/grpc_query_test.go          |  18 +-
 x/staking/keeper/historical_info.go          |   2 +-
 x/staking/keeper/historical_info_test.go     |   6 +-
 x/staking/keeper/invariants.go               |   4 +-
 x/staking/keeper/keeper_test.go              |   2 +-
 x/staking/keeper/params.go                   |   8 +
 x/staking/keeper/power_reduction.go          |  15 ++
 x/staking/keeper/power_reduction_test.go     |  21 +++
 x/staking/keeper/querier_test.go             |  34 ++--
 x/staking/keeper/slash.go                    |   2 +-
 x/staking/keeper/slash_test.go               |  48 ++---
 x/staking/keeper/val_state_change.go         |   6 +-
 x/staking/keeper/validator.go                |   8 +-
 x/staking/keeper/validator_test.go           | 188 +++++++++----------
 x/staking/legacy/v040/migrate.go             |   2 +
 x/staking/simulation/common_test.go          |   2 +-
 x/staking/simulation/genesis.go              |   2 +-
 x/staking/simulation/genesis_test.go         |   2 +
 x/staking/simulation/operations_test.go      |   8 +-
 x/staking/spec/01_state.md                   |   9 +-
 x/staking/spec/08_params.md                  |   1 +
 x/staking/teststaking/helper.go              |   4 +-
 x/staking/teststaking/tm.go                  |   9 +-
 x/staking/types/exported.go                  |   2 +-
 x/staking/types/historical_info.go           |   8 +-
 x/staking/types/historical_info_test.go      |   5 +-
 x/staking/types/keys.go                      |   4 +-
 x/staking/types/keys_test.go                 |   8 +-
 x/staking/types/params.go                    |  19 +-
 x/staking/types/validator.go                 |  28 +--
 x/staking/types/validator_test.go            |  10 +-
 73 files changed, 447 insertions(+), 367 deletions(-)
 create mode 100644 x/staking/keeper/power_reduction.go
 create mode 100644 x/staking/keeper/power_reduction_test.go

diff --git a/simapp/simd/cmd/testnet.go b/simapp/simd/cmd/testnet.go
index 0717b398427c..99cf09958791 100644
--- a/simapp/simd/cmd/testnet.go
+++ b/simapp/simd/cmd/testnet.go
@@ -196,8 +196,8 @@ func InitTestnet(
 			return err
 		}
 
-		accTokens := sdk.TokensFromConsensusPower(1000)
-		accStakingTokens := sdk.TokensFromConsensusPower(500)
+		accTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)
+		accStakingTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction)
 		coins := sdk.Coins{
 			sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens),
 			sdk.NewCoin(sdk.DefaultBondDenom, accStakingTokens),
@@ -206,7 +206,7 @@ func InitTestnet(
 		genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: coins.Sort()})
 		genAccounts = append(genAccounts, authtypes.NewBaseAccount(addr, nil, 0, 0))
 
-		valTokens := sdk.TokensFromConsensusPower(100)
+		valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 		createValMsg, err := stakingtypes.NewMsgCreateValidator(
 			sdk.ValAddress(addr),
 			valPubKeys[i],
diff --git a/testutil/network/network.go b/testutil/network/network.go
index c73b69d18ab2..21102b51fdde 100644
--- a/testutil/network/network.go
+++ b/testutil/network/network.go
@@ -111,9 +111,9 @@ func DefaultConfig() Config {
 		NumValidators:     4,
 		BondDenom:         sdk.DefaultBondDenom,
 		MinGasPrices:      fmt.Sprintf("0.000006%s", sdk.DefaultBondDenom),
-		AccountTokens:     sdk.TokensFromConsensusPower(1000),
-		StakingTokens:     sdk.TokensFromConsensusPower(500),
-		BondedTokens:      sdk.TokensFromConsensusPower(100),
+		AccountTokens:     sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction),
+		StakingTokens:     sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction),
+		BondedTokens:      sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction),
 		PruningStrategy:   storetypes.PruningOptionNothing,
 		CleanupDir:        true,
 		SigningAlgo:       string(hd.Secp256k1Type),
diff --git a/types/staking.go b/types/staking.go
index 0753d808b2e8..563f94176ce9 100644
--- a/types/staking.go
+++ b/types/staking.go
@@ -22,15 +22,15 @@ const (
 	ValidatorUpdateDelay int64 = 1
 )
 
-// PowerReduction is the amount of staking tokens required for 1 unit of consensus-engine power
-var PowerReduction = NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
+// DefaultPowerReduction is the default amount of staking tokens required for 1 unit of consensus-engine power
+var DefaultPowerReduction = NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
 
 // TokensToConsensusPower - convert input tokens to potential consensus-engine power
-func TokensToConsensusPower(tokens Int) int64 {
-	return (tokens.Quo(PowerReduction)).Int64()
+func TokensToConsensusPower(tokens Int, powerReduction Int) int64 {
+	return (tokens.Quo(powerReduction)).Int64()
 }
 
 // TokensFromConsensusPower - convert input power to tokens
-func TokensFromConsensusPower(power int64) Int {
-	return NewInt(power).Mul(PowerReduction)
+func TokensFromConsensusPower(power int64, powerReduction Int) Int {
+	return NewInt(power).Mul(powerReduction)
 }
diff --git a/types/staking_test.go b/types/staking_test.go
index e307230cd990..fe6c36bd991b 100644
--- a/types/staking_test.go
+++ b/types/staking_test.go
@@ -21,6 +21,6 @@ func (s *stakingTestSuite) SetupSuite() {
 }
 
 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)))
+	s.Require().Equal(int64(0), sdk.TokensToConsensusPower(sdk.NewInt(999_999), sdk.DefaultPowerReduction))
+	s.Require().Equal(int64(1), sdk.TokensToConsensusPower(sdk.NewInt(1_000_000), sdk.DefaultPowerReduction))
 }
diff --git a/x/auth/client/cli/cli_test.go b/x/auth/client/cli/cli_test.go
index d8913d1ac07e..744e4c714a2e 100644
--- a/x/auth/client/cli/cli_test.go
+++ b/x/auth/client/cli/cli_test.go
@@ -321,7 +321,7 @@ func (s *IntegrationTestSuite) TestCLISendGenerateSignAndBroadcast() {
 	account, err := val1.ClientCtx.Keyring.Key("newAccount")
 	s.Require().NoError(err)
 
-	sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10))
+	sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))
 
 	normalGeneratedTx, err := bankcli.MsgSendExec(
 		val1.ClientCtx,
@@ -544,7 +544,7 @@ func (s *IntegrationTestSuite) TestCLIMultisignInsufficientCosigners() {
 func (s *IntegrationTestSuite) TestCLIEncode() {
 	val1 := s.network.Validators[0]
 
-	sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10))
+	sendTokens := sdk.NewCoin(s.cfg.BondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))
 
 	normalGeneratedTx, err := bankcli.MsgSendExec(
 		val1.ClientCtx,
diff --git a/x/authz/simulation/operations_test.go b/x/authz/simulation/operations_test.go
index 83be182df746..e8686f166a72 100644
--- a/x/authz/simulation/operations_test.go
+++ b/x/authz/simulation/operations_test.go
@@ -72,7 +72,7 @@ func (suite *SimTestSuite) TestWeightedOperations() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200000)
+	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	// add coins to the accounts
@@ -132,7 +132,7 @@ func (suite *SimTestSuite) TestSimulateRevokeAuthorization() {
 			AppHash: suite.app.LastCommitID().Hash,
 		}})
 
-	initAmt := sdk.TokensFromConsensusPower(200000)
+	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	granter := accounts[0]
@@ -167,7 +167,7 @@ func (suite *SimTestSuite) TestSimulateExecAuthorization() {
 	// begin a new block
 	suite.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}})
 
-	initAmt := sdk.TokensFromConsensusPower(200000)
+	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	granter := accounts[0]
diff --git a/x/bank/client/rest/tx_test.go b/x/bank/client/rest/tx_test.go
index d770ebec3da7..f189eb536328 100644
--- a/x/bank/client/rest/tx_test.go
+++ b/x/bank/client/rest/tx_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/simapp"
 	"github.com/cosmos/cosmos-sdk/testutil/network"
 	"github.com/cosmos/cosmos-sdk/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/types/rest"
 	authclient "github.com/cosmos/cosmos-sdk/x/auth/client"
@@ -28,7 +29,7 @@ func (s *IntegrationTestSuite) TestCoinSend() {
 
 	sendReq := generateSendReq(
 		account,
-		types.Coins{types.NewCoin(s.cfg.BondDenom, types.TokensFromConsensusPower(1))},
+		types.Coins{types.NewCoin(s.cfg.BondDenom, types.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))},
 	)
 
 	stdTx, err := submitSendReq(val, sendReq)
diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go
index 80b4b070c278..d57d60877a4b 100644
--- a/x/bank/keeper/keeper_test.go
+++ b/x/bank/keeper/keeper_test.go
@@ -35,7 +35,7 @@ var (
 	multiPermAcc  = authtypes.NewEmptyModuleAccount(multiPerm, authtypes.Burner, authtypes.Minter, authtypes.Staking)
 	randomPermAcc = authtypes.NewEmptyModuleAccount(randomPerm, "random")
 
-	initTokens = sdk.TokensFromConsensusPower(initialPower)
+	initTokens = sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction)
 	initCoins  = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
 )
 
@@ -86,7 +86,7 @@ func (suite *IntegrationTestSuite) TestSupply() {
 	app, ctx := suite.app, suite.ctx
 
 	initialPower := int64(100)
-	initTokens := sdk.TokensFromConsensusPower(initialPower)
+	initTokens := sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction)
 
 	totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
 	app.BankKeeper.SetSupply(ctx, types.NewSupply(totalSupply))
diff --git a/x/bank/simulation/operations_test.go b/x/bank/simulation/operations_test.go
index 144dc5dd3429..5add9942cef7 100644
--- a/x/bank/simulation/operations_test.go
+++ b/x/bank/simulation/operations_test.go
@@ -124,7 +124,7 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/distribution/keeper/delegation_test.go b/x/distribution/keeper/delegation_test.go
index ac8ac4a33402..0255a64ca3d9 100644
--- a/x/distribution/keeper/delegation_test.go
+++ b/x/distribution/keeper/delegation_test.go
@@ -112,7 +112,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10)
+	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -175,7 +175,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10)
+	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -270,7 +270,7 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
 
 func TestWithdrawDelegationRewardsBasic(t *testing.T) {
 	balancePower := int64(1000)
-	balanceTokens := sdk.TokensFromConsensusPower(balancePower)
+	balanceTokens := sdk.TokensFromConsensusPower(balancePower, sdk.DefaultPowerReduction)
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
@@ -305,7 +305,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
 	val := app.StakingKeeper.Validator(ctx, valAddrs[0])
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10)
+	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)}
 
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@@ -375,7 +375,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10).ToDec()
+	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec()
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -431,7 +431,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 	del1 := app.StakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0])
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(30).ToDec()
+	initial := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction).ToDec()
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go
index a8205dfdc1db..cd39dafaa72b 100644
--- a/x/distribution/keeper/keeper_test.go
+++ b/x/distribution/keeper/keeper_test.go
@@ -57,7 +57,7 @@ func TestWithdrawValidatorCommission(t *testing.T) {
 
 	// check initial balance
 	balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0]))
-	expTokens := sdk.TokensFromConsensusPower(1000)
+	expTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)
 	expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens))
 	require.Equal(t, expCoins, balance)
 
diff --git a/x/distribution/simulation/operations_test.go b/x/distribution/simulation/operations_test.go
index 4a3dff30878e..67ca4dd863ae 100644
--- a/x/distribution/simulation/operations_test.go
+++ b/x/distribution/simulation/operations_test.go
@@ -95,7 +95,7 @@ func (suite *SimTestSuite) TestSimulateMsgWithdrawDelegatorReward() {
 	validator0 := suite.getTestingValidator0(accounts)
 
 	// setup delegation
-	delTokens := sdk.TokensFromConsensusPower(2)
+	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	delegator := accounts[1]
 	delegation := stakingtypes.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@@ -223,7 +223,7 @@ func (suite *SimTestSuite) SetupTest() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/evidence/keeper/keeper_test.go b/x/evidence/keeper/keeper_test.go
index 9165730466b7..0d518fa61f71 100644
--- a/x/evidence/keeper/keeper_test.go
+++ b/x/evidence/keeper/keeper_test.go
@@ -34,7 +34,7 @@ var (
 		sdk.ValAddress(pubkeys[2].Address()),
 	}
 
-	initAmt   = sdk.TokensFromConsensusPower(200)
+	initAmt   = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 )
 
diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go
index bfda1b3590b6..56a401fffad7 100644
--- a/x/gov/abci_test.go
+++ b/x/gov/abci_test.go
@@ -221,7 +221,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	require.False(t, activeQueue.Valid())
 	activeQueue.Close()
 
-	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5))}
+	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))}
 	newProposalMsg, err := types.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0])
 	require.NoError(t, err)
 
@@ -295,7 +295,7 @@ func TestProposalPassedEndblocker(t *testing.T) {
 	proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
 	require.NoError(t, err)
 
-	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10))}
+	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))}
 	newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
 
 	handleAndCheck(t, handler, ctx, newDepositMsg)
@@ -343,7 +343,7 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
 	proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
 	require.NoError(t, err)
 
-	proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10)))
+	proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)))
 	newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
 
 	handleAndCheck(t, gov.NewHandler(app.GovKeeper), ctx, newDepositMsg)
diff --git a/x/gov/common_test.go b/x/gov/common_test.go
index 5ef50ea5db03..3ff367e15972 100644
--- a/x/gov/common_test.go
+++ b/x/gov/common_test.go
@@ -16,7 +16,7 @@ import (
 )
 
 var (
-	valTokens           = sdk.TokensFromConsensusPower(42)
+	valTokens           = sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction)
 	TestProposal        = types.NewTextProposal("Test", "description")
 	TestDescription     = stakingtypes.NewDescription("T", "E", "S", "T", "Z")
 	TestCommissionRates = stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
@@ -82,7 +82,7 @@ func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context,
 	require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.")
 
 	for i := 0; i < len(addrs); i++ {
-		valTokens := sdk.TokensFromConsensusPower(powerAmt[i])
+		valTokens := sdk.TokensFromConsensusPower(powerAmt[i], sdk.DefaultPowerReduction)
 		valCreateMsg, err := stakingtypes.NewMsgCreateValidator(
 			addrs[i], pubkeys[i], sdk.NewCoin(sdk.DefaultBondDenom, valTokens),
 			TestDescription, TestCommissionRates, sdk.OneInt(),
diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go
index c7516eb69773..a967b4e9cbc3 100644
--- a/x/gov/keeper/common_test.go
+++ b/x/gov/keeper/common_test.go
@@ -48,9 +48,9 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3)
 
-	_, _ = 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)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val1, true)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val2, true)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val3, true)
 
 	_ = staking.EndBlocker(ctx, app.StakingKeeper)
 
diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go
index dfa857dc57fe..e1415f099a0b 100644
--- a/x/gov/keeper/deposit_test.go
+++ b/x/gov/keeper/deposit_test.go
@@ -22,8 +22,8 @@ func TestDeposits(t *testing.T) {
 	require.NoError(t, err)
 	proposalID := proposal.ProposalId
 
-	fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4)))
-	fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5)))
+	fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)))
+	fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction)))
 
 	addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])
 	addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1])
diff --git a/x/gov/keeper/grpc_query_test.go b/x/gov/keeper/grpc_query_test.go
index dc330d734829..59bdd442c999 100644
--- a/x/gov/keeper/grpc_query_test.go
+++ b/x/gov/keeper/grpc_query_test.go
@@ -164,7 +164,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
 		{
 			"request with filter of deposit address",
 			func() {
-				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20)))
+				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
 				deposit := types.NewDeposit(testProposals[0].ProposalId, addrs[0], depositCoins)
 				app.GovKeeper.SetDeposit(ctx, deposit)
 
@@ -584,7 +584,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() {
 		{
 			"valid request",
 			func() {
-				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20)))
+				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
 				deposit := types.NewDeposit(proposal.ProposalId, addrs[0], depositCoins)
 				app.GovKeeper.SetDeposit(ctx, deposit)
 
@@ -671,11 +671,11 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() {
 		{
 			"get deposits with default limit",
 			func() {
-				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20)))
+				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
 				deposit1 := types.NewDeposit(proposal.ProposalId, addrs[0], depositAmount1)
 				app.GovKeeper.SetDeposit(ctx, deposit1)
 
-				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30)))
+				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)))
 				deposit2 := types.NewDeposit(proposal.ProposalId, addrs[1], depositAmount2)
 				app.GovKeeper.SetDeposit(ctx, deposit2)
 
diff --git a/x/gov/keeper/querier_test.go b/x/gov/keeper/querier_test.go
index 9960fb116bed..d416cb350db8 100644
--- a/x/gov/keeper/querier_test.go
+++ b/x/gov/keeper/querier_test.go
@@ -153,7 +153,7 @@ func TestQueries(t *testing.T) {
 	TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001))
 
 	oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1))
-	consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10)))
+	consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)))
 
 	tp := TestProposal
 
diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go
index 77f468cd2c0b..4e2ac847e9c6 100644
--- a/x/gov/keeper/tally_test.go
+++ b/x/gov/keeper/tally_test.go
@@ -245,7 +245,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(30)
+	delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0])
 	require.True(t, found)
 
@@ -281,7 +281,7 @@ func TestTallyDelgatorInherit(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(30)
+	delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
 	require.True(t, found)
 
@@ -316,7 +316,7 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	val1, found := app.StakingKeeper.GetValidator(ctx, vals[0])
 	require.True(t, found)
 	val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
@@ -358,7 +358,7 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
 	require.True(t, found)
 	val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
@@ -397,7 +397,7 @@ func TestTallyJailedValidator(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{25, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
 	require.True(t, found)
 	val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2])
@@ -440,7 +440,7 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{10, 10, 10})
 
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
 	require.True(t, found)
 
@@ -465,10 +465,10 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
 	require.True(t, passes)
 	require.False(t, burnDeposits)
 
-	expectedYes := sdk.TokensFromConsensusPower(30)
-	expectedAbstain := sdk.TokensFromConsensusPower(0)
-	expectedNo := sdk.TokensFromConsensusPower(10)
-	expectedNoWithVeto := sdk.TokensFromConsensusPower(0)
+	expectedYes := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	expectedAbstain := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)
+	expectedNo := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	expectedNoWithVeto := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)
 	expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto)
 
 	require.True(t, tallyResults.Equals(expectedTallyResult))
diff --git a/x/gov/simulation/operations_test.go b/x/gov/simulation/operations_test.go
index 9c6e8306f821..169665ad9f70 100644
--- a/x/gov/simulation/operations_test.go
+++ b/x/gov/simulation/operations_test.go
@@ -222,7 +222,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/gov/types/params.go b/x/gov/types/params.go
index 5421136f390f..45ed3ec522dc 100644
--- a/x/gov/types/params.go
+++ b/x/gov/types/params.go
@@ -17,7 +17,7 @@ const (
 
 // Default governance params
 var (
-	DefaultMinDepositTokens = sdk.TokensFromConsensusPower(10)
+	DefaultMinDepositTokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	DefaultQuorum           = sdk.NewDecWithPrec(334, 3)
 	DefaultThreshold        = sdk.NewDecWithPrec(5, 1)
 	DefaultVetoThreshold    = sdk.NewDecWithPrec(334, 3)
diff --git a/x/ibc/core/02-client/keeper/keeper_test.go b/x/ibc/core/02-client/keeper/keeper_test.go
index c22e80cc9ec8..b9ad609211c9 100644
--- a/x/ibc/core/02-client/keeper/keeper_test.go
+++ b/x/ibc/core/02-client/keeper/keeper_test.go
@@ -111,7 +111,7 @@ func (suite *KeeperTestSuite) SetupTest() {
 		val.Tokens = sdk.NewInt(rand.Int63())
 		validators = append(validators, val)
 
-		hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators)
+		hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, sdk.DefaultPowerReduction)
 		app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi)
 	}
 
diff --git a/x/ibc/testing/chain.go b/x/ibc/testing/chain.go
index 0534066d88d6..edf77a7f2456 100644
--- a/x/ibc/testing/chain.go
+++ b/x/ibc/testing/chain.go
@@ -329,7 +329,7 @@ func (chain *TestChain) GetValsAtHeight(height int64) (*tmtypes.ValidatorSet, bo
 
 	valSet := stakingtypes.Validators(histInfo.Valset)
 
-	tmValidators, err := teststaking.ToTmValidators(valSet)
+	tmValidators, err := teststaking.ToTmValidators(valSet, sdk.DefaultPowerReduction)
 	if err != nil {
 		panic(err)
 	}
diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go
index 50140eb58ebb..f07b1c81fa9d 100644
--- a/x/slashing/abci_test.go
+++ b/x/slashing/abci_test.go
@@ -21,7 +21,7 @@ func TestBeginBlocker(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 	addr, pk := sdk.ValAddress(pks[0].Address()), pks[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go
index 5ee23b7cc564..028d41755607 100644
--- a/x/slashing/app_test.go
+++ b/x/slashing/app_test.go
@@ -41,8 +41,8 @@ func checkValidatorSigningInfo(t *testing.T, app *simapp.SimApp, addr sdk.ConsAd
 }
 
 func TestSlashingMsgs(t *testing.T) {
-	genTokens := sdk.TokensFromConsensusPower(42)
-	bondTokens := sdk.TokensFromConsensusPower(10)
+	genTokens := sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction)
+	bondTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	genCoin := sdk.NewCoin(sdk.DefaultBondDenom, genTokens)
 	bondCoin := sdk.NewCoin(sdk.DefaultBondDenom, bondTokens)
 
diff --git a/x/slashing/genesis_test.go b/x/slashing/genesis_test.go
index b9241f0246ca..e31144f331ee 100644
--- a/x/slashing/genesis_test.go
+++ b/x/slashing/genesis_test.go
@@ -20,7 +20,7 @@ func TestExportAndInitGenesis(t *testing.T) {
 
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
 		time.Now().UTC().Add(100000000000), false, int64(10))
diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go
index 7a83014b9615..87746d867213 100644
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@@ -26,7 +26,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	slh := slashing.NewHandler(app.SlashingKeeper)
@@ -52,12 +52,12 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	slh := slashing.NewHandler(app.SlashingKeeper)
 	addr, val := sdk.ValAddress(pks[0].Address()), pks[0]
-	amt := sdk.TokensFromConsensusPower(100)
+	amt := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	msg := tstaking.CreateValidatorMsg(addr, val, amt)
 	msg.MinSelfDelegation = amt
 	tstaking.Handle(msg, true)
@@ -84,7 +84,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
 	pks := simapp.CreateTestPubKeys(3)
 
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -145,7 +145,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
 	power := int64(100)
diff --git a/x/slashing/init_test.go b/x/slashing/init_test.go
index 25a38a2d5e53..fac4f3f32625 100644
--- a/x/slashing/init_test.go
+++ b/x/slashing/init_test.go
@@ -5,5 +5,5 @@ import (
 )
 
 var (
-	InitTokens = sdk.TokensFromConsensusPower(200)
+	InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 )
diff --git a/x/slashing/keeper/common_test.go b/x/slashing/keeper/common_test.go
index 940d995cacc7..aed5aa920393 100644
--- a/x/slashing/keeper/common_test.go
+++ b/x/slashing/keeper/common_test.go
@@ -3,5 +3,5 @@ package keeper_test
 import sdk "github.com/cosmos/cosmos-sdk/types"
 
 var (
-	InitTokens = sdk.TokensFromConsensusPower(200)
+	InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 )
diff --git a/x/slashing/keeper/grpc_query_test.go b/x/slashing/keeper/grpc_query_test.go
index d923b822c76c..c4880afd7fab 100644
--- a/x/slashing/keeper/grpc_query_test.go
+++ b/x/slashing/keeper/grpc_query_test.go
@@ -35,7 +35,7 @@ func (suite *SlashingTestSuite) SetupTest() {
 	app.BankKeeper.SetParams(ctx, banktypes.DefaultParams())
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
 		time.Unix(2, 0), false, int64(10))
diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go
index e083df637a0f..002d6a03a39e 100644
--- a/x/slashing/keeper/keeper_test.go
+++ b/x/slashing/keeper/keeper_test.go
@@ -23,7 +23,7 @@ func TestUnJailNotBonded(t *testing.T) {
 	p.MaxValidators = 5
 	app.StakingKeeper.SetParams(ctx, p)
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(6)
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -39,7 +39,7 @@ func TestUnJailNotBonded(t *testing.T) {
 
 	// create a 6th validator with less power than the cliff validator (won't be bonded)
 	addr, val := valAddrs[5], pks[5]
-	amt := sdk.TokensFromConsensusPower(50)
+	amt := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction)
 	msg := tstaking.CreateValidatorMsg(addr, val, amt)
 	msg.MinSelfDelegation = amt
 	tstaking.Handle(msg, true)
@@ -51,7 +51,7 @@ func TestUnJailNotBonded(t *testing.T) {
 
 	// unbond below minimum self-delegation
 	require.Equal(t, p.BondDenom, tstaking.Denom)
-	tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1), true)
+	tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction), true)
 
 	staking.EndBlocker(ctx, app.StakingKeeper)
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
@@ -83,7 +83,7 @@ func TestHandleNewValidator(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(1)
 	addr, val := valAddrs[0], pks[0]
@@ -116,7 +116,7 @@ func TestHandleNewValidator(t *testing.T) {
 	validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, stakingtypes.Bonded, validator.GetStatus())
 	bondPool := app.StakingKeeper.GetBondedPool(ctx)
-	expTokens := sdk.TokensFromConsensusPower(100)
+	expTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	require.True(t, expTokens.Equal(app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount))
 }
 
@@ -127,7 +127,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(1)
 	addr, val := valAddrs[0], pks[0]
@@ -159,7 +159,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	require.Equal(t, stakingtypes.Unbonding, validator.GetStatus())
 
 	// validator should have been slashed
-	resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1))
+	resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))
 	require.Equal(t, resultingTokens, validator.GetTokens())
 
 	// another block missed
@@ -188,7 +188,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	power := int64(100)
 
 	pks := simapp.CreateTestPubKeys(3)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	addr, val := pks[0].Address(), pks[0]
 	consAddr := sdk.ConsAddress(addr)
diff --git a/x/slashing/keeper/signing_info_test.go b/x/slashing/keeper/signing_info_test.go
index 1b70c83b9712..e1b4f1720afe 100644
--- a/x/slashing/keeper/signing_info_test.go
+++ b/x/slashing/keeper/signing_info_test.go
@@ -15,7 +15,7 @@ import (
 func TestGetSetValidatorSigningInfo(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	info, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, sdk.ConsAddress(addrDels[0]))
 	require.False(t, found)
@@ -39,7 +39,7 @@ func TestGetSetValidatorSigningInfo(t *testing.T) {
 func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	missed := app.SlashingKeeper.GetValidatorMissedBlockBitArray(ctx, sdk.ConsAddress(addrDels[0]), 0)
 	require.False(t, missed) // treat empty key as not missed
@@ -51,7 +51,7 @@ func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
 func TestTombstoned(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	require.Panics(t, func() { app.SlashingKeeper.Tombstone(ctx, sdk.ConsAddress(addrDels[0])) })
 	require.False(t, app.SlashingKeeper.IsTombstoned(ctx, sdk.ConsAddress(addrDels[0])))
@@ -75,7 +75,7 @@ func TestTombstoned(t *testing.T) {
 func TestJailUntil(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
 
 	require.Panics(t, func() { app.SlashingKeeper.JailUntil(ctx, sdk.ConsAddress(addrDels[0]), time.Now()) })
 
diff --git a/x/slashing/simulation/operations_test.go b/x/slashing/simulation/operations_test.go
index 15764c631ebf..2042821c7a76 100644
--- a/x/slashing/simulation/operations_test.go
+++ b/x/slashing/simulation/operations_test.go
@@ -77,7 +77,7 @@ func TestSimulateMsgUnjail(t *testing.T) {
 	app.StakingKeeper.Jail(ctx, val0ConsAddress)
 
 	// setup self delegation
-	delTokens := sdk.TokensFromConsensusPower(2)
+	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress)
 	require.NoError(t, err)
@@ -116,7 +116,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/staking/app_test.go b/x/staking/app_test.go
index 207ac03e0cf6..65a6e4524ebf 100644
--- a/x/staking/app_test.go
+++ b/x/staking/app_test.go
@@ -40,8 +40,8 @@ func checkDelegation(
 }
 
 func TestStakingMsgs(t *testing.T) {
-	genTokens := sdk.TokensFromConsensusPower(42)
-	bondTokens := sdk.TokensFromConsensusPower(10)
+	genTokens := sdk.TokensFromConsensusPower(42, sdk.DefaultPowerReduction)
+	bondTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	genCoin := sdk.NewCoin(sdk.DefaultBondDenom, genTokens)
 	bondCoin := sdk.NewCoin(sdk.DefaultBondDenom, bondTokens)
 
diff --git a/x/staking/client/cli/tx.go b/x/staking/client/cli/tx.go
index 10ceba6a45e0..9b79fd3186b4 100644
--- a/x/staking/client/cli/tx.go
+++ b/x/staking/client/cli/tx.go
@@ -19,7 +19,7 @@ import (
 
 // default values
 var (
-	DefaultTokens                  = sdk.TokensFromConsensusPower(100)
+	DefaultTokens                  = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	defaultAmount                  = DefaultTokens.String() + sdk.DefaultBondDenom
 	defaultCommissionRate          = "0.1"
 	defaultCommissionMaxRate       = "0.2"
diff --git a/x/staking/common_test.go b/x/staking/common_test.go
index 0c26e6830d5a..5d8897b1c0a8 100644
--- a/x/staking/common_test.go
+++ b/x/staking/common_test.go
@@ -15,7 +15,7 @@ import (
 )
 
 func init() {
-	sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
+	sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
 }
 
 // nolint:deadcode,unused,varcheck
diff --git a/x/staking/genesis.go b/x/staking/genesis.go
index 02f6bc317473..2f2eb5bba9b6 100644
--- a/x/staking/genesis.go
+++ b/x/staking/genesis.go
@@ -143,7 +143,7 @@ func InitGenesis(
 				panic(fmt.Sprintf("validator %s not found", lv.Address))
 			}
 
-			update := validator.ABCIValidatorUpdate()
+			update := validator.ABCIValidatorUpdate(keeper.PowerReduction(ctx))
 			update.Power = lv.Power // keep the next-val-set offset, use the last power for the first block
 			res = append(res, update)
 		}
@@ -210,7 +210,7 @@ func WriteValidators(ctx sdk.Context, keeper keeper.Keeper) (vals []tmtypes.Gene
 		vals = append(vals, tmtypes.GenesisValidator{
 			Address: sdk.ConsAddress(tmPk.Address()).Bytes(),
 			PubKey:  tmPk,
-			Power:   validator.GetConsensusPower(),
+			Power:   validator.GetConsensusPower(keeper.PowerReduction(ctx)),
 			Name:    validator.GetMoniker(),
 		})
 
diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go
index 28e3dec8a0fd..4c4bf97847ce 100644
--- a/x/staking/genesis_test.go
+++ b/x/staking/genesis_test.go
@@ -23,7 +23,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
 
 	addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000))
 
-	amt := sdk.TokensFromConsensusPower(power)
+	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -39,7 +39,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
 func TestInitGenesis(t *testing.T) {
 	app, ctx, addrs := bootstrapGenesisTest(t, 1000, 10)
 
-	valTokens := sdk.TokensFromConsensusPower(1)
+	valTokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
 
 	params := app.StakingKeeper.GetParams(ctx)
 	validators := make([]types.Validator, 2)
@@ -91,7 +91,7 @@ func TestInitGenesis(t *testing.T) {
 
 	abcivals := make([]abci.ValidatorUpdate, len(vals))
 	for i, val := range validators {
-		abcivals[i] = val.ABCIValidatorUpdate()
+		abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction)
 	}
 
 	require.Equal(t, abcivals, vals)
@@ -113,9 +113,9 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 		require.NoError(t, err)
 		validators[i].Status = types.Bonded
 
-		tokens := sdk.TokensFromConsensusPower(1)
+		tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
 		if i < 100 {
-			tokens = sdk.TokensFromConsensusPower(2)
+			tokens = sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 		}
 		validators[i].Tokens = tokens
 		validators[i].DelegatorShares = tokens.ToDec()
@@ -126,7 +126,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 
 	abcivals := make([]abci.ValidatorUpdate, 100)
 	for i, val := range validators[:100] {
-		abcivals[i] = val.ABCIValidatorUpdate()
+		abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction)
 	}
 
 	require.Equal(t, abcivals, vals)
diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go
index 4b48f09427c9..07c3c23854c0 100644
--- a/x/staking/handler_test.go
+++ b/x/staking/handler_test.go
@@ -32,7 +32,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
 
 	addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount)
 
-	amt := sdk.TokensFromConsensusPower(power)
+	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -47,7 +47,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
 
 func TestValidatorByPowerIndex(t *testing.T) {
 	initPower := int64(1000000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, validatorAddr3 := valAddrs[0], valAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -68,7 +68,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// verify that the by power index exists
 	validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	power := types.GetValidatorsByPowerIndexKey(validator)
+	power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	// create a second validator keep it bonded
@@ -97,11 +97,11 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// but the new power record should have been created
 	validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	power2 := types.GetValidatorsByPowerIndexKey(validator)
+	power2 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power2))
 
 	// now the new record power index should be the same as the original record
-	power3 := types.GetValidatorsByPowerIndexKey(validator)
+	power3 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
 	require.Equal(t, power2, power3)
 
 	// unbond self-delegation
@@ -124,7 +124,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 
 func TestDuplicatesMsgCreateValidator(t *testing.T) {
 	initPower := int64(1000000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	addr1, addr2 := valAddrs[0], valAddrs[1]
 	pk1, pk2 := PKs[0], PKs[1]
@@ -172,7 +172,7 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
 
 func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	ctx = ctx.WithConsensusParams(&abci.ConsensusParams{
 		Validator: &tmproto.ValidatorParams{PubKeyTypes: []string{tmtypes.ABCIPubKeyTypeEd25519}},
 	})
@@ -218,7 +218,7 @@ func TestBothPubKeyTypesMsgCreateValidator(t *testing.T) {
 
 func TestLegacyValidatorDelegations(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	valAddr := valAddrs[0]
@@ -297,8 +297,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 
 func TestIncrementsMsgDelegate(t *testing.T) {
 	initPower := int64(1000)
-	initBond := sdk.TokensFromConsensusPower(initPower)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	initBond := sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	params := app.StakingKeeper.GetParams(ctx)
 	validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1]
@@ -356,8 +356,8 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 
 func TestEditValidatorDecreaseMinSelfDelegation(t *testing.T) {
 	initPower := int64(100)
-	initBond := sdk.TokensFromConsensusPower(100)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower))
+	initBond := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	validatorAddr := valAddrs[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -387,9 +387,9 @@ func TestEditValidatorDecreaseMinSelfDelegation(t *testing.T) {
 
 func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) {
 	initPower := int64(100)
-	initBond := sdk.TokensFromConsensusPower(100)
+	initBond := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr := valAddrs[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -419,7 +419,7 @@ func TestEditValidatorIncreaseMinSelfDelegationBeyondCurrentBond(t *testing.T) {
 func TestIncrementsMsgUnbond(t *testing.T) {
 	initPower := int64(1000)
 
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	params := app.StakingKeeper.GetParams(ctx)
 	denom := params.BondDenom
@@ -491,8 +491,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	errorCases := []sdk.Int{
 		//1<<64 - 1, // more than int64 power
 		//1<<63 + 1, // more than int64 power
-		sdk.TokensFromConsensusPower(1<<63 - 1),
-		sdk.TokensFromConsensusPower(1 << 31),
+		sdk.TokensFromConsensusPower(1<<63-1, sdk.DefaultPowerReduction),
+		sdk.TokensFromConsensusPower(1<<31, sdk.DefaultPowerReduction),
 		initBond,
 	}
 
@@ -507,8 +507,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 
 func TestMultipleMsgCreateValidator(t *testing.T) {
 	initPower := int64(1000)
-	initTokens := sdk.TokensFromConsensusPower(initPower)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower))
+	initTokens := sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction)
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	params := app.StakingKeeper.GetParams(ctx)
 	blockTime := time.Now().UTC()
@@ -527,7 +527,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 	}
 
 	// bond them all
-	amt := sdk.TokensFromConsensusPower(10)
+	amt := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	for i, validatorAddr := range validatorAddrs {
 		tstaking.CreateValidator(validatorAddr, PKs[i], amt, true)
 		// verify that the account is bonded
@@ -577,7 +577,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 
 func TestMultipleMsgDelegate(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 50, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 50, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, delegatorAddrs := valAddrs[0], delAddrs[1:]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	var amount int64 = 10
@@ -611,7 +611,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 
 func TestJailValidator(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	var amt int64 = 10
@@ -650,7 +650,7 @@ func TestJailValidator(t *testing.T) {
 
 func TestValidatorQueue(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -697,7 +697,7 @@ func TestValidatorQueue(t *testing.T) {
 
 func TestUnbondingPeriod(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr := valAddrs[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -736,7 +736,7 @@ func TestUnbondingPeriod(t *testing.T) {
 
 func TestUnbondingFromUnbondingValidator(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, delegatorAddr := valAddrs[0], delAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -769,7 +769,7 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) {
 
 func TestRedelegationPeriod(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	validatorAddr, validatorAddr2 := valAddrs[0], valAddrs[1]
 	denom := app.StakingKeeper.GetParams(ctx).BondDenom
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -820,7 +820,7 @@ func TestRedelegationPeriod(t *testing.T) {
 
 func TestTransitiveRedelegation(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 
 	val1, val2, val3 := valAddrs[0], valAddrs[1], valAddrs[2]
 	blockTime := time.Now().UTC()
@@ -854,7 +854,7 @@ func TestTransitiveRedelegation(t *testing.T) {
 
 func TestMultipleRedelegationAtSameTime(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valAddr := valAddrs[0]
 	valAddr2 := valAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -898,7 +898,7 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
 
 func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 2, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valAddr := valAddrs[0]
 	valAddr2 := valAddrs[1]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -945,7 +945,7 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
 
 func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valAddr := valAddrs[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -985,7 +985,7 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
 
 func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 1, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valAddr := valAddrs[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
@@ -1033,7 +1033,7 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
 
 func TestUnbondingWhenExcessValidators(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	val1 := valAddrs[0]
 	val2 := valAddrs[1]
 	val3 := valAddrs[2]
@@ -1073,7 +1073,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 
 func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valA, valB, del := valAddrs[0], valAddrs[1], delAddrs[2]
 	consAddr0 := sdk.ConsAddress(PKs[0].Address())
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -1094,11 +1094,11 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	tstaking.Ctx = ctx
 
 	// begin unbonding 4 stake
-	unbondAmt := sdk.TokensFromConsensusPower(4)
+	unbondAmt := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
 	tstaking.Undelegate(del, valA, unbondAmt, true)
 
 	// begin redelegate 6 stake
-	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6))
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction))
 	msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt)
 	tstaking.Handle(msgBeginRedelegate, true)
 
@@ -1178,11 +1178,11 @@ func TestInvalidMsg(t *testing.T) {
 
 func TestInvalidCoinDenom(t *testing.T) {
 	initPower := int64(1000)
-	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower))
+	app, ctx, delAddrs, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 3, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
 	valA, valB, delAddr := valAddrs[0], valAddrs[1], delAddrs[2]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
-	valTokens := sdk.TokensFromConsensusPower(100)
+	valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	invalidCoin := sdk.NewCoin("churros", valTokens)
 	validCoin := sdk.NewCoin(sdk.DefaultBondDenom, valTokens)
 	oneCoin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt())
diff --git a/x/staking/keeper/common_test.go b/x/staking/keeper/common_test.go
index 7ec4e9677cbc..fb07d8694e8b 100644
--- a/x/staking/keeper/common_test.go
+++ b/x/staking/keeper/common_test.go
@@ -18,7 +18,7 @@ var (
 )
 
 func init() {
-	sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
+	sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
 }
 
 // createTestInput Returns a simapp with custom StakingKeeper
diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go
index 77f4cb8e2c81..7ec6bfe521d0 100644
--- a/x/staking/keeper/delegation_test.go
+++ b/x/staking/keeper/delegation_test.go
@@ -183,7 +183,7 @@ func TestUnbondDelegation(t *testing.T) {
 	delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	valAddrs := simapp.ConvertAddrsToValAddrs(delAddrs)
 
-	startTokens := sdk.TokensFromConsensusPower(10)
+	startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
 	require.NoError(t,
@@ -207,7 +207,7 @@ func TestUnbondDelegation(t *testing.T) {
 	delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares)
 	app.StakingKeeper.SetDelegation(ctx, delegation)
 
-	bondTokens := sdk.TokensFromConsensusPower(6)
+	bondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	amount, err := app.StakingKeeper.Unbond(ctx, delAddrs[0], valAddrs[0], bondTokens.ToDec())
 	require.NoError(t, err)
 	require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
@@ -228,7 +228,7 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(10)
+	startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 
 	bondDenom := app.StakingKeeper.BondDenom(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -310,7 +310,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	//create a validator with a self-delegation
@@ -358,7 +358,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 	app.StakingKeeper.SetDelegation(ctx, delegation)
 
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec())
+	_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction).ToDec())
 	require.NoError(t, err)
 
 	// end block
@@ -366,14 +366,14 @@ 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.TokensFromConsensusPower(14, sdk.DefaultPowerReduction), validator.Tokens)
 	require.Equal(t, types.Unbonding, validator.Status)
 	require.True(t, validator.Jailed)
 }
 
 func TestUndelegateFromUnbondingValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -466,7 +466,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
 
 func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -483,7 +483,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -534,7 +534,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	require.Equal(t, validator.Status, types.Unbonded)
 
 	// unbond some of the other delegation's shares
-	unbondTokens := sdk.TokensFromConsensusPower(6)
+	unbondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec())
 	require.NoError(t, err)
 
@@ -550,7 +550,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 
 func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -567,7 +567,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 
@@ -720,7 +720,7 @@ func TestRedelegateToSameValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens))
 
 	// add bonded tokens to pool for delegations
@@ -751,7 +751,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(20)
+	startTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -763,7 +763,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
 
 	// create a validator with a self-delegation
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -809,7 +809,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30)
+	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -823,7 +823,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 
@@ -841,7 +841,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	require.Equal(t, types.Bonded, validator2.Status)
 
 	// create a second delegation to validator 1
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -867,7 +867,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30)
+	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -881,7 +881,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -891,7 +891,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 
 	// create a second delegation to this validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -933,7 +933,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)
 
 	// unbond some of the other delegation's shares
-	redelegateTokens := sdk.TokensFromConsensusPower(6)
+	redelegateTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec())
 	require.NoError(t, err)
 
@@ -951,7 +951,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30)
+	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -965,7 +965,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -975,7 +975,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 
 	// create a second delegation to this validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
-	delTokens := sdk.TokensFromConsensusPower(10)
+	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -1009,7 +1009,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	app.StakingKeeper.UnbondingToUnbonded(ctx, validator)
 
 	// redelegate some of the delegation's shares
-	redelegationTokens := sdk.TokensFromConsensusPower(6)
+	redelegationTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegationTokens.ToDec())
 	require.NoError(t, err)
 
diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go
index aa3b341b0953..a1d4c88883ff 100644
--- a/x/staking/keeper/grpc_query_test.go
+++ b/x/staking/keeper/grpc_query_test.go
@@ -395,7 +395,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryUnbondingDelegation() {
 	addrAcc2 := addrs[1]
 	addrVal2 := vals[1].OperatorAddress
 
-	unbondingTokens := sdk.TokensFromConsensusPower(2)
+	unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	valAddr, err1 := sdk.ValAddressFromBech32(addrVal2)
 	suite.NoError(err1)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, valAddr, unbondingTokens.ToDec())
@@ -450,7 +450,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDelegatorUnbondingDelegations() {
 	addrAcc, addrAcc1 := addrs[0], addrs[1]
 	addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress
 
-	unbondingTokens := sdk.TokensFromConsensusPower(2)
+	unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	valAddr1, err1 := sdk.ValAddressFromBech32(addrVal)
 	suite.NoError(err1)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc, valAddr1, unbondingTokens.ToDec())
@@ -592,12 +592,12 @@ func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() {
 	addrAcc, addrAcc1 := addrs[0], addrs[1]
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
 	val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4]
-	delAmount := sdk.TokensFromConsensusPower(1)
+	delAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
 
-	rdAmount := sdk.TokensFromConsensusPower(1)
+	rdAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@@ -684,7 +684,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
 	val1 := vals[0]
 
 	// undelegate
-	undelAmount := sdk.TokensFromConsensusPower(2)
+	undelAmount := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@@ -729,7 +729,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
 }
 
 func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress, []types.Validator) {
-	addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300))
+	addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300, sdk.DefaultPowerReduction))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
 	pks := simapp.CreateTestPubKeys(5)
 	cdc := simapp.MakeTestEncodingConfig().Marshaler
@@ -752,11 +752,11 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1)
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
 
-	_, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), types.Unbonded, val1, true)
+	_, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), types.Unbonded, val1, true)
 	require.NoError(t, err)
-	_, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), types.Unbonded, val2, true)
+	_, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), types.Unbonded, val2, true)
 	require.NoError(t, err)
-	_, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2]), types.Unbonded, val2, true)
+	_, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), types.Unbonded, val2, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
diff --git a/x/staking/keeper/historical_info.go b/x/staking/keeper/historical_info.go
index 20c5a8ce85c9..f56f49eb145f 100644
--- a/x/staking/keeper/historical_info.go
+++ b/x/staking/keeper/historical_info.go
@@ -91,7 +91,7 @@ func (k Keeper) TrackHistoricalInfo(ctx sdk.Context) {
 
 	// Create HistoricalInfo struct
 	lastVals := k.GetLastValidators(ctx)
-	historicalEntry := types.NewHistoricalInfo(ctx.BlockHeader(), lastVals)
+	historicalEntry := types.NewHistoricalInfo(ctx.BlockHeader(), lastVals, k.PowerReduction(ctx))
 
 	// Set latest HistoricalInfo at current height
 	k.SetHistoricalInfo(ctx, ctx.BlockHeight(), &historicalEntry)
diff --git a/x/staking/keeper/historical_info_test.go b/x/staking/keeper/historical_info_test.go
index a9411d0db974..b31407cf8e96 100644
--- a/x/staking/keeper/historical_info_test.go
+++ b/x/staking/keeper/historical_info_test.go
@@ -25,7 +25,7 @@ func TestHistoricalInfo(t *testing.T) {
 		validators[i] = teststaking.NewValidator(t, valAddr, PKs[i])
 	}
 
-	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators)
+	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, sdk.DefaultPowerReduction)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi)
 
 	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
@@ -65,8 +65,8 @@ func TestTrackHistoricalInfo(t *testing.T) {
 		teststaking.NewValidator(t, addrVals[0], PKs[0]),
 		teststaking.NewValidator(t, addrVals[1], PKs[1]),
 	}
-	hi4 := types.NewHistoricalInfo(h4, valSet)
-	hi5 := types.NewHistoricalInfo(h5, valSet)
+	hi4 := types.NewHistoricalInfo(h4, valSet, sdk.DefaultPowerReduction)
+	hi5 := types.NewHistoricalInfo(h5, valSet, sdk.DefaultPowerReduction)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5)
 	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4)
diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go
index e21de8f9511d..3516316f6c8b 100644
--- a/x/staking/keeper/invariants.go
+++ b/x/staking/keeper/invariants.go
@@ -105,13 +105,13 @@ func NonNegativePowerInvariant(k Keeper) sdk.Invariant {
 				panic(fmt.Sprintf("validator record not found for address: %X\n", iterator.Value()))
 			}
 
-			powerKey := types.GetValidatorsByPowerIndexKey(validator)
+			powerKey := types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx))
 
 			if !bytes.Equal(iterator.Key(), powerKey) {
 				broken = true
 				msg += fmt.Sprintf("power store invariance:\n\tvalidator.Power: %v"+
 					"\n\tkey should be: %v\n\tkey in store: %v\n",
-					validator.GetConsensusPower(), powerKey, iterator.Key())
+					validator.GetConsensusPower(k.PowerReduction(ctx)), powerKey, iterator.Key())
 			}
 
 			if validator.Tokens.IsNegative() {
diff --git a/x/staking/keeper/keeper_test.go b/x/staking/keeper/keeper_test.go
index 2f9819989ff0..bc0825a8e74a 100644
--- a/x/staking/keeper/keeper_test.go
+++ b/x/staking/keeper/keeper_test.go
@@ -45,7 +45,7 @@ func (suite *KeeperTestSuite) SetupTest() {
 	// have its order changed
 	sortedVals := make([]types.Validator, len(validators))
 	copy(sortedVals, validators)
-	hi := types.NewHistoricalInfo(header, sortedVals)
+	hi := types.NewHistoricalInfo(header, sortedVals, sdk.DefaultPowerReduction)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators
diff --git a/x/staking/keeper/params.go b/x/staking/keeper/params.go
index 7fe0a8d098eb..37c433415b0d 100644
--- a/x/staking/keeper/params.go
+++ b/x/staking/keeper/params.go
@@ -39,6 +39,13 @@ func (k Keeper) BondDenom(ctx sdk.Context) (res string) {
 	return
 }
 
+// PowerReduction - is the amount of staking tokens required for 1 unit of consensus-engine power
+// governance can update it on a running chain
+func (k Keeper) PowerReduction(ctx sdk.Context) (res sdk.Int) {
+	k.paramstore.Get(ctx, types.KeyPowerReduction, &res)
+	return
+}
+
 // Get all parameteras as types.Params
 func (k Keeper) GetParams(ctx sdk.Context) types.Params {
 	return types.NewParams(
@@ -47,6 +54,7 @@ func (k Keeper) GetParams(ctx sdk.Context) types.Params {
 		k.MaxEntries(ctx),
 		k.HistoricalEntries(ctx),
 		k.BondDenom(ctx),
+		k.PowerReduction(ctx),
 	)
 }
 
diff --git a/x/staking/keeper/power_reduction.go b/x/staking/keeper/power_reduction.go
new file mode 100644
index 000000000000..d979228b36fa
--- /dev/null
+++ b/x/staking/keeper/power_reduction.go
@@ -0,0 +1,15 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// TokensToConsensusPower - convert input tokens to potential consensus-engine power
+func (k Keeper) TokensToConsensusPower(ctx sdk.Context, tokens sdk.Int) int64 {
+	return sdk.TokensToConsensusPower(tokens, k.PowerReduction(ctx))
+}
+
+// TokensFromConsensusPower - convert input power to tokens
+func (k Keeper) TokensFromConsensusPower(ctx sdk.Context, power int64) sdk.Int {
+	return sdk.TokensFromConsensusPower(power, k.PowerReduction(ctx))
+}
diff --git a/x/staking/keeper/power_reduction_test.go b/x/staking/keeper/power_reduction_test.go
new file mode 100644
index 000000000000..df54a0358f07
--- /dev/null
+++ b/x/staking/keeper/power_reduction_test.go
@@ -0,0 +1,21 @@
+package keeper_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (suite *KeeperTestSuite) TestPowerReductionChange(t *testing.T) {
+	// TODO: Implement!
+}
+
+func (suite *KeeperTestSuite) TestTokensToConsensusPower() {
+	suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(999_999)))
+	suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(1_000_000)))
+}
+
+func (suite *KeeperTestSuite) TestTokensFromConsensusPower() {
+	suite.Require().Equal(sdk.NewInt(0), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 0))
+	suite.Require().Equal(sdk.NewInt(1_000_000), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 1))
+}
diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go
index 0b194bd6dc71..14cd841f2e9b 100644
--- a/x/staking/keeper/querier_test.go
+++ b/x/staking/keeper/querier_test.go
@@ -37,7 +37,7 @@ func TestNewQuerier(t *testing.T) {
 		ChainID: "HelloChain",
 		Height:  5,
 	}
-	hi := types.NewHistoricalInfo(header, validators[:])
+	hi := types.NewHistoricalInfo(header, validators[:], sdk.DefaultPowerReduction)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	query := abci.RequestQuery{
@@ -140,7 +140,7 @@ func TestQueryValidators(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 
 	// Create Validators
 	amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
@@ -208,7 +208,7 @@ func TestQueryDelegation(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -224,7 +224,7 @@ func TestQueryDelegation(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val2)
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2)
 
-	delTokens := sdk.TokensFromConsensusPower(20)
+	delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true)
 	require.NoError(t, err)
 
@@ -348,7 +348,7 @@ func TestQueryDelegation(t *testing.T) {
 	require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance)
 
 	// Query unbonding delegation
-	unbondingTokens := sdk.TokensFromConsensusPower(10)
+	unbondingTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.GetOperator(), unbondingTokens.ToDec())
 	require.NoError(t, err)
 
@@ -401,7 +401,7 @@ func TestQueryDelegation(t *testing.T) {
 	require.Error(t, err)
 
 	// Query redelegation
-	redelegationTokens := sdk.TokensFromConsensusPower(10)
+	redelegationTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(),
 		val2.GetOperator(), redelegationTokens.ToDec())
 	require.NoError(t, err)
@@ -456,7 +456,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 	pubKeys := simapp.CreateTestPubKeys(1)
 
 	valAddress := sdk.ValAddress(addrs[0])
@@ -472,7 +472,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 			t.Error("expected validator not found")
 		}
 
-		delTokens := sdk.TokensFromConsensusPower(20)
+		delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 		_, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true)
 		require.NoError(t, err)
 	}
@@ -506,7 +506,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 
 	// Undelegate
 	for _, addr := range addrs {
-		delTokens := sdk.TokensFromConsensusPower(20)
+		delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 		_, err := app.StakingKeeper.Undelegate(ctx, addr, val1.GetOperator(), delTokens.ToDec())
 		require.NoError(t, err)
 	}
@@ -541,7 +541,7 @@ func TestQueryRedelegations(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -551,12 +551,12 @@ func TestQueryRedelegations(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val1)
 	app.StakingKeeper.SetValidator(ctx, val2)
 
-	delAmount := sdk.TokensFromConsensusPower(100)
+	delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
-	rdAmount := sdk.TokensFromConsensusPower(20)
+	rdAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -613,7 +613,7 @@ func TestQueryUnbondingDelegation(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1 := sdk.ValAddress(addrAcc1)
 
@@ -622,13 +622,13 @@ func TestQueryUnbondingDelegation(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val1)
 
 	// delegate
-	delAmount := sdk.TokensFromConsensusPower(100)
+	delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
 	// undelegate
-	undelAmount := sdk.TokensFromConsensusPower(20)
+	undelAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -709,7 +709,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(cdc)
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -724,7 +724,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
 		ChainID: "HelloChain",
 		Height:  5,
 	}
-	hi := types.NewHistoricalInfo(header, vals)
+	hi := types.NewHistoricalInfo(header, vals, sdk.DefaultPowerReduction)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4}
diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go
index a36f6f2e6e20..42e5b383ef02 100644
--- a/x/staking/keeper/slash.go
+++ b/x/staking/keeper/slash.go
@@ -29,7 +29,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
 	}
 
 	// Amount of slashing = slash slashFactor * power at time of infraction
-	amount := sdk.TokensFromConsensusPower(power)
+	amount := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 	slashAmountDec := amount.ToDec().Mul(slashFactor)
 	slashAmount := slashAmountDec.TruncateInt()
 
diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go
index 356c022e4e26..941a5a70be46 100644
--- a/x/staking/keeper/slash_test.go
+++ b/x/staking/keeper/slash_test.go
@@ -22,7 +22,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context,
 
 	addrDels, addrVals := generateAddresses(app, ctx, 100)
 
-	amt := sdk.TokensFromConsensusPower(power)
+	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -219,12 +219,12 @@ func TestSlashAtNegativeHeight(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	require.True(t, found)
 	// power decreased
-	require.Equal(t, int64(5), validator.GetConsensusPower())
+	require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// pool bonded shares decreased
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(5).String(), diffTokens.String())
+	require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String())
 }
 
 // tests Slash at the current height
@@ -250,12 +250,12 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	assert.True(t, found)
 	// power decreased
-	require.Equal(t, int64(5), validator.GetConsensusPower())
+	require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// pool bonded shares decreased
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(5).String(), diffTokens.String())
+	require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String())
 }
 
 // tests Slash at a previous height with an unbonding delegation
@@ -267,7 +267,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 
 	// set an unbonding delegation with expiration timestamp beyond which the
 	// unbonding delegation shouldn't be slashed
-	ubdTokens := sdk.TokensFromConsensusPower(4)
+	ubdTokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
 	ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
 		time.Unix(0, 0), ubdTokens)
 	app.StakingKeeper.SetUnbondingDelegation(ctx, ubd)
@@ -290,12 +290,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	require.Len(t, ubd.Entries, 1)
 
 	// balance decreased
-	require.Equal(t, sdk.TokensFromConsensusPower(2), ubd.Entries[0].Balance)
+	require.Equal(t, sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction), ubd.Entries[0].Balance)
 
 	// bonded tokens burned
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(3), diffTokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(3, sdk.DefaultPowerReduction), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
@@ -305,7 +305,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.Equal(t, int64(7), validator.GetConsensusPower())
+	require.Equal(t, int64(7), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// slash validator again
 	ctx = ctx.WithBlockHeight(13)
@@ -321,14 +321,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// bonded tokens burned again
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(6), diffTokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	// power decreased by 3 again
-	require.Equal(t, int64(4), validator.GetConsensusPower())
+	require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -347,14 +347,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// bonded tokens burned again
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(9), diffTokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	// power decreased by 3 again
-	require.Equal(t, int64(1), validator.GetConsensusPower())
+	require.Equal(t, int64(1), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -373,7 +373,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// just 1 bonded token burned again since that's all the validator now has
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(10), diffTokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction), diffTokens)
 
 	// apply TM updates
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -394,7 +394,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	bondDenom := app.StakingKeeper.BondDenom(ctx)
 
 	// set a redelegation
-	rdTokens := sdk.TokensFromConsensusPower(6)
+	rdTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
 		time.Unix(0, 0), rdTokens, rdTokens.ToDec())
 	app.StakingKeeper.SetRedelegation(ctx, rd)
@@ -424,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	require.True(t, found)
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, fraction) })
-	burnAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt()
+	burnAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt()
 
 	bondedPool = app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
@@ -448,14 +448,14 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.Equal(t, int64(8), validator.GetConsensusPower())
+	require.Equal(t, int64(8), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// slash the validator again
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
-	burnAmount = sdk.TokensFromConsensusPower(7)
+	burnAmount = sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction)
 
 	// read updated pool
 	bondedPool = app.StakingKeeper.GetBondedPool(ctx)
@@ -481,7 +481,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 	// power decreased by 4
-	require.Equal(t, int64(4), validator.GetConsensusPower())
+	require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// slash the validator again, by 100%
 	ctx = ctx.WithBlockHeight(12)
@@ -490,7 +490,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
 
-	burnAmount = sdk.TokensFromConsensusPower(10).ToDec().Mul(sdk.OneDec()).TruncateInt()
+	burnAmount = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(sdk.OneDec()).TruncateInt()
 	burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt())
 
 	// read updated pool
@@ -550,7 +550,7 @@ func TestSlashBoth(t *testing.T) {
 
 	// set a redelegation with expiration timestamp beyond which the
 	// redelegation shouldn't be slashed
-	rdATokens := sdk.TokensFromConsensusPower(6)
+	rdATokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
 	rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
 		time.Unix(0, 0), rdATokens,
 		rdATokens.ToDec())
@@ -562,7 +562,7 @@ func TestSlashBoth(t *testing.T) {
 
 	// set an unbonding delegation with expiration timestamp (beyond which the
 	// unbonding delegation shouldn't be slashed)
-	ubdATokens := sdk.TokensFromConsensusPower(4)
+	ubdATokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
 	ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
 		time.Unix(0, 0), ubdATokens)
 	app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA)
@@ -593,7 +593,7 @@ func TestSlashBoth(t *testing.T) {
 	app.StakingKeeper.Slash(ctx, consAddr0, 10, 10, fraction)
 
 	burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt()
-	burnedBondAmount := sdk.TokensFromConsensusPower(10).ToDec().Mul(fraction).TruncateInt()
+	burnedBondAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt()
 	burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount)
 
 	// read updated pool
@@ -614,5 +614,5 @@ func TestSlashBoth(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0]))
 	require.True(t, found)
 	// power not decreased, all stake was bonded since
-	require.Equal(t, int64(10), validator.GetConsensusPower())
+	require.Equal(t, int64(10), validator.GetConsensusPower(sdk.DefaultPowerReduction))
 }
diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go
index f06994f44f70..b8e1c3d4584c 100644
--- a/x/staking/keeper/val_state_change.go
+++ b/x/staking/keeper/val_state_change.go
@@ -135,7 +135,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 
 		// if we get to a zero-power validator (which we don't bond),
 		// there are no more possible bonded validators
-		if validator.PotentialConsensusPower() == 0 {
+		if validator.PotentialConsensusPower(k.PowerReduction(ctx)) == 0 {
 			break
 		}
 
@@ -164,12 +164,12 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 
 		copy(valAddrBytes[:], valAddr[:])
 		oldPowerBytes, found := last[valAddrBytes]
-		newPower := validator.ConsensusPower()
+		newPower := validator.ConsensusPower(k.PowerReduction(ctx))
 		newPowerBytes := k.cdc.MustMarshalBinaryBare(&gogotypes.Int64Value{Value: newPower})
 
 		// update the validator set if power has changed
 		if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) {
-			updates = append(updates, validator.ABCIValidatorUpdate())
+			updates = append(updates, validator.ABCIValidatorUpdate(k.PowerReduction(ctx)))
 
 			k.SetLastValidatorPower(ctx, valAddr, newPower)
 		}
diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go
index edb00ddba55b..591ab374d7ab 100644
--- a/x/staking/keeper/validator.go
+++ b/x/staking/keeper/validator.go
@@ -118,19 +118,19 @@ func (k Keeper) SetValidatorByPowerIndex(ctx sdk.Context, validator types.Valida
 	}
 
 	store := ctx.KVStore(k.storeKey)
-	store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.GetOperator())
+	store.Set(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)), validator.GetOperator())
 }
 
 // validator index
 func (k Keeper) DeleteValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(types.GetValidatorsByPowerIndexKey(validator))
+	store.Delete(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)))
 }
 
 // validator index
 func (k Keeper) SetNewValidatorByPowerIndex(ctx sdk.Context, validator types.Validator) {
 	store := ctx.KVStore(k.storeKey)
-	store.Set(types.GetValidatorsByPowerIndexKey(validator), validator.GetOperator())
+	store.Set(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)), validator.GetOperator())
 }
 
 // Update the tokens of an existing validator, update the validators power index key
@@ -210,7 +210,7 @@ func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.ValAddress) {
 	store := ctx.KVStore(k.storeKey)
 	store.Delete(types.GetValidatorKey(address))
 	store.Delete(types.GetValidatorByConsAddrKey(valConsAddr))
-	store.Delete(types.GetValidatorsByPowerIndexKey(validator))
+	store.Delete(types.GetValidatorsByPowerIndexKey(validator, k.PowerReduction(ctx)))
 
 	// call hooks
 	k.AfterValidatorRemoved(ctx, valConsAddr, validator.GetOperator())
diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go
index ae98c177ef30..4d847977c91a 100644
--- a/x/staking/keeper/validator_test.go
+++ b/x/staking/keeper/validator_test.go
@@ -30,7 +30,7 @@ func bootstrapValidatorTest(t *testing.T, power int64, numAddrs int) (*simapp.Si
 
 	addrDels, addrVals := generateAddresses(app, ctx, numAddrs)
 
-	amt := sdk.TokensFromConsensusPower(power)
+	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -49,7 +49,7 @@ func initValidators(t *testing.T, power int64, numAddrs int, powers []int64) (*s
 	vs := make([]types.Validator, len(powers))
 	for i, power := range powers {
 		vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		vs[i], _ = vs[i].AddTokensFromDel(tokens)
 	}
 	return app, ctx, addrs, valAddrs, vs
@@ -60,7 +60,7 @@ func TestSetValidator(t *testing.T) {
 
 	valPubKey := PKs[0]
 	valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
-	valTokens := sdk.TokensFromConsensusPower(10)
+	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 
 	// test how the validator is set from a purely unbonbed pool
 	validator := teststaking.NewValidator(t, valAddr, valPubKey)
@@ -75,7 +75,7 @@ func TestSetValidator(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validator, found := app.StakingKeeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.Equal(t, validator.ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 
 	// after the save the validator should be bonded
 	require.Equal(t, types.Bonded, validator.Status)
@@ -114,10 +114,10 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@@ -125,28 +125,28 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 
 	// add a validator
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100))
+	validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction))
 	require.Equal(t, types.Unbonded, validator.Status)
-	require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
 	validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	require.Equal(t, sdk.TokensFromConsensusPower(100), validator.Tokens)
+	require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens)
 
-	power := types.GetValidatorsByPowerIndexKey(validator)
+	power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	// burn half the delegator shares
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
 	validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2)))
-	require.Equal(t, sdk.TokensFromConsensusPower(50), burned)
+	require.Equal(t, sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction), burned)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) // update the validator, possibly kicking it out
 	require.False(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
 
-	power = types.GetValidatorsByPowerIndexKey(validator)
+	power = types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 }
 
@@ -166,10 +166,10 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	app.StakingKeeper.SetParams(ctx, params)
 
 	// create a random pool
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@@ -179,7 +179,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	for i := 0; i < len(validators); i++ {
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		val := newMonikerValidator(t, valAddrs[i], PKs[i], moniker)
-		delTokens := sdk.TokensFromConsensusPower(int64((i + 1) * 10))
+		delTokens := sdk.TokensFromConsensusPower(int64((i+1)*10), sdk.DefaultPowerReduction)
 		val, _ = val.AddTokensFromDel(delTokens)
 
 		val = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, val, true)
@@ -191,7 +191,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	// remove enough tokens to kick out the validator below the current cliff
 	// validator and next in line cliff validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal)
-	shares := sdk.TokensFromConsensusPower(21)
+	shares := sdk.TokensFromConsensusPower(21, sdk.DefaultPowerReduction)
 	nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec())
 	nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true)
 
@@ -220,7 +220,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
 
 	// add a validator
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	valTokens := sdk.TokensFromConsensusPower(100)
+	valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 
@@ -256,13 +256,13 @@ func TestValidatorBasics(t *testing.T) {
 		validators[i] = teststaking.NewValidator(t, addrVals[i], PKs[i])
 		validators[i].Status = types.Unbonded
 		validators[i].Tokens = sdk.ZeroInt()
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
-	assert.Equal(t, sdk.TokensFromConsensusPower(9), validators[0].Tokens)
-	assert.Equal(t, sdk.TokensFromConsensusPower(8), validators[1].Tokens)
-	assert.Equal(t, sdk.TokensFromConsensusPower(7), validators[2].Tokens)
+	assert.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].Tokens)
+	assert.Equal(t, sdk.TokensFromConsensusPower(8, sdk.DefaultPowerReduction), validators[1].Tokens)
+	assert.Equal(t, sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction), validators[2].Tokens)
 
 	// check the empty keeper first
 	_, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
@@ -292,11 +292,11 @@ func TestValidatorBasics(t *testing.T) {
 	require.Equal(t, 1, len(resVals))
 	assert.True(ValEq(t, validators[0], resVals[0]))
 	assert.Equal(t, types.Bonded, validators[0].Status)
-	assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9), validators[0].BondedTokens()))
+	assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].BondedTokens()))
 
 	// modify a records, save, and retrieve
 	validators[0].Status = types.Bonded
-	validators[0].Tokens = sdk.TokensFromConsensusPower(10)
+	validators[0].Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validators[0].DelegatorShares = validators[0].Tokens.ToDec()
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
 	resVal, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
@@ -351,10 +351,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	// initialize some validators into the state
 	amts := []sdk.Int{
 		sdk.NewIntFromUint64(0),
-		sdk.PowerReduction.MulRaw(100),
-		sdk.PowerReduction,
-		sdk.PowerReduction.MulRaw(400),
-		sdk.PowerReduction.MulRaw(200)}
+		sdk.DefaultPowerReduction.MulRaw(100),
+		sdk.DefaultPowerReduction,
+		sdk.DefaultPowerReduction.MulRaw(400),
+		sdk.DefaultPowerReduction.MulRaw(200)}
 	n := len(amts)
 	var validators [5]types.Validator
 	for i, amt := range amts {
@@ -368,10 +368,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	// first make sure everything made it in to the gotValidator group
 	resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	assert.Equal(t, n, len(resValidators))
-	assert.Equal(t, sdk.NewInt(400).Mul(sdk.PowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(200).Mul(sdk.PowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(100).Mul(sdk.PowerReduction), resValidators[2].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(1).Mul(sdk.PowerReduction), resValidators[3].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(100).Mul(sdk.DefaultPowerReduction), resValidators[2].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(1).Mul(sdk.DefaultPowerReduction), resValidators[3].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
 	assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
@@ -380,14 +380,14 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.Equal(t, validators[0].OperatorAddress, resValidators[4].OperatorAddress, "%v", resValidators)
 
 	// test a basic increase in voting power
-	validators[3].Tokens = sdk.NewInt(500).Mul(sdk.PowerReduction)
+	validators[3].Tokens = sdk.NewInt(500).Mul(sdk.DefaultPowerReduction)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
 	assert.True(ValEq(t, validators[3], resValidators[0]))
 
 	// test a decrease in voting power
-	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction)
+	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
@@ -395,7 +395,7 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], resValidators[1]))
 
 	// test equal voting power, different age
-	validators[3].Tokens = sdk.NewInt(200).Mul(sdk.PowerReduction)
+	validators[3].Tokens = sdk.NewInt(200).Mul(sdk.DefaultPowerReduction)
 	ctx = ctx.WithBlockHeight(10)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@@ -412,8 +412,8 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], resValidators[1]))
 
 	// change in voting power of both validators, both still in v-set, no age change
-	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction)
-	validators[4].Tokens = sdk.NewInt(300).Mul(sdk.PowerReduction)
+	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
+	validators[4].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
@@ -430,10 +430,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -447,10 +447,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	// initialize some validators into the state
 	amts := []sdk.Int{
 		sdk.NewIntFromUint64(0),
-		sdk.PowerReduction.MulRaw(100),
-		sdk.PowerReduction,
-		sdk.PowerReduction.MulRaw(400),
-		sdk.PowerReduction.MulRaw(200)}
+		sdk.DefaultPowerReduction.MulRaw(100),
+		sdk.DefaultPowerReduction,
+		sdk.DefaultPowerReduction.MulRaw(400),
+		sdk.DefaultPowerReduction.MulRaw(200)}
 
 	var validators [5]types.Validator
 	for i, amt := range amts {
@@ -481,8 +481,8 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	// The validators returned should match the max validators
 	assert.Equal(t, 2, len(resValidators))
-	assert.Equal(t, sdk.NewInt(400).Mul(sdk.PowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(200).Mul(sdk.PowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
 	assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
 }
@@ -504,7 +504,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		validators[i] = newMonikerValidator(t, sdk.ValAddress(addrs[i]), PKs[i], moniker)
 
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -523,7 +523,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 
 	// delegate 500 tokens to validator 0
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	delTokens := sdk.TokensFromConsensusPower(500)
+	delTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].AddTokensFromDel(delTokens)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
@@ -558,10 +558,10 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	validators[3], found = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
 	assert.True(t, found)
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[3])
-	validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1))
+	validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))
 
 	notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
-	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1)))
+	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)))
 	balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress())
 	require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...)))
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -620,9 +620,9 @@ func TestValidatorBondHeight(t *testing.T) {
 	validators[1] = teststaking.NewValidator(t, sdk.ValAddress(addrs[1]), PKs[1])
 	validators[2] = teststaking.NewValidator(t, sdk.ValAddress(addrs[2]), PKs[2])
 
-	tokens0 := sdk.TokensFromConsensusPower(200)
-	tokens1 := sdk.TokensFromConsensusPower(100)
-	tokens2 := sdk.TokensFromConsensusPower(100)
+	tokens0 := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	tokens1 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	tokens2 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens0)
 	validators[1], _ = validators[1].AddTokensFromDel(tokens1)
 	validators[2], _ = validators[2].AddTokensFromDel(tokens2)
@@ -642,7 +642,7 @@ func TestValidatorBondHeight(t *testing.T) {
 	assert.True(ValEq(t, validators[1], resValidators[1]))
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[2])
-	delTokens := sdk.TokensFromConsensusPower(50)
+	delTokens := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction)
 	validators[1], _ = validators[1].AddTokensFromDel(delTokens)
 	validators[2], _ = validators[2].AddTokensFromDel(delTokens)
 	validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true)
@@ -665,7 +665,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 	var validators [5]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 		keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true)
 	}
@@ -686,7 +686,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 
 	// test a swap in voting power
 
-	tokens := sdk.TokensFromConsensusPower(600)
+	tokens := sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@@ -705,7 +705,7 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 
@@ -720,8 +720,8 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	assert.Equal(t, validators[0].ABCIValidatorUpdate(), updates[1])
-	assert.Equal(t, validators[1].ABCIValidatorUpdate(), updates[0])
+	assert.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	assert.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
@@ -732,7 +732,7 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
 
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 	}
@@ -755,7 +755,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
 
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 	}
@@ -766,11 +766,11 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	// test single value change
 	//  tendermintUpdate set: {} -> {c1'}
 	validators[0].Status = types.Bonded
-	validators[0].Tokens = sdk.TokensFromConsensusPower(600)
+	validators[0].Tokens = sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
@@ -784,16 +784,16 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
 
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
-	delTokens1 := sdk.TokensFromConsensusPower(190)
-	delTokens2 := sdk.TokensFromConsensusPower(80)
+	delTokens1 := sdk.TokensFromConsensusPower(190, sdk.DefaultPowerReduction)
+	delTokens2 := sdk.TokensFromConsensusPower(80, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].AddTokensFromDel(delTokens1)
 	validators[1], _ = validators[1].AddTokensFromDel(delTokens2)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 	validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
 
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
@@ -810,7 +810,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
-	require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 
 	// test validtor added at the beginning
 	//  tendermintUpdate set: {} -> {c0}
@@ -818,7 +818,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[3])
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[3], _ = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
-	require.Equal(t, validators[3].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[3].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 
 	// test validtor added at the end
 	//  tendermintUpdate set: {} -> {c0}
@@ -826,7 +826,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[4])
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[4], _ = app.StakingKeeper.GetValidator(ctx, validators[4].GetOperator())
-	require.Equal(t, validators[4].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[4].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
@@ -839,7 +839,7 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	var validators [5]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@@ -855,14 +855,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	//  tendermintUpdate set: {}     -> {c0, c4}
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
-	tokens := sdk.TokensFromConsensusPower(10)
+	tokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	validators[2], _ = validators[2].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[2])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
 	require.Equal(t, validators[0].ABCIValidatorUpdateZero(), updates[1])
-	require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
@@ -872,7 +872,7 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	var validators [2]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@@ -880,26 +880,26 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 
 	// check initial power
-	require.Equal(t, int64(100), validators[0].GetConsensusPower())
-	require.Equal(t, int64(100), validators[1].GetConsensusPower())
+	require.Equal(t, int64(100), validators[0].GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(100), validators[1].GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
-	delTokens1 := sdk.TokensFromConsensusPower(20)
-	delTokens2 := sdk.TokensFromConsensusPower(30)
+	delTokens1 := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+	delTokens2 := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec())
 	validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec())
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 	validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
 
 	// power has changed
-	require.Equal(t, int64(80), validators[0].GetConsensusPower())
-	require.Equal(t, int64(70), validators[1].GetConsensusPower())
+	require.Equal(t, int64(80), validators[0].GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(70), validators[1].GetConsensusPower(sdk.DefaultPowerReduction))
 
 	// Tendermint updates should reflect power change
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
@@ -918,7 +918,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		app.StakingKeeper.SetValidator(ctx, validators[i])
@@ -929,8 +929,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, len(validators))
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
@@ -938,7 +938,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	for i, power := range powers {
 
 		app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i])
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		app.StakingKeeper.SetValidator(ctx, validators[i])
@@ -965,7 +965,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
 
 	validator = teststaking.NewValidator(t, valAddr, valPubKey)
-	tokens := sdk.TokensFromConsensusPower(500)
+	tokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction)
 	validator, _ = validator.AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validator)
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator)
@@ -975,9 +975,9 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	validator, _ = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validator.ABCIValidatorUpdate(), updates[0])
-	require.Equal(t, validators[0].ABCIValidatorUpdate(), updates[1])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[2])
+	require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[2])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
@@ -997,7 +997,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
-		tokens := sdk.TokensFromConsensusPower(power)
+		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 		app.StakingKeeper.SetValidator(ctx, validators[i])
 		app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i])
@@ -1007,8 +1007,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validators[2].ABCIValidatorUpdate(), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[1])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
@@ -1020,7 +1020,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	require.True(t, found)
 
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	tokens := sdk.TokensFromConsensusPower(1)
+	tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[0])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0])
@@ -1042,14 +1042,14 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
-	tokens = sdk.TokensFromConsensusPower(250)
+	tokens = sdk.TokensFromConsensusPower(250, sdk.DefaultPowerReduction)
 	validators[1], _ = validators[1].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[1])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[1])
 
 	// verify initial Tendermint updates are correct
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
-	require.Equal(t, validators[1].ABCIValidatorUpdate(), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 }
diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go
index b0746fa363a4..87ec0000efb7 100644
--- a/x/staking/legacy/v040/migrate.go
+++ b/x/staking/legacy/v040/migrate.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	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"
@@ -129,6 +130,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			MaxEntries:        uint32(stakingState.Params.MaxEntries),
 			HistoricalEntries: uint32(stakingState.Params.HistoricalEntries),
 			BondDenom:         stakingState.Params.BondDenom,
+			PowerReduction:    sdk.DefaultPowerReduction,
 		},
 		LastTotalPower:       stakingState.LastTotalPower,
 		LastValidatorPowers:  newLastValidatorPowers,
diff --git a/x/staking/simulation/common_test.go b/x/staking/simulation/common_test.go
index 880cb442deff..e22ecd15aa2c 100644
--- a/x/staking/simulation/common_test.go
+++ b/x/staking/simulation/common_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func init() {
-	sdk.PowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
+	sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil))
 }
diff --git a/x/staking/simulation/genesis.go b/x/staking/simulation/genesis.go
index 0c33fa9ee282..bf01b90bfe9c 100644
--- a/x/staking/simulation/genesis.go
+++ b/x/staking/simulation/genesis.go
@@ -63,7 +63,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 	// NOTE: the slashing module need to be defined after the staking module on the
 	// NewSimulationManager constructor for this to work
 	simState.UnbondTime = unbondTime
-	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, sdk.DefaultBondDenom)
+	params := types.NewParams(simState.UnbondTime, maxVals, 7, histEntries, sdk.DefaultBondDenom, sdk.DefaultPowerReduction)
 
 	// validators & delegations
 	var (
diff --git a/x/staking/simulation/genesis_test.go b/x/staking/simulation/genesis_test.go
index aba85cd2bf5f..35e59b6c2342 100644
--- a/x/staking/simulation/genesis_test.go
+++ b/x/staking/simulation/genesis_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking/simulation"
@@ -46,6 +47,7 @@ func TestRandomizedGenState(t *testing.T) {
 	require.Equal(t, uint32(8687), stakingGenesis.Params.HistoricalEntries)
 	require.Equal(t, "stake", stakingGenesis.Params.BondDenom)
 	require.Equal(t, float64(238280), stakingGenesis.Params.UnbondingTime.Seconds())
+	require.Equal(t, sdk.NewInt(1000000), stakingGenesis.Params.PowerReduction)
 	// check numbers of Delegations and Validators
 	require.Len(t, stakingGenesis.Delegations, 3)
 	require.Len(t, stakingGenesis.Validators, 3)
diff --git a/x/staking/simulation/operations_test.go b/x/staking/simulation/operations_test.go
index fca3b78125a9..6ca1886bf592 100644
--- a/x/staking/simulation/operations_test.go
+++ b/x/staking/simulation/operations_test.go
@@ -181,7 +181,7 @@ func TestSimulateMsgUndelegate(t *testing.T) {
 	validator0 := getTestingValidator0(t, app, ctx, accounts)
 
 	// setup delegation
-	delTokens := sdk.TokensFromConsensusPower(2)
+	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	delegator := accounts[1]
 	delegation := types.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@@ -227,7 +227,7 @@ func TestSimulateMsgBeginRedelegate(t *testing.T) {
 	validator0 := getTestingValidator0(t, app, ctx, accounts)
 	validator1 := getTestingValidator1(t, app, ctx, accounts)
 
-	delTokens := sdk.TokensFromConsensusPower(2)
+	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 
 	// setup accounts[2] as delegator
@@ -276,7 +276,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
@@ -309,7 +309,7 @@ func getTestingValidator(t *testing.T, app *simapp.SimApp, ctx sdk.Context, acco
 	require.NoError(t, err)
 
 	validator.DelegatorShares = sdk.NewDec(100)
-	validator.Tokens = sdk.TokensFromConsensusPower(100)
+	validator.Tokens = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
 
 	app.StakingKeeper.SetValidator(ctx, validator)
 
diff --git a/x/staking/spec/01_state.md b/x/staking/spec/01_state.md
index c5f7376d7655..c0aae9943bc9 100644
--- a/x/staking/spec/01_state.md
+++ b/x/staking/spec/01_state.md
@@ -19,10 +19,11 @@ and defines overall functioning of the staking module.
 
 ```go
 type Params struct {
-    UnbondingTime time.Duration // time duration of unbonding
-    MaxValidators uint16        // maximum number of validators
-    MaxEntries    uint16        // max entries for either unbonding delegation or redelegation (per pair/trio)
-    BondDenom     string        // bondable coin denomination
+    UnbondingTime  time.Duration // time duration of unbonding
+    MaxValidators  uint16        // maximum number of validators
+    MaxEntries     uint16        // max entries for either unbonding delegation or redelegation (per pair/trio)
+    BondDenom      string        // bondable coin denomination
+    PowerReduction sdk.Int       // power reduction on-chain param
 }
 ```
 
diff --git a/x/staking/spec/08_params.md b/x/staking/spec/08_params.md
index 3d87879e18a0..706f41fc35e4 100644
--- a/x/staking/spec/08_params.md
+++ b/x/staking/spec/08_params.md
@@ -13,3 +13,4 @@ The staking module contains the following parameters:
 | KeyMaxEntries     | uint16           | 7                 |
 | HistoricalEntries | uint16           | 3                 |
 | BondDenom         | string           | "uatom"           |
+| PowerReduction    | string           | "1000000"         |
diff --git a/x/staking/teststaking/helper.go b/x/staking/teststaking/helper.go
index b33118f541fd..607ad56ada4c 100644
--- a/x/staking/teststaking/helper.go
+++ b/x/staking/teststaking/helper.go
@@ -40,7 +40,7 @@ func (sh *Helper) CreateValidator(addr sdk.ValAddress, pk cryptotypes.PubKey, st
 // CreateValidatorWithValPower calls handler to create a new staking validator with zero
 // commission
 func (sh *Helper) CreateValidatorWithValPower(addr sdk.ValAddress, pk cryptotypes.PubKey, valPower int64, ok bool) sdk.Int {
-	amount := sdk.TokensFromConsensusPower(valPower)
+	amount := sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction)
 	coin := sdk.NewCoin(sh.Denom, amount)
 	sh.createValidator(addr, pk, coin, ok)
 	return amount
@@ -69,7 +69,7 @@ func (sh *Helper) Delegate(delegator sdk.AccAddress, val sdk.ValAddress, amount
 
 // DelegateWithPower calls handler to delegate stake for a validator
 func (sh *Helper) DelegateWithPower(delegator sdk.AccAddress, val sdk.ValAddress, power int64) {
-	coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power))
+	coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction))
 	msg := stakingtypes.NewMsgDelegate(delegator, val, coin)
 	sh.Handle(msg, true)
 }
diff --git a/x/staking/teststaking/tm.go b/x/staking/teststaking/tm.go
index 9a9c030d061c..4c0863f593cd 100644
--- a/x/staking/teststaking/tm.go
+++ b/x/staking/teststaking/tm.go
@@ -5,6 +5,7 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"
 
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
@@ -19,21 +20,21 @@ func GetTmConsPubKey(v types.Validator) (tmcrypto.PubKey, error) {
 }
 
 // ToTmValidator casts an SDK validator to a tendermint type Validator.
-func ToTmValidator(v types.Validator) (*tmtypes.Validator, error) {
+func ToTmValidator(v types.Validator, powerReduction sdk.Int) (*tmtypes.Validator, error) {
 	tmPk, err := GetTmConsPubKey(v)
 	if err != nil {
 		return nil, err
 	}
 
-	return tmtypes.NewValidator(tmPk, v.ConsensusPower()), nil
+	return tmtypes.NewValidator(tmPk, v.ConsensusPower(powerReduction)), nil
 }
 
 // ToTmValidators casts all validators to the corresponding tendermint type.
-func ToTmValidators(v types.Validators) ([]*tmtypes.Validator, error) {
+func ToTmValidators(v types.Validators, powerReduction sdk.Int) ([]*tmtypes.Validator, error) {
 	validators := make([]*tmtypes.Validator, len(v))
 	var err error
 	for i, val := range v {
-		validators[i], err = ToTmValidator(val)
+		validators[i], err = ToTmValidator(val, powerReduction)
 		if err != nil {
 			return nil, err
 		}
diff --git a/x/staking/types/exported.go b/x/staking/types/exported.go
index a02adc34bade..9599da100d20 100644
--- a/x/staking/types/exported.go
+++ b/x/staking/types/exported.go
@@ -28,7 +28,7 @@ type ValidatorI interface {
 	GetConsAddr() (sdk.ConsAddress, error)                  // validation consensus address
 	GetTokens() sdk.Int                                     // validation tokens
 	GetBondedTokens() sdk.Int                               // validator bonded tokens
-	GetConsensusPower() int64                               // validation power in tendermint
+	GetConsensusPower(sdk.Int) 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
diff --git a/x/staking/types/historical_info.go b/x/staking/types/historical_info.go
index 1a8461ad130c..c06e82dc0261 100644
--- a/x/staking/types/historical_info.go
+++ b/x/staking/types/historical_info.go
@@ -8,14 +8,18 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // NewHistoricalInfo will create a historical information struct from header and valset
 // it will first sort valset before inclusion into historical info
-func NewHistoricalInfo(header tmproto.Header, valSet Validators) HistoricalInfo {
+func NewHistoricalInfo(header tmproto.Header, valSet Validators, powerReduction sdk.Int) HistoricalInfo {
 	// Must sort in the same way that tendermint does
-	sort.Sort(ValidatorsByVotingPower(valSet))
+	// TODO: check with sort.Sort(ValidatorsByVotingPower(valSet))
+	sort.SliceStable(valSet, func(i, j int) bool {
+		return ValidatorsByVotingPower(valSet).LessAfterPowerReductionApply(i, j, powerReduction)
+	})
 
 	return HistoricalInfo{
 		Header: header,
diff --git a/x/staking/types/historical_info_test.go b/x/staking/types/historical_info_test.go
index d8a25fa92924..b465a3db6ae5 100644
--- a/x/staking/types/historical_info_test.go
+++ b/x/staking/types/historical_info_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/require"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
@@ -26,7 +27,7 @@ func createValidators(t *testing.T) []types.Validator {
 
 func TestHistoricalInfo(t *testing.T) {
 	validators := createValidators(t)
-	hi := types.NewHistoricalInfo(header, validators)
+	hi := types.NewHistoricalInfo(header, validators, sdk.DefaultPowerReduction)
 	require.True(t, sort.IsSorted(types.Validators(hi.Valset)), "Validators are not sorted")
 
 	var value []byte
@@ -67,7 +68,7 @@ func TestValidateBasic(t *testing.T) {
 	err = types.ValidateBasic(hi)
 	require.Error(t, err, "ValidateBasic passed on unsorted ValSet")
 
-	hi = types.NewHistoricalInfo(header, validators)
+	hi = types.NewHistoricalInfo(header, validators, sdk.DefaultPowerReduction)
 	err = types.ValidateBasic(hi)
 	require.NoError(t, err, "ValidateBasic failed on valid HistoricalInfo")
 }
diff --git a/x/staking/types/keys.go b/x/staking/types/keys.go
index 40d62244a041..abdbe8ccff1b 100644
--- a/x/staking/types/keys.go
+++ b/x/staking/types/keys.go
@@ -69,11 +69,11 @@ func AddressFromLastValidatorPowerKey(key []byte) []byte {
 // Power index is the key used in the power-store, and represents the relative
 // power ranking of the validator.
 // VALUE: validator operator address ([]byte)
-func GetValidatorsByPowerIndexKey(validator Validator) []byte {
+func GetValidatorsByPowerIndexKey(validator Validator, powerReduction sdk.Int) []byte {
 	// NOTE the address doesn't need to be stored because counter bytes must always be different
 	// NOTE the larger values are of higher value
 
-	consensusPower := sdk.TokensToConsensusPower(validator.Tokens)
+	consensusPower := sdk.TokensToConsensusPower(validator.Tokens, powerReduction)
 	consensusPowerBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(consensusPowerBytes, uint64(consensusPower))
 
diff --git a/x/staking/types/keys_test.go b/x/staking/types/keys_test.go
index 0f63617f26b3..0bd7a7c20bb7 100644
--- a/x/staking/types/keys_test.go
+++ b/x/staking/types/keys_test.go
@@ -28,10 +28,10 @@ func TestGetValidatorPowerRank(t *testing.T) {
 	val1 := newValidator(t, valAddr1, keysPK1)
 	val1.Tokens = sdk.ZeroInt()
 	val2, val3, val4 := val1, val1, val1
-	val2.Tokens = sdk.TokensFromConsensusPower(1)
-	val3.Tokens = sdk.TokensFromConsensusPower(10)
+	val2.Tokens = sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+	val3.Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 	x := new(big.Int).Exp(big.NewInt(2), big.NewInt(40), big.NewInt(0))
-	val4.Tokens = sdk.TokensFromConsensusPower(x.Int64())
+	val4.Tokens = sdk.TokensFromConsensusPower(x.Int64(), sdk.DefaultPowerReduction)
 
 	tests := []struct {
 		validator types.Validator
@@ -43,7 +43,7 @@ func TestGetValidatorPowerRank(t *testing.T) {
 		{val4, "2300000100000000009c288ede7df62742fc3b7d0962045a8cef0f79f6"},
 	}
 	for i, tt := range tests {
-		got := hex.EncodeToString(types.GetValidatorsByPowerIndexKey(tt.validator))
+		got := hex.EncodeToString(types.GetValidatorsByPowerIndexKey(tt.validator, sdk.DefaultPowerReduction))
 
 		require.Equal(t, tt.wantHex, got, "Keys did not match on test case %d", i)
 	}
diff --git a/x/staking/types/params.go b/x/staking/types/params.go
index 549189fa4f69..92fb0dad898d 100644
--- a/x/staking/types/params.go
+++ b/x/staking/types/params.go
@@ -38,6 +38,7 @@ var (
 	KeyMaxEntries        = []byte("MaxEntries")
 	KeyBondDenom         = []byte("BondDenom")
 	KeyHistoricalEntries = []byte("HistoricalEntries")
+	KeyPowerReduction    = []byte("PowerReduction")
 )
 
 var _ paramtypes.ParamSet = (*Params)(nil)
@@ -48,13 +49,14 @@ func ParamKeyTable() paramtypes.KeyTable {
 }
 
 // NewParams creates a new Params instance
-func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string) Params {
+func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, powerReduction sdk.Int) Params {
 	return Params{
 		UnbondingTime:     unbondingTime,
 		MaxValidators:     maxValidators,
 		MaxEntries:        maxEntries,
 		HistoricalEntries: historicalEntries,
 		BondDenom:         bondDenom,
+		PowerReduction:    powerReduction,
 	}
 }
 
@@ -66,6 +68,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(KeyMaxEntries, &p.MaxEntries, validateMaxEntries),
 		paramtypes.NewParamSetPair(KeyHistoricalEntries, &p.HistoricalEntries, validateHistoricalEntries),
 		paramtypes.NewParamSetPair(KeyBondDenom, &p.BondDenom, validateBondDenom),
+		paramtypes.NewParamSetPair(KeyPowerReduction, &p.PowerReduction, validatePowerReduction),
 	}
 }
 
@@ -77,6 +80,7 @@ func DefaultParams() Params {
 		DefaultMaxEntries,
 		DefaultHistoricalEntries,
 		sdk.DefaultBondDenom,
+		sdk.DefaultPowerReduction,
 	)
 }
 
@@ -191,3 +195,16 @@ func validateBondDenom(i interface{}) error {
 
 	return nil
 }
+
+func validatePowerReduction(i interface{}) error {
+	v, ok := i.(sdk.Int)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", i)
+	}
+
+	if v.LT(sdk.NewInt(1)) {
+		return fmt.Errorf("power reduction cannot be lower than 1")
+	}
+
+	return nil
+}
diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go
index e551e752528c..5cf55db5d636 100644
--- a/x/staking/types/validator.go
+++ b/x/staking/types/validator.go
@@ -117,7 +117,11 @@ type ValidatorsByVotingPower []Validator
 func (valz ValidatorsByVotingPower) Len() int { return len(valz) }
 
 func (valz ValidatorsByVotingPower) Less(i, j int) bool {
-	if valz[i].ConsensusPower() == valz[j].ConsensusPower() {
+	return valz.LessAfterPowerReductionApply(i, j, sdk.DefaultPowerReduction)
+}
+
+func (valz ValidatorsByVotingPower) LessAfterPowerReductionApply(i, j int, powerReduction sdk.Int) bool {
+	if valz[i].ConsensusPower(powerReduction) == valz[j].ConsensusPower(powerReduction) {
 		addrI, errI := valz[i].GetConsAddr()
 		addrJ, errJ := valz[j].GetConsAddr()
 		// If either returns error, then return false
@@ -126,7 +130,7 @@ func (valz ValidatorsByVotingPower) Less(i, j int) bool {
 		}
 		return bytes.Compare(addrI, addrJ) == -1
 	}
-	return valz[i].ConsensusPower() > valz[j].ConsensusPower()
+	return valz[i].ConsensusPower(powerReduction) > valz[j].ConsensusPower(powerReduction)
 }
 
 func (valz ValidatorsByVotingPower) Swap(i, j int) {
@@ -257,7 +261,7 @@ func (d Description) EnsureLength() (Description, error) {
 
 // ABCIValidatorUpdate returns an abci.ValidatorUpdate from a staking validator type
 // with the full validator power
-func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate {
+func (v Validator) ABCIValidatorUpdate(powerReduction sdk.Int) abci.ValidatorUpdate {
 	tmProtoPk, err := v.TmConsPublicKey()
 	if err != nil {
 		panic(err)
@@ -265,7 +269,7 @@ func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate {
 
 	return abci.ValidatorUpdate{
 		PubKey: tmProtoPk,
-		Power:  v.ConsensusPower(),
+		Power:  v.ConsensusPower(powerReduction),
 	}
 }
 
@@ -349,17 +353,17 @@ func (v Validator) BondedTokens() sdk.Int {
 
 // ConsensusPower gets the consensus-engine power. Aa reduction of 10^6 from
 // validator tokens is applied
-func (v Validator) ConsensusPower() int64 {
+func (v Validator) ConsensusPower(powerReduction sdk.Int) int64 {
 	if v.IsBonded() {
-		return v.PotentialConsensusPower()
+		return v.PotentialConsensusPower(powerReduction)
 	}
 
 	return 0
 }
 
 // PotentialConsensusPower returns the potential consensus-engine power.
-func (v Validator) PotentialConsensusPower() int64 {
-	return sdk.TokensToConsensusPower(v.Tokens)
+func (v Validator) PotentialConsensusPower(powerReduction sdk.Int) int64 {
+	return sdk.TokensToConsensusPower(v.Tokens, powerReduction)
 }
 
 // UpdateStatus updates the location of the shares within a validator
@@ -505,9 +509,11 @@ func (v Validator) GetConsAddr() (sdk.ConsAddress, error) {
 	return sdk.ConsAddress(pk.Address()), nil
 }
 
-func (v Validator) GetTokens() sdk.Int            { return v.Tokens }
-func (v Validator) GetBondedTokens() sdk.Int      { return v.BondedTokens() }
-func (v Validator) GetConsensusPower() int64      { return v.ConsensusPower() }
+func (v Validator) GetTokens() sdk.Int       { return v.Tokens }
+func (v Validator) GetBondedTokens() sdk.Int { return v.BondedTokens() }
+func (v Validator) GetConsensusPower(powerReduction sdk.Int) int64 {
+	return v.ConsensusPower(powerReduction)
+}
 func (v Validator) GetCommission() sdk.Dec        { return v.Commission.Rate }
 func (v Validator) GetMinSelfDelegation() sdk.Int { return v.MinSelfDelegation }
 func (v Validator) GetDelegatorShares() sdk.Dec   { return v.DelegatorShares }
diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go
index 08204215d595..f7888b7e425f 100644
--- a/x/staking/types/validator_test.go
+++ b/x/staking/types/validator_test.go
@@ -58,7 +58,7 @@ func TestUpdateDescription(t *testing.T) {
 
 func TestABCIValidatorUpdate(t *testing.T) {
 	validator := newValidator(t, valAddr1, pk1)
-	abciVal := validator.ABCIValidatorUpdate()
+	abciVal := validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction)
 	pk, err := validator.TmConsPublicKey()
 	require.NoError(t, err)
 	require.Equal(t, pk, abciVal.PubKey)
@@ -290,13 +290,13 @@ func TestValidatorsSortTendermint(t *testing.T) {
 	valz := types.Validators(vals)
 
 	// create expected tendermint validators by converting to tendermint then sorting
-	expectedVals, err := teststaking.ToTmValidators(valz)
+	expectedVals, err := teststaking.ToTmValidators(valz, sdk.DefaultPowerReduction)
 	require.NoError(t, err)
 	sort.Sort(tmtypes.ValidatorsByVotingPower(expectedVals))
 
 	// sort in SDK and then convert to tendermint
 	sort.Sort(types.ValidatorsByVotingPower(valz))
-	actualVals, err := teststaking.ToTmValidators(valz)
+	actualVals, err := teststaking.ToTmValidators(valz, sdk.DefaultPowerReduction)
 	require.NoError(t, err)
 
 	require.Equal(t, expectedVals, actualVals, "sorting in SDK is not the same as sorting in Tendermint")
@@ -314,9 +314,9 @@ func TestValidatorToTm(t *testing.T) {
 		vals[i] = val
 		tmPk, err := cryptocodec.ToTmPubKeyInterface(pk)
 		require.NoError(t, err)
-		expected[i] = tmtypes.NewValidator(tmPk, val.ConsensusPower())
+		expected[i] = tmtypes.NewValidator(tmPk, val.ConsensusPower(sdk.DefaultPowerReduction))
 	}
-	vs, err := teststaking.ToTmValidators(vals)
+	vs, err := teststaking.ToTmValidators(vals, sdk.DefaultPowerReduction)
 	require.NoError(t, err)
 	require.Equal(t, expected, vs)
 }

From cb17feddc047fd174dba626888d7de7aae640e9e Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Thu, 28 Jan 2021 23:54:39 +1000
Subject: [PATCH 03/23] use on-chain params on tests + fix tests + add new
 tests for power reduction change

---
 client/flags/flags.go                        |   2 +-
 x/authz/simulation/operations_test.go        |   6 +-
 x/bank/keeper/keeper_test.go                 |   2 +-
 x/bank/simulation/operations_test.go         |   2 +-
 x/distribution/keeper/delegation_test.go     |  14 +-
 x/distribution/keeper/keeper_test.go         |   2 +-
 x/distribution/simulation/operations_test.go |   4 +-
 x/gov/abci_test.go                           |   6 +-
 x/gov/keeper/common_test.go                  |   6 +-
 x/gov/keeper/deposit_test.go                 |   4 +-
 x/gov/keeper/grpc_query_test.go              |   8 +-
 x/gov/keeper/querier_test.go                 |   2 +-
 x/gov/keeper/tally_test.go                   |  20 +-
 x/gov/simulation/operations_test.go          |   2 +-
 x/ibc/core/02-client/keeper/keeper_test.go   |   2 +-
 x/slashing/abci_test.go                      |   2 +-
 x/slashing/genesis_test.go                   |   2 +-
 x/slashing/handler_test.go                   |  10 +-
 x/slashing/keeper/grpc_query_test.go         |   2 +-
 x/slashing/keeper/keeper_test.go             |  16 +-
 x/slashing/keeper/signing_info_test.go       |   8 +-
 x/slashing/simulation/operations_test.go     |   4 +-
 x/staking/client/cli/cli_test.go             |   3 +-
 x/staking/genesis_test.go                    |  12 +-
 x/staking/handler_test.go                    |  65 ++++++-
 x/staking/keeper/delegation_test.go          |  52 ++---
 x/staking/keeper/grpc_query_test.go          |  18 +-
 x/staking/keeper/historical_info_test.go     |   6 +-
 x/staking/keeper/keeper_test.go              |   2 +-
 x/staking/keeper/power_reduction_test.go     |  19 +-
 x/staking/keeper/querier_test.go             |  34 ++--
 x/staking/keeper/slash.go                    |   2 +-
 x/staking/keeper/slash_test.go               |  48 ++---
 x/staking/keeper/validator_test.go           | 188 +++++++++----------
 x/staking/legacy/v040/migrate_test.go        |   1 +
 x/staking/simulation/genesis_test.go         |   2 +-
 x/staking/simulation/operations_test.go      |   8 +-
 x/staking/teststaking/helper.go              |   4 +-
 38 files changed, 322 insertions(+), 268 deletions(-)

diff --git a/client/flags/flags.go b/client/flags/flags.go
index 282a61c4c9fb..bf861dbf0d60 100644
--- a/client/flags/flags.go
+++ b/client/flags/flags.go
@@ -15,7 +15,7 @@ const (
 	// failures due to state changes that might occur between the tx simulation
 	// and the actual run.
 	DefaultGasAdjustment = 1.0
-	DefaultGasLimit      = 200000
+	DefaultGasLimit      = 300000
 	GasFlagAuto          = "auto"
 
 	// DefaultKeyringBackend
diff --git a/x/authz/simulation/operations_test.go b/x/authz/simulation/operations_test.go
index e8686f166a72..a21f0158667a 100644
--- a/x/authz/simulation/operations_test.go
+++ b/x/authz/simulation/operations_test.go
@@ -72,7 +72,7 @@ func (suite *SimTestSuite) TestWeightedOperations() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
+	initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	// add coins to the accounts
@@ -132,7 +132,7 @@ func (suite *SimTestSuite) TestSimulateRevokeAuthorization() {
 			AppHash: suite.app.LastCommitID().Hash,
 		}})
 
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
+	initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	granter := accounts[0]
@@ -167,7 +167,7 @@ func (suite *SimTestSuite) TestSimulateExecAuthorization() {
 	// begin a new block
 	suite.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}})
 
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
+	initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
 	initCoins := sdk.NewCoins(sdk.NewCoin("foo", initAmt))
 
 	granter := accounts[0]
diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go
index d57d60877a4b..b86887a9afd0 100644
--- a/x/bank/keeper/keeper_test.go
+++ b/x/bank/keeper/keeper_test.go
@@ -86,7 +86,7 @@ func (suite *IntegrationTestSuite) TestSupply() {
 	app, ctx := suite.app, suite.ctx
 
 	initialPower := int64(100)
-	initTokens := sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction)
+	initTokens := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, initialPower)
 
 	totalSupply := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
 	app.BankKeeper.SetSupply(ctx, types.NewSupply(totalSupply))
diff --git a/x/bank/simulation/operations_test.go b/x/bank/simulation/operations_test.go
index 5add9942cef7..94aeaaa682c9 100644
--- a/x/bank/simulation/operations_test.go
+++ b/x/bank/simulation/operations_test.go
@@ -124,7 +124,7 @@ func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/distribution/keeper/delegation_test.go b/x/distribution/keeper/delegation_test.go
index 0255a64ca3d9..eebacc44a4de 100644
--- a/x/distribution/keeper/delegation_test.go
+++ b/x/distribution/keeper/delegation_test.go
@@ -112,7 +112,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -175,7 +175,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial.ToDec()}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -269,11 +269,11 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
 }
 
 func TestWithdrawDelegationRewardsBasic(t *testing.T) {
-	balancePower := int64(1000)
-	balanceTokens := sdk.TokensFromConsensusPower(balancePower, sdk.DefaultPowerReduction)
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
+	balancePower := int64(1000)
+	balanceTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, balancePower)
 	addr := simapp.AddTestAddrs(app, ctx, 1, sdk.NewInt(1000000000))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addr)
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -305,7 +305,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
 	val := app.StakingKeeper.Validator(ctx, valAddrs[0])
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	tokens := sdk.DecCoins{sdk.NewDecCoin(sdk.DefaultBondDenom, initial)}
 
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@@ -375,7 +375,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec()
+	initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec()
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
@@ -431,7 +431,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 	del1 := app.StakingKeeper.Delegation(ctx, sdk.AccAddress(valAddrs[0]), valAddrs[0])
 
 	// allocate some rewards
-	initial := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction).ToDec()
+	initial := app.StakingKeeper.TokensFromConsensusPower(ctx, 30).ToDec()
 	tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
 	app.DistrKeeper.AllocateTokensToValidator(ctx, val, tokens)
 
diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go
index cd39dafaa72b..0791364f2b2e 100644
--- a/x/distribution/keeper/keeper_test.go
+++ b/x/distribution/keeper/keeper_test.go
@@ -57,7 +57,7 @@ func TestWithdrawValidatorCommission(t *testing.T) {
 
 	// check initial balance
 	balance := app.BankKeeper.GetAllBalances(ctx, sdk.AccAddress(valAddrs[0]))
-	expTokens := sdk.TokensFromConsensusPower(1000, sdk.DefaultPowerReduction)
+	expTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1000)
 	expCoins := sdk.NewCoins(sdk.NewCoin("stake", expTokens))
 	require.Equal(t, expCoins, balance)
 
diff --git a/x/distribution/simulation/operations_test.go b/x/distribution/simulation/operations_test.go
index 67ca4dd863ae..1c6f67f89fb1 100644
--- a/x/distribution/simulation/operations_test.go
+++ b/x/distribution/simulation/operations_test.go
@@ -95,7 +95,7 @@ func (suite *SimTestSuite) TestSimulateMsgWithdrawDelegatorReward() {
 	validator0 := suite.getTestingValidator0(accounts)
 
 	// setup delegation
-	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	delTokens := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 2)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	delegator := accounts[1]
 	delegation := stakingtypes.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@@ -223,7 +223,7 @@ func (suite *SimTestSuite) SetupTest() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	initAmt := suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go
index 56a401fffad7..9c3aabf74f00 100644
--- a/x/gov/abci_test.go
+++ b/x/gov/abci_test.go
@@ -221,7 +221,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	require.False(t, activeQueue.Valid())
 	activeQueue.Close()
 
-	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction))}
+	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 5))}
 	newProposalMsg, err := types.NewMsgSubmitProposal(TestProposal, proposalCoins, addrs[0])
 	require.NoError(t, err)
 
@@ -295,7 +295,7 @@ func TestProposalPassedEndblocker(t *testing.T) {
 	proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
 	require.NoError(t, err)
 
-	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))}
+	proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10))}
 	newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
 
 	handleAndCheck(t, handler, ctx, newDepositMsg)
@@ -343,7 +343,7 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) {
 	proposal, err := app.GovKeeper.SubmitProposal(ctx, TestProposal)
 	require.NoError(t, err)
 
-	proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)))
+	proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
 	newDepositMsg := types.NewMsgDeposit(addrs[0], proposal.ProposalId, proposalCoins)
 
 	handleAndCheck(t, gov.NewHandler(app.GovKeeper), ctx, newDepositMsg)
diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go
index a967b4e9cbc3..e39ca9c70380 100644
--- a/x/gov/keeper/common_test.go
+++ b/x/gov/keeper/common_test.go
@@ -48,9 +48,9 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val3)
 
-	_, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val1, true)
-	_, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val2, true)
-	_, _ = app.StakingKeeper.Delegate(ctx, addrs[2], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), stakingtypes.Unbonded, val3, true)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), stakingtypes.Unbonded, val1, true)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[1], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), stakingtypes.Unbonded, val2, true)
+	_, _ = app.StakingKeeper.Delegate(ctx, addrs[2], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), stakingtypes.Unbonded, val3, true)
 
 	_ = staking.EndBlocker(ctx, app.StakingKeeper)
 
diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go
index e1415f099a0b..b99db4a5f16b 100644
--- a/x/gov/keeper/deposit_test.go
+++ b/x/gov/keeper/deposit_test.go
@@ -22,8 +22,8 @@ func TestDeposits(t *testing.T) {
 	require.NoError(t, err)
 	proposalID := proposal.ProposalId
 
-	fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)))
-	fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction)))
+	fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 4)))
+	fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 5)))
 
 	addr0Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[0])
 	addr1Initial := app.BankKeeper.GetAllBalances(ctx, TestAddrs[1])
diff --git a/x/gov/keeper/grpc_query_test.go b/x/gov/keeper/grpc_query_test.go
index 59bdd442c999..af03f767c7d6 100644
--- a/x/gov/keeper/grpc_query_test.go
+++ b/x/gov/keeper/grpc_query_test.go
@@ -164,7 +164,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() {
 		{
 			"request with filter of deposit address",
 			func() {
-				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
+				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit := types.NewDeposit(testProposals[0].ProposalId, addrs[0], depositCoins)
 				app.GovKeeper.SetDeposit(ctx, deposit)
 
@@ -584,7 +584,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() {
 		{
 			"valid request",
 			func() {
-				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
+				depositCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit := types.NewDeposit(proposal.ProposalId, addrs[0], depositCoins)
 				app.GovKeeper.SetDeposit(ctx, deposit)
 
@@ -671,11 +671,11 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() {
 		{
 			"get deposits with default limit",
 			func() {
-				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)))
+				depositAmount1 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 20)))
 				deposit1 := types.NewDeposit(proposal.ProposalId, addrs[0], depositAmount1)
 				app.GovKeeper.SetDeposit(ctx, deposit1)
 
-				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)))
+				depositAmount2 := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 30)))
 				deposit2 := types.NewDeposit(proposal.ProposalId, addrs[1], depositAmount2)
 				app.GovKeeper.SetDeposit(ctx, deposit2)
 
diff --git a/x/gov/keeper/querier_test.go b/x/gov/keeper/querier_test.go
index d416cb350db8..a725aec9e6b2 100644
--- a/x/gov/keeper/querier_test.go
+++ b/x/gov/keeper/querier_test.go
@@ -153,7 +153,7 @@ func TestQueries(t *testing.T) {
 	TestAddrs := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(20000001))
 
 	oneCoins := sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1))
-	consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)))
+	consCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 10)))
 
 	tp := TestProposal
 
diff --git a/x/gov/keeper/tally_test.go b/x/gov/keeper/tally_test.go
index 4e2ac847e9c6..d7699889d5e6 100644
--- a/x/gov/keeper/tally_test.go
+++ b/x/gov/keeper/tally_test.go
@@ -245,7 +245,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	val1, found := app.StakingKeeper.GetValidator(ctx, valAddrs[0])
 	require.True(t, found)
 
@@ -281,7 +281,7 @@ func TestTallyDelgatorInherit(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
 	require.True(t, found)
 
@@ -316,7 +316,7 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	val1, found := app.StakingKeeper.GetValidator(ctx, vals[0])
 	require.True(t, found)
 	val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
@@ -358,7 +358,7 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 
 	addrs, vals := createValidators(t, ctx, app, []int64{5, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	val2, found := app.StakingKeeper.GetValidator(ctx, vals[1])
 	require.True(t, found)
 	val3, found := app.StakingKeeper.GetValidator(ctx, vals[2])
@@ -397,7 +397,7 @@ func TestTallyJailedValidator(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{25, 6, 7})
 
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
 	require.True(t, found)
 	val3, found := app.StakingKeeper.GetValidator(ctx, valAddrs[2])
@@ -440,7 +440,7 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
 
 	addrs, valAddrs := createValidators(t, ctx, app, []int64{10, 10, 10})
 
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	val2, found := app.StakingKeeper.GetValidator(ctx, valAddrs[1])
 	require.True(t, found)
 
@@ -465,10 +465,10 @@ func TestTallyValidatorMultipleDelegations(t *testing.T) {
 	require.True(t, passes)
 	require.False(t, burnDeposits)
 
-	expectedYes := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
-	expectedAbstain := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)
-	expectedNo := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
-	expectedNoWithVeto := sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction)
+	expectedYes := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
+	expectedAbstain := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
+	expectedNo := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
+	expectedNoWithVeto := app.StakingKeeper.TokensFromConsensusPower(ctx, 0)
 	expectedTallyResult := types.NewTallyResult(expectedYes, expectedAbstain, expectedNo, expectedNoWithVeto)
 
 	require.True(t, tallyResults.Equals(expectedTallyResult))
diff --git a/x/gov/simulation/operations_test.go b/x/gov/simulation/operations_test.go
index 169665ad9f70..e61fe8ac1b60 100644
--- a/x/gov/simulation/operations_test.go
+++ b/x/gov/simulation/operations_test.go
@@ -222,7 +222,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/ibc/core/02-client/keeper/keeper_test.go b/x/ibc/core/02-client/keeper/keeper_test.go
index b9ad609211c9..364a505c5044 100644
--- a/x/ibc/core/02-client/keeper/keeper_test.go
+++ b/x/ibc/core/02-client/keeper/keeper_test.go
@@ -111,7 +111,7 @@ func (suite *KeeperTestSuite) SetupTest() {
 		val.Tokens = sdk.NewInt(rand.Int63())
 		validators = append(validators, val)
 
-		hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, sdk.DefaultPowerReduction)
+		hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, app.StakingKeeper.PowerReduction(suite.ctx))
 		app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi)
 	}
 
diff --git a/x/slashing/abci_test.go b/x/slashing/abci_test.go
index f07b1c81fa9d..6121e3572b88 100644
--- a/x/slashing/abci_test.go
+++ b/x/slashing/abci_test.go
@@ -21,7 +21,7 @@ func TestBeginBlocker(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 	addr, pk := sdk.ValAddress(pks[0].Address()), pks[0]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
diff --git a/x/slashing/genesis_test.go b/x/slashing/genesis_test.go
index e31144f331ee..1467fac6efd1 100644
--- a/x/slashing/genesis_test.go
+++ b/x/slashing/genesis_test.go
@@ -20,7 +20,7 @@ func TestExportAndInitGenesis(t *testing.T) {
 
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
 		time.Now().UTC().Add(100000000000), false, int64(10))
diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go
index 87746d867213..e6b6af64b68d 100644
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@@ -26,7 +26,7 @@ func TestCannotUnjailUnlessJailed(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	slh := slashing.NewHandler(app.SlashingKeeper)
@@ -52,12 +52,12 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 	slh := slashing.NewHandler(app.SlashingKeeper)
 	addr, val := sdk.ValAddress(pks[0].Address()), pks[0]
-	amt := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	msg := tstaking.CreateValidatorMsg(addr, val, amt)
 	msg.MinSelfDelegation = amt
 	tstaking.Handle(msg, true)
@@ -84,7 +84,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
 	pks := simapp.CreateTestPubKeys(3)
 
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 20))
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -145,7 +145,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Unix(0, 0)})
 	pks := simapp.CreateTestPubKeys(1)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
 	power := int64(100)
diff --git a/x/slashing/keeper/grpc_query_test.go b/x/slashing/keeper/grpc_query_test.go
index c4880afd7fab..6290b94e0004 100644
--- a/x/slashing/keeper/grpc_query_test.go
+++ b/x/slashing/keeper/grpc_query_test.go
@@ -35,7 +35,7 @@ func (suite *SlashingTestSuite) SetupTest() {
 	app.BankKeeper.SetParams(ctx, banktypes.DefaultParams())
 	app.SlashingKeeper.SetParams(ctx, testslashing.TestParams())
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	info1 := types.NewValidatorSigningInfo(sdk.ConsAddress(addrDels[0]), int64(4), int64(3),
 		time.Unix(2, 0), false, int64(10))
diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go
index 002d6a03a39e..7f3d42b0a7ed 100644
--- a/x/slashing/keeper/keeper_test.go
+++ b/x/slashing/keeper/keeper_test.go
@@ -23,7 +23,7 @@ func TestUnJailNotBonded(t *testing.T) {
 	p.MaxValidators = 5
 	app.StakingKeeper.SetParams(ctx, p)
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 6, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(6)
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
@@ -39,7 +39,7 @@ func TestUnJailNotBonded(t *testing.T) {
 
 	// create a 6th validator with less power than the cliff validator (won't be bonded)
 	addr, val := valAddrs[5], pks[5]
-	amt := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
 	msg := tstaking.CreateValidatorMsg(addr, val, amt)
 	msg.MinSelfDelegation = amt
 	tstaking.Handle(msg, true)
@@ -51,7 +51,7 @@ func TestUnJailNotBonded(t *testing.T) {
 
 	// unbond below minimum self-delegation
 	require.Equal(t, p.BondDenom, tstaking.Denom)
-	tstaking.Undelegate(sdk.AccAddress(addr), addr, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction), true)
+	tstaking.Undelegate(sdk.AccAddress(addr), addr, app.StakingKeeper.TokensFromConsensusPower(ctx, 1), true)
 
 	staking.EndBlocker(ctx, app.StakingKeeper)
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
@@ -83,7 +83,7 @@ func TestHandleNewValidator(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(1)
 	addr, val := valAddrs[0], pks[0]
@@ -116,7 +116,7 @@ func TestHandleNewValidator(t *testing.T) {
 	validator, _ := app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, stakingtypes.Bonded, validator.GetStatus())
 	bondPool := app.StakingKeeper.GetBondedPool(ctx)
-	expTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	expTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	require.True(t, expTokens.Equal(app.BankKeeper.GetBalance(ctx, bondPool.GetAddress(), app.StakingKeeper.BondDenom(ctx)).Amount))
 }
 
@@ -127,7 +127,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
 
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrDels)
 	pks := simapp.CreateTestPubKeys(1)
 	addr, val := valAddrs[0], pks[0]
@@ -159,7 +159,7 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	require.Equal(t, stakingtypes.Unbonding, validator.GetStatus())
 
 	// validator should have been slashed
-	resultingTokens := amt.Sub(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))
+	resultingTokens := amt.Sub(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
 	require.Equal(t, resultingTokens, validator.GetTokens())
 
 	// another block missed
@@ -188,7 +188,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	power := int64(100)
 
 	pks := simapp.CreateTestPubKeys(3)
-	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	simapp.AddTestAddrsFromPubKeys(app, ctx, pks, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	addr, val := pks[0].Address(), pks[0]
 	consAddr := sdk.ConsAddress(addr)
diff --git a/x/slashing/keeper/signing_info_test.go b/x/slashing/keeper/signing_info_test.go
index e1b4f1720afe..2748042b3600 100644
--- a/x/slashing/keeper/signing_info_test.go
+++ b/x/slashing/keeper/signing_info_test.go
@@ -15,7 +15,7 @@ import (
 func TestGetSetValidatorSigningInfo(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	info, found := app.SlashingKeeper.GetValidatorSigningInfo(ctx, sdk.ConsAddress(addrDels[0]))
 	require.False(t, found)
@@ -39,7 +39,7 @@ func TestGetSetValidatorSigningInfo(t *testing.T) {
 func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	missed := app.SlashingKeeper.GetValidatorMissedBlockBitArray(ctx, sdk.ConsAddress(addrDels[0]), 0)
 	require.False(t, missed) // treat empty key as not missed
@@ -51,7 +51,7 @@ func TestGetSetValidatorMissedBlockBitArray(t *testing.T) {
 func TestTombstoned(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	require.Panics(t, func() { app.SlashingKeeper.Tombstone(ctx, sdk.ConsAddress(addrDels[0])) })
 	require.False(t, app.SlashingKeeper.IsTombstoned(ctx, sdk.ConsAddress(addrDels[0])))
@@ -75,7 +75,7 @@ func TestTombstoned(t *testing.T) {
 func TestJailUntil(t *testing.T) {
 	app := simapp.Setup(false)
 	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
-	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction))
+	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, app.StakingKeeper.TokensFromConsensusPower(ctx, 200))
 
 	require.Panics(t, func() { app.SlashingKeeper.JailUntil(ctx, sdk.ConsAddress(addrDels[0]), time.Now()) })
 
diff --git a/x/slashing/simulation/operations_test.go b/x/slashing/simulation/operations_test.go
index 2042821c7a76..707233b21e53 100644
--- a/x/slashing/simulation/operations_test.go
+++ b/x/slashing/simulation/operations_test.go
@@ -77,7 +77,7 @@ func TestSimulateMsgUnjail(t *testing.T) {
 	app.StakingKeeper.Jail(ctx, val0ConsAddress)
 
 	// setup self delegation
-	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress)
 	require.NoError(t, err)
@@ -116,7 +116,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/staking/client/cli/cli_test.go b/x/staking/client/cli/cli_test.go
index f1ef9edc6b8a..ab67a38b63d1 100644
--- a/x/staking/client/cli/cli_test.go
+++ b/x/staking/client/cli/cli_test.go
@@ -861,12 +861,13 @@ func (s *IntegrationTestSuite) TestGetCmdQueryParams() {
 historical_entries: 10000
 max_entries: 7
 max_validators: 100
+power_reduction: "1000000"
 unbonding_time: 1814400s`,
 		},
 		{
 			"with json output",
 			[]string{fmt.Sprintf("--%s=json", tmcli.OutputFlag)},
-			`{"unbonding_time":"1814400s","max_validators":100,"max_entries":7,"historical_entries":10000,"bond_denom":"stake"}`,
+			`{"unbonding_time":"1814400s","max_validators":100,"max_entries":7,"historical_entries":10000,"bond_denom":"stake","power_reduction":"1000000"}`,
 		},
 	}
 	for _, tc := range testCases {
diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go
index 4c4bf97847ce..745d851ca67d 100644
--- a/x/staking/genesis_test.go
+++ b/x/staking/genesis_test.go
@@ -23,7 +23,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
 
 	addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000))
 
-	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -39,7 +39,7 @@ func bootstrapGenesisTest(t *testing.T, power int64, numAddrs int) (*simapp.SimA
 func TestInitGenesis(t *testing.T) {
 	app, ctx, addrs := bootstrapGenesisTest(t, 1000, 10)
 
-	valTokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
 
 	params := app.StakingKeeper.GetParams(ctx)
 	validators := make([]types.Validator, 2)
@@ -91,7 +91,7 @@ func TestInitGenesis(t *testing.T) {
 
 	abcivals := make([]abci.ValidatorUpdate, len(vals))
 	for i, val := range validators {
-		abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction)
+		abcivals[i] = val.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx))
 	}
 
 	require.Equal(t, abcivals, vals)
@@ -113,9 +113,9 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 		require.NoError(t, err)
 		validators[i].Status = types.Bonded
 
-		tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
 		if i < 100 {
-			tokens = sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+			tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 		}
 		validators[i].Tokens = tokens
 		validators[i].DelegatorShares = tokens.ToDec()
@@ -126,7 +126,7 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 
 	abcivals := make([]abci.ValidatorUpdate, 100)
 	for i, val := range validators[:100] {
-		abcivals[i] = val.ABCIValidatorUpdate(sdk.DefaultPowerReduction)
+		abcivals[i] = val.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx))
 	}
 
 	require.Equal(t, abcivals, vals)
diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go
index 07c3c23854c0..aed5ab1b7041 100644
--- a/x/staking/handler_test.go
+++ b/x/staking/handler_test.go
@@ -32,7 +32,7 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
 
 	addrDels, addrVals := generateAddresses(app, ctx, numAddrs, accAmount)
 
-	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -45,6 +45,51 @@ func bootstrapHandlerGenesisTest(t *testing.T, power int64, numAddrs int, accAmo
 	return app, ctx, addrDels, addrVals
 }
 
+func TestPowerReductionChangeValidatorSetUpdates(t *testing.T) {
+	initPower := int64(1000000)
+	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
+	validatorAddr, validatorAddr3 := valAddrs[0], valAddrs[1]
+	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
+
+	// create validator
+	tstaking.CreateValidatorWithValPower(validatorAddr, PKs[0], initPower, true)
+
+	// must end-block
+	updates, err := app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(updates))
+
+	// create a second validator keep it bonded
+	tstaking.CreateValidatorWithValPower(validatorAddr3, PKs[2], initPower, true)
+
+	// must end-block
+	updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(updates))
+
+	// modify power reduction to 10 times bigger one
+	params := app.StakingKeeper.GetParams(ctx)
+	params.PowerReduction = sdk.DefaultPowerReduction.Mul(sdk.NewInt(10))
+	app.StakingKeeper.SetParams(ctx, params)
+
+	// validator updates for tendermint power
+	updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(updates))
+	require.Equal(t, updates[0].Power, initPower/10)
+	require.Equal(t, updates[1].Power, initPower/10)
+
+	// power reduction back to default
+	params = app.StakingKeeper.GetParams(ctx)
+	params.PowerReduction = sdk.DefaultPowerReduction
+	app.StakingKeeper.SetParams(ctx, params)
+
+	// power reduction change for all validators
+	updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(updates))
+}
+
 func TestValidatorByPowerIndex(t *testing.T) {
 	initPower := int64(1000000)
 	app, ctx, _, valAddrs := bootstrapHandlerGenesisTest(t, initPower, 10, sdk.TokensFromConsensusPower(initPower, sdk.DefaultPowerReduction))
@@ -68,7 +113,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// verify that the by power index exists
 	validator, found := app.StakingKeeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
+	power := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	// create a second validator keep it bonded
@@ -97,11 +142,11 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// but the new power record should have been created
 	validator, found = app.StakingKeeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	power2 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
+	power2 := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power2))
 
 	// now the new record power index should be the same as the original record
-	power3 := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
+	power3 := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
 	require.Equal(t, power2, power3)
 
 	// unbond self-delegation
@@ -491,8 +536,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	errorCases := []sdk.Int{
 		//1<<64 - 1, // more than int64 power
 		//1<<63 + 1, // more than int64 power
-		sdk.TokensFromConsensusPower(1<<63-1, sdk.DefaultPowerReduction),
-		sdk.TokensFromConsensusPower(1<<31, sdk.DefaultPowerReduction),
+		app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<63-1),
+		app.StakingKeeper.TokensFromConsensusPower(ctx, 1<<31),
 		initBond,
 	}
 
@@ -527,7 +572,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 	}
 
 	// bond them all
-	amt := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	for i, validatorAddr := range validatorAddrs {
 		tstaking.CreateValidator(validatorAddr, PKs[i], amt, true)
 		// verify that the account is bonded
@@ -1094,11 +1139,11 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	tstaking.Ctx = ctx
 
 	// begin unbonding 4 stake
-	unbondAmt := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
+	unbondAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
 	tstaking.Undelegate(del, valA, unbondAmt, true)
 
 	// begin redelegate 6 stake
-	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction))
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 6))
 	msgBeginRedelegate := types.NewMsgBeginRedelegate(del, valA, valB, redAmt)
 	tstaking.Handle(msgBeginRedelegate, true)
 
@@ -1182,7 +1227,7 @@ func TestInvalidCoinDenom(t *testing.T) {
 	valA, valB, delAddr := valAddrs[0], valAddrs[1], delAddrs[2]
 	tstaking := teststaking.NewHelper(t, ctx, app.StakingKeeper)
 
-	valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	invalidCoin := sdk.NewCoin("churros", valTokens)
 	validCoin := sdk.NewCoin(sdk.DefaultBondDenom, valTokens)
 	oneCoin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt())
diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go
index 7ec6bfe521d0..9e45b69f70ae 100644
--- a/x/staking/keeper/delegation_test.go
+++ b/x/staking/keeper/delegation_test.go
@@ -183,7 +183,7 @@ func TestUnbondDelegation(t *testing.T) {
 	delAddrs := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	valAddrs := simapp.ConvertAddrsToValAddrs(delAddrs)
 
-	startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
 	require.NoError(t,
@@ -207,7 +207,7 @@ func TestUnbondDelegation(t *testing.T) {
 	delegation := types.NewDelegation(delAddrs[0], valAddrs[0], issuedShares)
 	app.StakingKeeper.SetDelegation(ctx, delegation)
 
-	bondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	bondTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	amount, err := app.StakingKeeper.Unbond(ctx, delAddrs[0], valAddrs[0], bondTokens.ToDec())
 	require.NoError(t, err)
 	require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
@@ -228,7 +228,7 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 
 	bondDenom := app.StakingKeeper.BondDenom(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -310,7 +310,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(10000))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	//create a validator with a self-delegation
@@ -358,7 +358,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 	app.StakingKeeper.SetDelegation(ctx, delegation)
 
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction).ToDec())
+	_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], app.StakingKeeper.TokensFromConsensusPower(ctx, 6).ToDec())
 	require.NoError(t, err)
 
 	// end block
@@ -366,14 +366,14 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 
 	validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	require.Equal(t, sdk.TokensFromConsensusPower(14, sdk.DefaultPowerReduction), validator.Tokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 14), validator.Tokens)
 	require.Equal(t, types.Unbonding, validator.Status)
 	require.True(t, validator.Jailed)
 }
 
 func TestUndelegateFromUnbondingValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -466,7 +466,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
 
 func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -483,7 +483,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -534,7 +534,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	require.Equal(t, validator.Status, types.Unbonded)
 
 	// unbond some of the other delegation's shares
-	unbondTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	unbondTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrDels[1], addrVals[0], unbondTokens.ToDec())
 	require.NoError(t, err)
 
@@ -550,7 +550,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 
 func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	_, app, ctx := createTestInput()
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	delCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), delTokens))
 
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
@@ -567,7 +567,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 
@@ -720,7 +720,7 @@ func TestRedelegateToSameValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 1, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), valTokens))
 
 	// add bonded tokens to pool for delegations
@@ -751,7 +751,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -763,7 +763,7 @@ func TestRedelegationMaxEntries(t *testing.T) {
 
 	// create a validator with a self-delegation
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -809,7 +809,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -823,7 +823,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 
@@ -841,7 +841,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	require.Equal(t, types.Bonded, validator2.Status)
 
 	// create a second delegation to validator 1
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -867,7 +867,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -881,7 +881,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -891,7 +891,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 
 	// create a second delegation to this validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -933,7 +933,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)
 
 	// unbond some of the other delegation's shares
-	redelegateTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	redelegateTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegateTokens.ToDec())
 	require.NoError(t, err)
 
@@ -951,7 +951,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	addrDels := simapp.AddTestAddrsIncremental(app, ctx, 2, sdk.NewInt(0))
 	addrVals := simapp.ConvertAddrsToValAddrs(addrDels)
 
-	startTokens := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	startTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	startCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), startTokens))
 
 	// add bonded tokens to pool for delegations
@@ -965,7 +965,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
 	app.StakingKeeper.SetValidatorByConsAddr(ctx, validator)
 
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares := validator.AddTokensFromDel(valTokens)
 	require.Equal(t, valTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -975,7 +975,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 
 	// create a second delegation to this validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
-	delTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validator, issuedShares = validator.AddTokensFromDel(delTokens)
 	require.Equal(t, delTokens, issuedShares.RoundInt())
 	validator = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
@@ -1009,7 +1009,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	app.StakingKeeper.UnbondingToUnbonded(ctx, validator)
 
 	// redelegate some of the delegation's shares
-	redelegationTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	redelegationTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], redelegationTokens.ToDec())
 	require.NoError(t, err)
 
diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go
index a1d4c88883ff..c82f71552e0f 100644
--- a/x/staking/keeper/grpc_query_test.go
+++ b/x/staking/keeper/grpc_query_test.go
@@ -395,7 +395,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryUnbondingDelegation() {
 	addrAcc2 := addrs[1]
 	addrVal2 := vals[1].OperatorAddress
 
-	unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	valAddr, err1 := sdk.ValAddressFromBech32(addrVal2)
 	suite.NoError(err1)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, valAddr, unbondingTokens.ToDec())
@@ -450,7 +450,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDelegatorUnbondingDelegations() {
 	addrAcc, addrAcc1 := addrs[0], addrs[1]
 	addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress
 
-	unbondingTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	valAddr1, err1 := sdk.ValAddressFromBech32(addrVal)
 	suite.NoError(err1)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc, valAddr1, unbondingTokens.ToDec())
@@ -592,12 +592,12 @@ func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() {
 	addrAcc, addrAcc1 := addrs[0], addrs[1]
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
 	val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4]
-	delAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+	delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
 
-	rdAmount := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+	rdAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@@ -684,7 +684,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
 	val1 := vals[0]
 
 	// undelegate
-	undelAmount := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	undelAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	_, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
 	suite.NoError(err)
 	applyValidatorSetUpdates(suite.T(), ctx, app.StakingKeeper, -1)
@@ -729,7 +729,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() {
 }
 
 func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress, []types.Validator) {
-	addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.TokensFromConsensusPower(300, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, app.StakingKeeper.TokensFromConsensusPower(ctx, 300))
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
 	pks := simapp.CreateTestPubKeys(5)
 	cdc := simapp.MakeTestEncodingConfig().Marshaler
@@ -752,11 +752,11 @@ func createValidators(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1)
 	app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2)
 
-	_, err := app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0], sdk.DefaultPowerReduction), types.Unbonded, val1, true)
+	_, err := app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[0]), types.Unbonded, val1, true)
 	require.NoError(t, err)
-	_, err = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1], sdk.DefaultPowerReduction), types.Unbonded, val2, true)
+	_, err = app.StakingKeeper.Delegate(ctx, addrs[1], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[1]), types.Unbonded, val2, true)
 	require.NoError(t, err)
-	_, err = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2], sdk.DefaultPowerReduction), types.Unbonded, val2, true)
+	_, err = app.StakingKeeper.Delegate(ctx, addrs[0], app.StakingKeeper.TokensFromConsensusPower(ctx, powers[2]), types.Unbonded, val2, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
diff --git a/x/staking/keeper/historical_info_test.go b/x/staking/keeper/historical_info_test.go
index b31407cf8e96..727fe58959af 100644
--- a/x/staking/keeper/historical_info_test.go
+++ b/x/staking/keeper/historical_info_test.go
@@ -25,7 +25,7 @@ func TestHistoricalInfo(t *testing.T) {
 		validators[i] = teststaking.NewValidator(t, valAddr, PKs[i])
 	}
 
-	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, sdk.DefaultPowerReduction)
+	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators, app.StakingKeeper.PowerReduction(ctx))
 	app.StakingKeeper.SetHistoricalInfo(ctx, 2, &hi)
 
 	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
@@ -65,8 +65,8 @@ func TestTrackHistoricalInfo(t *testing.T) {
 		teststaking.NewValidator(t, addrVals[0], PKs[0]),
 		teststaking.NewValidator(t, addrVals[1], PKs[1]),
 	}
-	hi4 := types.NewHistoricalInfo(h4, valSet, sdk.DefaultPowerReduction)
-	hi5 := types.NewHistoricalInfo(h5, valSet, sdk.DefaultPowerReduction)
+	hi4 := types.NewHistoricalInfo(h4, valSet, app.StakingKeeper.PowerReduction(ctx))
+	hi5 := types.NewHistoricalInfo(h5, valSet, app.StakingKeeper.PowerReduction(ctx))
 	app.StakingKeeper.SetHistoricalInfo(ctx, 4, &hi4)
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi5)
 	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 4)
diff --git a/x/staking/keeper/keeper_test.go b/x/staking/keeper/keeper_test.go
index bc0825a8e74a..b0533c8ab02f 100644
--- a/x/staking/keeper/keeper_test.go
+++ b/x/staking/keeper/keeper_test.go
@@ -45,7 +45,7 @@ func (suite *KeeperTestSuite) SetupTest() {
 	// have its order changed
 	sortedVals := make([]types.Validator, len(validators))
 	copy(sortedVals, validators)
-	hi := types.NewHistoricalInfo(header, sortedVals, sdk.DefaultPowerReduction)
+	hi := types.NewHistoricalInfo(header, sortedVals, app.StakingKeeper.PowerReduction(ctx))
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators
diff --git a/x/staking/keeper/power_reduction_test.go b/x/staking/keeper/power_reduction_test.go
index df54a0358f07..b1e3c79429fd 100644
--- a/x/staking/keeper/power_reduction_test.go
+++ b/x/staking/keeper/power_reduction_test.go
@@ -1,21 +1,28 @@
 package keeper_test
 
 import (
-	"testing"
+	"math/big"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func (suite *KeeperTestSuite) TestPowerReductionChange(t *testing.T) {
-	// TODO: Implement!
+func (suite *KeeperTestSuite) TestPowerReductionChange() {
+	// modify power reduction
+	newPowerReduction := sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(12), nil))
+	params := suite.app.StakingKeeper.GetParams(suite.ctx)
+	params.PowerReduction = newPowerReduction
+	suite.app.StakingKeeper.SetParams(suite.ctx, params)
+
+	// check power reduction change
+	suite.Require().Equal(newPowerReduction, suite.app.StakingKeeper.PowerReduction(suite.ctx))
 }
 
 func (suite *KeeperTestSuite) TestTokensToConsensusPower() {
-	suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(999_999)))
-	suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.NewInt(1_000_000)))
+	suite.Require().Equal(int64(0), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.DefaultPowerReduction.Sub(sdk.NewInt(1))))
+	suite.Require().Equal(int64(1), suite.app.StakingKeeper.TokensToConsensusPower(suite.ctx, sdk.DefaultPowerReduction))
 }
 
 func (suite *KeeperTestSuite) TestTokensFromConsensusPower() {
 	suite.Require().Equal(sdk.NewInt(0), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 0))
-	suite.Require().Equal(sdk.NewInt(1_000_000), suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 1))
+	suite.Require().Equal(sdk.DefaultPowerReduction, suite.app.StakingKeeper.TokensFromConsensusPower(suite.ctx, 1))
 }
diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go
index 14cd841f2e9b..6abe7d53cddd 100644
--- a/x/staking/keeper/querier_test.go
+++ b/x/staking/keeper/querier_test.go
@@ -37,7 +37,7 @@ func TestNewQuerier(t *testing.T) {
 		ChainID: "HelloChain",
 		Height:  5,
 	}
-	hi := types.NewHistoricalInfo(header, validators[:], sdk.DefaultPowerReduction)
+	hi := types.NewHistoricalInfo(header, validators[:], app.StakingKeeper.PowerReduction(ctx))
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	query := abci.RequestQuery{
@@ -140,7 +140,7 @@ func TestQueryValidators(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 500, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 500, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 
 	// Create Validators
 	amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
@@ -208,7 +208,7 @@ func TestQueryDelegation(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -224,7 +224,7 @@ func TestQueryDelegation(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val2)
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2)
 
-	delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, types.Unbonded, val1, true)
 	require.NoError(t, err)
 
@@ -348,7 +348,7 @@ func TestQueryDelegation(t *testing.T) {
 	require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance)
 
 	// Query unbonding delegation
-	unbondingTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	unbondingTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.GetOperator(), unbondingTokens.ToDec())
 	require.NoError(t, err)
 
@@ -401,7 +401,7 @@ func TestQueryDelegation(t *testing.T) {
 	require.Error(t, err)
 
 	// Query redelegation
-	redelegationTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	redelegationTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(),
 		val2.GetOperator(), redelegationTokens.ToDec())
 	require.NoError(t, err)
@@ -456,7 +456,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 100, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 100, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 	pubKeys := simapp.CreateTestPubKeys(1)
 
 	valAddress := sdk.ValAddress(addrs[0])
@@ -472,7 +472,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 			t.Error("expected validator not found")
 		}
 
-		delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+		delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 		_, err := app.StakingKeeper.Delegate(ctx, addr, delTokens, types.Unbonded, validator, true)
 		require.NoError(t, err)
 	}
@@ -506,7 +506,7 @@ func TestQueryValidatorDelegations_Pagination(t *testing.T) {
 
 	// Undelegate
 	for _, addr := range addrs {
-		delTokens := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+		delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 		_, err := app.StakingKeeper.Undelegate(ctx, addr, val1.GetOperator(), delTokens.ToDec())
 		require.NoError(t, err)
 	}
@@ -541,7 +541,7 @@ func TestQueryRedelegations(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -551,12 +551,12 @@ func TestQueryRedelegations(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val1)
 	app.StakingKeeper.SetValidator(ctx, val2)
 
-	delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc2, delAmount, types.Unbonded, val1, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
-	rdAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+	rdAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 	_, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -613,7 +613,7 @@ func TestQueryUnbondingDelegation(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino())
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1 := sdk.ValAddress(addrAcc1)
 
@@ -622,13 +622,13 @@ func TestQueryUnbondingDelegation(t *testing.T) {
 	app.StakingKeeper.SetValidator(ctx, val1)
 
 	// delegate
-	delAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	delAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	_, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, types.Unbonded, val1, true)
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
 
 	// undelegate
-	undelAmount := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
+	undelAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
 	_, err = app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
 	require.NoError(t, err)
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -709,7 +709,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
 	legacyQuerierCdc := codec.NewAminoCodec(cdc)
 	querier := keeper.NewQuerier(app.StakingKeeper, legacyQuerierCdc.LegacyAmino)
 
-	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))
 	addrAcc1, addrAcc2 := addrs[0], addrs[1]
 	addrVal1, addrVal2 := sdk.ValAddress(addrAcc1), sdk.ValAddress(addrAcc2)
 
@@ -724,7 +724,7 @@ func TestQueryHistoricalInfo(t *testing.T) {
 		ChainID: "HelloChain",
 		Height:  5,
 	}
-	hi := types.NewHistoricalInfo(header, vals, sdk.DefaultPowerReduction)
+	hi := types.NewHistoricalInfo(header, vals, app.StakingKeeper.PowerReduction(ctx))
 	app.StakingKeeper.SetHistoricalInfo(ctx, 5, &hi)
 
 	queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4}
diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go
index 42e5b383ef02..7b88fbfca17c 100644
--- a/x/staking/keeper/slash.go
+++ b/x/staking/keeper/slash.go
@@ -29,7 +29,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
 	}
 
 	// Amount of slashing = slash slashFactor * power at time of infraction
-	amount := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+	amount := k.TokensFromConsensusPower(ctx, power)
 	slashAmountDec := amount.ToDec().Mul(slashFactor)
 	slashAmount := slashAmountDec.TruncateInt()
 
diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go
index 941a5a70be46..2320ac857983 100644
--- a/x/staking/keeper/slash_test.go
+++ b/x/staking/keeper/slash_test.go
@@ -22,7 +22,7 @@ func bootstrapSlashTest(t *testing.T, power int64) (*simapp.SimApp, sdk.Context,
 
 	addrDels, addrVals := generateAddresses(app, ctx, 100)
 
-	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -219,12 +219,12 @@ func TestSlashAtNegativeHeight(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	require.True(t, found)
 	// power decreased
-	require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(5), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// pool bonded shares decreased
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String())
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
 }
 
 // tests Slash at the current height
@@ -250,12 +250,12 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	assert.True(t, found)
 	// power decreased
-	require.Equal(t, int64(5), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(5), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// pool bonded shares decreased
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(5, sdk.DefaultPowerReduction).String(), diffTokens.String())
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 5).String(), diffTokens.String())
 }
 
 // tests Slash at a previous height with an unbonding delegation
@@ -267,7 +267,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 
 	// set an unbonding delegation with expiration timestamp beyond which the
 	// unbonding delegation shouldn't be slashed
-	ubdTokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
+	ubdTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
 	ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
 		time.Unix(0, 0), ubdTokens)
 	app.StakingKeeper.SetUnbondingDelegation(ctx, ubd)
@@ -290,12 +290,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	require.Len(t, ubd.Entries, 1)
 
 	// balance decreased
-	require.Equal(t, sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction), ubd.Entries[0].Balance)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 2), ubd.Entries[0].Balance)
 
 	// bonded tokens burned
 	newBondedPoolBalances := app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens := oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(3, sdk.DefaultPowerReduction), diffTokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 3), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
@@ -305,7 +305,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.Equal(t, int64(7), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(7), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// slash validator again
 	ctx = ctx.WithBlockHeight(13)
@@ -321,14 +321,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// bonded tokens burned again
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction), diffTokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 6), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	// power decreased by 3 again
-	require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(4), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -347,14 +347,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// bonded tokens burned again
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), diffTokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), diffTokens)
 
 	// read updated validator
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	// power decreased by 3 again
-	require.Equal(t, int64(1), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(1), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -373,7 +373,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// just 1 bonded token burned again since that's all the validator now has
 	newBondedPoolBalances = app.BankKeeper.GetAllBalances(ctx, bondedPool.GetAddress())
 	diffTokens = oldBondedPoolBalances.Sub(newBondedPoolBalances).AmountOf(app.StakingKeeper.BondDenom(ctx))
-	require.Equal(t, sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction), diffTokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 10), diffTokens)
 
 	// apply TM updates
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, -1)
@@ -394,7 +394,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	bondDenom := app.StakingKeeper.BondDenom(ctx)
 
 	// set a redelegation
-	rdTokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	rdTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
 		time.Unix(0, 0), rdTokens, rdTokens.ToDec())
 	app.StakingKeeper.SetRedelegation(ctx, rd)
@@ -424,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	require.True(t, found)
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, fraction) })
-	burnAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt()
+	burnAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
 
 	bondedPool = app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
@@ -448,14 +448,14 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.Equal(t, int64(8), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(8), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// slash the validator again
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
-	burnAmount = sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction)
+	burnAmount = app.StakingKeeper.TokensFromConsensusPower(ctx, 7)
 
 	// read updated pool
 	bondedPool = app.StakingKeeper.GetBondedPool(ctx)
@@ -481,7 +481,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 	// power decreased by 4
-	require.Equal(t, int64(4), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(4), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// slash the validator again, by 100%
 	ctx = ctx.WithBlockHeight(12)
@@ -490,7 +490,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 
 	require.NotPanics(t, func() { app.StakingKeeper.Slash(ctx, consAddr, 10, 10, sdk.OneDec()) })
 
-	burnAmount = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(sdk.OneDec()).TruncateInt()
+	burnAmount = app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(sdk.OneDec()).TruncateInt()
 	burnAmount = burnAmount.Sub(sdk.OneDec().MulInt(rdTokens).TruncateInt())
 
 	// read updated pool
@@ -550,7 +550,7 @@ func TestSlashBoth(t *testing.T) {
 
 	// set a redelegation with expiration timestamp beyond which the
 	// redelegation shouldn't be slashed
-	rdATokens := sdk.TokensFromConsensusPower(6, sdk.DefaultPowerReduction)
+	rdATokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 6)
 	rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
 		time.Unix(0, 0), rdATokens,
 		rdATokens.ToDec())
@@ -562,7 +562,7 @@ func TestSlashBoth(t *testing.T) {
 
 	// set an unbonding delegation with expiration timestamp (beyond which the
 	// unbonding delegation shouldn't be slashed)
-	ubdATokens := sdk.TokensFromConsensusPower(4, sdk.DefaultPowerReduction)
+	ubdATokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 4)
 	ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
 		time.Unix(0, 0), ubdATokens)
 	app.StakingKeeper.SetUnbondingDelegation(ctx, ubdA)
@@ -593,7 +593,7 @@ func TestSlashBoth(t *testing.T) {
 	app.StakingKeeper.Slash(ctx, consAddr0, 10, 10, fraction)
 
 	burnedNotBondedAmount := fraction.MulInt(ubdATokens).TruncateInt()
-	burnedBondAmount := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction).ToDec().Mul(fraction).TruncateInt()
+	burnedBondAmount := app.StakingKeeper.TokensFromConsensusPower(ctx, 10).ToDec().Mul(fraction).TruncateInt()
 	burnedBondAmount = burnedBondAmount.Sub(burnedNotBondedAmount)
 
 	// read updated pool
@@ -614,5 +614,5 @@ func TestSlashBoth(t *testing.T) {
 	validator, found = app.StakingKeeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0]))
 	require.True(t, found)
 	// power not decreased, all stake was bonded since
-	require.Equal(t, int64(10), validator.GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(10), validator.GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 }
diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go
index 4d847977c91a..9d9c0635cbbf 100644
--- a/x/staking/keeper/validator_test.go
+++ b/x/staking/keeper/validator_test.go
@@ -30,7 +30,7 @@ func bootstrapValidatorTest(t *testing.T, power int64, numAddrs int) (*simapp.Si
 
 	addrDels, addrVals := generateAddresses(app, ctx, numAddrs)
 
-	amt := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
 
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -49,7 +49,7 @@ func initValidators(t *testing.T, power int64, numAddrs int, powers []int64) (*s
 	vs := make([]types.Validator, len(powers))
 	for i, power := range powers {
 		vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		vs[i], _ = vs[i].AddTokensFromDel(tokens)
 	}
 	return app, ctx, addrs, valAddrs, vs
@@ -60,7 +60,7 @@ func TestSetValidator(t *testing.T) {
 
 	valPubKey := PKs[0]
 	valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
-	valTokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 
 	// test how the validator is set from a purely unbonbed pool
 	validator := teststaking.NewValidator(t, valAddr, valPubKey)
@@ -75,7 +75,7 @@ func TestSetValidator(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validator, found := app.StakingKeeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validator.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 
 	// after the save the validator should be bonded
 	require.Equal(t, types.Bonded, validator.Status)
@@ -114,10 +114,10 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@@ -125,28 +125,28 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 
 	// add a validator
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	validator, delSharesCreated := validator.AddTokensFromDel(sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction))
+	validator, delSharesCreated := validator.AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 100))
 	require.Equal(t, types.Unbonded, validator.Status)
-	require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), validator.Tokens)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true)
 	validator, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	require.Equal(t, sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction), validator.Tokens)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 100), validator.Tokens)
 
-	power := types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
+	power := types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	// burn half the delegator shares
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validator)
 	validator, burned := validator.RemoveDelShares(delSharesCreated.Quo(sdk.NewDec(2)))
-	require.Equal(t, sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction), burned)
+	require.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 50), burned)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validator, true) // update the validator, possibly kicking it out
 	require.False(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 
 	validator, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
 
-	power = types.GetValidatorsByPowerIndexKey(validator, sdk.DefaultPowerReduction)
+	power = types.GetValidatorsByPowerIndexKey(validator, app.StakingKeeper.PowerReduction(ctx))
 	require.True(t, keeper.ValidatorByPowerIndexExists(ctx, app.StakingKeeper, power))
 }
 
@@ -166,10 +166,10 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	app.StakingKeeper.SetParams(ctx, params)
 
 	// create a random pool
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234, sdk.DefaultPowerReduction))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000, sdk.DefaultPowerReduction))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@@ -179,7 +179,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	for i := 0; i < len(validators); i++ {
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		val := newMonikerValidator(t, valAddrs[i], PKs[i], moniker)
-		delTokens := sdk.TokensFromConsensusPower(int64((i+1)*10), sdk.DefaultPowerReduction)
+		delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, int64((i+1)*10))
 		val, _ = val.AddTokensFromDel(delTokens)
 
 		val = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, val, true)
@@ -191,7 +191,7 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	// remove enough tokens to kick out the validator below the current cliff
 	// validator and next in line cliff validator
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal)
-	shares := sdk.TokensFromConsensusPower(21, sdk.DefaultPowerReduction)
+	shares := app.StakingKeeper.TokensFromConsensusPower(ctx, 21)
 	nextCliffVal, _ = nextCliffVal.RemoveDelShares(shares.ToDec())
 	nextCliffVal = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, nextCliffVal, true)
 
@@ -220,7 +220,7 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
 
 	// add a validator
 	validator := teststaking.NewValidator(t, addrVals[0], PKs[0])
-	valTokens := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	valTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 
@@ -256,13 +256,13 @@ func TestValidatorBasics(t *testing.T) {
 		validators[i] = teststaking.NewValidator(t, addrVals[i], PKs[i])
 		validators[i].Status = types.Unbonded
 		validators[i].Tokens = sdk.ZeroInt()
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
-	assert.Equal(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].Tokens)
-	assert.Equal(t, sdk.TokensFromConsensusPower(8, sdk.DefaultPowerReduction), validators[1].Tokens)
-	assert.Equal(t, sdk.TokensFromConsensusPower(7, sdk.DefaultPowerReduction), validators[2].Tokens)
+	assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].Tokens)
+	assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 8), validators[1].Tokens)
+	assert.Equal(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 7), validators[2].Tokens)
 
 	// check the empty keeper first
 	_, found := app.StakingKeeper.GetValidator(ctx, addrVals[0])
@@ -292,11 +292,11 @@ func TestValidatorBasics(t *testing.T) {
 	require.Equal(t, 1, len(resVals))
 	assert.True(ValEq(t, validators[0], resVals[0]))
 	assert.Equal(t, types.Bonded, validators[0].Status)
-	assert.True(sdk.IntEq(t, sdk.TokensFromConsensusPower(9, sdk.DefaultPowerReduction), validators[0].BondedTokens()))
+	assert.True(sdk.IntEq(t, app.StakingKeeper.TokensFromConsensusPower(ctx, 9), validators[0].BondedTokens()))
 
 	// modify a records, save, and retrieve
 	validators[0].Status = types.Bonded
-	validators[0].Tokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	validators[0].Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validators[0].DelegatorShares = validators[0].Tokens.ToDec()
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
 	resVal, found = app.StakingKeeper.GetValidator(ctx, addrVals[0])
@@ -351,10 +351,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	// initialize some validators into the state
 	amts := []sdk.Int{
 		sdk.NewIntFromUint64(0),
-		sdk.DefaultPowerReduction.MulRaw(100),
-		sdk.DefaultPowerReduction,
-		sdk.DefaultPowerReduction.MulRaw(400),
-		sdk.DefaultPowerReduction.MulRaw(200)}
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
+		app.StakingKeeper.PowerReduction(ctx),
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
 	n := len(amts)
 	var validators [5]types.Validator
 	for i, amt := range amts {
@@ -368,10 +368,10 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	// first make sure everything made it in to the gotValidator group
 	resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	assert.Equal(t, n, len(resValidators))
-	assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(100).Mul(sdk.DefaultPowerReduction), resValidators[2].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(1).Mul(sdk.DefaultPowerReduction), resValidators[3].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(400).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(100).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[2].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(1).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[3].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, sdk.NewInt(0), resValidators[4].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
 	assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
@@ -380,14 +380,14 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.Equal(t, validators[0].OperatorAddress, resValidators[4].OperatorAddress, "%v", resValidators)
 
 	// test a basic increase in voting power
-	validators[3].Tokens = sdk.NewInt(500).Mul(sdk.DefaultPowerReduction)
+	validators[3].Tokens = sdk.NewInt(500).Mul(app.StakingKeeper.PowerReduction(ctx))
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
 	assert.True(ValEq(t, validators[3], resValidators[0]))
 
 	// test a decrease in voting power
-	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
+	validators[3].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
@@ -395,7 +395,7 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], resValidators[1]))
 
 	// test equal voting power, different age
-	validators[3].Tokens = sdk.NewInt(200).Mul(sdk.DefaultPowerReduction)
+	validators[3].Tokens = sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx))
 	ctx = ctx.WithBlockHeight(10)
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@@ -412,8 +412,8 @@ func TestGetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], resValidators[1]))
 
 	// change in voting power of both validators, both still in v-set, no age change
-	validators[3].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
-	validators[4].Tokens = sdk.NewInt(300).Mul(sdk.DefaultPowerReduction)
+	validators[3].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
+	validators[4].Tokens = sdk.NewInt(300).Mul(app.StakingKeeper.PowerReduction(ctx))
 	keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	require.Equal(t, len(resValidators), n)
@@ -430,10 +430,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501, sdk.DefaultPowerReduction))))
+	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 501))))
 	require.NoError(t, err)
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0, sdk.DefaultPowerReduction))))
+	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 0))))
 	require.NoError(t, err)
 
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -447,10 +447,10 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	// initialize some validators into the state
 	amts := []sdk.Int{
 		sdk.NewIntFromUint64(0),
-		sdk.DefaultPowerReduction.MulRaw(100),
-		sdk.DefaultPowerReduction,
-		sdk.DefaultPowerReduction.MulRaw(400),
-		sdk.DefaultPowerReduction.MulRaw(200)}
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(100),
+		app.StakingKeeper.PowerReduction(ctx),
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(400),
+		app.StakingKeeper.PowerReduction(ctx).MulRaw(200)}
 
 	var validators [5]types.Validator
 	for i, amt := range amts {
@@ -481,8 +481,8 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	resValidators := app.StakingKeeper.GetBondedValidatorsByPower(ctx)
 	// The validators returned should match the max validators
 	assert.Equal(t, 2, len(resValidators))
-	assert.Equal(t, sdk.NewInt(400).Mul(sdk.DefaultPowerReduction), resValidators[0].BondedTokens(), "%v", resValidators)
-	assert.Equal(t, sdk.NewInt(200).Mul(sdk.DefaultPowerReduction), resValidators[1].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(400).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[0].BondedTokens(), "%v", resValidators)
+	assert.Equal(t, sdk.NewInt(200).Mul(app.StakingKeeper.PowerReduction(ctx)), resValidators[1].BondedTokens(), "%v", resValidators)
 	assert.Equal(t, validators[3].OperatorAddress, resValidators[0].OperatorAddress, "%v", resValidators)
 	assert.Equal(t, validators[4].OperatorAddress, resValidators[1].OperatorAddress, "%v", resValidators)
 }
@@ -504,7 +504,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		validators[i] = newMonikerValidator(t, sdk.ValAddress(addrs[i]), PKs[i], moniker)
 
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
@@ -523,7 +523,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 
 	// delegate 500 tokens to validator 0
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	delTokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
 	validators[0], _ = validators[0].AddTokensFromDel(delTokens)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
@@ -558,10 +558,10 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	validators[3], found = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
 	assert.True(t, found)
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[3])
-	validators[3], _ = validators[3].AddTokensFromDel(sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction))
+	validators[3], _ = validators[3].AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
 
 	notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
-	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)))
+	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 1)))
 	balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress())
 	require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...)))
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -620,9 +620,9 @@ func TestValidatorBondHeight(t *testing.T) {
 	validators[1] = teststaking.NewValidator(t, sdk.ValAddress(addrs[1]), PKs[1])
 	validators[2] = teststaking.NewValidator(t, sdk.ValAddress(addrs[2]), PKs[2])
 
-	tokens0 := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
-	tokens1 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
-	tokens2 := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	tokens0 := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
+	tokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
+	tokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens0)
 	validators[1], _ = validators[1].AddTokensFromDel(tokens1)
 	validators[2], _ = validators[2].AddTokensFromDel(tokens2)
@@ -642,7 +642,7 @@ func TestValidatorBondHeight(t *testing.T) {
 	assert.True(ValEq(t, validators[1], resValidators[1]))
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[2])
-	delTokens := sdk.TokensFromConsensusPower(50, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 50)
 	validators[1], _ = validators[1].AddTokensFromDel(delTokens)
 	validators[2], _ = validators[2].AddTokensFromDel(delTokens)
 	validators[2] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[2], true)
@@ -665,7 +665,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 	var validators [5]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 		keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[i], true)
 	}
@@ -686,7 +686,7 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 
 	// test a swap in voting power
 
-	tokens := sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction)
+	tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], true)
 	resValidators = app.StakingKeeper.GetBondedValidatorsByPower(ctx)
@@ -705,7 +705,7 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 
@@ -720,8 +720,8 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	assert.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
-	assert.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	assert.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
+	assert.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
@@ -732,7 +732,7 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
 
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 	}
@@ -755,7 +755,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
 
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 	}
@@ -766,11 +766,11 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	// test single value change
 	//  tendermintUpdate set: {} -> {c1'}
 	validators[0].Status = types.Bonded
-	validators[0].Tokens = sdk.TokensFromConsensusPower(600, sdk.DefaultPowerReduction)
+	validators[0].Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 600)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
@@ -784,16 +784,16 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
 
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
-	delTokens1 := sdk.TokensFromConsensusPower(190, sdk.DefaultPowerReduction)
-	delTokens2 := sdk.TokensFromConsensusPower(80, sdk.DefaultPowerReduction)
+	delTokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 190)
+	delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 80)
 	validators[0], _ = validators[0].AddTokensFromDel(delTokens1)
 	validators[1], _ = validators[1].AddTokensFromDel(delTokens2)
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 	validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
 
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
@@ -810,7 +810,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
-	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 
 	// test validtor added at the beginning
 	//  tendermintUpdate set: {} -> {c0}
@@ -818,7 +818,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[3])
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[3], _ = app.StakingKeeper.GetValidator(ctx, validators[3].GetOperator())
-	require.Equal(t, validators[3].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[3].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 
 	// test validtor added at the end
 	//  tendermintUpdate set: {} -> {c0}
@@ -826,7 +826,7 @@ func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[4])
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
 	validators[4], _ = app.StakingKeeper.GetValidator(ctx, validators[4].GetOperator())
-	require.Equal(t, validators[4].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[4].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
@@ -839,7 +839,7 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	var validators [5]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@@ -855,14 +855,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	//  tendermintUpdate set: {}     -> {c0, c4}
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
-	tokens := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	validators[2], _ = validators[2].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[2])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[2])
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
 	require.Equal(t, validators[0].ABCIValidatorUpdateZero(), updates[1])
-	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
@@ -872,7 +872,7 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	var validators [2]types.Validator
 	for i, power := range powers {
 		validators[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 	}
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
@@ -880,26 +880,26 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 
 	// check initial power
-	require.Equal(t, int64(100), validators[0].GetConsensusPower(sdk.DefaultPowerReduction))
-	require.Equal(t, int64(100), validators[1].GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(100), validators[0].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
+	require.Equal(t, int64(100), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
-	delTokens1 := sdk.TokensFromConsensusPower(20, sdk.DefaultPowerReduction)
-	delTokens2 := sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction)
+	delTokens1 := app.StakingKeeper.TokensFromConsensusPower(ctx, 20)
+	delTokens2 := app.StakingKeeper.TokensFromConsensusPower(ctx, 30)
 	validators[0], _ = validators[0].RemoveDelShares(delTokens1.ToDec())
 	validators[1], _ = validators[1].RemoveDelShares(delTokens2.ToDec())
 	validators[0] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[0], false)
 	validators[1] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[1], false)
 
 	// power has changed
-	require.Equal(t, int64(80), validators[0].GetConsensusPower(sdk.DefaultPowerReduction))
-	require.Equal(t, int64(70), validators[1].GetConsensusPower(sdk.DefaultPowerReduction))
+	require.Equal(t, int64(80), validators[0].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
+	require.Equal(t, int64(70), validators[1].GetConsensusPower(app.StakingKeeper.PowerReduction(ctx)))
 
 	// Tendermint updates should reflect power change
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
-	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
@@ -918,7 +918,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = teststaking.NewValidator(t, valAddr, valPubKey)
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		app.StakingKeeper.SetValidator(ctx, validators[i])
@@ -929,8 +929,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, len(validators))
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
@@ -938,7 +938,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	for i, power := range powers {
 
 		app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[i])
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 
 		app.StakingKeeper.SetValidator(ctx, validators[i])
@@ -965,7 +965,7 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
 
 	validator = teststaking.NewValidator(t, valAddr, valPubKey)
-	tokens := sdk.TokensFromConsensusPower(500, sdk.DefaultPowerReduction)
+	tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 500)
 	validator, _ = validator.AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validator)
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validator)
@@ -975,9 +975,9 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	validator, _ = app.StakingKeeper.GetValidator(ctx, validator.GetOperator())
 	validators[0], _ = app.StakingKeeper.GetValidator(ctx, validators[0].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validator.ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
-	require.Equal(t, validators[0].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[2])
+	require.Equal(t, validator.ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
+	require.Equal(t, validators[0].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[2])
 }
 
 func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
@@ -997,7 +997,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = newMonikerValidator(t, valAddr, valPubKey, moniker)
-		tokens := sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction)
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		validators[i], _ = validators[i].AddTokensFromDel(tokens)
 		app.StakingKeeper.SetValidator(ctx, validators[i])
 		app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i])
@@ -1007,8 +1007,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	updates := applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 2)
 	validators[2], _ = app.StakingKeeper.GetValidator(ctx, validators[2].GetOperator())
 	validators[1], _ = app.StakingKeeper.GetValidator(ctx, validators[1].GetOperator())
-	require.Equal(t, validators[2].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[1])
+	require.Equal(t, validators[2].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[1])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
@@ -1020,7 +1020,7 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	require.True(t, found)
 
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	tokens := sdk.TokensFromConsensusPower(1, sdk.DefaultPowerReduction)
+	tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 1)
 	validators[0], _ = validators[0].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[0])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[0])
@@ -1042,14 +1042,14 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 
 	app.StakingKeeper.DeleteValidatorByPowerIndex(ctx, validators[1])
-	tokens = sdk.TokensFromConsensusPower(250, sdk.DefaultPowerReduction)
+	tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 250)
 	validators[1], _ = validators[1].AddTokensFromDel(tokens)
 	app.StakingKeeper.SetValidator(ctx, validators[1])
 	app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[1])
 
 	// verify initial Tendermint updates are correct
 	updates = applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 1)
-	require.Equal(t, validators[1].ABCIValidatorUpdate(sdk.DefaultPowerReduction), updates[0])
+	require.Equal(t, validators[1].ABCIValidatorUpdate(app.StakingKeeper.PowerReduction(ctx)), updates[0])
 
 	applyValidatorSetUpdates(t, ctx, app.StakingKeeper, 0)
 }
diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go
index 2be5e80dbc31..16bb4374b503 100644
--- a/x/staking/legacy/v040/migrate_test.go
+++ b/x/staking/legacy/v040/migrate_test.go
@@ -55,6 +55,7 @@ func TestMigrate(t *testing.T) {
     "historical_entries": 0,
     "max_entries": 0,
     "max_validators": 0,
+    "power_reduction": "1000000",
     "unbonding_time": "0s"
   },
   "redelegations": [],
diff --git a/x/staking/simulation/genesis_test.go b/x/staking/simulation/genesis_test.go
index 35e59b6c2342..a307ce9ad756 100644
--- a/x/staking/simulation/genesis_test.go
+++ b/x/staking/simulation/genesis_test.go
@@ -47,7 +47,7 @@ func TestRandomizedGenState(t *testing.T) {
 	require.Equal(t, uint32(8687), stakingGenesis.Params.HistoricalEntries)
 	require.Equal(t, "stake", stakingGenesis.Params.BondDenom)
 	require.Equal(t, float64(238280), stakingGenesis.Params.UnbondingTime.Seconds())
-	require.Equal(t, sdk.NewInt(1000000), stakingGenesis.Params.PowerReduction)
+	require.Equal(t, sdk.DefaultPowerReduction, stakingGenesis.Params.PowerReduction)
 	// check numbers of Delegations and Validators
 	require.Len(t, stakingGenesis.Delegations, 3)
 	require.Len(t, stakingGenesis.Validators, 3)
diff --git a/x/staking/simulation/operations_test.go b/x/staking/simulation/operations_test.go
index 6ca1886bf592..2942a6ed626a 100644
--- a/x/staking/simulation/operations_test.go
+++ b/x/staking/simulation/operations_test.go
@@ -181,7 +181,7 @@ func TestSimulateMsgUndelegate(t *testing.T) {
 	validator0 := getTestingValidator0(t, app, ctx, accounts)
 
 	// setup delegation
-	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 	delegator := accounts[1]
 	delegation := types.NewDelegation(delegator.Address, validator0.GetOperator(), issuedShares)
@@ -227,7 +227,7 @@ func TestSimulateMsgBeginRedelegate(t *testing.T) {
 	validator0 := getTestingValidator0(t, app, ctx, accounts)
 	validator1 := getTestingValidator1(t, app, ctx, accounts)
 
-	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
+	delTokens := app.StakingKeeper.TokensFromConsensusPower(ctx, 2)
 	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
 
 	// setup accounts[2] as delegator
@@ -276,7 +276,7 @@ func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
 func getTestingAccounts(t *testing.T, r *rand.Rand, app *simapp.SimApp, ctx sdk.Context, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
+	initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
@@ -309,7 +309,7 @@ func getTestingValidator(t *testing.T, app *simapp.SimApp, ctx sdk.Context, acco
 	require.NoError(t, err)
 
 	validator.DelegatorShares = sdk.NewDec(100)
-	validator.Tokens = sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	validator.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 100)
 
 	app.StakingKeeper.SetValidator(ctx, validator)
 
diff --git a/x/staking/teststaking/helper.go b/x/staking/teststaking/helper.go
index 607ad56ada4c..25b021df07a1 100644
--- a/x/staking/teststaking/helper.go
+++ b/x/staking/teststaking/helper.go
@@ -40,7 +40,7 @@ func (sh *Helper) CreateValidator(addr sdk.ValAddress, pk cryptotypes.PubKey, st
 // CreateValidatorWithValPower calls handler to create a new staking validator with zero
 // commission
 func (sh *Helper) CreateValidatorWithValPower(addr sdk.ValAddress, pk cryptotypes.PubKey, valPower int64, ok bool) sdk.Int {
-	amount := sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction)
+	amount := sh.k.TokensFromConsensusPower(sh.Ctx, valPower)
 	coin := sdk.NewCoin(sh.Denom, amount)
 	sh.createValidator(addr, pk, coin, ok)
 	return amount
@@ -69,7 +69,7 @@ func (sh *Helper) Delegate(delegator sdk.AccAddress, val sdk.ValAddress, amount
 
 // DelegateWithPower calls handler to delegate stake for a validator
 func (sh *Helper) DelegateWithPower(delegator sdk.AccAddress, val sdk.ValAddress, power int64) {
-	coin := sdk.NewCoin(sh.Denom, sdk.TokensFromConsensusPower(power, sdk.DefaultPowerReduction))
+	coin := sdk.NewCoin(sh.Denom, sh.k.TokensFromConsensusPower(sh.Ctx, power))
 	msg := stakingtypes.NewMsgDelegate(delegator, val, coin)
 	sh.Handle(msg, true)
 }

From 86844b24d9ebb511b3a124527abfa925072d5359 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Thu, 28 Jan 2021 23:59:16 +1000
Subject: [PATCH 04/23] comment update

---
 x/staking/handler_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go
index aed5ab1b7041..aa9da641b4ba 100644
--- a/x/staking/handler_test.go
+++ b/x/staking/handler_test.go
@@ -84,7 +84,7 @@ func TestPowerReductionChangeValidatorSetUpdates(t *testing.T) {
 	params.PowerReduction = sdk.DefaultPowerReduction
 	app.StakingKeeper.SetParams(ctx, params)
 
-	// power reduction change for all validators
+	// validator updates for tendermint power
 	updates, err = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	require.NoError(t, err)
 	require.Equal(t, 2, len(updates))

From 60c6c0a3c0836305da5fe2a2b11299ccb6995f75 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Tue, 2 Feb 2021 00:00:45 +1000
Subject: [PATCH 05/23] legacy genesis migration test and feedbacks

---
 x/bank/keeper/keeper_test.go                |    1 +
 x/evidence/keeper/keeper_test.go            |    1 +
 x/slashing/init_test.go                     |    1 +
 x/slashing/keeper/common_test.go            |    1 +
 x/staking/keeper/val_state_change.go        |    8 +-
 x/staking/legacy/v040/commission.go         |   17 +
 x/staking/legacy/v040/delegation.go         |  100 +
 x/staking/legacy/v040/genesis.pb.go         |  777 +++++
 x/staking/legacy/v040/{types.go => keys.go} |    0
 x/staking/legacy/v040/migrate.go            |   51 +-
 x/staking/legacy/v040/migrate_test.go       |    1 -
 x/staking/legacy/v040/params.go             |   11 +
 x/staking/legacy/v040/staking.pb.go         | 3293 +++++++++++++++++++
 x/staking/legacy/v040/validator.go          |   43 +
 x/staking/legacy/v042/migrate.go            |  117 +
 x/staking/legacy/v042/migrate_test.go       |  101 +
 x/staking/legacy/v042/types.go              |    5 +
 x/staking/types/historical_info.go          |    1 -
 18 files changed, 4497 insertions(+), 32 deletions(-)
 create mode 100644 x/staking/legacy/v040/commission.go
 create mode 100644 x/staking/legacy/v040/delegation.go
 create mode 100644 x/staking/legacy/v040/genesis.pb.go
 rename x/staking/legacy/v040/{types.go => keys.go} (100%)
 create mode 100644 x/staking/legacy/v040/params.go
 create mode 100644 x/staking/legacy/v040/staking.pb.go
 create mode 100644 x/staking/legacy/v040/validator.go
 create mode 100644 x/staking/legacy/v042/migrate.go
 create mode 100644 x/staking/legacy/v042/migrate_test.go
 create mode 100644 x/staking/legacy/v042/types.go

diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go
index b86887a9afd0..6ddecb42bc6c 100644
--- a/x/bank/keeper/keeper_test.go
+++ b/x/bank/keeper/keeper_test.go
@@ -35,6 +35,7 @@ var (
 	multiPermAcc  = authtypes.NewEmptyModuleAccount(multiPerm, authtypes.Burner, authtypes.Minter, authtypes.Staking)
 	randomPermAcc = authtypes.NewEmptyModuleAccount(randomPerm, "random")
 
+	// The default power validators are initialized to have within tests
 	initTokens = sdk.TokensFromConsensusPower(initialPower, sdk.DefaultPowerReduction)
 	initCoins  = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initTokens))
 )
diff --git a/x/evidence/keeper/keeper_test.go b/x/evidence/keeper/keeper_test.go
index 0d518fa61f71..f40b8d2d7b95 100644
--- a/x/evidence/keeper/keeper_test.go
+++ b/x/evidence/keeper/keeper_test.go
@@ -34,6 +34,7 @@ var (
 		sdk.ValAddress(pubkeys[2].Address()),
 	}
 
+	// The default power validators are initialized to have within tests
 	initAmt   = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 )
diff --git a/x/slashing/init_test.go b/x/slashing/init_test.go
index fac4f3f32625..a2217cfda7b0 100644
--- a/x/slashing/init_test.go
+++ b/x/slashing/init_test.go
@@ -5,5 +5,6 @@ import (
 )
 
 var (
+	// The default power validators are initialized to have within tests
 	InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 )
diff --git a/x/slashing/keeper/common_test.go b/x/slashing/keeper/common_test.go
index aed5aa920393..91a972ed1110 100644
--- a/x/slashing/keeper/common_test.go
+++ b/x/slashing/keeper/common_test.go
@@ -3,5 +3,6 @@ package keeper_test
 import sdk "github.com/cosmos/cosmos-sdk/types"
 
 var (
+	// The default power validators are initialized to have within tests
 	InitTokens = sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 )
diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go
index b8e1c3d4584c..20333d62ff11 100644
--- a/x/staking/keeper/val_state_change.go
+++ b/x/staking/keeper/val_state_change.go
@@ -110,7 +110,9 @@ func (k Keeper) BlockValidatorUpdates(ctx sdk.Context) []abci.ValidatorUpdate {
 // at the previous block height or were removed from the validator set entirely
 // are returned to Tendermint.
 func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []abci.ValidatorUpdate, err error) {
-	maxValidators := k.GetParams(ctx).MaxValidators
+	params := k.GetParams(ctx)
+	maxValidators := params.MaxValidators
+	powerReduction := params.PowerReduction
 	totalPower := sdk.ZeroInt()
 	amtFromBondedToNotBonded, amtFromNotBondedToBonded := sdk.ZeroInt(), sdk.ZeroInt()
 
@@ -164,12 +166,12 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 
 		copy(valAddrBytes[:], valAddr[:])
 		oldPowerBytes, found := last[valAddrBytes]
-		newPower := validator.ConsensusPower(k.PowerReduction(ctx))
+		newPower := validator.ConsensusPower(powerReduction)
 		newPowerBytes := k.cdc.MustMarshalBinaryBare(&gogotypes.Int64Value{Value: newPower})
 
 		// update the validator set if power has changed
 		if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) {
-			updates = append(updates, validator.ABCIValidatorUpdate(k.PowerReduction(ctx)))
+			updates = append(updates, validator.ABCIValidatorUpdate(powerReduction))
 
 			k.SetLastValidatorPower(ctx, valAddr, newPower)
 		}
diff --git a/x/staking/legacy/v040/commission.go b/x/staking/legacy/v040/commission.go
new file mode 100644
index 000000000000..c7d4044a213d
--- /dev/null
+++ b/x/staking/legacy/v040/commission.go
@@ -0,0 +1,17 @@
+package v040
+
+import (
+	yaml "gopkg.in/yaml.v2"
+)
+
+// String implements the Stringer interface for a Commission object.
+func (c Commission) String() string {
+	out, _ := yaml.Marshal(c)
+	return string(out)
+}
+
+// String implements the Stringer interface for a CommissionRates object.
+func (cr CommissionRates) String() string {
+	out, _ := yaml.Marshal(cr)
+	return string(out)
+}
diff --git a/x/staking/legacy/v040/delegation.go b/x/staking/legacy/v040/delegation.go
new file mode 100644
index 000000000000..8c3f99874cee
--- /dev/null
+++ b/x/staking/legacy/v040/delegation.go
@@ -0,0 +1,100 @@
+package v040
+
+import (
+	"fmt"
+	"strings"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+// String returns a human readable string representation of a Delegation.
+func (d Delegation) String() string {
+	out, _ := yaml.Marshal(d)
+	return string(out)
+}
+
+// Delegations is a collection of delegations
+type Delegations []Delegation
+
+func (d Delegations) String() (out string) {
+	for _, del := range d {
+		out += del.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the stringer interface for a UnbondingDelegationEntry.
+func (e UnbondingDelegationEntry) String() string {
+	out, _ := yaml.Marshal(e)
+	return string(out)
+}
+
+// String returns a human readable string representation of an UnbondingDelegation.
+func (ubd UnbondingDelegation) String() string {
+	out := fmt.Sprintf(`Unbonding Delegations between:
+  Delegator:                 %s
+  Validator:                 %s
+	Entries:`, ubd.DelegatorAddress, ubd.ValidatorAddress)
+	for i, entry := range ubd.Entries {
+		out += fmt.Sprintf(`    Unbonding Delegation %d:
+      Creation Height:           %v
+      Min time to unbond (unix): %v
+      Expected balance:          %s`, i, entry.CreationHeight,
+			entry.CompletionTime, entry.Balance)
+	}
+
+	return out
+}
+
+// UnbondingDelegations is a collection of UnbondingDelegation
+type UnbondingDelegations []UnbondingDelegation
+
+func (ubds UnbondingDelegations) String() (out string) {
+	for _, u := range ubds {
+		out += u.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the Stringer interface for a RedelegationEntry object.
+func (e RedelegationEntry) String() string {
+	out, _ := yaml.Marshal(e)
+	return string(out)
+}
+
+// String returns a human readable string representation of a Redelegation.
+func (red Redelegation) String() string {
+	out := fmt.Sprintf(`Redelegations between:
+  Delegator:                 %s
+  Source Validator:          %s
+  Destination Validator:     %s
+  Entries:
+`,
+		red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress,
+	)
+
+	for i, entry := range red.Entries {
+		out += fmt.Sprintf(`    Redelegation Entry #%d:
+      Creation height:           %v
+      Min time to unbond (unix): %v
+      Dest Shares:               %s
+`,
+			i, entry.CreationHeight, entry.CompletionTime, entry.SharesDst,
+		)
+	}
+
+	return strings.TrimRight(out, "\n")
+}
+
+// Redelegations are a collection of Redelegation
+type Redelegations []Redelegation
+
+func (d Redelegations) String() (out string) {
+	for _, red := range d {
+		out += red.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
diff --git a/x/staking/legacy/v040/genesis.pb.go b/x/staking/legacy/v040/genesis.pb.go
new file mode 100644
index 000000000000..11649dfde948
--- /dev/null
+++ b/x/staking/legacy/v040/genesis.pb.go
@@ -0,0 +1,777 @@
+package v040
+
+import (
+	fmt "fmt"
+	io "io"
+	math_bits "math/bits"
+
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+)
+
+// GenesisState defines the staking module's genesis state.
+type GenesisState struct {
+	// params defines all the paramaters of related to deposit.
+	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	// last_total_power tracks the total amounts of bonded tokens recorded during
+	// the previous end block.
+	LastTotalPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power" yaml:"last_total_power"`
+	// last_validator_powers is a special index that provides a historical list
+	// of the last-block's bonded validators.
+	LastValidatorPowers []LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers" yaml:"last_validator_powers"`
+	// delegations defines the validator set at genesis.
+	Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"`
+	// delegations defines the delegations active at genesis.
+	Delegations []Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"`
+	// unbonding_delegations defines the unbonding delegations active at genesis.
+	UnbondingDelegations []UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations" yaml:"unbonding_delegations"`
+	// redelegations defines the redelegations active at genesis.
+	Redelegations []Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"`
+	Exported      bool           `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"`
+}
+
+func (m *GenesisState) Reset()         { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage()    {}
+
+// LastValidatorPower required for validator set update logic.
+type LastValidatorPower struct {
+	// address is the address of the validator.
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	// power defines the power of the validator.
+	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
+}
+
+func (m *LastValidatorPower) Reset()         { *m = LastValidatorPower{} }
+func (m *LastValidatorPower) String() string { return proto.CompactTextString(m) }
+func (*LastValidatorPower) ProtoMessage()    {}
+
+func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Exported {
+		i--
+		if m.Exported {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x40
+	}
+	if len(m.Redelegations) > 0 {
+		for iNdEx := len(m.Redelegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Redelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x3a
+		}
+	}
+	if len(m.UnbondingDelegations) > 0 {
+		for iNdEx := len(m.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.UnbondingDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if len(m.Delegations) > 0 {
+		for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
+	if len(m.Validators) > 0 {
+		for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.LastValidatorPowers) > 0 {
+		for iNdEx := len(m.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.LastValidatorPowers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	{
+		size := m.LastTotalPower.Size()
+		i -= size
+		if _, err := m.LastTotalPower.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *LastValidatorPower) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LastValidatorPower) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LastValidatorPower) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Power != 0 {
+		i = encodeVarintGenesis(dAtA, i, uint64(m.Power))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenesis(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GenesisState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Params.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	l = m.LastTotalPower.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	if len(m.LastValidatorPowers) > 0 {
+		for _, e := range m.LastValidatorPowers {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Validators) > 0 {
+		for _, e := range m.Validators {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Delegations) > 0 {
+		for _, e := range m.Delegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.UnbondingDelegations) > 0 {
+		for _, e := range m.UnbondingDelegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Redelegations) > 0 {
+		for _, e := range m.Redelegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if m.Exported {
+		n += 2
+	}
+	return n
+}
+
+func (m *LastValidatorPower) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovGenesis(uint64(l))
+	}
+	if m.Power != 0 {
+		n += 1 + sovGenesis(uint64(m.Power))
+	}
+	return n
+}
+
+func sovGenesis(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastTotalPower", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.LastTotalPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.LastValidatorPowers = append(m.LastValidatorPowers, LastValidatorPower{})
+			if err := m.LastValidatorPowers[len(m.LastValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Validators = append(m.Validators, Validator{})
+			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Delegations = append(m.Delegations, Delegation{})
+			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.UnbondingDelegations = append(m.UnbondingDelegations, UnbondingDelegation{})
+			if err := m.UnbondingDelegations[len(m.UnbondingDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Redelegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Redelegations = append(m.Redelegations, Redelegation{})
+			if err := m.Redelegations[len(m.Redelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Exported = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LastValidatorPower) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LastValidatorPower: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LastValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
+			}
+			m.Power = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Power |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthGenesis
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupGenesis
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthGenesis
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/staking/legacy/v040/types.go b/x/staking/legacy/v040/keys.go
similarity index 100%
rename from x/staking/legacy/v040/types.go
rename to x/staking/legacy/v040/keys.go
diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go
index 87ec0000efb7..a0d9b4c90378 100644
--- a/x/staking/legacy/v040/migrate.go
+++ b/x/staking/legacy/v040/migrate.go
@@ -4,22 +4,20 @@ import (
 	"fmt"
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	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) v040staking.BondStatus {
+func migrateBondStatus(oldStatus v034staking.BondStatus) BondStatus {
 	switch oldStatus {
 	case v034staking.Unbonded:
-		return v040staking.Unbonded
+		return Unbonded
 
 	case v034staking.Unbonding:
-		return v040staking.Unbonding
+		return Unbonding
 
 	case v034staking.Bonded:
-		return v040staking.Bonded
+		return Bonded
 
 	default:
 		panic(fmt.Errorf("invalid bond status %d", oldStatus))
@@ -32,29 +30,29 @@ func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus
 // - 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))
+func Migrate(stakingState v038staking.GenesisState) *GenesisState {
+	newLastValidatorPowers := make([]LastValidatorPower, len(stakingState.LastValidatorPowers))
 	for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
-		newLastValidatorPowers[i] = v040staking.LastValidatorPower{
+		newLastValidatorPowers[i] = LastValidatorPower{
 			Address: oldLastValidatorPower.Address.String(),
 			Power:   oldLastValidatorPower.Power,
 		}
 	}
 
-	newValidators := make([]v040staking.Validator, len(stakingState.Validators))
+	newValidators := make([]Validator, len(stakingState.Validators))
 	for i, oldValidator := range stakingState.Validators {
 		pkAny, err := codectypes.NewAnyWithValue(oldValidator.ConsPubKey)
 		if err != nil {
 			panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
 		}
-		newValidators[i] = v040staking.Validator{
+		newValidators[i] = Validator{
 			OperatorAddress: oldValidator.OperatorAddress.String(),
 			ConsensusPubkey: pkAny,
 			Jailed:          oldValidator.Jailed,
 			Status:          migrateBondStatus(oldValidator.Status),
 			Tokens:          oldValidator.Tokens,
 			DelegatorShares: oldValidator.DelegatorShares,
-			Description: v040staking.Description{
+			Description: Description{
 				Moniker:         oldValidator.Description.Moniker,
 				Identity:        oldValidator.Description.Identity,
 				Website:         oldValidator.Description.Website,
@@ -63,8 +61,8 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			},
 			UnbondingHeight: oldValidator.UnbondingHeight,
 			UnbondingTime:   oldValidator.UnbondingCompletionTime,
-			Commission: v040staking.Commission{
-				CommissionRates: v040staking.CommissionRates{
+			Commission: Commission{
+				CommissionRates: CommissionRates{
 					Rate:          oldValidator.Commission.Rate,
 					MaxRate:       oldValidator.Commission.MaxRate,
 					MaxChangeRate: oldValidator.Commission.MaxChangeRate,
@@ -75,20 +73,20 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 		}
 	}
 
-	newDelegations := make([]v040staking.Delegation, len(stakingState.Delegations))
+	newDelegations := make([]Delegation, len(stakingState.Delegations))
 	for i, oldDelegation := range stakingState.Delegations {
-		newDelegations[i] = v040staking.Delegation{
+		newDelegations[i] = Delegation{
 			DelegatorAddress: oldDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldDelegation.ValidatorAddress.String(),
 			Shares:           oldDelegation.Shares,
 		}
 	}
 
-	newUnbondingDelegations := make([]v040staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
+	newUnbondingDelegations := make([]UnbondingDelegation, len(stakingState.UnbondingDelegations))
 	for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
-		newEntries := make([]v040staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
+		newEntries := make([]UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
 		for j, oldEntry := range oldUnbondingDelegation.Entries {
-			newEntries[j] = v040staking.UnbondingDelegationEntry{
+			newEntries[j] = UnbondingDelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -96,18 +94,18 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			}
 		}
 
-		newUnbondingDelegations[i] = v040staking.UnbondingDelegation{
+		newUnbondingDelegations[i] = UnbondingDelegation{
 			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(),
 			Entries:          newEntries,
 		}
 	}
 
-	newRedelegations := make([]v040staking.Redelegation, len(stakingState.Redelegations))
+	newRedelegations := make([]Redelegation, len(stakingState.Redelegations))
 	for i, oldRedelegation := range stakingState.Redelegations {
-		newEntries := make([]v040staking.RedelegationEntry, len(oldRedelegation.Entries))
+		newEntries := make([]RedelegationEntry, len(oldRedelegation.Entries))
 		for j, oldEntry := range oldRedelegation.Entries {
-			newEntries[j] = v040staking.RedelegationEntry{
+			newEntries[j] = RedelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -115,7 +113,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			}
 		}
 
-		newRedelegations[i] = v040staking.Redelegation{
+		newRedelegations[i] = Redelegation{
 			DelegatorAddress:    oldRedelegation.DelegatorAddress.String(),
 			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(),
 			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(),
@@ -123,14 +121,13 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 		}
 	}
 
-	return &v040staking.GenesisState{
-		Params: v040staking.Params{
+	return &GenesisState{
+		Params: Params{
 			UnbondingTime:     stakingState.Params.UnbondingTime,
 			MaxValidators:     uint32(stakingState.Params.MaxValidators),
 			MaxEntries:        uint32(stakingState.Params.MaxEntries),
 			HistoricalEntries: uint32(stakingState.Params.HistoricalEntries),
 			BondDenom:         stakingState.Params.BondDenom,
-			PowerReduction:    sdk.DefaultPowerReduction,
 		},
 		LastTotalPower:       stakingState.LastTotalPower,
 		LastValidatorPowers:  newLastValidatorPowers,
diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go
index 16bb4374b503..2be5e80dbc31 100644
--- a/x/staking/legacy/v040/migrate_test.go
+++ b/x/staking/legacy/v040/migrate_test.go
@@ -55,7 +55,6 @@ func TestMigrate(t *testing.T) {
     "historical_entries": 0,
     "max_entries": 0,
     "max_validators": 0,
-    "power_reduction": "1000000",
     "unbonding_time": "0s"
   },
   "redelegations": [],
diff --git a/x/staking/legacy/v040/params.go b/x/staking/legacy/v040/params.go
new file mode 100644
index 000000000000..32ad0c72ebba
--- /dev/null
+++ b/x/staking/legacy/v040/params.go
@@ -0,0 +1,11 @@
+package v040
+
+import (
+	yaml "gopkg.in/yaml.v2"
+)
+
+// String returns a human readable string representation of the parameters.
+func (p Params) String() string {
+	out, _ := yaml.Marshal(p)
+	return string(out)
+}
diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
new file mode 100644
index 000000000000..f5bd8fe5e7cd
--- /dev/null
+++ b/x/staking/legacy/v040/staking.pb.go
@@ -0,0 +1,3293 @@
+package v040
+
+import (
+	fmt "fmt"
+	io "io"
+	math_bits "math/bits"
+	reflect "reflect"
+	strings "strings"
+	time "time"
+
+	types1 "github.com/cosmos/cosmos-sdk/codec/types"
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	types2 "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	_ "github.com/golang/protobuf/ptypes/duration"
+	_ "github.com/golang/protobuf/ptypes/timestamp"
+	_ "github.com/regen-network/cosmos-proto"
+)
+
+// 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: "BOND_STATUS_UNSPECIFIED",
+	1: "BOND_STATUS_UNBONDED",
+	2: "BOND_STATUS_UNBONDING",
+	3: "BOND_STATUS_BONDED",
+}
+
+var BondStatus_value = map[string]int32{
+	"BOND_STATUS_UNSPECIFIED": 0,
+	"BOND_STATUS_UNBONDED":    1,
+	"BOND_STATUS_UNBONDING":   2,
+	"BOND_STATUS_BONDED":      3,
+}
+
+func (x BondStatus) String() string {
+	return proto.EnumName(BondStatus_name, int32(x))
+}
+
+// CommissionRates defines the initial commission rates to be used for creating
+// a validator.
+type CommissionRates struct {
+	Rate          github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
+	MaxRate       github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
+	MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
+}
+
+func (m *CommissionRates) Reset()      { *m = CommissionRates{} }
+func (*CommissionRates) ProtoMessage() {}
+
+// Commission defines commission parameters for a given validator.
+type Commission struct {
+	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
+	UpdateTime      time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
+}
+
+func (m *Commission) Reset()      { *m = Commission{} }
+func (*Commission) ProtoMessage() {}
+
+// Description defines a validator description.
+type Description struct {
+	Moniker         string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
+	Identity        string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
+	Website         string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
+	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty" yaml:"security_contact"`
+	Details         string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
+}
+
+func (m *Description) Reset()      { *m = Description{} }
+func (*Description) ProtoMessage() {}
+
+// Validator defines a validator, together with the total amount of the
+// Validator's bond shares and their exchange rate to coins. Slashing results in
+// a decrease in the exchange rate, allowing correct calculation of future
+// undelegations without iterating over delegators. When coins are delegated to
+// this validator, the validator is credited with a delegation whose number of
+// bond shares is based on the amount of coins delegated divided by the current
+// 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   *types1.Any                            `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{} }
+func (*Validator) ProtoMessage() {}
+
+// ValAddresses defines a repeated set of validator addresses.
+type ValAddresses struct {
+	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
+}
+
+func (m *ValAddresses) Reset()      { *m = ValAddresses{} }
+func (*ValAddresses) ProtoMessage() {}
+
+// Delegation represents the bond with tokens held by an account. It is
+// owned by one delegator, and is associated with the voting power of one
+// validator.
+type Delegation struct {
+	DelegatorAddress string                                 `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string                                 `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	Shares           github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
+}
+
+func (m *Delegation) Reset()      { *m = Delegation{} }
+func (*Delegation) ProtoMessage() {}
+
+// UnbondingDelegation stores all of a single delegator's unbonding bonds
+// for a single validator in an time-ordered list.
+type UnbondingDelegation struct {
+	DelegatorAddress string                     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string                     `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	Entries          []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *UnbondingDelegation) Reset()      { *m = UnbondingDelegation{} }
+func (*UnbondingDelegation) ProtoMessage() {}
+
+// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
+type UnbondingDelegationEntry struct {
+	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	Balance        github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
+}
+
+func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
+func (*UnbondingDelegationEntry) ProtoMessage() {}
+
+// RedelegationEntry defines a redelegation object with relevant metadata.
+type RedelegationEntry struct {
+	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	SharesDst      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
+}
+
+func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
+func (*RedelegationEntry) ProtoMessage() {}
+
+// Redelegation contains the list of a particular delegator's redelegating bonds
+// from a particular source validator to a particular destination validator.
+type Redelegation struct {
+	DelegatorAddress    string              `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorSrcAddress string              `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
+	ValidatorDstAddress string              `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
+	Entries             []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *Redelegation) Reset()      { *m = Redelegation{} }
+func (*Redelegation) ProtoMessage() {}
+
+// Params defines the parameters for the staking module.
+type Params struct {
+	UnbondingTime     time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
+	MaxValidators     uint32        `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
+	MaxEntries        uint32        `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
+	HistoricalEntries uint32        `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
+	BondDenom         string        `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
+}
+
+func (m *Params) Reset()      { *m = Params{} }
+func (*Params) ProtoMessage() {}
+
+// DelegationResponse is equivalent to Delegation except that it contains a
+// balance in addition to shares which is more suitable for client responses.
+type DelegationResponse struct {
+	Delegation Delegation  `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
+	Balance    types2.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
+}
+
+// Pool is used for tracking bonded and not-bonded token supply of the bond
+// denomination.
+type Pool struct {
+	NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
+	BondedTokens    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"`
+}
+
+func (m *Pool) Reset()         { *m = Pool{} }
+func (m *Pool) String() string { return proto.CompactTextString(m) }
+func (*Pool) ProtoMessage()    {}
+
+func (m *CommissionRates) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *CommissionRates) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CommissionRates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.MaxChangeRate.Size()
+		i -= size
+		if _, err := m.MaxChangeRate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size := m.MaxRate.Size()
+		i -= size
+		if _, err := m.MaxRate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size := m.Rate.Size()
+		i -= size
+		if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Commission) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Commission) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):])
+	if err2 != nil {
+		return 0, err2
+	}
+	i -= n2
+	i = encodeVarintStaking(dAtA, i, uint64(n2))
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.CommissionRates.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Description) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Description) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Description) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Details) > 0 {
+		i -= len(m.Details)
+		copy(dAtA[i:], m.Details)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Details)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.SecurityContact) > 0 {
+		i -= len(m.SecurityContact)
+		copy(dAtA[i:], m.SecurityContact)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.SecurityContact)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Website) > 0 {
+		i -= len(m.Website)
+		copy(dAtA[i:], m.Website)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Website)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Identity) > 0 {
+		i -= len(m.Identity)
+		copy(dAtA[i:], m.Identity)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Identity)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Moniker) > 0 {
+		i -= len(m.Moniker)
+		copy(dAtA[i:], m.Moniker)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Moniker)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Validator) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.MinSelfDelegation.Size()
+		i -= size
+		if _, err := m.MinSelfDelegation.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x5a
+	{
+		size, err := m.Commission.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x52
+	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):])
+	if err5 != nil {
+		return 0, err5
+	}
+	i -= n5
+	i = encodeVarintStaking(dAtA, i, uint64(n5))
+	i--
+	dAtA[i] = 0x4a
+	if m.UnbondingHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.UnbondingHeight))
+		i--
+		dAtA[i] = 0x40
+	}
+	{
+		size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x3a
+	{
+		size := m.DelegatorShares.Size()
+		i -= size
+		if _, err := m.DelegatorShares.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x32
+	{
+		size := m.Tokens.Size()
+		i -= size
+		if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x2a
+	if m.Status != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.Status))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.Jailed {
+		i--
+		if m.Jailed {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.ConsensusPubkey != nil {
+		{
+			size, err := m.ConsensusPubkey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStaking(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.OperatorAddress) > 0 {
+		i -= len(m.OperatorAddress)
+		copy(dAtA[i:], m.OperatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.OperatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValAddresses) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ValAddresses) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Addresses) > 0 {
+		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Addresses[iNdEx])
+			copy(dAtA[i:], m.Addresses[iNdEx])
+			i = encodeVarintStaking(dAtA, i, uint64(len(m.Addresses[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Delegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Delegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Delegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Shares.Size()
+		i -= size
+		if _, err := m.Shares.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *UnbondingDelegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnbondingDelegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnbondingDelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *UnbondingDelegationEntry) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnbondingDelegationEntry) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Balance.Size()
+		i -= size
+		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	{
+		size := m.InitialBalance.Size()
+		i -= size
+		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
+	if err8 != nil {
+		return 0, err8
+	}
+	i -= n8
+	i = encodeVarintStaking(dAtA, i, uint64(n8))
+	i--
+	dAtA[i] = 0x12
+	if m.CreationHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *RedelegationEntry) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RedelegationEntry) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.SharesDst.Size()
+		i -= size
+		if _, err := m.SharesDst.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	{
+		size := m.InitialBalance.Size()
+		i -= size
+		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
+	if err9 != nil {
+		return 0, err9
+	}
+	i -= n9
+	i = encodeVarintStaking(dAtA, i, uint64(n9))
+	i--
+	dAtA[i] = 0x12
+	if m.CreationHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Redelegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Redelegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Redelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.ValidatorDstAddress) > 0 {
+		i -= len(m.ValidatorDstAddress)
+		copy(dAtA[i:], m.ValidatorDstAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.ValidatorSrcAddress) > 0 {
+		i -= len(m.ValidatorSrcAddress)
+		copy(dAtA[i:], m.ValidatorSrcAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Params) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Params) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i--
+	dAtA[i] = 0x32
+	if len(m.BondDenom) > 0 {
+		i -= len(m.BondDenom)
+		copy(dAtA[i:], m.BondDenom)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.HistoricalEntries != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.HistoricalEntries))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.MaxEntries != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.MaxEntries))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.MaxValidators != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.MaxValidators))
+		i--
+		dAtA[i] = 0x10
+	}
+	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):])
+	if err10 != nil {
+		return 0, err10
+	}
+	i -= n10
+	i = encodeVarintStaking(dAtA, i, uint64(n10))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Pool) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Pool) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.BondedTokens.Size()
+		i -= size
+		if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size := m.NotBondedTokens.Size()
+		i -= size
+		if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintStaking(dAtA []byte, offset int, v uint64) int {
+	offset -= sovStaking(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+
+func (m *CommissionRates) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Rate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MaxRate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MaxChangeRate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Commission) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.CommissionRates.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime)
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Description) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Moniker)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Identity)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Website)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.SecurityContact)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Details)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	return n
+}
+
+func (m *Validator) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.OperatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if m.ConsensusPubkey != nil {
+		l = m.ConsensusPubkey.Size()
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if m.Jailed {
+		n += 2
+	}
+	if m.Status != 0 {
+		n += 1 + sovStaking(uint64(m.Status))
+	}
+	l = m.Tokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.DelegatorShares.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Description.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	if m.UnbondingHeight != 0 {
+		n += 1 + sovStaking(uint64(m.UnbondingHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Commission.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MinSelfDelegation.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *ValAddresses) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Addresses) > 0 {
+		for _, s := range m.Addresses {
+			l = len(s)
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Delegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = m.Shares.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *UnbondingDelegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *UnbondingDelegationEntry) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreationHeight != 0 {
+		n += 1 + sovStaking(uint64(m.CreationHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.InitialBalance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Balance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *RedelegationEntry) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreationHeight != 0 {
+		n += 1 + sovStaking(uint64(m.CreationHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.InitialBalance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.SharesDst.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Redelegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorSrcAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorDstAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Params) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime)
+	n += 1 + l + sovStaking(uint64(l))
+	if m.MaxValidators != 0 {
+		n += 1 + sovStaking(uint64(m.MaxValidators))
+	}
+	if m.MaxEntries != 0 {
+		n += 1 + sovStaking(uint64(m.MaxEntries))
+	}
+	if m.HistoricalEntries != 0 {
+		n += 1 + sovStaking(uint64(m.HistoricalEntries))
+	}
+	l = len(m.BondDenom)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Pool) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.NotBondedTokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.BondedTokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func sovStaking(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozStaking(x uint64) (n int) {
+	return sovStaking(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (this *ValAddresses) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&ValAddresses{`,
+		`Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func valueToStringStaking(v interface{}) string {
+	rv := reflect.ValueOf(v)
+	if rv.IsNil() {
+		return "nil"
+	}
+	pv := reflect.Indirect(rv).Interface()
+	return fmt.Sprintf("*%v", pv)
+}
+
+func (m *CommissionRates) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: CommissionRates: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxRate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxChangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Commission) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Commission: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.CommissionRates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Description) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Description: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Moniker = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Identity = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Website = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SecurityContact = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Details = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Validator) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ConsensusPubkey == nil {
+				m.ConsensusPubkey = &types1.Any{}
+			}
+			if err := m.ConsensusPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Jailed = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+			}
+			m.Status = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Status |= BondStatus(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Tokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.DelegatorShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType)
+			}
+			m.UnbondingHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Commission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MinSelfDelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ValAddresses) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ValAddresses: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *Delegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Delegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Shares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *UnbondingDelegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnbondingDelegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, UnbondingDelegationEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnbondingDelegationEntry: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+			}
+			m.CreationHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreationHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RedelegationEntry) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RedelegationEntry: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+			}
+			m.CreationHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreationHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SharesDst", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.SharesDst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Redelegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Redelegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, RedelegationEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Params) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Params: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
+			}
+			m.MaxValidators = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxValidators |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType)
+			}
+			m.MaxEntries = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxEntries |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
+			}
+			m.HistoricalEntries = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.HistoricalEntries |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.BondDenom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Pool) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Pool: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipStaking(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthStaking
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupStaking
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthStaking
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthStaking        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowStaking          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupStaking = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/staking/legacy/v040/validator.go b/x/staking/legacy/v040/validator.go
new file mode 100644
index 000000000000..e68b3b6dd913
--- /dev/null
+++ b/x/staking/legacy/v040/validator.go
@@ -0,0 +1,43 @@
+package v040
+
+import (
+	"strings"
+
+	"gopkg.in/yaml.v2"
+)
+
+var (
+	BondStatusUnspecified = BondStatus_name[int32(Unspecified)]
+	BondStatusUnbonded    = BondStatus_name[int32(Unbonded)]
+	BondStatusUnbonding   = BondStatus_name[int32(Unbonding)]
+	BondStatusBonded      = BondStatus_name[int32(Bonded)]
+)
+
+// String implements the Stringer interface for a Validator object.
+func (v Validator) String() string {
+	out, _ := yaml.Marshal(v)
+	return string(out)
+}
+
+// Validators is a collection of Validator
+type Validators []Validator
+
+func (v Validators) String() (out string) {
+	for _, val := range v {
+		out += val.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// ValidatorsByVotingPower implements sort.Interface for []Validator based on
+// the VotingPower and Address fields.
+// The validators are sorted first by their voting power (descending). Secondary index - Address (ascending).
+// Copied from tendermint/types/validator_set.go
+type ValidatorsByVotingPower []Validator
+
+// String implements the Stringer interface for a Description object.
+func (d Description) String() string {
+	out, _ := yaml.Marshal(d)
+	return string(out)
+}
diff --git a/x/staking/legacy/v042/migrate.go b/x/staking/legacy/v042/migrate.go
new file mode 100644
index 000000000000..8e3a0eacc1cb
--- /dev/null
+++ b/x/staking/legacy/v042/migrate.go
@@ -0,0 +1,117 @@
+package v042
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
+	v042staking "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+// Migrate accepts exported v0.40 x/staking genesis state and migrates it to
+// v0.42 x/staking genesis state. The migration includes:
+//
+// - Adding power reduction on-chain param
+func Migrate(stakingState v040staking.GenesisState) *v042staking.GenesisState {
+	newLastValidatorPowers := make([]v042staking.LastValidatorPower, len(stakingState.LastValidatorPowers))
+	for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
+		newLastValidatorPowers[i] = v042staking.LastValidatorPower{
+			Address: oldLastValidatorPower.Address,
+			Power:   oldLastValidatorPower.Power,
+		}
+	}
+
+	newValidators := make([]v042staking.Validator, len(stakingState.Validators))
+	for i, oldValidator := range stakingState.Validators {
+		newValidators[i] = v042staking.Validator{
+			OperatorAddress: oldValidator.OperatorAddress,
+			ConsensusPubkey: oldValidator.ConsensusPubkey,
+			Jailed:          oldValidator.Jailed,
+			Status:          v042staking.BondStatus(oldValidator.Status),
+			Tokens:          oldValidator.Tokens,
+			DelegatorShares: oldValidator.DelegatorShares,
+			Description: v042staking.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.UnbondingTime,
+			Commission: v042staking.Commission{
+				CommissionRates: v042staking.CommissionRates{
+					Rate:          oldValidator.Commission.Rate,
+					MaxRate:       oldValidator.Commission.MaxRate,
+					MaxChangeRate: oldValidator.Commission.MaxChangeRate,
+				},
+				UpdateTime: oldValidator.Commission.UpdateTime,
+			},
+			MinSelfDelegation: oldValidator.MinSelfDelegation,
+		}
+	}
+
+	newDelegations := make([]v042staking.Delegation, len(stakingState.Delegations))
+	for i, oldDelegation := range stakingState.Delegations {
+		newDelegations[i] = v042staking.Delegation{
+			DelegatorAddress: oldDelegation.DelegatorAddress,
+			ValidatorAddress: oldDelegation.ValidatorAddress,
+			Shares:           oldDelegation.Shares,
+		}
+	}
+
+	newUnbondingDelegations := make([]v042staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
+	for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
+		newEntries := make([]v042staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
+		for j, oldEntry := range oldUnbondingDelegation.Entries {
+			newEntries[j] = v042staking.UnbondingDelegationEntry{
+				CreationHeight: oldEntry.CreationHeight,
+				CompletionTime: oldEntry.CompletionTime,
+				InitialBalance: oldEntry.InitialBalance,
+				Balance:        oldEntry.Balance,
+			}
+		}
+
+		newUnbondingDelegations[i] = v042staking.UnbondingDelegation{
+			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress,
+			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress,
+			Entries:          newEntries,
+		}
+	}
+
+	newRedelegations := make([]v042staking.Redelegation, len(stakingState.Redelegations))
+	for i, oldRedelegation := range stakingState.Redelegations {
+		newEntries := make([]v042staking.RedelegationEntry, len(oldRedelegation.Entries))
+		for j, oldEntry := range oldRedelegation.Entries {
+			newEntries[j] = v042staking.RedelegationEntry{
+				CreationHeight: oldEntry.CreationHeight,
+				CompletionTime: oldEntry.CompletionTime,
+				InitialBalance: oldEntry.InitialBalance,
+				SharesDst:      oldEntry.SharesDst,
+			}
+		}
+
+		newRedelegations[i] = v042staking.Redelegation{
+			DelegatorAddress:    oldRedelegation.DelegatorAddress,
+			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress,
+			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress,
+			Entries:             newEntries,
+		}
+	}
+
+	return &v042staking.GenesisState{
+		Params: v042staking.Params{
+			UnbondingTime:     stakingState.Params.UnbondingTime,
+			MaxValidators:     stakingState.Params.MaxValidators,
+			MaxEntries:        stakingState.Params.MaxEntries,
+			HistoricalEntries: stakingState.Params.HistoricalEntries,
+			BondDenom:         stakingState.Params.BondDenom,
+			PowerReduction:    sdk.DefaultPowerReduction,
+		},
+		LastTotalPower:       stakingState.LastTotalPower,
+		LastValidatorPowers:  newLastValidatorPowers,
+		Validators:           newValidators,
+		Delegations:          newDelegations,
+		UnbondingDelegations: newUnbondingDelegations,
+		Redelegations:        newRedelegations,
+		Exported:             stakingState.Exported,
+	}
+}
diff --git a/x/staking/legacy/v042/migrate_test.go b/x/staking/legacy/v042/migrate_test.go
new file mode 100644
index 000000000000..8bd00fd4db07
--- /dev/null
+++ b/x/staking/legacy/v042/migrate_test.go
@@ -0,0 +1,101 @@
+package v042_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
+	v042staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v042"
+)
+
+func TestMigrate(t *testing.T) {
+	encodingConfig := simapp.MakeTestEncodingConfig()
+	clientCtx := client.Context{}.
+		WithInterfaceRegistry(encodingConfig.InterfaceRegistry).
+		WithTxConfig(encodingConfig.TxConfig).
+		WithLegacyAmino(encodingConfig.Amino).
+		WithJSONMarshaler(encodingConfig.Marshaler)
+
+	consPubKey := ed25519.GenPrivKeyFromSecret([]byte("val0")).PubKey()
+	pkAny, err := codectypes.NewAnyWithValue(consPubKey)
+	if err != nil {
+		panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
+	}
+	stakingGenState := v040staking.GenesisState{
+		Validators: v040staking.Validators{v040staking.Validator{
+			ConsensusPubkey: pkAny,
+			Status:          v040staking.Unbonded,
+		}},
+	}
+
+	migrated := v042staking.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 an any
+	// - 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,
+    "power_reduction": "1000000",
+    "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": {
+        "@type": "/cosmos.crypto.ed25519.PubKey",
+        "key": "KTeVrjP7NJIufvgMJsQRxZjfFyD+Exda6O7x+oxIvmA="
+      },
+      "delegator_shares": "0",
+      "description": {
+        "details": "",
+        "identity": "",
+        "moniker": "",
+        "security_contact": "",
+        "website": ""
+      },
+      "jailed": false,
+      "min_self_delegation": "0",
+      "operator_address": "",
+      "status": "BOND_STATUS_UNBONDED",
+      "tokens": "0",
+      "unbonding_height": "0",
+      "unbonding_time": "0001-01-01T00:00:00Z"
+    }
+  ]
+}`
+
+	require.Equal(t, expected, string(indentedBz))
+}
diff --git a/x/staking/legacy/v042/types.go b/x/staking/legacy/v042/types.go
new file mode 100644
index 000000000000..0a7df2a327d0
--- /dev/null
+++ b/x/staking/legacy/v042/types.go
@@ -0,0 +1,5 @@
+package v042
+
+const (
+	ModuleName = "staking"
+)
diff --git a/x/staking/types/historical_info.go b/x/staking/types/historical_info.go
index c06e82dc0261..5a278a7e541d 100644
--- a/x/staking/types/historical_info.go
+++ b/x/staking/types/historical_info.go
@@ -16,7 +16,6 @@ import (
 // it will first sort valset before inclusion into historical info
 func NewHistoricalInfo(header tmproto.Header, valSet Validators, powerReduction sdk.Int) HistoricalInfo {
 	// Must sort in the same way that tendermint does
-	// TODO: check with sort.Sort(ValidatorsByVotingPower(valSet))
 	sort.SliceStable(valSet, func(i, j int) bool {
 		return ValidatorsByVotingPower(valSet).LessAfterPowerReductionApply(i, j, powerReduction)
 	})

From 7b5cf61eef0cc370f1fc6ff46008f14c86863a7c Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Tue, 2 Feb 2021 00:11:33 +1000
Subject: [PATCH 06/23] remove dependency between min deposit tokens and power
 reduction

---
 x/gov/types/params.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x/gov/types/params.go b/x/gov/types/params.go
index 45ed3ec522dc..95621e100f8e 100644
--- a/x/gov/types/params.go
+++ b/x/gov/types/params.go
@@ -17,7 +17,7 @@ const (
 
 // Default governance params
 var (
-	DefaultMinDepositTokens = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
+	DefaultMinDepositTokens = sdk.NewInt(10000000)
 	DefaultQuorum           = sdk.NewDecWithPrec(334, 3)
 	DefaultThreshold        = sdk.NewDecWithPrec(5, 1)
 	DefaultVetoThreshold    = sdk.NewDecWithPrec(334, 3)

From 1c1e67fa51103c5da7f3258550867b0c1eaa92c0 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Tue, 2 Feb 2021 13:12:05 +1000
Subject: [PATCH 07/23] Less function to not use default power reduction

---
 x/staking/keeper/historical_info_test.go | 22 ++++++++++++++++++----
 x/staking/types/historical_info.go       |  2 +-
 x/staking/types/validator.go             |  6 +-----
 x/staking/types/validator_test.go        |  4 +++-
 4 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/x/staking/keeper/historical_info_test.go b/x/staking/keeper/historical_info_test.go
index 727fe58959af..db6c6a6b47af 100644
--- a/x/staking/keeper/historical_info_test.go
+++ b/x/staking/keeper/historical_info_test.go
@@ -1,7 +1,6 @@
 package keeper_test
 
 import (
-	"sort"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -13,6 +12,17 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
+// IsValSetSorted reports whether valset is sorted.
+func IsValSetSorted(data []types.Validator, powerReduction sdk.Int) bool {
+	n := len(data)
+	for i := n - 1; i > 0; i-- {
+		if types.ValidatorsByVotingPower(data).Less(i, i-1, powerReduction) {
+			return false
+		}
+	}
+	return true
+}
+
 func TestHistoricalInfo(t *testing.T) {
 	_, app, ctx := createTestInput()
 
@@ -31,7 +41,7 @@ func TestHistoricalInfo(t *testing.T) {
 	recv, found := app.StakingKeeper.GetHistoricalInfo(ctx, 2)
 	require.True(t, found, "HistoricalInfo not found after set")
 	require.Equal(t, hi, recv, "HistoricalInfo not equal")
-	require.True(t, sort.IsSorted(types.ValidatorsByVotingPower(recv.Valset)), "HistoricalInfo validators is not sorted")
+	require.True(t, IsValSetSorted(recv.Valset, app.StakingKeeper.PowerReduction(ctx)), "HistoricalInfo validators is not sorted")
 
 	app.StakingKeeper.DeleteHistoricalInfo(ctx, 2)
 
@@ -78,14 +88,18 @@ func TestTrackHistoricalInfo(t *testing.T) {
 
 	// Set bonded validators in keeper
 	val1 := teststaking.NewValidator(t, addrVals[2], PKs[2])
+	val1.Status = types.Bonded // when not bonded, consensus power is Zero
+	val1.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 10)
 	app.StakingKeeper.SetValidator(ctx, val1)
 	app.StakingKeeper.SetLastValidatorPower(ctx, val1.GetOperator(), 10)
 	val2 := teststaking.NewValidator(t, addrVals[3], PKs[3])
+	val1.Status = types.Bonded
+	val2.Tokens = app.StakingKeeper.TokensFromConsensusPower(ctx, 80)
 	app.StakingKeeper.SetValidator(ctx, val2)
 	app.StakingKeeper.SetLastValidatorPower(ctx, val2.GetOperator(), 80)
 
 	vals := []types.Validator{val1, val2}
-	sort.Sort(types.ValidatorsByVotingPower(vals))
+	IsValSetSorted(vals, app.StakingKeeper.PowerReduction(ctx))
 
 	// Set Header for BeginBlock context
 	header := tmproto.Header{
@@ -103,7 +117,7 @@ func TestTrackHistoricalInfo(t *testing.T) {
 	}
 	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 10)
 	require.True(t, found, "GetHistoricalInfo failed after BeginBlock")
-	require.Equal(t, expected, recv, "GetHistoricalInfo returned eunexpected result")
+	require.Equal(t, expected, recv, "GetHistoricalInfo returned unexpected result")
 
 	// Check HistoricalInfo at height 5, 4 is pruned
 	recv, found = app.StakingKeeper.GetHistoricalInfo(ctx, 4)
diff --git a/x/staking/types/historical_info.go b/x/staking/types/historical_info.go
index 5a278a7e541d..6e474bb0c673 100644
--- a/x/staking/types/historical_info.go
+++ b/x/staking/types/historical_info.go
@@ -17,7 +17,7 @@ import (
 func NewHistoricalInfo(header tmproto.Header, valSet Validators, powerReduction sdk.Int) HistoricalInfo {
 	// Must sort in the same way that tendermint does
 	sort.SliceStable(valSet, func(i, j int) bool {
-		return ValidatorsByVotingPower(valSet).LessAfterPowerReductionApply(i, j, powerReduction)
+		return ValidatorsByVotingPower(valSet).Less(i, j, powerReduction)
 	})
 
 	return HistoricalInfo{
diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go
index 5cf55db5d636..d8b113bbc56e 100644
--- a/x/staking/types/validator.go
+++ b/x/staking/types/validator.go
@@ -116,11 +116,7 @@ type ValidatorsByVotingPower []Validator
 
 func (valz ValidatorsByVotingPower) Len() int { return len(valz) }
 
-func (valz ValidatorsByVotingPower) Less(i, j int) bool {
-	return valz.LessAfterPowerReductionApply(i, j, sdk.DefaultPowerReduction)
-}
-
-func (valz ValidatorsByVotingPower) LessAfterPowerReductionApply(i, j int, powerReduction sdk.Int) bool {
+func (valz ValidatorsByVotingPower) Less(i, j int, powerReduction sdk.Int) bool {
 	if valz[i].ConsensusPower(powerReduction) == valz[j].ConsensusPower(powerReduction) {
 		addrI, errI := valz[i].GetConsAddr()
 		addrJ, errJ := valz[j].GetConsAddr()
diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go
index f7888b7e425f..8601fbeec723 100644
--- a/x/staking/types/validator_test.go
+++ b/x/staking/types/validator_test.go
@@ -295,7 +295,9 @@ func TestValidatorsSortTendermint(t *testing.T) {
 	sort.Sort(tmtypes.ValidatorsByVotingPower(expectedVals))
 
 	// sort in SDK and then convert to tendermint
-	sort.Sort(types.ValidatorsByVotingPower(valz))
+	sort.SliceStable(valz, func(i, j int) bool {
+		return types.ValidatorsByVotingPower(valz).Less(i, j, sdk.DefaultPowerReduction)
+	})
 	actualVals, err := teststaking.ToTmValidators(valz, sdk.DefaultPowerReduction)
 	require.NoError(t, err)
 

From 5acdc07df4e143cfe1ca55c413eebcfb333c72e1 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 19:59:37 +1000
Subject: [PATCH 08/23] reduce power reduction var name

---
 x/staking/teststaking/tm.go  |  8 ++++----
 x/staking/types/validator.go | 22 +++++++++++-----------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/x/staking/teststaking/tm.go b/x/staking/teststaking/tm.go
index 4c0863f593cd..e927c0e0387a 100644
--- a/x/staking/teststaking/tm.go
+++ b/x/staking/teststaking/tm.go
@@ -20,21 +20,21 @@ func GetTmConsPubKey(v types.Validator) (tmcrypto.PubKey, error) {
 }
 
 // ToTmValidator casts an SDK validator to a tendermint type Validator.
-func ToTmValidator(v types.Validator, powerReduction sdk.Int) (*tmtypes.Validator, error) {
+func ToTmValidator(v types.Validator, r sdk.Int) (*tmtypes.Validator, error) {
 	tmPk, err := GetTmConsPubKey(v)
 	if err != nil {
 		return nil, err
 	}
 
-	return tmtypes.NewValidator(tmPk, v.ConsensusPower(powerReduction)), nil
+	return tmtypes.NewValidator(tmPk, v.ConsensusPower(r)), nil
 }
 
 // ToTmValidators casts all validators to the corresponding tendermint type.
-func ToTmValidators(v types.Validators, powerReduction sdk.Int) ([]*tmtypes.Validator, error) {
+func ToTmValidators(v types.Validators, r sdk.Int) ([]*tmtypes.Validator, error) {
 	validators := make([]*tmtypes.Validator, len(v))
 	var err error
 	for i, val := range v {
-		validators[i], err = ToTmValidator(val, powerReduction)
+		validators[i], err = ToTmValidator(val, r)
 		if err != nil {
 			return nil, err
 		}
diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go
index d8b113bbc56e..1bed8192cc52 100644
--- a/x/staking/types/validator.go
+++ b/x/staking/types/validator.go
@@ -116,8 +116,8 @@ type ValidatorsByVotingPower []Validator
 
 func (valz ValidatorsByVotingPower) Len() int { return len(valz) }
 
-func (valz ValidatorsByVotingPower) Less(i, j int, powerReduction sdk.Int) bool {
-	if valz[i].ConsensusPower(powerReduction) == valz[j].ConsensusPower(powerReduction) {
+func (valz ValidatorsByVotingPower) Less(i, j int, r sdk.Int) bool {
+	if valz[i].ConsensusPower(r) == valz[j].ConsensusPower(r) {
 		addrI, errI := valz[i].GetConsAddr()
 		addrJ, errJ := valz[j].GetConsAddr()
 		// If either returns error, then return false
@@ -126,7 +126,7 @@ func (valz ValidatorsByVotingPower) Less(i, j int, powerReduction sdk.Int) bool
 		}
 		return bytes.Compare(addrI, addrJ) == -1
 	}
-	return valz[i].ConsensusPower(powerReduction) > valz[j].ConsensusPower(powerReduction)
+	return valz[i].ConsensusPower(r) > valz[j].ConsensusPower(r)
 }
 
 func (valz ValidatorsByVotingPower) Swap(i, j int) {
@@ -257,7 +257,7 @@ func (d Description) EnsureLength() (Description, error) {
 
 // ABCIValidatorUpdate returns an abci.ValidatorUpdate from a staking validator type
 // with the full validator power
-func (v Validator) ABCIValidatorUpdate(powerReduction sdk.Int) abci.ValidatorUpdate {
+func (v Validator) ABCIValidatorUpdate(r sdk.Int) abci.ValidatorUpdate {
 	tmProtoPk, err := v.TmConsPublicKey()
 	if err != nil {
 		panic(err)
@@ -265,7 +265,7 @@ func (v Validator) ABCIValidatorUpdate(powerReduction sdk.Int) abci.ValidatorUpd
 
 	return abci.ValidatorUpdate{
 		PubKey: tmProtoPk,
-		Power:  v.ConsensusPower(powerReduction),
+		Power:  v.ConsensusPower(r),
 	}
 }
 
@@ -349,17 +349,17 @@ func (v Validator) BondedTokens() sdk.Int {
 
 // ConsensusPower gets the consensus-engine power. Aa reduction of 10^6 from
 // validator tokens is applied
-func (v Validator) ConsensusPower(powerReduction sdk.Int) int64 {
+func (v Validator) ConsensusPower(r sdk.Int) int64 {
 	if v.IsBonded() {
-		return v.PotentialConsensusPower(powerReduction)
+		return v.PotentialConsensusPower(r)
 	}
 
 	return 0
 }
 
 // PotentialConsensusPower returns the potential consensus-engine power.
-func (v Validator) PotentialConsensusPower(powerReduction sdk.Int) int64 {
-	return sdk.TokensToConsensusPower(v.Tokens, powerReduction)
+func (v Validator) PotentialConsensusPower(r sdk.Int) int64 {
+	return sdk.TokensToConsensusPower(v.Tokens, r)
 }
 
 // UpdateStatus updates the location of the shares within a validator
@@ -507,8 +507,8 @@ func (v Validator) GetConsAddr() (sdk.ConsAddress, error) {
 
 func (v Validator) GetTokens() sdk.Int       { return v.Tokens }
 func (v Validator) GetBondedTokens() sdk.Int { return v.BondedTokens() }
-func (v Validator) GetConsensusPower(powerReduction sdk.Int) int64 {
-	return v.ConsensusPower(powerReduction)
+func (v Validator) GetConsensusPower(r sdk.Int) int64 {
+	return v.ConsensusPower(r)
 }
 func (v Validator) GetCommission() sdk.Dec        { return v.Commission.Rate }
 func (v Validator) GetMinSelfDelegation() sdk.Int { return v.MinSelfDelegation }

From 2ce6d4bcba5aa59e17d356fab3a99fbee2d240ee Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 20:14:37 +1000
Subject: [PATCH 09/23] increase gas limit for redelegation only

---
 client/flags/flags.go                     | 2 +-
 x/staking/client/testutil/test_helpers.go | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/client/flags/flags.go b/client/flags/flags.go
index bf861dbf0d60..282a61c4c9fb 100644
--- a/client/flags/flags.go
+++ b/client/flags/flags.go
@@ -15,7 +15,7 @@ const (
 	// failures due to state changes that might occur between the tx simulation
 	// and the actual run.
 	DefaultGasAdjustment = 1.0
-	DefaultGasLimit      = 300000
+	DefaultGasLimit      = 200000
 	GasFlagAuto          = "auto"
 
 	// DefaultKeyringBackend
diff --git a/x/staking/client/testutil/test_helpers.go b/x/staking/client/testutil/test_helpers.go
index 1a2a4b84bcbf..e3e822703bb8 100644
--- a/x/staking/client/testutil/test_helpers.go
+++ b/x/staking/client/testutil/test_helpers.go
@@ -26,6 +26,7 @@ func MsgRedelegateExec(clientCtx client.Context, from, src, dst, amount fmt.Stri
 		dst.String(),
 		amount.String(),
 		fmt.Sprintf("--%s=%s", flags.FlagFrom, from.String()),
+		fmt.Sprintf("--%s=%d", flags.FlagGas, 300000),
 	}
 
 	args = append(args, commonArgs...)

From cc4ef50d2a37531e9c65ae0462bb4fe9bf8d7742 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 22:36:29 +1000
Subject: [PATCH 10/23] Merge cosmos-sdk master

---
 .github/workflows/docker.yml                  |    1 +
 .github/workflows/proto-docker.yml            |    1 +
 .github/workflows/test.yml                    |   20 +
 CHANGELOG.md                                  |   12 +
 Makefile                                      |    2 +-
 client/cmd.go                                 |   13 +
 client/cmd_test.go                            |    3 +-
 client/context.go                             |    8 +
 client/flags/flags.go                         |    2 +
 client/grpc/tmservice/block.go                |    4 +-
 client/grpc/tmservice/service.go              |   18 +-
 client/grpc/tmservice/status.go               |    4 +-
 client/keys/migrate.go                        |   26 +-
 client/keys/parse.go                          |    3 +-
 client/keys/testdata/keys/keys.db/000002.ldb  |  Bin 391 -> 0 bytes
 client/keys/testdata/keys/keys.db/CURRENT     |    2 +-
 client/keys/testdata/keys/keys.db/CURRENT.bak |    2 +-
 client/keys/testdata/keys/keys.db/LOG         |   48 +-
 .../testdata/keys/keys.db/MANIFEST-000004     |  Bin 237 -> 0 bytes
 .../testdata/keys/keys.db/MANIFEST-000005     |  Bin 0 -> 41 bytes
 client/query.go                               |    5 +
 client/rpc/validators.go                      |   10 +-
 client/tx/tx.go                               |    1 +
 client/tx_config.go                           |    1 +
 contrib/rosetta/configuration/bootstrap.json  |    4 +-
 contrib/rosetta/configuration/data.sh         |    5 +-
 contrib/rosetta/configuration/staking.ros     |    4 +-
 contrib/rosetta/node/data.tar.gz              |  Bin 34626 -> 36558 bytes
 crypto/armor_test.go                          |    2 +
 crypto/keyring/keyring.go                     |    1 +
 crypto/keys/internal/benchmarking/bench.go    |    1 +
 crypto/keys/secp256k1/bench_test.go           |    3 +
 docs/building-modules/beginblock-endblock.md  |    2 +-
 docs/building-modules/module-manager.md       |    5 +-
 docs/core/cli.md                              |   18 +
 docs/core/proto-docs.md                       |  424 +++-
 docs/run-node/interact-node.md                |    8 +-
 docs/run-node/run-node.md                     |    4 +-
 docs/run-node/txs.md                          |    2 +-
 proto/cosmos/feegrant/v1beta1/feegrant.proto  |   81 +
 proto/cosmos/feegrant/v1beta1/genesis.proto   |   12 +
 proto/cosmos/feegrant/v1beta1/query.proto     |   52 +
 proto/cosmos/feegrant/v1beta1/tx.proto        |   40 +
 proto/cosmos/staking/v1beta1/staking.proto    |   45 +
 server/tm_cmds.go                             |    6 +-
 server/util.go                                |   35 +
 simapp/app.go                                 |   17 +-
 simapp/export.go                              |    2 +-
 simapp/params/weights.go                      |    4 +
 simapp/sim_bench_test.go                      |    2 +
 snapshots/helpers_test.go                     |    6 +-
 snapshots/store.go                            |    6 +-
 snapshots/store_test.go                       |    6 +-
 store/cache/benchmark_test.go                 |    1 +
 store/cachekv/store_bench_test.go             |    1 +
 store/cachekv/store_test.go                   |    2 +
 store/iavl/store_test.go                      |    1 +
 store/rootmulti/store.go                      |    4 +-
 store/rootmulti/store_test.go                 |    2 +
 types/address.go                              |   14 +-
 types/address/store_key.go                    |   33 +
 types/address/store_key_test.go               |   38 +
 types/address_bench_test.go                   |    2 +
 types/address_test.go                         |   40 +-
 types/coin_benchmark_test.go                  |    4 +-
 types/decimal_test.go                         |    1 +
 types/query/filtered_pagination_test.go       |    5 +-
 types/query/pagination_test.go                |    3 +-
 x/auth/client/cli/query.go                    |    5 +-
 x/auth/keeper/keeper_bench_test.go            |    1 +
 x/auth/legacy/legacytx/stdtx_builder.go       |    3 +
 x/authz/types/keys.go                         |   19 +-
 x/bank/bench_test.go                          |    1 +
 x/bank/client/cli/query.go                    |   13 +-
 x/bank/client/testutil/cli_helpers.go         |    3 +-
 x/bank/keeper/grpc_query.go                   |    4 +-
 x/bank/keeper/send.go                         |    9 +-
 x/bank/keeper/view.go                         |   15 +-
 x/bank/types/key.go                           |   18 +-
 x/bank/types/key_test.go                      |    5 +-
 x/bank/types/metadata.go                      |   39 +-
 x/bank/types/metadata_test.go                 |   55 +-
 x/bank/types/msgs_test.go                     |   21 +-
 x/distribution/client/cli/query.go            |   16 +-
 x/distribution/client/cli/tx.go               |    3 +-
 x/distribution/types/keys.go                  |  143 +-
 x/evidence/types/evidence.go                  |    3 +-
 x/evidence/types/evidence_test.go             |   20 +
 x/feegrant/ante/ante.go                       |   35 +
 x/feegrant/ante/fee.go                        |   82 +
 x/feegrant/ante/fee_test.go                   |  287 +++
 x/feegrant/client/cli/cli_test.go             |  621 ++++++
 x/feegrant/client/cli/query.go                |  129 ++
 x/feegrant/client/cli/tx.go                   |  211 ++
 x/feegrant/client/rest/grpc_query_test.go     |  209 ++
 x/feegrant/doc.go                             |   29 +
 x/feegrant/genesis.go                         |   61 +
 x/feegrant/genesis_test.go                    |   56 +
 x/feegrant/keeper/grpc_query.go               |   94 +
 x/feegrant/keeper/keeper.go                   |  190 ++
 x/feegrant/keeper/keeper_test.go              |  257 +++
 x/feegrant/keeper/msg_server.go               |   72 +
 x/feegrant/module.go                          |  210 ++
 x/feegrant/simulation/decoder.go              |   26 +
 x/feegrant/simulation/decoder_test.go         |   62 +
 x/feegrant/simulation/genesis.go              |   38 +
 x/feegrant/simulation/genesis_test.go         |   39 +
 x/feegrant/simulation/operations.go           |  200 ++
 x/feegrant/simulation/operations_test.go      |  173 ++
 x/feegrant/types/basic_fee.go                 |   61 +
 x/feegrant/types/basic_fee_test.go            |  140 ++
 x/feegrant/types/codec.go                     |   24 +
 x/feegrant/types/errors.go                    |   21 +
 x/feegrant/types/events.go                    |   13 +
 x/feegrant/types/expected_keepers.go          |   23 +
 x/feegrant/types/expiration.go                |  138 ++
 x/feegrant/types/expiration_test.go           |  161 ++
 x/feegrant/types/feegrant.pb.go               | 1701 +++++++++++++++++
 x/feegrant/types/fees.go                      |   32 +
 x/feegrant/types/genesis.go                   |   40 +
 x/feegrant/types/genesis.pb.go                |  333 ++++
 x/feegrant/types/grant.go                     |   92 +
 x/feegrant/types/grant_test.go                |   99 +
 x/feegrant/types/key.go                       |   36 +
 x/feegrant/types/msgs.go                      |  101 +
 x/feegrant/types/periodic_fee.go              |  120 ++
 x/feegrant/types/periodic_fee_test.go         |  205 ++
 x/feegrant/types/query.pb.go                  | 1172 ++++++++++++
 x/feegrant/types/query.pb.gw.go               |  322 ++++
 x/feegrant/types/tx.pb.go                     | 1033 ++++++++++
 x/gov/client/cli/query.go                     |   39 +-
 x/gov/types/keys.go                           |   17 +-
 x/gov/types/keys_test.go                      |   10 -
 .../applications/transfer/client/cli/query.go |    7 +-
 x/ibc/applications/transfer/module.go         |    6 +-
 x/ibc/core/02-client/client/cli/query.go      |    7 +-
 x/ibc/core/02-client/types/client.go          |    2 +-
 x/ibc/core/03-connection/client/cli/query.go  |    3 +-
 x/ibc/core/04-channel/client/cli/query.go     |   11 +-
 x/ibc/core/04-channel/keeper/packet.go        |   12 +
 x/ibc/core/04-channel/types/events.go         |    1 +
 x/mint/client/cli/query.go                    |    7 +-
 x/mint/simulation/decoder.go                  |    2 +-
 x/mint/types/minter_test.go                   |    3 +
 x/params/client/cli/query.go                  |    4 +-
 x/slashing/client/cli/query.go                |    7 +-
 x/slashing/types/keys.go                      |   23 +-
 x/staking/client/cli/query.go                 |   27 +-
 x/staking/keeper/val_state_change.go          |   63 +-
 x/staking/keeper/validator.go                 |    2 +-
 x/staking/spec/01_state.md                    |  147 +-
 x/staking/spec/02_state_transitions.md        |   25 +-
 x/staking/spec/03_messages.md                 |  101 +-
 x/staking/spec/07_events.md                   |   16 +-
 x/staking/spec/README.md                      |   18 +-
 x/staking/types/keys.go                       |  155 +-
 x/staking/types/keys_test.go                  |   20 +-
 x/staking/types/staking.pb.go                 |  105 +-
 x/upgrade/client/cli/query.go                 |    9 +-
 159 files changed, 10603 insertions(+), 724 deletions(-)
 delete mode 100644 client/keys/testdata/keys/keys.db/000002.ldb
 delete mode 100644 client/keys/testdata/keys/keys.db/MANIFEST-000004
 create mode 100644 client/keys/testdata/keys/keys.db/MANIFEST-000005
 create mode 100644 proto/cosmos/feegrant/v1beta1/feegrant.proto
 create mode 100644 proto/cosmos/feegrant/v1beta1/genesis.proto
 create mode 100644 proto/cosmos/feegrant/v1beta1/query.proto
 create mode 100644 proto/cosmos/feegrant/v1beta1/tx.proto
 create mode 100644 types/address/store_key.go
 create mode 100644 types/address/store_key_test.go
 create mode 100644 x/feegrant/ante/ante.go
 create mode 100644 x/feegrant/ante/fee.go
 create mode 100644 x/feegrant/ante/fee_test.go
 create mode 100644 x/feegrant/client/cli/cli_test.go
 create mode 100644 x/feegrant/client/cli/query.go
 create mode 100644 x/feegrant/client/cli/tx.go
 create mode 100644 x/feegrant/client/rest/grpc_query_test.go
 create mode 100644 x/feegrant/doc.go
 create mode 100644 x/feegrant/genesis.go
 create mode 100644 x/feegrant/genesis_test.go
 create mode 100644 x/feegrant/keeper/grpc_query.go
 create mode 100644 x/feegrant/keeper/keeper.go
 create mode 100644 x/feegrant/keeper/keeper_test.go
 create mode 100644 x/feegrant/keeper/msg_server.go
 create mode 100644 x/feegrant/module.go
 create mode 100644 x/feegrant/simulation/decoder.go
 create mode 100644 x/feegrant/simulation/decoder_test.go
 create mode 100644 x/feegrant/simulation/genesis.go
 create mode 100644 x/feegrant/simulation/genesis_test.go
 create mode 100644 x/feegrant/simulation/operations.go
 create mode 100644 x/feegrant/simulation/operations_test.go
 create mode 100644 x/feegrant/types/basic_fee.go
 create mode 100644 x/feegrant/types/basic_fee_test.go
 create mode 100644 x/feegrant/types/codec.go
 create mode 100644 x/feegrant/types/errors.go
 create mode 100644 x/feegrant/types/events.go
 create mode 100644 x/feegrant/types/expected_keepers.go
 create mode 100644 x/feegrant/types/expiration.go
 create mode 100644 x/feegrant/types/expiration_test.go
 create mode 100644 x/feegrant/types/feegrant.pb.go
 create mode 100644 x/feegrant/types/fees.go
 create mode 100644 x/feegrant/types/genesis.go
 create mode 100644 x/feegrant/types/genesis.pb.go
 create mode 100644 x/feegrant/types/grant.go
 create mode 100644 x/feegrant/types/grant_test.go
 create mode 100644 x/feegrant/types/key.go
 create mode 100644 x/feegrant/types/msgs.go
 create mode 100644 x/feegrant/types/periodic_fee.go
 create mode 100644 x/feegrant/types/periodic_fee_test.go
 create mode 100644 x/feegrant/types/query.pb.go
 create mode 100644 x/feegrant/types/query.pb.gw.go
 create mode 100644 x/feegrant/types/tx.pb.go

diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 9456ebf30255..6116e6d92107 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -42,6 +42,7 @@ jobs:
         uses: docker/setup-buildx-action@v1
 
       - name: Login to DockerHub
+        if: ${{ github.event_name != 'pull_request' }}
         uses: docker/login-action@v1
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
diff --git a/.github/workflows/proto-docker.yml b/.github/workflows/proto-docker.yml
index b127de0a5874..7a9aecfb25ee 100644
--- a/.github/workflows/proto-docker.yml
+++ b/.github/workflows/proto-docker.yml
@@ -31,6 +31,7 @@ jobs:
         uses: docker/setup-buildx-action@v1
 
       - name: Login to DockerHub
+        if: ${{ github.event_name != 'pull_request' }}
         uses: docker/login-action@v1
         with:
           username: ${{ secrets.DOCKERHUBTM_USERNAME }}
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d8f051e60cb7..dd09041862d3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -31,6 +31,26 @@ jobs:
           path: ~/go/bin
           key: ${{ runner.os }}-go-tparse-binary
 
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-arch: ["amd64", "arm", "arm64"]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2.1.3
+        with:
+          go-version: 1.15
+      - uses: technote-space/get-diff-action@v4
+        id: git_diff
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - name: Build
+        run: GOARCH=${{ matrix.go-arch }} LEDGER_ENABLED=false make build
+
   test-cosmovisor:
     runs-on: ubuntu-latest
     steps:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75f7adb0b421..73b4ff3ecd3a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -36,20 +36,32 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ## [Unreleased]
 
+### Client Breaking Changes
+
+* [\#8363](https://github.com/cosmos/cosmos-sdk/issues/8363) Addresses no longer have a fixed 20-byte length. From the SDK modules' point of view, any 1-255 bytes-long byte array is a valid address.
+
 ### State Machine Breaking
 
+* (x/{bank,distrib,gov,slashing,staking}) [\#8363](https://github.com/cosmos/cosmos-sdk/issues/8363) Store keys have been modified to allow for variable-length addresses.
 * (x/ibc) [\#8266](https://github.com/cosmos/cosmos-sdk/issues/8266) Add amino JSON for IBC messages in order to support Ledger text signing.
 
 ### Improvements
 
+* (x/ibc) [\#8458](https://github.com/cosmos/cosmos-sdk/pull/8458) Add `packet_connection` attribute to ibc events to enable relayer filtering
+* (x/bank) [\#8479](https://github.com/cosmos/cosmos-sdk/pull/8479) Adittional client denom metadata validation for `base` and `display` denoms.
 * (x/ibc) [\#8404](https://github.com/cosmos/cosmos-sdk/pull/8404) Reorder IBC `ChanOpenAck` and `ChanOpenConfirm` handler execution to perform core handler first, followed by application callbacks.
+* [\#8396](https://github.com/cosmos/cosmos-sdk/pull/8396) Add support for ARM platform
 
 ### Bug Fixes
 
+* (x/evidence) [#8461](https://github.com/cosmos/cosmos-sdk/pull/8461) Fix bech32 prefix in evidence validator address conversion
 * (x/slashing) [\#8427](https://github.com/cosmos/cosmos-sdk/pull/8427) Fix query signing infos command
 * (simapp) [\#8418](https://github.com/cosmos/cosmos-sdk/pull/8418) Add balance coin to supply when adding a new genesis account
 * (x/bank) [\#8417](https://github.com/cosmos/cosmos-sdk/pull/8417) Validate balances and coin denom metadata on genesis
 * (server) [\#8399](https://github.com/cosmos/cosmos-sdk/pull/8399) fix gRPC-web flag default value
+* (client/keys) [\#8436](https://github.com/cosmos/cosmos-sdk/pull/8436) Fix key migration issue
+* (server) [\#8481](https://github.com/cosmos/cosmos-sdk/pull/8481) Don't create
+  files when running `{appd} tendermint show-*` subcommands
 
 ## [v0.40.1](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.40.1) - 2021-01-19
 
diff --git a/Makefile b/Makefile
index 0f4cf9e80fb2..f49f95e73449 100644
--- a/Makefile
+++ b/Makefile
@@ -479,4 +479,4 @@ rosetta-data:
 	docker run --name data_dir_build -t rosetta-ci:latest sh /rosetta/data.sh
 	docker cp data_dir_build:/tmp/data.tar.gz "$(CURDIR)/contrib/rosetta/node/data.tar.gz"
 	docker container rm data_dir_build
-.PHONY: rosetta-data
\ No newline at end of file
+.PHONY: rosetta-data
diff --git a/client/cmd.go b/client/cmd.go
index eccf59c3515c..437022695d47 100644
--- a/client/cmd.go
+++ b/client/cmd.go
@@ -221,6 +221,19 @@ func readTxCommandFlags(clientCtx Context, flagSet *pflag.FlagSet) (Context, err
 		clientCtx = clientCtx.WithSignModeStr(signModeStr)
 	}
 
+	if clientCtx.FeeGranter == nil || flagSet.Changed(flags.FlagFeeAccount) {
+		granter, _ := flagSet.GetString(flags.FlagFeeAccount)
+
+		if granter != "" {
+			granterAcc, err := sdk.AccAddressFromBech32(granter)
+			if err != nil {
+				return clientCtx, err
+			}
+
+			clientCtx = clientCtx.WithFeeGranterAddress(granterAcc)
+		}
+	}
+
 	if clientCtx.From == "" || flagSet.Changed(flags.FlagFrom) {
 		from, _ := flagSet.GetString(flags.FlagFrom)
 		fromAddr, fromName, keyType, err := GetFromFields(clientCtx.Keyring, from, clientCtx.GenerateOnly)
diff --git a/client/cmd_test.go b/client/cmd_test.go
index 02e2c414f63a..65161fe4752b 100644
--- a/client/cmd_test.go
+++ b/client/cmd_test.go
@@ -97,8 +97,7 @@ func TestSetCmdClientContextHandler(t *testing.T) {
 		tc := tc
 
 		t.Run(tc.name, func(t *testing.T) {
-			ctx := context.Background()
-			ctx = context.WithValue(ctx, client.ClientContextKey, &client.Context{})
+			ctx := context.WithValue(context.Background(), client.ClientContextKey, &client.Context{})
 
 			cmd := newCmd()
 			_ = testutil.ApplyMockIODiscardOutErr(cmd)
diff --git a/client/context.go b/client/context.go
index 0e3d1181af6e..f7f555339c2c 100644
--- a/client/context.go
+++ b/client/context.go
@@ -44,6 +44,7 @@ type Context struct {
 	TxConfig          TxConfig
 	AccountRetriever  AccountRetriever
 	NodeURI           string
+	FeeGranter        sdk.AccAddress
 
 	// TODO: Deprecated (remove).
 	LegacyAmino *codec.LegacyAmino
@@ -166,6 +167,13 @@ func (ctx Context) WithFromAddress(addr sdk.AccAddress) Context {
 	return ctx
 }
 
+// WithFeeGranterAddress returns a copy of the context with an updated fee granter account
+// address.
+func (ctx Context) WithFeeGranterAddress(addr sdk.AccAddress) Context {
+	ctx.FeeGranter = addr
+	return ctx
+}
+
 // WithBroadcastMode returns a copy of the context with an updated broadcast
 // mode.
 func (ctx Context) WithBroadcastMode(mode string) Context {
diff --git a/client/flags/flags.go b/client/flags/flags.go
index 282a61c4c9fb..1afb55b46733 100644
--- a/client/flags/flags.go
+++ b/client/flags/flags.go
@@ -70,6 +70,7 @@ const (
 	FlagCountTotal       = "count-total"
 	FlagTimeoutHeight    = "timeout-height"
 	FlagKeyAlgorithm     = "algo"
+	FlagFeeAccount       = "fee-account"
 
 	// Tendermint logging flags
 	FlagLogLevel  = "log_level"
@@ -112,6 +113,7 @@ func AddTxFlagsToCmd(cmd *cobra.Command) {
 	cmd.Flags().String(FlagKeyringBackend, DefaultKeyringBackend, "Select keyring's backend (os|file|kwallet|pass|test)")
 	cmd.Flags().String(FlagSignMode, "", "Choose sign mode (direct|amino-json), this is an advanced feature")
 	cmd.Flags().Uint64(FlagTimeoutHeight, 0, "Set a block timeout height to prevent the tx from being committed past a certain height")
+	cmd.Flags().String(FlagFeeAccount, "", "Fee account pays fees for the transaction instead of deducting from the signer")
 
 	// --gas can accept integers and "auto"
 	cmd.Flags().String(FlagGas, "", fmt.Sprintf("gas limit to set per-transaction; set to %q to calculate sufficient gas automatically (default %d)", GasFlagAuto, DefaultGasLimit))
diff --git a/client/grpc/tmservice/block.go b/client/grpc/tmservice/block.go
index e92fbec72bd2..554156982dda 100644
--- a/client/grpc/tmservice/block.go
+++ b/client/grpc/tmservice/block.go
@@ -8,12 +8,12 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 )
 
-func getBlock(clientCtx client.Context, height *int64) (*ctypes.ResultBlock, error) {
+func getBlock(ctx context.Context, clientCtx client.Context, height *int64) (*ctypes.ResultBlock, error) {
 	// get the node
 	node, err := clientCtx.GetNode()
 	if err != nil {
 		return nil, err
 	}
 
-	return node.Block(context.Background(), height)
+	return node.Block(ctx, height)
 }
diff --git a/client/grpc/tmservice/service.go b/client/grpc/tmservice/service.go
index 58d44af579cc..b621dff570c2 100644
--- a/client/grpc/tmservice/service.go
+++ b/client/grpc/tmservice/service.go
@@ -34,8 +34,8 @@ func NewQueryServer(clientCtx client.Context, interfaceRegistry codectypes.Inter
 }
 
 // GetSyncing implements ServiceServer.GetSyncing
-func (s queryServer) GetSyncing(_ context.Context, _ *GetSyncingRequest) (*GetSyncingResponse, error) {
-	status, err := getNodeStatus(s.clientCtx)
+func (s queryServer) GetSyncing(ctx context.Context, _ *GetSyncingRequest) (*GetSyncingResponse, error) {
+	status, err := getNodeStatus(ctx, s.clientCtx)
 	if err != nil {
 		return nil, err
 	}
@@ -45,8 +45,8 @@ func (s queryServer) GetSyncing(_ context.Context, _ *GetSyncingRequest) (*GetSy
 }
 
 // GetLatestBlock implements ServiceServer.GetLatestBlock
-func (s queryServer) GetLatestBlock(context.Context, *GetLatestBlockRequest) (*GetLatestBlockResponse, error) {
-	status, err := getBlock(s.clientCtx, nil)
+func (s queryServer) GetLatestBlock(ctx context.Context, _ *GetLatestBlockRequest) (*GetLatestBlockResponse, error) {
+	status, err := getBlock(ctx, s.clientCtx, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -64,7 +64,7 @@ func (s queryServer) GetLatestBlock(context.Context, *GetLatestBlockRequest) (*G
 }
 
 // GetBlockByHeight implements ServiceServer.GetBlockByHeight
-func (s queryServer) GetBlockByHeight(_ context.Context, req *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error) {
+func (s queryServer) GetBlockByHeight(ctx context.Context, req *GetBlockByHeightRequest) (*GetBlockByHeightResponse, error) {
 	chainHeight, err := rpc.GetChainHeight(s.clientCtx)
 	if err != nil {
 		return nil, err
@@ -74,7 +74,7 @@ func (s queryServer) GetBlockByHeight(_ context.Context, req *GetBlockByHeightRe
 		return nil, status.Error(codes.InvalidArgument, "requested block height is bigger then the chain length")
 	}
 
-	res, err := getBlock(s.clientCtx, &req.Height)
+	res, err := getBlock(ctx, s.clientCtx, &req.Height)
 	if err != nil {
 		return nil, err
 	}
@@ -96,7 +96,7 @@ func (s queryServer) GetLatestValidatorSet(ctx context.Context, req *GetLatestVa
 		return nil, err
 	}
 
-	validatorsRes, err := rpc.GetValidators(s.clientCtx, nil, &page, &limit)
+	validatorsRes, err := rpc.GetValidators(ctx, s.clientCtx, nil, &page, &limit)
 	if err != nil {
 		return nil, err
 	}
@@ -147,7 +147,7 @@ func (s queryServer) GetValidatorSetByHeight(ctx context.Context, req *GetValida
 		return nil, status.Error(codes.InvalidArgument, "requested block height is bigger then the chain length")
 	}
 
-	validatorsRes, err := rpc.GetValidators(s.clientCtx, &req.Height, &page, &limit)
+	validatorsRes, err := rpc.GetValidators(ctx, s.clientCtx, &req.Height, &page, &limit)
 
 	if err != nil {
 		return nil, err
@@ -175,7 +175,7 @@ func (s queryServer) GetValidatorSetByHeight(ctx context.Context, req *GetValida
 
 // GetNodeInfo implements ServiceServer.GetNodeInfo
 func (s queryServer) GetNodeInfo(ctx context.Context, req *GetNodeInfoRequest) (*GetNodeInfoResponse, error) {
-	status, err := getNodeStatus(s.clientCtx)
+	status, err := getNodeStatus(ctx, s.clientCtx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/client/grpc/tmservice/status.go b/client/grpc/tmservice/status.go
index f1a8da8e8362..9e9c3d200943 100644
--- a/client/grpc/tmservice/status.go
+++ b/client/grpc/tmservice/status.go
@@ -8,10 +8,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 )
 
-func getNodeStatus(clientCtx client.Context) (*ctypes.ResultStatus, error) {
+func getNodeStatus(ctx context.Context, clientCtx client.Context) (*ctypes.ResultStatus, error) {
 	node, err := clientCtx.GetNode()
 	if err != nil {
 		return &ctypes.ResultStatus{}, err
 	}
-	return node.Status(context.Background())
+	return node.Status(ctx)
 }
diff --git a/client/keys/migrate.go b/client/keys/migrate.go
index d80bbe163097..836a2655b087 100644
--- a/client/keys/migrate.go
+++ b/client/keys/migrate.go
@@ -62,7 +62,7 @@ func runMigrateCmd(cmd *cobra.Command, args []string) error {
 
 	var (
 		tmpDir   string
-		migrator keyring.InfoImporter
+		migrator keyring.Importer
 	)
 
 	if dryRun, _ := cmd.Flags().GetBool(flags.FlagDryRun); dryRun {
@@ -73,10 +73,10 @@ func runMigrateCmd(cmd *cobra.Command, args []string) error {
 
 		defer os.RemoveAll(tmpDir)
 
-		migrator, err = keyring.NewInfoImporter(keyringServiceName, "test", tmpDir, buf)
+		migrator, err = keyring.New(keyringServiceName, keyring.BackendTest, tmpDir, buf)
 	} else {
 		backend, _ := cmd.Flags().GetString(flags.FlagKeyringBackend)
-		migrator, err = keyring.NewInfoImporter(keyringServiceName, backend, rootDir, buf)
+		migrator, err = keyring.New(keyringServiceName, backend, rootDir, buf)
 	}
 
 	if err != nil {
@@ -86,12 +86,12 @@ func runMigrateCmd(cmd *cobra.Command, args []string) error {
 		))
 	}
 
-	for _, key := range oldKeys {
-		legKeyInfo, err := legacyKb.Export(key.GetName())
-		if err != nil {
-			return err
-		}
+	if len(oldKeys) == 0 {
+		cmd.Print("Migration Aborted: no keys to migrate")
+		return nil
+	}
 
+	for _, key := range oldKeys {
 		keyName := key.GetName()
 		keyType := key.GetType()
 
@@ -107,7 +107,12 @@ func runMigrateCmd(cmd *cobra.Command, args []string) error {
 		}
 
 		if keyType != keyring.TypeLocal {
-			if err := migrator.Import(keyName, legKeyInfo); err != nil {
+			pubkeyArmor, err := legacyKb.ExportPubKey(keyName)
+			if err != nil {
+				return err
+			}
+
+			if err := migrator.ImportPubKey(keyName, pubkeyArmor); err != nil {
 				return err
 			}
 
@@ -127,10 +132,11 @@ func runMigrateCmd(cmd *cobra.Command, args []string) error {
 			return err
 		}
 
-		if err := migrator.Import(keyName, armoredPriv); err != nil {
+		if err := migrator.ImportPrivKey(keyName, armoredPriv, migratePassphrase); err != nil {
 			return err
 		}
 	}
+	cmd.Print("Migration Complete")
 
 	return err
 }
diff --git a/client/keys/parse.go b/client/keys/parse.go
index 2af792c03c8e..b1169d68cc0e 100644
--- a/client/keys/parse.go
+++ b/client/keys/parse.go
@@ -1,7 +1,6 @@
 package keys
 
 import (
-	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -86,7 +85,7 @@ hexadecimal into bech32 cosmos prefixed format and vice versa.
 }
 
 func parseKey(cmd *cobra.Command, args []string) error {
-	config, _ := sdk.GetSealedConfig(context.Background())
+	config, _ := sdk.GetSealedConfig(cmd.Context())
 	return doParseKey(cmd, config, args)
 }
 
diff --git a/client/keys/testdata/keys/keys.db/000002.ldb b/client/keys/testdata/keys/keys.db/000002.ldb
deleted file mode 100644
index b36586df3626e4a01631c987005dd5b167ff1da2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 391
zcmey$^r4Z#RxCNcI5)r8Fr~Dl+#<2KsJx`KtSZ&C+#n^bq%tF`u)-ugH7~cY)V$I%
zr?5&dF(suawYZp(g#iqTO7lVsQW8s2opV#-y;CcV^fL3(^4ZPAathMRi}EtE%8be?
z%1q6&N-NC^O3Kqxat-nfiYqI#QcBBG%aVb{ar!ebvHCgrGpHDX^)kqL7g=R6a7wZ;
zGIE+rc**<PUE>mTQf0Uyr1m=MWxFC%+6+;l*L&_w+s))UMK~hzht#w>p1XUJc$A%Z
zPwESPNR;9%PE9T_GBwLK6yWnVVl8E1WG;$fU@+p1Im5hYq0H<PDOvo--`72GRK0y%
zlj9ZJwXg|Xs=_Bd4z+LHhol+gK}Hbf{3Ex6Lk7-eGnqd@T!ev>xtQ@kC!+?#3MRPJ
a`@iD$YnizAFo}VL@PqK*4c#iG?zaJJVsO>~

diff --git a/client/keys/testdata/keys/keys.db/CURRENT b/client/keys/testdata/keys/keys.db/CURRENT
index cacca7574c03..aa5bb8ea5090 100644
--- a/client/keys/testdata/keys/keys.db/CURRENT
+++ b/client/keys/testdata/keys/keys.db/CURRENT
@@ -1 +1 @@
-MANIFEST-000004
+MANIFEST-000005
diff --git a/client/keys/testdata/keys/keys.db/CURRENT.bak b/client/keys/testdata/keys/keys.db/CURRENT.bak
index feda7d6b2481..4fb1dad19e03 100644
--- a/client/keys/testdata/keys/keys.db/CURRENT.bak
+++ b/client/keys/testdata/keys/keys.db/CURRENT.bak
@@ -1 +1 @@
-MANIFEST-000000
+MANIFEST-000003
diff --git a/client/keys/testdata/keys/keys.db/LOG b/client/keys/testdata/keys/keys.db/LOG
index 386101e4fb91..e37648b855bb 100644
--- a/client/keys/testdata/keys/keys.db/LOG
+++ b/client/keys/testdata/keys/keys.db/LOG
@@ -1,18 +1,30 @@
-=============== Mar 30, 2020 (CEST) ===============
-02:07:34.137606 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
-02:07:34.144547 db@open opening
-02:07:34.144770 version@stat F·[] S·0B[] Sc·[]
-02:07:34.145843 db@janitor F·2 G·0
-02:07:34.145875 db@open done T·1.315251ms
-02:07:34.335635 db@close closing
-02:07:34.335736 db@close done T·98.95µs
-=============== Mar 30, 2020 (CEST) ===============
-02:08:33.239115 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
-02:08:33.239264 version@stat F·[] S·0B[] Sc·[]
-02:08:33.239281 db@open opening
-02:08:33.239310 journal@recovery F·1
-02:08:33.239398 journal@recovery recovering @1
-02:08:33.322008 memdb@flush created L0@2 N·4 S·391B "cos..ess,v4":"run..nfo,v3"
-02:08:33.323091 version@stat F·[1] S·391B[391B] Sc·[0.25]
-02:08:33.421979 db@janitor F·3 G·0
-02:08:33.422153 db@open done T·182.707962ms
+=============== Feb 2, 2021 (IST) ===============
+00:03:25.348369 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
+00:03:25.350695 db@open opening
+00:03:25.350888 version@stat F·[] S·0B[] Sc·[]
+00:03:25.351864 db@janitor F·2 G·0
+00:03:25.351881 db@open done T·1.169825ms
+00:03:25.351895 db@close closing
+00:03:25.351929 db@close done T·33.042µs
+=============== Feb 2, 2021 (IST) ===============
+00:03:34.450638 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
+00:03:34.450722 version@stat F·[] S·0B[] Sc·[]
+00:03:34.450737 db@open opening
+00:03:34.450765 journal@recovery F·1
+00:03:34.450851 journal@recovery recovering @1
+00:03:34.451173 version@stat F·[] S·0B[] Sc·[]
+00:03:34.454278 db@janitor F·2 G·0
+00:03:34.454298 db@open done T·3.548046ms
+00:03:34.454307 db@close closing
+00:03:34.454327 db@close done T·19.017µs
+=============== Feb 2, 2021 (IST) ===============
+00:03:42.025705 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
+00:03:42.025892 version@stat F·[] S·0B[] Sc·[]
+00:03:42.025907 db@open opening
+00:03:42.025943 journal@recovery F·1
+00:03:42.026790 journal@recovery recovering @2
+00:03:42.026946 version@stat F·[] S·0B[] Sc·[]
+00:03:42.031645 db@janitor F·2 G·0
+00:03:42.031661 db@open done T·5.750008ms
+00:03:42.283102 db@close closing
+00:03:42.283162 db@close done T·58.775µs
diff --git a/client/keys/testdata/keys/keys.db/MANIFEST-000004 b/client/keys/testdata/keys/keys.db/MANIFEST-000004
deleted file mode 100644
index 557b4bdbbc93fd41441cfe30d1ca16f08f47f344..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 237
zcmeykNagJ_21Z7yoYb<^oRlOzr^=Gl^338?=ltA)#G=HK{30f1W>ywfb_S+)X4~Za
z;@tdV!<5pJa*M>`qVkf`vZ_?ma)Xq#lFE#%!U~i0)V$onQu9j7oWd%-#FUhx)Z$`B
l76veoD=N(kEl5c$Np;RmiT6&eG}6n=OUq|uhDg)i1^~DrOBnzF

diff --git a/client/keys/testdata/keys/keys.db/MANIFEST-000005 b/client/keys/testdata/keys/keys.db/MANIFEST-000005
new file mode 100644
index 0000000000000000000000000000000000000000..a9e8a261c7882e802f65360dc49782db7df6fb77
GIT binary patch
literal 41
wcmYcef4W17fss)vC$%g!CnZVGsj?)sJhM2}IX|}`u_&=5zle#2nT>@304?eb82|tP

literal 0
HcmV?d00001

diff --git a/client/query.go b/client/query.go
index 18a5c3c2f4ee..bb65d9bf3833 100644
--- a/client/query.go
+++ b/client/query.go
@@ -57,6 +57,11 @@ func (ctx Context) GetFromAddress() sdk.AccAddress {
 	return ctx.FromAddress
 }
 
+// GetFeeGranterAddress returns the fee granter address from the context
+func (ctx Context) GetFeeGranterAddress() sdk.AccAddress {
+	return ctx.FeeGranter
+}
+
 // GetFromName returns the key name for the current context.
 func (ctx Context) GetFromName() string {
 	return ctx.FromName
diff --git a/client/rpc/validators.go b/client/rpc/validators.go
index 66c594966ed7..175e7ff91ee6 100644
--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@@ -50,7 +50,7 @@ func ValidatorCommand() *cobra.Command {
 			page, _ := cmd.Flags().GetInt(flags.FlagPage)
 			limit, _ := cmd.Flags().GetInt(flags.FlagLimit)
 
-			result, err := GetValidators(clientCtx, height, &page, &limit)
+			result, err := GetValidators(cmd.Context(), clientCtx, height, &page, &limit)
 			if err != nil {
 				return err
 			}
@@ -117,14 +117,14 @@ func validatorOutput(validator *tmtypes.Validator) (ValidatorOutput, error) {
 }
 
 // GetValidators from client
-func GetValidators(clientCtx client.Context, height *int64, page, limit *int) (ResultValidatorsOutput, error) {
+func GetValidators(ctx context.Context, clientCtx client.Context, height *int64, page, limit *int) (ResultValidatorsOutput, error) {
 	// get the node
 	node, err := clientCtx.GetNode()
 	if err != nil {
 		return ResultValidatorsOutput{}, err
 	}
 
-	validatorsRes, err := node.Validators(context.Background(), height, page, limit)
+	validatorsRes, err := node.Validators(ctx, height, page, limit)
 	if err != nil {
 		return ResultValidatorsOutput{}, err
 	}
@@ -172,7 +172,7 @@ func ValidatorSetRequestHandlerFn(clientCtx client.Context) http.HandlerFunc {
 			return
 		}
 
-		output, err := GetValidators(clientCtx, &height, &page, &limit)
+		output, err := GetValidators(r.Context(), clientCtx, &height, &page, &limit)
 		if rest.CheckInternalServerError(w, err) {
 			return
 		}
@@ -189,7 +189,7 @@ func LatestValidatorSetRequestHandlerFn(clientCtx client.Context) http.HandlerFu
 			return
 		}
 
-		output, err := GetValidators(clientCtx, nil, &page, &limit)
+		output, err := GetValidators(r.Context(), clientCtx, nil, &page, &limit)
 		if rest.CheckInternalServerError(w, err) {
 			return
 		}
diff --git a/client/tx/tx.go b/client/tx/tx.go
index 594293732bc8..62e3e9098eea 100644
--- a/client/tx/tx.go
+++ b/client/tx/tx.go
@@ -117,6 +117,7 @@ func BroadcastTx(clientCtx client.Context, txf Factory, msgs ...sdk.Msg) error {
 		}
 	}
 
+	tx.SetFeeGranter(clientCtx.GetFeeGranterAddress())
 	err = Sign(txf, clientCtx.GetFromName(), tx, true)
 	if err != nil {
 		return err
diff --git a/client/tx_config.go b/client/tx_config.go
index 6992a7a2402d..8220e917b2bb 100644
--- a/client/tx_config.go
+++ b/client/tx_config.go
@@ -42,5 +42,6 @@ type (
 		SetFeeAmount(amount sdk.Coins)
 		SetGasLimit(limit uint64)
 		SetTimeoutHeight(height uint64)
+		SetFeeGranter(feeGranter sdk.AccAddress)
 	}
 )
diff --git a/contrib/rosetta/configuration/bootstrap.json b/contrib/rosetta/configuration/bootstrap.json
index 15b75b550862..1793988f37e5 100644
--- a/contrib/rosetta/configuration/bootstrap.json
+++ b/contrib/rosetta/configuration/bootstrap.json
@@ -1,12 +1,12 @@
 [
   {
     "account_identifier": {
-      "address":"cosmos1hdmjfmqmf8ck4pv4evu0s3up0ucm0yjjqfl87e"
+      "address":"cosmos158nkd0l9tyemv2crp579rmj8dg37qty8lzff88"
     },
     "currency":{
       "symbol":"stake",
       "decimals":0
     },
-    "value": "999900000000"
+    "value": "999990000000"
   }
 ]
\ No newline at end of file
diff --git a/contrib/rosetta/configuration/data.sh b/contrib/rosetta/configuration/data.sh
index dc4f2cb59a86..45297d5a21bf 100644
--- a/contrib/rosetta/configuration/data.sh
+++ b/contrib/rosetta/configuration/data.sh
@@ -16,12 +16,13 @@ simd init simd --chain-id testing
 simd keys add fd --keyring-backend=test
 
 addr=$(simd keys show fd -a --keyring-backend=test)
+val_addr=$(simd keys show fd  --keyring-backend=test --bech val -a)
 
 # give the accounts some money
 simd add-genesis-account "$addr" 1000000000000stake --keyring-backend=test
 
 # save configs for the daemon
-simd gentx fd --chain-id testing --keyring-backend=test
+simd gentx fd 10000000stake --chain-id testing --keyring-backend=test
 
 # input genTx to the genesis file
 simd collect-gentxs
@@ -55,4 +56,4 @@ echo zipping data dir and saving to /tmp/data.tar.gz
 
 tar -czvf /tmp/data.tar.gz /root/.simapp
 
-echo new address for bootstrap.json "$addr"
+echo new address for bootstrap.json "$addr" "$val_addr"
diff --git a/contrib/rosetta/configuration/staking.ros b/contrib/rosetta/configuration/staking.ros
index 1d9de1d180fa..4f89a43b9893 100644
--- a/contrib/rosetta/configuration/staking.ros
+++ b/contrib/rosetta/configuration/staking.ros
@@ -94,7 +94,7 @@ staking(1){
         "account": {
             "address": "staking_account",
             "sub_account": {
-                "address" : "cosmosvaloper1hdmjfmqmf8ck4pv4evu0s3up0ucm0yjj9atjj2"
+                "address" : "cosmosvaloper158nkd0l9tyemv2crp579rmj8dg37qty86kaut5"
             }
         },
         "amount":{
@@ -134,7 +134,7 @@ staking(1){
             "account": {
                 "address": "staking_account",
                 "sub_account": {
-                    "address" : "cosmosvaloper1hdmjfmqmf8ck4pv4evu0s3up0ucm0yjj9atjj2"
+                    "address" : "cosmosvaloper158nkd0l9tyemv2crp579rmj8dg37qty86kaut5"
                 }
             },
             "amount":{
diff --git a/contrib/rosetta/node/data.tar.gz b/contrib/rosetta/node/data.tar.gz
index a7bed60579ea098baa390af3a29e05b08d16dcc8..ad285ac62e75198c4945859e12ccf7b563c7c29b 100644
GIT binary patch
literal 36558
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
W{ds@hpZDkg{P{11*Qv_@PyztMa6X;@

literal 34626
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
O?DZF9r!))zMgjoC3=_)$

diff --git a/crypto/armor_test.go b/crypto/armor_test.go
index abbc7870aaee..70854f6dcb41 100644
--- a/crypto/armor_test.go
+++ b/crypto/armor_test.go
@@ -158,6 +158,8 @@ func TestUnarmorInfoBytesErrors(t *testing.T) {
 }
 
 func BenchmarkBcryptGenerateFromPassword(b *testing.B) {
+	b.ReportAllocs()
+
 	passphrase := []byte("passphrase")
 	for securityParam := 9; securityParam < 16; securityParam++ {
 		param := securityParam
diff --git a/crypto/keyring/keyring.go b/crypto/keyring/keyring.go
index f88ffdc37010..164e6bfc19d5 100644
--- a/crypto/keyring/keyring.go
+++ b/crypto/keyring/keyring.go
@@ -108,6 +108,7 @@ type Signer interface {
 type Importer interface {
 	// ImportPrivKey imports ASCII armored passphrase-encrypted private keys.
 	ImportPrivKey(uid, armor, passphrase string) error
+
 	// ImportPubKey imports ASCII armored public keys.
 	ImportPubKey(uid string, armor string) error
 }
diff --git a/crypto/keys/internal/benchmarking/bench.go b/crypto/keys/internal/benchmarking/bench.go
index a789da91f9c9..a55936d5c3c8 100644
--- a/crypto/keys/internal/benchmarking/bench.go
+++ b/crypto/keys/internal/benchmarking/bench.go
@@ -25,6 +25,7 @@ func (zeroReader) Read(buf []byte) (int, error) {
 // BenchmarkKeyGeneration benchmarks the given key generation algorithm using
 // a dummy reader.
 func BenchmarkKeyGeneration(b *testing.B, generateKey func(reader io.Reader) types.PrivKey) {
+	b.ReportAllocs()
 	var zero zeroReader
 	for i := 0; i < b.N; i++ {
 		generateKey(zero)
diff --git a/crypto/keys/secp256k1/bench_test.go b/crypto/keys/secp256k1/bench_test.go
index 423f7a5a52de..a9f694de7552 100644
--- a/crypto/keys/secp256k1/bench_test.go
+++ b/crypto/keys/secp256k1/bench_test.go
@@ -9,6 +9,7 @@ import (
 )
 
 func BenchmarkKeyGeneration(b *testing.B) {
+	b.ReportAllocs()
 	benchmarkKeygenWrapper := func(reader io.Reader) types.PrivKey {
 		priv := genPrivKey(reader)
 		return &PrivKey{Key: priv}
@@ -17,11 +18,13 @@ func BenchmarkKeyGeneration(b *testing.B) {
 }
 
 func BenchmarkSigning(b *testing.B) {
+	b.ReportAllocs()
 	priv := GenPrivKey()
 	benchmarking.BenchmarkSigning(b, priv)
 }
 
 func BenchmarkVerification(b *testing.B) {
+	b.ReportAllocs()
 	priv := GenPrivKey()
 	benchmarking.BenchmarkVerification(b, priv)
 }
diff --git a/docs/building-modules/beginblock-endblock.md b/docs/building-modules/beginblock-endblock.md
index 09a48df8807a..cb8dbba1dda2 100644
--- a/docs/building-modules/beginblock-endblock.md
+++ b/docs/building-modules/beginblock-endblock.md
@@ -24,7 +24,7 @@ The actual implementation of `BeginBlocker` and `EndBlocker` in `./abci.go` are
 
 A specificity of the `EndBlocker` is that it can return validator updates to the underlying consensus engine in the form of an [`[]abci.ValidatorUpdates`](https://tendermint.com/docs/app-dev/abci-spec.html#validatorupdate). This is the preferred way to implement custom validator changes. 
 
-It is possible for developers to defined the order of execution between the `BeginBlocker`/`EndBlocker` functions of each of their application's modules via the module's manager `SetOrderBeginBlocker`/`SetOrderEndBlocker` methods. For more on the module manager, click [here](./module-manager.md#manager). 
+It is possible for developers to define the order of execution between the `BeginBlocker`/`EndBlocker` functions of each of their application's modules via the module's manager `SetOrderBeginBlocker`/`SetOrderEndBlocker` methods. For more on the module manager, click [here](./module-manager.md#manager). 
 
 See an example implementation of `BeginBlocker` from the `distr` module:
 
diff --git a/docs/building-modules/module-manager.md b/docs/building-modules/module-manager.md
index cd8cc4b9eca0..919ec1425c84 100644
--- a/docs/building-modules/module-manager.md
+++ b/docs/building-modules/module-manager.md
@@ -74,7 +74,8 @@ Let us go through the methods of `AppModule`:
 - `LegacyQuerierHandler(*codec.LegacyAmino)` (deprecated): Returns a [`querier`](./query-services.md#legacy-queriers) given the query `path`, in order to process the `query`.
 - `RegisterServices(Configurator)`: Allows a module to register services.
 - `BeginBlock(sdk.Context, abci.RequestBeginBlock)`: This method gives module developers the option to implement logic that is automatically triggered at the beginning of each block. Implement empty if no logic needs to be triggered at the beginning of each block for this module.
-- `EndBlock(sdk.Context, abci.RequestEndBlock)`: This method gives module developers the option to implement logic that is automatically triggered at the beginning of each block. This is also where the module can inform the underlying consensus engine of validator set changes (e.g. the `staking` module). Implement empty if no logic needs to be triggered at the beginning of each block for this module.
+- `EndBlock(sdk.Context, abci.RequestEndBlock)`: This method gives module developers the option to implement logic that is automatically triggered at the end of each block. This is also where the module can inform the underlying consensus engine of validator set changes (e.g. the `staking` module). Implement empty if no logic needs to be triggered at the end of each block for this module.
+
 
 ### Implementing the Application Module Interfaces
 
@@ -132,7 +133,7 @@ The module manager is used throughout the application whenever an action on a co
 - `SetOrderInitGenesis(moduleNames ...string)`: Sets the order in which the [`InitGenesis`](./genesis.md#initgenesis) function of each module will be called when the application is first started. This function is generally called from the application's main [constructor function](../basics/app-anatomy.md#constructor-function).
 - `SetOrderExportGenesis(moduleNames ...string)`: Sets the order in which the [`ExportGenesis`](./genesis.md#exportgenesis) function of each module will be called in case of an export. This function is generally called from the application's main [constructor function](../basics/app-anatomy.md#constructor-function).
 - `SetOrderBeginBlockers(moduleNames ...string)`: Sets the order in which the `BeginBlock()` function of each module will be called at the beginning of each block. This function is generally called from the application's main [constructor function](../basics/app-anatomy.md#constructor-function).
-- `SetOrderEndBlockers(moduleNames ...string)`: Sets the order in which the `EndBlock()` function of each module will be called at the beginning of each block. This function is generally called from the application's main [constructor function](../basics/app-anatomy.md#constructor-function).
+- `SetOrderEndBlockers(moduleNames ...string)`: Sets the order in which the `EndBlock()` function of each module will be called at the end of each block. This function is generally called from the application's main [constructor function](../basics/app-anatomy.md#constructor-function).
 - `RegisterInvariants(ir sdk.InvariantRegistry)`: Registers the [invariants](./invariants.md) of each module.
 - `RegisterRoutes(router sdk.Router, queryRouter sdk.QueryRouter, legacyQuerierCdc *codec.LegacyAmino)`: Registers legacy [`Msg`](./messages-and-queries.md#messages) and [`querier`](./query-services.md#legacy-queriers) routes. 
 - `RegisterServices(cfg Configurator)`: Registers all module services.
diff --git a/docs/core/cli.md b/docs/core/cli.md
index 8e11bf488d2b..10203e769e8c 100644
--- a/docs/core/cli.md
+++ b/docs/core/cli.md
@@ -108,6 +108,24 @@ Flags are added to commands directly (generally in the [module's CLI file](../bu
 
 +++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/simapp/simd/cmd/root.go#L118
 
+## Environment variables
+
+Each flag is bound to it's respecteve named environment variable. Then name of the environment variable consist of two parts - capital case `basename` followed by flag name of the flag. `-` must be substituted with `_`. For example flag `--home` for application with basename `GAIA` is bound to `GAIA_HOME`. It allows to reduce amount of flags typed for routine operations. For example instead of:
+```sh
+gaia --home=./ --node=<node address> --chain-id="testchain-1" --keyring-backend=test tx ... --from=<key name>
+```
+this will be more convinient:
+```sh
+# define env variables in .env, .envrc etc
+GAIA_HOME=<path to home>
+GAIA_NODE=<node address>
+GAIA_CHAIN_ID="testchain-1"
+GAIA_KEYRING_BACKEND="test"
+
+# and later just use
+gaia tx ... --from=<key name>
+```
+
 ## Configurations
 
 It is vital that the root command of an application uses `PersistentPreRun()` cobra command property for executing the command, so all child commands have access to the server and client contexts. These contexts are set as their default values initially and maybe modified, scoped to the command, in their respective `PersistentPreRun()` functions. Note that the `client.Context` is typically pre-populated with "default" values that may be useful for all commands to inherit and override if necessary.
diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index ec30ba730ba1..b06aaf246185 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -264,6 +264,32 @@
   
     - [Msg](#cosmos.evidence.v1beta1.Msg)
   
+- [cosmos/feegrant/v1beta1/feegrant.proto](#cosmos/feegrant/v1beta1/feegrant.proto)
+    - [BasicFeeAllowance](#cosmos.feegrant.v1beta1.BasicFeeAllowance)
+    - [Duration](#cosmos.feegrant.v1beta1.Duration)
+    - [ExpiresAt](#cosmos.feegrant.v1beta1.ExpiresAt)
+    - [FeeAllowanceGrant](#cosmos.feegrant.v1beta1.FeeAllowanceGrant)
+    - [PeriodicFeeAllowance](#cosmos.feegrant.v1beta1.PeriodicFeeAllowance)
+  
+- [cosmos/feegrant/v1beta1/genesis.proto](#cosmos/feegrant/v1beta1/genesis.proto)
+    - [GenesisState](#cosmos.feegrant.v1beta1.GenesisState)
+  
+- [cosmos/feegrant/v1beta1/query.proto](#cosmos/feegrant/v1beta1/query.proto)
+    - [QueryFeeAllowanceRequest](#cosmos.feegrant.v1beta1.QueryFeeAllowanceRequest)
+    - [QueryFeeAllowanceResponse](#cosmos.feegrant.v1beta1.QueryFeeAllowanceResponse)
+    - [QueryFeeAllowancesRequest](#cosmos.feegrant.v1beta1.QueryFeeAllowancesRequest)
+    - [QueryFeeAllowancesResponse](#cosmos.feegrant.v1beta1.QueryFeeAllowancesResponse)
+  
+    - [Query](#cosmos.feegrant.v1beta1.Query)
+  
+- [cosmos/feegrant/v1beta1/tx.proto](#cosmos/feegrant/v1beta1/tx.proto)
+    - [MsgGrantFeeAllowance](#cosmos.feegrant.v1beta1.MsgGrantFeeAllowance)
+    - [MsgGrantFeeAllowanceResponse](#cosmos.feegrant.v1beta1.MsgGrantFeeAllowanceResponse)
+    - [MsgRevokeFeeAllowance](#cosmos.feegrant.v1beta1.MsgRevokeFeeAllowance)
+    - [MsgRevokeFeeAllowanceResponse](#cosmos.feegrant.v1beta1.MsgRevokeFeeAllowanceResponse)
+  
+    - [Msg](#cosmos.feegrant.v1beta1.Msg)
+  
 - [cosmos/genutil/v1beta1/genesis.proto](#cosmos/genutil/v1beta1/genesis.proto)
     - [GenesisState](#cosmos.genutil.v1beta1.GenesisState)
   
@@ -4097,6 +4123,312 @@ Msg defines the evidence Msg service.
 
 
 
+<a name="cosmos/feegrant/v1beta1/feegrant.proto"></a>
+<p align="right"><a href="#top">Top</a></p>
+
+## cosmos/feegrant/v1beta1/feegrant.proto
+
+
+
+<a name="cosmos.feegrant.v1beta1.BasicFeeAllowance"></a>
+
+### BasicFeeAllowance
+BasicFeeAllowance implements FeeAllowance with a one-time grant of tokens
+that optionally expires. The delegatee can use up to SpendLimit to cover fees.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `spend_limit` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | spend_limit specifies the maximum amount of tokens that can be spent by this allowance and will be updated as tokens are spent. If it is empty, there is no spend limit and any amount of coins can be spent. |
+| `expiration` | [ExpiresAt](#cosmos.feegrant.v1beta1.ExpiresAt) |  | expiration specifies an optional time when this allowance expires |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.Duration"></a>
+
+### Duration
+Duration is a span of a clock time or number of blocks.
+This is designed to be added to an ExpiresAt struct.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `duration` | [google.protobuf.Duration](#google.protobuf.Duration) |  |  |
+| `blocks` | [uint64](#uint64) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.ExpiresAt"></a>
+
+### ExpiresAt
+ExpiresAt is a point in time where something expires.
+It may be *either* block time or block height
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  |  |
+| `height` | [int64](#int64) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.FeeAllowanceGrant"></a>
+
+### FeeAllowanceGrant
+FeeAllowanceGrant is stored in the KVStore to record a grant with full context
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `granter` | [string](#string) |  |  |
+| `grantee` | [string](#string) |  |  |
+| `allowance` | [google.protobuf.Any](#google.protobuf.Any) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.PeriodicFeeAllowance"></a>
+
+### PeriodicFeeAllowance
+PeriodicFeeAllowance extends FeeAllowance to allow for both a maximum cap,
+as well as a limit per time period.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `basic` | [BasicFeeAllowance](#cosmos.feegrant.v1beta1.BasicFeeAllowance) |  | basic specifies a struct of `BasicFeeAllowance` |
+| `period` | [Duration](#cosmos.feegrant.v1beta1.Duration) |  | period specifies the time duration in which period_spend_limit coins can be spent before that allowance is reset |
+| `period_spend_limit` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | period_spend_limit specifies the maximum number of coins that can be spent in the period |
+| `period_can_spend` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | period_can_spend is the number of coins left to be spent before the period_reset time |
+| `period_reset` | [ExpiresAt](#cosmos.feegrant.v1beta1.ExpiresAt) |  | period_reset is the time at which this period resets and a new one begins, it is calculated from the start time of the first transaction after the last period ended |
+
+
+
+
+
+ <!-- end messages -->
+
+ <!-- end enums -->
+
+ <!-- end HasExtensions -->
+
+ <!-- end services -->
+
+
+
+<a name="cosmos/feegrant/v1beta1/genesis.proto"></a>
+<p align="right"><a href="#top">Top</a></p>
+
+## cosmos/feegrant/v1beta1/genesis.proto
+
+
+
+<a name="cosmos.feegrant.v1beta1.GenesisState"></a>
+
+### GenesisState
+GenesisState contains a set of fee allowances, persisted from the store
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `fee_allowances` | [FeeAllowanceGrant](#cosmos.feegrant.v1beta1.FeeAllowanceGrant) | repeated |  |
+
+
+
+
+
+ <!-- end messages -->
+
+ <!-- end enums -->
+
+ <!-- end HasExtensions -->
+
+ <!-- end services -->
+
+
+
+<a name="cosmos/feegrant/v1beta1/query.proto"></a>
+<p align="right"><a href="#top">Top</a></p>
+
+## cosmos/feegrant/v1beta1/query.proto
+
+
+
+<a name="cosmos.feegrant.v1beta1.QueryFeeAllowanceRequest"></a>
+
+### QueryFeeAllowanceRequest
+QueryFeeAllowanceRequest is the request type for the Query/FeeAllowance RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `granter` | [string](#string) |  |  |
+| `grantee` | [string](#string) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.QueryFeeAllowanceResponse"></a>
+
+### QueryFeeAllowanceResponse
+QueryFeeAllowanceResponse is the response type for the Query/FeeAllowance RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `fee_allowance` | [FeeAllowanceGrant](#cosmos.feegrant.v1beta1.FeeAllowanceGrant) |  | fee_allowance is a fee_allowance granted for grantee by granter. |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.QueryFeeAllowancesRequest"></a>
+
+### QueryFeeAllowancesRequest
+QueryFeeAllowancesRequest is the request type for the Query/FeeAllowances RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `grantee` | [string](#string) |  |  |
+| `pagination` | [cosmos.base.query.v1beta1.PageRequest](#cosmos.base.query.v1beta1.PageRequest) |  | pagination defines an pagination for the request. |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.QueryFeeAllowancesResponse"></a>
+
+### QueryFeeAllowancesResponse
+QueryFeeAllowancesResponse is the response type for the Query/FeeAllowances RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `fee_allowances` | [FeeAllowanceGrant](#cosmos.feegrant.v1beta1.FeeAllowanceGrant) | repeated | fee_allowances are fee_allowance's granted for grantee by granter. |
+| `pagination` | [cosmos.base.query.v1beta1.PageResponse](#cosmos.base.query.v1beta1.PageResponse) |  | pagination defines an pagination for the response. |
+
+
+
+
+
+ <!-- end messages -->
+
+ <!-- end enums -->
+
+ <!-- end HasExtensions -->
+
+
+<a name="cosmos.feegrant.v1beta1.Query"></a>
+
+### Query
+Query defines the gRPC querier service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `FeeAllowance` | [QueryFeeAllowanceRequest](#cosmos.feegrant.v1beta1.QueryFeeAllowanceRequest) | [QueryFeeAllowanceResponse](#cosmos.feegrant.v1beta1.QueryFeeAllowanceResponse) | FeeAllowance returns fee granted to the grantee by the granter. | GET|/cosmos/feegrant/v1beta1/fee_allowance/{granter}/{grantee}|
+| `FeeAllowances` | [QueryFeeAllowancesRequest](#cosmos.feegrant.v1beta1.QueryFeeAllowancesRequest) | [QueryFeeAllowancesResponse](#cosmos.feegrant.v1beta1.QueryFeeAllowancesResponse) | FeeAllowances returns all the grants for address. | GET|/cosmos/feegrant/v1beta1/fee_allowances/{grantee}|
+
+ <!-- end services -->
+
+
+
+<a name="cosmos/feegrant/v1beta1/tx.proto"></a>
+<p align="right"><a href="#top">Top</a></p>
+
+## cosmos/feegrant/v1beta1/tx.proto
+
+
+
+<a name="cosmos.feegrant.v1beta1.MsgGrantFeeAllowance"></a>
+
+### MsgGrantFeeAllowance
+MsgGrantFeeAllowance adds permission for Grantee to spend up to Allowance
+of fees from the account of Granter.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `granter` | [string](#string) |  |  |
+| `grantee` | [string](#string) |  |  |
+| `allowance` | [google.protobuf.Any](#google.protobuf.Any) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.MsgGrantFeeAllowanceResponse"></a>
+
+### MsgGrantFeeAllowanceResponse
+MsgGrantFeeAllowanceResponse defines the Msg/GrantFeeAllowanceResponse response type.
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.MsgRevokeFeeAllowance"></a>
+
+### MsgRevokeFeeAllowance
+MsgRevokeFeeAllowance removes any existing FeeAllowance from Granter to Grantee.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `granter` | [string](#string) |  |  |
+| `grantee` | [string](#string) |  |  |
+
+
+
+
+
+
+<a name="cosmos.feegrant.v1beta1.MsgRevokeFeeAllowanceResponse"></a>
+
+### MsgRevokeFeeAllowanceResponse
+MsgRevokeFeeAllowanceResponse defines the Msg/RevokeFeeAllowanceResponse response type.
+
+
+
+
+
+ <!-- end messages -->
+
+ <!-- end enums -->
+
+ <!-- end HasExtensions -->
+
+
+<a name="cosmos.feegrant.v1beta1.Msg"></a>
+
+### Msg
+Msg defines the feegrant msg service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `GrantFeeAllowance` | [MsgGrantFeeAllowance](#cosmos.feegrant.v1beta1.MsgGrantFeeAllowance) | [MsgGrantFeeAllowanceResponse](#cosmos.feegrant.v1beta1.MsgGrantFeeAllowanceResponse) | GrantFeeAllowance grants fee allowance to the grantee on the granter's account with the provided expiration time. | |
+| `RevokeFeeAllowance` | [MsgRevokeFeeAllowance](#cosmos.feegrant.v1beta1.MsgRevokeFeeAllowance) | [MsgRevokeFeeAllowanceResponse](#cosmos.feegrant.v1beta1.MsgRevokeFeeAllowanceResponse) | RevokeFeeAllowance revokes any fee allowance of granter's account that has been granted to the grantee. | |
+
+ <!-- end services -->
+
+
+
 <a name="cosmos/genutil/v1beta1/genesis.proto"></a>
 <p align="right"><a href="#top">Top</a></p>
 
@@ -5375,8 +5707,8 @@ Commission defines commission parameters for a given validator.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `commission_rates` | [CommissionRates](#cosmos.staking.v1beta1.CommissionRates) |  |  |
-| `update_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  |  |
+| `commission_rates` | [CommissionRates](#cosmos.staking.v1beta1.CommissionRates) |  | commission_rates defines the initial commission rates to be used for creating a validator. |
+| `update_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  | update_time is the last time the commission rate was changed. |
 
 
 
@@ -5392,9 +5724,9 @@ a validator.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `rate` | [string](#string) |  |  |
-| `max_rate` | [string](#string) |  |  |
-| `max_change_rate` | [string](#string) |  |  |
+| `rate` | [string](#string) |  | rate is the commission rate charged to delegators, as a fraction. |
+| `max_rate` | [string](#string) |  | max_rate defines the maximum commission rate which validator can ever charge, as a fraction. |
+| `max_change_rate` | [string](#string) |  | max_change_rate defines the maximum daily increase of the validator commission, as a fraction. |
 
 
 
@@ -5479,9 +5811,9 @@ validator.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `delegator_address` | [string](#string) |  |  |
-| `validator_address` | [string](#string) |  |  |
-| `shares` | [string](#string) |  |  |
+| `delegator_address` | [string](#string) |  | delegator_address is the bech32-encoded address of the delegator. |
+| `validator_address` | [string](#string) |  | validator_address is the bech32-encoded address of the validator. |
+| `shares` | [string](#string) |  | shares define the delegation shares received. |
 
 
 
@@ -5513,11 +5845,11 @@ Description defines a validator description.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `moniker` | [string](#string) |  |  |
-| `identity` | [string](#string) |  |  |
-| `website` | [string](#string) |  |  |
-| `security_contact` | [string](#string) |  |  |
-| `details` | [string](#string) |  |  |
+| `moniker` | [string](#string) |  | moniker defines a human-readable name for the validator. |
+| `identity` | [string](#string) |  | identity defines an optional identity signature (ex. UPort or Keybase). |
+| `website` | [string](#string) |  | website defines an optional website link. |
+| `security_contact` | [string](#string) |  | security_contact defines an optional email for security contact. |
+| `details` | [string](#string) |  | details define other optional details. |
 
 
 
@@ -5551,11 +5883,11 @@ Params defines the parameters for the staking module.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `unbonding_time` | [google.protobuf.Duration](#google.protobuf.Duration) |  |  |
-| `max_validators` | [uint32](#uint32) |  |  |
-| `max_entries` | [uint32](#uint32) |  |  |
-| `historical_entries` | [uint32](#uint32) |  |  |
-| `bond_denom` | [string](#string) |  |  |
+| `unbonding_time` | [google.protobuf.Duration](#google.protobuf.Duration) |  | unbonding_time is the time duration of unbonding. |
+| `max_validators` | [uint32](#uint32) |  | max_validators is the maximum number of validators. |
+| `max_entries` | [uint32](#uint32) |  | max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). |
+| `historical_entries` | [uint32](#uint32) |  | historical_entries is the number of historical entries to persist. |
+| `bond_denom` | [string](#string) |  | bond_denom defines the bondable coin denomination. |
 
 
 
@@ -5588,10 +5920,12 @@ from a particular source validator to a particular destination validator.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `delegator_address` | [string](#string) |  |  |
-| `validator_src_address` | [string](#string) |  |  |
-| `validator_dst_address` | [string](#string) |  |  |
-| `entries` | [RedelegationEntry](#cosmos.staking.v1beta1.RedelegationEntry) | repeated | redelegation entries |
+| `delegator_address` | [string](#string) |  | delegator_address is the bech32-encoded address of the delegator. |
+| `validator_src_address` | [string](#string) |  | validator_src_address is the validator redelegation source operator address. |
+| `validator_dst_address` | [string](#string) |  | validator_dst_address is the validator redelegation destination operator address. |
+| `entries` | [RedelegationEntry](#cosmos.staking.v1beta1.RedelegationEntry) | repeated | entries are the redelegation entries.
+
+redelegation entries |
 
 
 
@@ -5606,10 +5940,10 @@ RedelegationEntry defines a redelegation object with relevant metadata.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `creation_height` | [int64](#int64) |  |  |
-| `completion_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  |  |
-| `initial_balance` | [string](#string) |  |  |
-| `shares_dst` | [string](#string) |  |  |
+| `creation_height` | [int64](#int64) |  | creation_height defines the height which the redelegation took place. |
+| `completion_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  | completion_time defines the unix time for redelegation completion. |
+| `initial_balance` | [string](#string) |  | initial_balance defines the initial balance when redelegation started. |
+| `shares_dst` | [string](#string) |  | shares_dst is the amount of destination-validator shares created by redelegation. |
 
 
 
@@ -5661,9 +5995,11 @@ for a single validator in an time-ordered list.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `delegator_address` | [string](#string) |  |  |
-| `validator_address` | [string](#string) |  |  |
-| `entries` | [UnbondingDelegationEntry](#cosmos.staking.v1beta1.UnbondingDelegationEntry) | repeated | unbonding delegation entries |
+| `delegator_address` | [string](#string) |  | delegator_address is the bech32-encoded address of the delegator. |
+| `validator_address` | [string](#string) |  | validator_address is the bech32-encoded address of the validator. |
+| `entries` | [UnbondingDelegationEntry](#cosmos.staking.v1beta1.UnbondingDelegationEntry) | repeated | entries are the unbonding delegation entries.
+
+unbonding delegation entries |
 
 
 
@@ -5678,10 +6014,10 @@ UnbondingDelegationEntry defines an unbonding object with relevant metadata.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `creation_height` | [int64](#int64) |  |  |
-| `completion_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  |  |
-| `initial_balance` | [string](#string) |  |  |
-| `balance` | [string](#string) |  |  |
+| `creation_height` | [int64](#int64) |  | creation_height is the height which the unbonding took place. |
+| `completion_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  | completion_time is the unix time for unbonding completion. |
+| `initial_balance` | [string](#string) |  | initial_balance defines the tokens initially scheduled to receive at completion. |
+| `balance` | [string](#string) |  | balance defines the tokens to receive at completion. |
 
 
 
@@ -5718,17 +6054,17 @@ multiplied by exchange rate.
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `operator_address` | [string](#string) |  |  |
-| `consensus_pubkey` | [google.protobuf.Any](#google.protobuf.Any) |  |  |
-| `jailed` | [bool](#bool) |  |  |
-| `status` | [BondStatus](#cosmos.staking.v1beta1.BondStatus) |  |  |
-| `tokens` | [string](#string) |  |  |
-| `delegator_shares` | [string](#string) |  |  |
-| `description` | [Description](#cosmos.staking.v1beta1.Description) |  |  |
-| `unbonding_height` | [int64](#int64) |  |  |
-| `unbonding_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  |  |
-| `commission` | [Commission](#cosmos.staking.v1beta1.Commission) |  |  |
-| `min_self_delegation` | [string](#string) |  |  |
+| `operator_address` | [string](#string) |  | operator_address defines the address of the validator's operator; bech encoded in JSON. |
+| `consensus_pubkey` | [google.protobuf.Any](#google.protobuf.Any) |  | consensus_pubkey is the consensus public key of the validator, as a Protobuf Any. |
+| `jailed` | [bool](#bool) |  | jailed defined whether the validator has been jailed from bonded status or not. |
+| `status` | [BondStatus](#cosmos.staking.v1beta1.BondStatus) |  | status is the validator status (bonded/unbonding/unbonded). |
+| `tokens` | [string](#string) |  | tokens define the delegated tokens (incl. self-delegation). |
+| `delegator_shares` | [string](#string) |  | delegator_shares defines total shares issued to a validator's delegators. |
+| `description` | [Description](#cosmos.staking.v1beta1.Description) |  | description defines the description terms for the validator. |
+| `unbonding_height` | [int64](#int64) |  | unbonding_height defines, if unbonding, the height at which this validator has begun unbonding. |
+| `unbonding_time` | [google.protobuf.Timestamp](#google.protobuf.Timestamp) |  | unbonding_time defines, if unbonding, the min time for the validator to complete unbonding. |
+| `commission` | [Commission](#cosmos.staking.v1beta1.Commission) |  | commission defines the commission parameters. |
+| `min_self_delegation` | [string](#string) |  | min_self_delegation is the validator's self declared minimum self delegation. |
 
 
 
diff --git a/docs/run-node/interact-node.md b/docs/run-node/interact-node.md
index a07981341fe7..bb208f7d8df1 100644
--- a/docs/run-node/interact-node.md
+++ b/docs/run-node/interact-node.md
@@ -16,7 +16,7 @@ There are multiple ways to interact with a node: using the CLI, using gRPC or us
 Now that your chain is running, it is time to try sending tokens from the first account you created to a second account. In a new terminal window, start by running the following query command:
 
 ```bash
-simd query account $MY_VALIDATOR_ADDRESS --chain-id my-test-chain
+simd query bank balances $MY_VALIDATOR_ADDRESS --chain-id my-test-chain
 ```
 
 You should see the current balance of the account you created, equal to the original balance of `stake` you granted it minus the amount you delegated via the `gentx`. Now, create a second account:
@@ -31,16 +31,16 @@ RECIPIENT=$(simd keys show recipient -a --keyring-backend test)
 The command above creates a local key-pair that is not yet registered on the chain. An account is created the first time it receives tokens from another account. Now, run the following command to send tokens to the `recipient` account:
 
 ```bash
-simd tx bank send $MY_VALIDATOR_ADDRESS $RECIPIENT 1000stake --chain-id my-test-chain
+simd tx bank send $MY_VALIDATOR_ADDRESS $RECIPIENT 1000000stake --chain-id my-test-chain --keyring-backend test
 
 # Check that the recipient account did receive the tokens.
-simd query account $RECIPIENT --chain-id my-test-chain
+simd query bank balances $RECIPIENT --chain-id my-test-chain
 ```
 
 Finally, delegate some of the stake tokens sent to the `recipient` account to the validator:
 
 ```bash
-simd tx staking delegate $(simd keys show my_validator --bech val -a --keyring-backend test) 500stake --from recipient --chain-id my-test-chain
+simd tx staking delegate $(simd keys show my_validator --bech val -a --keyring-backend test) 500stake --from recipient --chain-id my-test-chain --keyring-backend test
 
 # Query the total delegations to `validator`.
 simd query staking delegations-to $(simd keys show my_validator --bech val -a --keyring-backend test) --chain-id my-test-chain
diff --git a/docs/run-node/run-node.md b/docs/run-node/run-node.md
index aee7d84e1301..d7aaf8f5822d 100644
--- a/docs/run-node/run-node.md
+++ b/docs/run-node/run-node.md
@@ -44,7 +44,7 @@ Before starting the chain, you need to populate the state with at least one acco
 Now that you have created a local account, go ahead and grant it some `stake` tokens in your chain's genesis file. Doing so will also make sure your chain is aware of this account's existence:
 
 ```bash
-simd add-genesis-account $MY_VALIDATOR_ADDRESS 100000000stake
+simd add-genesis-account $MY_VALIDATOR_ADDRESS 100000000000stake
 ```
 
 Recall that `$MY_VALIDATOR_ADDRESS` is a variable that holds the address of the `my_validator` key in the [keyring](./keyring.md#adding-keys-to-the-keyring). Also note that the tokens in the SDK have the `{amount}{denom}` format: `amount` is is a 18-digit-precision decimal number, and `denom` is the unique token identifier with its denomination key (e.g. `atom` or `uatom`). Here, we are granting `stake` tokens, as `stake` is the token identifier used for staking in [`simapp`](https://github.com/cosmos/cosmos-sdk/tree/v0.40.0-rc3/simapp). For your own chain with its own staking denom, that token identifier should be used instead.
@@ -53,7 +53,7 @@ Now that your account has some tokens, you need to add a validator to your chain
 
 ```bash
 # Create a gentx.
-simd gentx my_validator 100000stake --chain-id my-test-chain --keyring-backend test
+simd gentx my_validator 100000000stake --chain-id my-test-chain --keyring-backend test
 
 # Add the gentx to the genesis file.
 simd collect-gentxs
diff --git a/docs/run-node/txs.md b/docs/run-node/txs.md
index 9fbc642efc9d..ce977212d232 100644
--- a/docs/run-node/txs.md
+++ b/docs/run-node/txs.md
@@ -11,7 +11,7 @@ This document describes how to generate an (unsigned) transaction, signing it (w
 The easiest way to send transactions is using the CLI, as we have seen in the previous page when [interacting with a node](./interact-node.md#using-the-cli). For example, running the following command
 
 ```bash
-simd tx bank send $MY_VALIDATOR_ADDRESS $RECIPIENT 1000stake --chain-id my-test-chain
+simd tx bank send $MY_VALIDATOR_ADDRESS $RECIPIENT 1000stake --chain-id my-test-chain --keyring-backend test
 ```
 
 will run the following steps:
diff --git a/proto/cosmos/feegrant/v1beta1/feegrant.proto b/proto/cosmos/feegrant/v1beta1/feegrant.proto
new file mode 100644
index 000000000000..534de582d977
--- /dev/null
+++ b/proto/cosmos/feegrant/v1beta1/feegrant.proto
@@ -0,0 +1,81 @@
+syntax = "proto3";
+package cosmos.feegrant.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "google/protobuf/any.proto";
+import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/duration.proto";
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/feegrant/types";
+
+// BasicFeeAllowance implements FeeAllowance with a one-time grant of tokens
+// that optionally expires. The delegatee can use up to SpendLimit to cover fees.
+message BasicFeeAllowance {
+  option (cosmos_proto.implements_interface) = "FeeAllowanceI";
+
+  // spend_limit specifies the maximum amount of tokens that can be spent
+  // by this allowance and will be updated as tokens are spent. If it is
+  // empty, there is no spend limit and any amount of coins can be spent.
+  repeated cosmos.base.v1beta1.Coin spend_limit = 1
+      [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
+
+  // expiration specifies an optional time when this allowance expires
+  ExpiresAt expiration = 2 [(gogoproto.nullable) = false];
+}
+
+// PeriodicFeeAllowance extends FeeAllowance to allow for both a maximum cap,
+// as well as a limit per time period.
+message PeriodicFeeAllowance {
+  option (cosmos_proto.implements_interface) = "FeeAllowanceI";
+
+  // basic specifies a struct of `BasicFeeAllowance`
+  BasicFeeAllowance basic = 1 [(gogoproto.nullable) = false];
+
+  // period specifies the time duration in which period_spend_limit coins can
+  // be spent before that allowance is reset
+  Duration period = 2 [(gogoproto.nullable) = false];
+
+  // period_spend_limit specifies the maximum number of coins that can be spent
+  // in the period
+  repeated cosmos.base.v1beta1.Coin period_spend_limit = 3
+      [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
+
+  // period_can_spend is the number of coins left to be spent before the period_reset time
+  repeated cosmos.base.v1beta1.Coin period_can_spend = 4
+      [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
+
+  // period_reset is the time at which this period resets and a new one begins,
+  // it is calculated from the start time of the first transaction after the
+  // last period ended
+  ExpiresAt period_reset = 5 [(gogoproto.nullable) = false];
+}
+
+// Duration is a span of a clock time or number of blocks.
+// This is designed to be added to an ExpiresAt struct.
+message Duration {
+  // sum is the oneof that represents either duration or block
+  oneof sum {
+    google.protobuf.Duration duration = 1 [(gogoproto.stdduration) = true];
+    uint64                   blocks   = 2;
+  }
+}
+
+// ExpiresAt is a point in time where something expires.
+// It may be *either* block time or block height
+message ExpiresAt {
+  // sum is the oneof that represents either time or height
+  oneof sum {
+    google.protobuf.Timestamp time   = 1 [(gogoproto.stdtime) = true];
+    int64                     height = 2;
+  }
+}
+
+// FeeAllowanceGrant is stored in the KVStore to record a grant with full context
+message FeeAllowanceGrant {
+
+  string              granter   = 1;
+  string              grantee   = 2;
+  google.protobuf.Any allowance = 3 [(cosmos_proto.accepts_interface) = "FeeAllowanceI"];
+}
diff --git a/proto/cosmos/feegrant/v1beta1/genesis.proto b/proto/cosmos/feegrant/v1beta1/genesis.proto
new file mode 100644
index 000000000000..a021ea61dfc7
--- /dev/null
+++ b/proto/cosmos/feegrant/v1beta1/genesis.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+package cosmos.feegrant.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/feegrant/v1beta1/feegrant.proto";
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/feegrant/types";
+
+// GenesisState contains a set of fee allowances, persisted from the store
+message GenesisState {
+  repeated FeeAllowanceGrant fee_allowances = 1 [(gogoproto.nullable) = false];
+}
diff --git a/proto/cosmos/feegrant/v1beta1/query.proto b/proto/cosmos/feegrant/v1beta1/query.proto
new file mode 100644
index 000000000000..42d5f302005f
--- /dev/null
+++ b/proto/cosmos/feegrant/v1beta1/query.proto
@@ -0,0 +1,52 @@
+syntax = "proto3";
+package cosmos.feegrant.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/feegrant/v1beta1/feegrant.proto";
+import "cosmos/base/query/v1beta1/pagination.proto";
+import "google/api/annotations.proto";
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/feegrant/types";
+
+// Query defines the gRPC querier service.
+service Query {
+
+  // FeeAllowance returns fee granted to the grantee by the granter.
+  rpc FeeAllowance(QueryFeeAllowanceRequest) returns (QueryFeeAllowanceResponse) {
+    option (google.api.http).get = "/cosmos/feegrant/v1beta1/fee_allowance/{granter}/{grantee}";
+  }
+
+  // FeeAllowances returns all the grants for address.
+  rpc FeeAllowances(QueryFeeAllowancesRequest) returns (QueryFeeAllowancesResponse) {
+    option (google.api.http).get = "/cosmos/feegrant/v1beta1/fee_allowances/{grantee}";
+  }
+}
+
+// QueryFeeAllowanceRequest is the request type for the Query/FeeAllowance RPC method.
+message QueryFeeAllowanceRequest {
+  string granter = 1;
+  string grantee = 2;
+}
+
+// QueryFeeAllowanceResponse is the response type for the Query/FeeAllowance RPC method.
+message QueryFeeAllowanceResponse {
+  // fee_allowance is a fee_allowance granted for grantee by granter.
+  cosmos.feegrant.v1beta1.FeeAllowanceGrant fee_allowance = 1;
+}
+
+// QueryFeeAllowancesRequest is the request type for the Query/FeeAllowances RPC method.
+message QueryFeeAllowancesRequest {
+  string grantee = 1;
+
+  // pagination defines an pagination for the request.
+  cosmos.base.query.v1beta1.PageRequest pagination = 2;
+}
+
+// QueryFeeAllowancesResponse is the response type for the Query/FeeAllowances RPC method.
+message QueryFeeAllowancesResponse {
+  // fee_allowances are fee_allowance's granted for grantee by granter.
+  repeated cosmos.feegrant.v1beta1.FeeAllowanceGrant fee_allowances = 1;
+
+  // pagination defines an pagination for the response.
+  cosmos.base.query.v1beta1.PageResponse pagination = 2;
+}
diff --git a/proto/cosmos/feegrant/v1beta1/tx.proto b/proto/cosmos/feegrant/v1beta1/tx.proto
new file mode 100644
index 000000000000..a36f358f2503
--- /dev/null
+++ b/proto/cosmos/feegrant/v1beta1/tx.proto
@@ -0,0 +1,40 @@
+syntax = "proto3";
+package cosmos.feegrant.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "google/protobuf/any.proto";
+import "cosmos_proto/cosmos.proto";
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/feegrant/types";
+
+// Msg defines the feegrant msg service.
+service Msg {
+
+  // GrantFeeAllowance grants fee allowance to the grantee on the granter's
+  // account with the provided expiration time.
+  rpc GrantFeeAllowance(MsgGrantFeeAllowance) returns (MsgGrantFeeAllowanceResponse);
+
+  // RevokeFeeAllowance revokes any fee allowance of granter's account that
+  // has been granted to the grantee.
+  rpc RevokeFeeAllowance(MsgRevokeFeeAllowance) returns (MsgRevokeFeeAllowanceResponse);
+}
+
+// MsgGrantFeeAllowance adds permission for Grantee to spend up to Allowance
+// of fees from the account of Granter.
+message MsgGrantFeeAllowance {
+  string              granter   = 1;
+  string              grantee   = 2;
+  google.protobuf.Any allowance = 3 [(cosmos_proto.accepts_interface) = "FeeAllowanceI"];
+}
+
+// MsgGrantFeeAllowanceResponse defines the Msg/GrantFeeAllowanceResponse response type.
+message MsgGrantFeeAllowanceResponse {}
+
+// MsgRevokeFeeAllowance removes any existing FeeAllowance from Granter to Grantee.
+message MsgRevokeFeeAllowance {
+  string granter = 1;
+  string grantee = 2;
+}
+
+// MsgRevokeFeeAllowanceResponse defines the Msg/RevokeFeeAllowanceResponse response type.
+message MsgRevokeFeeAllowanceResponse {}
diff --git a/proto/cosmos/staking/v1beta1/staking.proto b/proto/cosmos/staking/v1beta1/staking.proto
index 456655cb86ea..987515bd380c 100644
--- a/proto/cosmos/staking/v1beta1/staking.proto
+++ b/proto/cosmos/staking/v1beta1/staking.proto
@@ -27,12 +27,15 @@ message CommissionRates {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // rate is the commission rate charged to delegators, as a fraction.
   string rate     = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false];
+  // max_rate defines the maximum commission rate which validator can ever charge, as a fraction.
   string max_rate = 2 [
     (gogoproto.moretags)   = "yaml:\"max_rate\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.nullable)   = false
   ];
+  // max_change_rate defines the maximum daily increase of the validator commission, as a fraction.
   string max_change_rate = 3 [
     (gogoproto.moretags)   = "yaml:\"max_change_rate\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
@@ -45,7 +48,9 @@ message Commission {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // commission_rates defines the initial commission rates to be used for creating a validator.
   CommissionRates           commission_rates = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false];
+  // update_time is the last time the commission rate was changed.
   google.protobuf.Timestamp update_time      = 2
       [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"update_time\""];
 }
@@ -55,10 +60,15 @@ message Description {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // moniker defines a human-readable name for the validator.
   string moniker          = 1;
+  // identity defines an optional identity signature (ex. UPort or Keybase).
   string identity         = 2;
+  // website defines an optional website link.
   string website          = 3;
+  // security_contact defines an optional email for security contact.
   string security_contact = 4 [(gogoproto.moretags) = "yaml:\"security_contact\""];
+  // details define other optional details.
   string details          = 5;
 }
 
@@ -75,22 +85,33 @@ message Validator {
   option (gogoproto.goproto_stringer) = false;
   option (gogoproto.goproto_getters)  = false;
 
+  // operator_address defines the address of the validator's operator; bech encoded in JSON.
   string              operator_address = 1 [(gogoproto.moretags) = "yaml:\"operator_address\""];
+  // consensus_pubkey is the consensus public key of the validator, as a Protobuf Any.
   google.protobuf.Any consensus_pubkey = 2
       [(cosmos_proto.accepts_interface) = "cosmos.crypto.PubKey", (gogoproto.moretags) = "yaml:\"consensus_pubkey\""];
+  // jailed defined whether the validator has been jailed from bonded status or not.
   bool       jailed = 3;
+  // status is the validator status (bonded/unbonding/unbonded).
   BondStatus status = 4;
+  // tokens define the delegated tokens (incl. self-delegation).
   string tokens = 5 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false];
+  // delegator_shares defines total shares issued to a validator's delegators.
   string delegator_shares = 6 [
     (gogoproto.moretags)   = "yaml:\"delegator_shares\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.nullable)   = false
   ];
+  // description defines the description terms for the validator.
   Description               description      = 7 [(gogoproto.nullable) = false];
+  // unbonding_height defines, if unbonding, the height at which this validator has begun unbonding.
   int64                     unbonding_height = 8 [(gogoproto.moretags) = "yaml:\"unbonding_height\""];
+  // unbonding_time defines, if unbonding, the min time for the validator to complete unbonding.
   google.protobuf.Timestamp unbonding_time   = 9
       [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"unbonding_time\""];
+  // commission defines the commission parameters.
   Commission commission          = 10 [(gogoproto.nullable) = false];
+  // min_self_delegation is the validator's self declared minimum self delegation.
   string     min_self_delegation = 11 [
     (gogoproto.moretags)   = "yaml:\"min_self_delegation\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
@@ -164,8 +185,11 @@ message Delegation {
   option (gogoproto.goproto_getters)  = false;
   option (gogoproto.goproto_stringer) = false;
 
+  // delegator_address is the bech32-encoded address of the delegator.
   string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""];
+  // validator_address is the bech32-encoded address of the validator.
   string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""];
+  // shares define the delegation shares received.
   string shares = 3 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false];
 }
 
@@ -176,8 +200,11 @@ message UnbondingDelegation {
   option (gogoproto.goproto_getters)  = false;
   option (gogoproto.goproto_stringer) = false;
 
+  // delegator_address is the bech32-encoded address of the delegator.
   string                            delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""];
+  // validator_address is the bech32-encoded address of the validator.
   string                            validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""];
+  // entries are the unbonding delegation entries.
   repeated UnbondingDelegationEntry entries = 3 [(gogoproto.nullable) = false]; // unbonding delegation entries
 }
 
@@ -186,14 +213,18 @@ message UnbondingDelegationEntry {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // creation_height is the height which the unbonding took place.
   int64                     creation_height = 1 [(gogoproto.moretags) = "yaml:\"creation_height\""];
+  // completion_time is the unix time for unbonding completion.
   google.protobuf.Timestamp completion_time = 2
       [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"completion_time\""];
+  // initial_balance defines the tokens initially scheduled to receive at completion.
   string initial_balance = 3 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable)   = false,
     (gogoproto.moretags)   = "yaml:\"initial_balance\""
   ];
+  // balance defines the tokens to receive at completion.
   string balance = 4 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false];
 }
 
@@ -202,14 +233,18 @@ message RedelegationEntry {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // creation_height  defines the height which the redelegation took place.
   int64                     creation_height = 1 [(gogoproto.moretags) = "yaml:\"creation_height\""];
+  // completion_time defines the unix time for redelegation completion.
   google.protobuf.Timestamp completion_time = 2
       [(gogoproto.nullable) = false, (gogoproto.stdtime) = true, (gogoproto.moretags) = "yaml:\"completion_time\""];
+  // initial_balance defines the initial balance when redelegation started.
   string initial_balance = 3 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable)   = false,
     (gogoproto.moretags)   = "yaml:\"initial_balance\""
   ];
+  // shares_dst is the amount of destination-validator shares created by redelegation.
   string shares_dst = 4
       [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", (gogoproto.nullable) = false];
 }
@@ -221,9 +256,13 @@ message Redelegation {
   option (gogoproto.goproto_getters)  = false;
   option (gogoproto.goproto_stringer) = false;
 
+  // delegator_address is the bech32-encoded address of the delegator.
   string                     delegator_address     = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""];
+  // validator_src_address is the validator redelegation source operator address.
   string                     validator_src_address = 2 [(gogoproto.moretags) = "yaml:\"validator_src_address\""];
+  // validator_dst_address is the validator redelegation destination operator address.
   string                     validator_dst_address = 3 [(gogoproto.moretags) = "yaml:\"validator_dst_address\""];
+  // entries are the redelegation entries.
   repeated RedelegationEntry entries               = 4 [(gogoproto.nullable) = false]; // redelegation entries
 }
 
@@ -232,12 +271,18 @@ message Params {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_stringer) = false;
 
+  // unbonding_time is the time duration of unbonding.
   google.protobuf.Duration unbonding_time = 1
       [(gogoproto.nullable) = false, (gogoproto.stdduration) = true, (gogoproto.moretags) = "yaml:\"unbonding_time\""];
+  // max_validators is the maximum number of validators.
   uint32 max_validators     = 2 [(gogoproto.moretags) = "yaml:\"max_validators\""];
+  // max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio).
   uint32 max_entries        = 3 [(gogoproto.moretags) = "yaml:\"max_entries\""];
+  // historical_entries is the number of historical entries to persist.
   uint32 historical_entries = 4 [(gogoproto.moretags) = "yaml:\"historical_entries\""];
+  // bond_denom defines the bondable coin denomination.
   string bond_denom         = 5 [(gogoproto.moretags) = "yaml:\"bond_denom\""];
+  // power_reduction is the amount of staking tokens required for 1 unit of consensus-engine power
   string power_reduction    = 6 [
     (gogoproto.moretags)   = "yaml:\"power_reduction\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
diff --git a/server/tm_cmds.go b/server/tm_cmds.go
index b05a88f797da..854d4597fee8 100644
--- a/server/tm_cmds.go
+++ b/server/tm_cmds.go
@@ -28,7 +28,7 @@ func ShowNodeIDCmd() *cobra.Command {
 			serverCtx := GetServerContextFromCmd(cmd)
 			cfg := serverCtx.Config
 
-			nodeKey, err := p2p.LoadOrGenNodeKey(cfg.NodeKeyFile())
+			nodeKey, err := p2p.LoadNodeKey(cfg.NodeKeyFile())
 			if err != nil {
 				return err
 			}
@@ -48,7 +48,7 @@ func ShowValidatorCmd() *cobra.Command {
 			serverCtx := GetServerContextFromCmd(cmd)
 			cfg := serverCtx.Config
 
-			privValidator := pvm.LoadOrGenFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
 			valPubKey, err := privValidator.GetPubKey()
 			if err != nil {
 				return err
@@ -86,7 +86,7 @@ func ShowAddressCmd() *cobra.Command {
 			serverCtx := GetServerContextFromCmd(cmd)
 			cfg := serverCtx.Config
 
-			privValidator := pvm.LoadOrGenFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
 			valConsAddr := (sdk.ConsAddress)(privValidator.GetAddress())
 
 			output, _ := cmd.Flags().GetString(cli.OutputFlag)
diff --git a/server/util.go b/server/util.go
index e461a12fb843..b431b715db27 100644
--- a/server/util.go
+++ b/server/util.go
@@ -17,6 +17,7 @@ import (
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
 	tmcfg "github.com/tendermint/tendermint/config"
 	tmlog "github.com/tendermint/tendermint/libs/log"
@@ -63,6 +64,37 @@ func NewContext(v *viper.Viper, config *tmcfg.Config, logger tmlog.Logger) *Cont
 	return &Context{v, config, logger}
 }
 
+func bindFlags(basename string, cmd *cobra.Command, v *viper.Viper) (err error) {
+	defer func() {
+		recover()
+	}()
+
+	cmd.Flags().VisitAll(func(f *pflag.Flag) {
+		// Environment variables can't have dashes in them, so bind them to their equivalent
+		// keys with underscores, e.g. --favorite-color to STING_FAVORITE_COLOR
+		err = v.BindEnv(f.Name, fmt.Sprintf("%s_%s", basename, strings.ToUpper(strings.ReplaceAll(f.Name, "-", "_"))))
+		if err != nil {
+			panic(err)
+		}
+
+		err = v.BindPFlag(f.Name, f)
+		if err != nil {
+			panic(err)
+		}
+
+		// Apply the viper config value to the flag when the flag is not set and viper has a value
+		if !f.Changed && v.IsSet(f.Name) {
+			val := v.Get(f.Name)
+			err = cmd.Flags().Set(f.Name, fmt.Sprintf("%v", val))
+			if err != nil {
+				panic(err)
+			}
+		}
+	})
+
+	return
+}
+
 // InterceptConfigsPreRunHandler performs a pre-run function for the root daemon
 // application command. It will create a Viper literal and a default server
 // Context. The server Tendermint configuration will either be read and parsed
@@ -98,6 +130,9 @@ func InterceptConfigsPreRunHandler(cmd *cobra.Command) error {
 
 	// return value is a tendermint configuration object
 	serverCtx.Config = config
+	if err = bindFlags(basename, cmd, serverCtx.Viper); err != nil {
+		return err
+	}
 
 	var logWriter io.Writer
 	if strings.ToLower(serverCtx.Viper.GetString(flags.FlagLogFormat)) == tmcfg.LogFormatPlain {
diff --git a/simapp/app.go b/simapp/app.go
index 5e9c3e29e163..23ced043d047 100644
--- a/simapp/app.go
+++ b/simapp/app.go
@@ -55,6 +55,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/evidence"
 	evidencekeeper "github.com/cosmos/cosmos-sdk/x/evidence/keeper"
 	evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types"
+	feegrant "github.com/cosmos/cosmos-sdk/x/feegrant"
+	feegrantante "github.com/cosmos/cosmos-sdk/x/feegrant/ante"
+	feegrantkeeper "github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	feegranttypes "github.com/cosmos/cosmos-sdk/x/feegrant/types"
 	"github.com/cosmos/cosmos-sdk/x/genutil"
 	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
 	"github.com/cosmos/cosmos-sdk/x/gov"
@@ -120,6 +124,7 @@ var (
 		crisis.AppModuleBasic{},
 		slashing.AppModuleBasic{},
 		ibc.AppModuleBasic{},
+		feegrant.AppModuleBasic{},
 		upgrade.AppModuleBasic{},
 		evidence.AppModuleBasic{},
 		transfer.AppModuleBasic{},
@@ -181,6 +186,7 @@ type SimApp struct {
 	IBCKeeper        *ibckeeper.Keeper // IBC Keeper must be a pointer in the app, so we can SetRouter on it correctly
 	EvidenceKeeper   evidencekeeper.Keeper
 	TransferKeeper   ibctransferkeeper.Keeper
+	FeeGrantKeeper   feegrantkeeper.Keeper
 
 	// make scoped keepers public for test purposes
 	ScopedIBCKeeper      capabilitykeeper.ScopedKeeper
@@ -222,7 +228,7 @@ func NewSimApp(
 	keys := sdk.NewKVStoreKeys(
 		authtypes.StoreKey, banktypes.StoreKey, stakingtypes.StoreKey,
 		minttypes.StoreKey, distrtypes.StoreKey, slashingtypes.StoreKey,
-		govtypes.StoreKey, paramstypes.StoreKey, ibchost.StoreKey, upgradetypes.StoreKey,
+		govtypes.StoreKey, paramstypes.StoreKey, ibchost.StoreKey, upgradetypes.StoreKey, feegranttypes.StoreKey,
 		evidencetypes.StoreKey, ibctransfertypes.StoreKey, capabilitytypes.StoreKey,
 		authztypes.StoreKey,
 	)
@@ -277,6 +283,8 @@ func NewSimApp(
 	app.CrisisKeeper = crisiskeeper.NewKeeper(
 		app.GetSubspace(crisistypes.ModuleName), invCheckPeriod, app.BankKeeper, authtypes.FeeCollectorName,
 	)
+
+	app.FeeGrantKeeper = feegrantkeeper.NewKeeper(appCodec, keys[feegranttypes.StoreKey], app.AccountKeeper)
 	app.UpgradeKeeper = upgradekeeper.NewKeeper(skipUpgradeHeights, keys[upgradetypes.StoreKey], appCodec, homePath)
 
 	// register the staking hooks
@@ -347,6 +355,7 @@ func NewSimApp(
 		bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper),
 		capability.NewAppModule(appCodec, *app.CapabilityKeeper),
 		crisis.NewAppModule(&app.CrisisKeeper, skipGenesisInvariants),
+		feegrant.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry),
 		gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper),
 		mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper),
 		slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper),
@@ -379,6 +388,7 @@ func NewSimApp(
 		capabilitytypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName, stakingtypes.ModuleName,
 		slashingtypes.ModuleName, govtypes.ModuleName, minttypes.ModuleName, crisistypes.ModuleName,
 		ibchost.ModuleName, genutiltypes.ModuleName, evidencetypes.ModuleName, authztypes.ModuleName, ibctransfertypes.ModuleName,
+		feegranttypes.ModuleName,
 	)
 
 	app.mm.RegisterInvariants(&app.CrisisKeeper)
@@ -396,6 +406,7 @@ func NewSimApp(
 		auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts),
 		bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper),
 		capability.NewAppModule(appCodec, *app.CapabilityKeeper),
+		feegrant.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry),
 		gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper),
 		mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper),
 		staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper),
@@ -419,8 +430,8 @@ func NewSimApp(
 	app.SetInitChainer(app.InitChainer)
 	app.SetBeginBlocker(app.BeginBlocker)
 	app.SetAnteHandler(
-		ante.NewAnteHandler(
-			app.AccountKeeper, app.BankKeeper, ante.DefaultSigVerificationGasConsumer,
+		feegrantante.NewAnteHandler(
+			app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, ante.DefaultSigVerificationGasConsumer,
 			encodingConfig.TxConfig.SignModeHandler(),
 		),
 	)
diff --git a/simapp/export.go b/simapp/export.go
index 887308d30a94..8d09e333a2e1 100644
--- a/simapp/export.go
+++ b/simapp/export.go
@@ -157,7 +157,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
 	counter := int16(0)
 
 	for ; iter.Valid(); iter.Next() {
-		addr := sdk.ValAddress(iter.Key()[1:])
+		addr := sdk.ValAddress(stakingtypes.AddressFromValidatorsKey(iter.Key()))
 		validator, found := app.StakingKeeper.GetValidator(ctx, addr)
 		if !found {
 			panic("expected validator, not found")
diff --git a/simapp/params/weights.go b/simapp/params/weights.go
index 0ba377b009b1..a7ea85ef7c1d 100644
--- a/simapp/params/weights.go
+++ b/simapp/params/weights.go
@@ -20,4 +20,8 @@ const (
 	DefaultWeightCommunitySpendProposal int = 5
 	DefaultWeightTextProposal           int = 5
 	DefaultWeightParamChangeProposal    int = 5
+
+	// feegrant
+	DefaultWeightGrantFeeAllowance  int = 100
+	DefaultWeightRevokeFeeAllowance int = 100
 )
diff --git a/simapp/sim_bench_test.go b/simapp/sim_bench_test.go
index 7c22dcfe8a44..ba5c71c6f3fb 100644
--- a/simapp/sim_bench_test.go
+++ b/simapp/sim_bench_test.go
@@ -14,6 +14,7 @@ import (
 // Profile with:
 // /usr/local/go/bin/go test -benchmem -run=^$ github.com/cosmos/cosmos-sdk/simapp -bench ^BenchmarkFullAppSimulation$ -Commit=true -cpuprofile cpu.out
 func BenchmarkFullAppSimulation(b *testing.B) {
+	b.ReportAllocs()
 	config, db, dir, logger, _, err := SetupSimulation("goleveldb-app-sim", "Simulation")
 	if err != nil {
 		b.Fatalf("simulation setup failed: %s", err.Error())
@@ -57,6 +58,7 @@ func BenchmarkFullAppSimulation(b *testing.B) {
 }
 
 func BenchmarkInvariants(b *testing.B) {
+	b.ReportAllocs()
 	config, db, dir, logger, _, err := SetupSimulation("leveldb-app-invariant-bench", "Simulation")
 	if err != nil {
 		b.Fatalf("simulation setup failed: %s", err.Error())
diff --git a/snapshots/helpers_test.go b/snapshots/helpers_test.go
index 5dbdd317536a..751ac212d352 100644
--- a/snapshots/helpers_test.go
+++ b/snapshots/helpers_test.go
@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io"
 	"io/ioutil"
+	"os"
 	"testing"
 	"time"
 
@@ -100,7 +101,10 @@ func (m *mockSnapshotter) Snapshot(height uint64, format uint32) (<-chan io.Read
 // setupBusyManager creates a manager with an empty store that is busy creating a snapshot at height 1.
 // The snapshot will complete when the returned closer is called.
 func setupBusyManager(t *testing.T) *snapshots.Manager {
-	tempdir := t.TempDir()
+	tempdir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = os.RemoveAll(tempdir) })
+
 	store, err := snapshots.NewStore(db.NewMemDB(), tempdir)
 	require.NoError(t, err)
 	hung := newHungSnapshotter()
diff --git a/snapshots/store.go b/snapshots/store.go
index e0bcbe6bd570..77ff58e22ff6 100644
--- a/snapshots/store.go
+++ b/snapshots/store.go
@@ -91,7 +91,7 @@ func (s *Store) Get(height uint64, format uint32) (*types.Snapshot, error) {
 
 // Get fetches the latest snapshot from the database, if any.
 func (s *Store) GetLatest() (*types.Snapshot, error) {
-	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(math.MaxUint64, math.MaxUint32))
+	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(uint64(math.MaxUint64), math.MaxUint32))
 	if err != nil {
 		return nil, sdkerrors.Wrap(err, "failed to find latest snapshot")
 	}
@@ -111,7 +111,7 @@ func (s *Store) GetLatest() (*types.Snapshot, error) {
 
 // List lists snapshots, in reverse order (newest first).
 func (s *Store) List() ([]*types.Snapshot, error) {
-	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(math.MaxUint64, math.MaxUint32))
+	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(uint64(math.MaxUint64), math.MaxUint32))
 	if err != nil {
 		return nil, sdkerrors.Wrap(err, "failed to list snapshots")
 	}
@@ -181,7 +181,7 @@ func (s *Store) loadChunkFile(height uint64, format uint32, chunk uint32) (io.Re
 
 // Prune removes old snapshots. The given number of most recent heights (regardless of format) are retained.
 func (s *Store) Prune(retain uint32) (uint64, error) {
-	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(math.MaxUint64, math.MaxUint32))
+	iter, err := s.db.ReverseIterator(encodeKey(0, 0), encodeKey(uint64(math.MaxUint64), math.MaxUint32))
 	if err != nil {
 		return 0, sdkerrors.Wrap(err, "failed to prune snapshots")
 	}
diff --git a/snapshots/store_test.go b/snapshots/store_test.go
index 1a04a393c1ed..325fd3410bea 100644
--- a/snapshots/store_test.go
+++ b/snapshots/store_test.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"io"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -19,7 +20,10 @@ import (
 )
 
 func setupStore(t *testing.T) *snapshots.Store {
-	tempdir := t.TempDir()
+	tempdir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = os.RemoveAll(tempdir) })
+
 	store, err := snapshots.NewStore(db.NewMemDB(), tempdir)
 	require.NoError(t, err)
 
diff --git a/store/cache/benchmark_test.go b/store/cache/benchmark_test.go
index cf8206272c41..10b5da2bfb0b 100644
--- a/store/cache/benchmark_test.go
+++ b/store/cache/benchmark_test.go
@@ -22,6 +22,7 @@ func populate(mgr *CommitKVStoreCacheManager) {
 }
 
 func BenchmarkReset(b *testing.B) {
+	b.ReportAllocs()
 	mgr := freshMgr()
 
 	b.ResetTimer()
diff --git a/store/cachekv/store_bench_test.go b/store/cachekv/store_bench_test.go
index 4902819834d8..2957fe6a6503 100644
--- a/store/cachekv/store_bench_test.go
+++ b/store/cachekv/store_bench_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func benchmarkCacheKVStoreIterator(numKVs int, b *testing.B) {
+	b.ReportAllocs()
 	mem := dbadapter.Store{DB: dbm.NewMemDB()}
 	cstore := cachekv.NewStore(mem)
 	keys := make([]string, numKVs)
diff --git a/store/cachekv/store_test.go b/store/cachekv/store_test.go
index e3b33341b8c4..0404f33f2a28 100644
--- a/store/cachekv/store_test.go
+++ b/store/cachekv/store_test.go
@@ -516,6 +516,7 @@ func (krc *keyRangeCounter) key() int {
 func bz(s string) []byte { return []byte(s) }
 
 func BenchmarkCacheKVStoreGetNoKeyFound(b *testing.B) {
+	b.ReportAllocs()
 	st := newCacheKVStore()
 	b.ResetTimer()
 	// assumes b.N < 2**24
@@ -525,6 +526,7 @@ func BenchmarkCacheKVStoreGetNoKeyFound(b *testing.B) {
 }
 
 func BenchmarkCacheKVStoreGetKeyFound(b *testing.B) {
+	b.ReportAllocs()
 	st := newCacheKVStore()
 	for i := 0; i < b.N; i++ {
 		arr := []byte{byte((i & 0xFF0000) >> 16), byte((i & 0xFF00) >> 8), byte(i & 0xFF)}
diff --git a/store/iavl/store_test.go b/store/iavl/store_test.go
index 790830038ba9..cfda5efacf37 100644
--- a/store/iavl/store_test.go
+++ b/store/iavl/store_test.go
@@ -556,6 +556,7 @@ func TestIAVLStoreQuery(t *testing.T) {
 }
 
 func BenchmarkIAVLIteratorNext(b *testing.B) {
+	b.ReportAllocs()
 	db := dbm.NewMemDB()
 	treeSize := 1000
 	tree, err := iavl.NewMutableTree(db, cacheSize)
diff --git a/store/rootmulti/store.go b/store/rootmulti/store.go
index 03fa1b561fdb..1ca43eae9d4e 100644
--- a/store/rootmulti/store.go
+++ b/store/rootmulti/store.go
@@ -711,9 +711,9 @@ func (rs *Store) Restore(
 	if height == 0 {
 		return sdkerrors.Wrap(sdkerrors.ErrLogic, "cannot restore snapshot at height 0")
 	}
-	if height > math.MaxInt64 {
+	if height > uint64(math.MaxInt64) {
 		return sdkerrors.Wrapf(snapshottypes.ErrInvalidMetadata,
-			"snapshot height %v cannot exceed %v", height, math.MaxInt64)
+			"snapshot height %v cannot exceed %v", height, int64(math.MaxInt64))
 	}
 
 	// Signal readiness. Must be done before the readers below are set up, since the zlib
diff --git a/store/rootmulti/store_test.go b/store/rootmulti/store_test.go
index e4654f410d0d..eafc0d6bb817 100644
--- a/store/rootmulti/store_test.go
+++ b/store/rootmulti/store_test.go
@@ -689,6 +689,7 @@ func BenchmarkMultistoreSnapshotRestore1M(b *testing.B) {
 }
 
 func benchmarkMultistoreSnapshot(b *testing.B, stores uint8, storeKeys uint64) {
+	b.ReportAllocs()
 	b.StopTimer()
 	source := newMultiStoreWithGeneratedData(dbm.NewMemDB(), stores, storeKeys)
 	version := source.LastCommitID().Version
@@ -716,6 +717,7 @@ func benchmarkMultistoreSnapshot(b *testing.B, stores uint8, storeKeys uint64) {
 }
 
 func benchmarkMultistoreSnapshotRestore(b *testing.B, stores uint8, storeKeys uint64) {
+	b.ReportAllocs()
 	b.StopTimer()
 	source := newMultiStoreWithGeneratedData(dbm.NewMemDB(), stores, storeKeys)
 	version := uint64(source.LastCommitID().Version)
diff --git a/types/address.go b/types/address.go
index ba9e5b303b6a..eabff6fa97ee 100644
--- a/types/address.go
+++ b/types/address.go
@@ -12,7 +12,9 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/codec/legacy"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 	"github.com/cosmos/cosmos-sdk/types/bech32"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 const (
@@ -28,8 +30,6 @@ const (
 	//	config.SetFullFundraiserPath(yourFullFundraiserPath)
 	//	config.Seal()
 
-	// AddrLen defines a valid address length
-	AddrLen = 20
 	// Bech32MainPrefix defines the main SDK Bech32 prefix of an account's address
 	Bech32MainPrefix = "cosmos"
 
@@ -110,9 +110,15 @@ func VerifyAddressFormat(bz []byte) error {
 	if verifier != nil {
 		return verifier(bz)
 	}
-	if len(bz) != AddrLen {
-		return fmt.Errorf("incorrect address length (expected: %d, actual: %d)", AddrLen, len(bz))
+
+	if len(bz) == 0 {
+		return sdkerrors.Wrap(sdkerrors.ErrUnknownAddress, "addresses cannot be empty")
+	}
+
+	if len(bz) > address.MaxAddrLen {
+		return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "address max length is %d, got %d", address.MaxAddrLen, len(bz))
 	}
+
 	return nil
 }
 
diff --git a/types/address/store_key.go b/types/address/store_key.go
new file mode 100644
index 000000000000..948491972936
--- /dev/null
+++ b/types/address/store_key.go
@@ -0,0 +1,33 @@
+package address
+
+import (
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// MaxAddrLen is the maximum allowed length (in bytes) for an address.
+const MaxAddrLen = 255
+
+// LengthPrefix prefixes the address bytes with its length, this is used
+// for example for variable-length components in store keys.
+func LengthPrefix(bz []byte) ([]byte, error) {
+	bzLen := len(bz)
+	if bzLen == 0 {
+		return bz, nil
+	}
+
+	if bzLen > MaxAddrLen {
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "address length should be max %d bytes, got %d", MaxAddrLen, bzLen)
+	}
+
+	return append([]byte{byte(bzLen)}, bz...), nil
+}
+
+// MustLengthPrefix is LengthPrefix with panic on error.
+func MustLengthPrefix(bz []byte) []byte {
+	res, err := LengthPrefix(bz)
+	if err != nil {
+		panic(err)
+	}
+
+	return res
+}
diff --git a/types/address/store_key_test.go b/types/address/store_key_test.go
new file mode 100644
index 000000000000..3bb00bd022b0
--- /dev/null
+++ b/types/address/store_key_test.go
@@ -0,0 +1,38 @@
+package address_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/types/address"
+)
+
+func TestLengthPrefixedAddressStoreKey(t *testing.T) {
+	addr10byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	addr20byte := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+	addr256byte := make([]byte, 256)
+
+	tests := []struct {
+		name        string
+		addr        []byte
+		expStoreKey []byte
+		expErr      bool
+	}{
+		{"10-byte address", addr10byte, append([]byte{byte(10)}, addr10byte...), false},
+		{"20-byte address", addr20byte, append([]byte{byte(20)}, addr20byte...), false},
+		{"256-byte address (too long)", addr256byte, nil, true},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			storeKey, err := address.LengthPrefix(tt.addr)
+			if tt.expErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.expStoreKey, storeKey)
+			}
+		})
+	}
+}
diff --git a/types/address_bench_test.go b/types/address_bench_test.go
index 59222dacf9b7..88a7e537a0d2 100644
--- a/types/address_bench_test.go
+++ b/types/address_bench_test.go
@@ -12,6 +12,7 @@ import (
 )
 
 func BenchmarkBech32ifyPubKey(b *testing.B) {
+	b.ReportAllocs()
 	pkBz := make([]byte, ed25519.PubKeySize)
 	pk := &ed25519.PubKey{Key: pkBz}
 	rng := rand.New(rand.NewSource(time.Now().Unix()))
@@ -29,6 +30,7 @@ func BenchmarkBech32ifyPubKey(b *testing.B) {
 }
 
 func BenchmarkGetPubKeyFromBech32(b *testing.B) {
+	b.ReportAllocs()
 	pkBz := make([]byte, ed25519.PubKeySize)
 	pk := &ed25519.PubKey{Key: pkBz}
 	rng := rand.New(rand.NewSource(time.Now().Unix()))
diff --git a/types/address_test.go b/types/address_test.go
index 5796c891acb0..b9bc0c3c5308 100644
--- a/types/address_test.go
+++ b/types/address_test.go
@@ -347,15 +347,18 @@ func (s *addressTestSuite) TestVerifyAddressFormat() {
 	addr5 := make([]byte, 5)
 	addr20 := make([]byte, 20)
 	addr32 := make([]byte, 32)
+	addr256 := make([]byte, 256)
 
 	err := types.VerifyAddressFormat(addr0)
-	s.Require().EqualError(err, "incorrect address length 0")
+	s.Require().EqualError(err, "addresses cannot be empty: unknown address")
 	err = types.VerifyAddressFormat(addr5)
-	s.Require().EqualError(err, "incorrect address length 5")
+	s.Require().NoError(err)
 	err = types.VerifyAddressFormat(addr20)
-	s.Require().Nil(err)
+	s.Require().NoError(err)
 	err = types.VerifyAddressFormat(addr32)
-	s.Require().EqualError(err, "incorrect address length 32")
+	s.Require().NoError(err)
+	err = types.VerifyAddressFormat(addr256)
+	s.Require().EqualError(err, "address max length is 255, got 256: unknown address")
 }
 
 func (s *addressTestSuite) TestCustomAddressVerifier() {
@@ -364,34 +367,39 @@ func (s *addressTestSuite) TestCustomAddressVerifier() {
 	accBech := types.AccAddress(addr).String()
 	valBech := types.ValAddress(addr).String()
 	consBech := types.ConsAddress(addr).String()
-	// Verifiy that the default logic rejects this 10 byte address
+	// Verify that the default logic doesn't reject this 10 byte address
+	// The default verifier is nil, we're only checking address length is
+	// between 1-255 bytes.
 	err := types.VerifyAddressFormat(addr)
-	s.Require().NotNil(err)
+	s.Require().Nil(err)
 	_, err = types.AccAddressFromBech32(accBech)
-	s.Require().NotNil(err)
+	s.Require().Nil(err)
 	_, err = types.ValAddressFromBech32(valBech)
-	s.Require().NotNil(err)
+	s.Require().Nil(err)
 	_, err = types.ConsAddressFromBech32(consBech)
-	s.Require().NotNil(err)
+	s.Require().Nil(err)
 
-	// Set a custom address verifier that accepts 10 or 20 byte addresses
+	// Set a custom address verifier only accepts 20 byte addresses
 	types.GetConfig().SetAddressVerifier(func(bz []byte) error {
 		n := len(bz)
-		if n == 10 || n == types.AddrLen {
+		if n == 20 {
 			return nil
 		}
 		return fmt.Errorf("incorrect address length %d", n)
 	})
 
-	// Verifiy that the custom logic accepts this 10 byte address
+	// Verifiy that the custom logic rejects this 10 byte address
 	err = types.VerifyAddressFormat(addr)
-	s.Require().Nil(err)
+	s.Require().NotNil(err)
 	_, err = types.AccAddressFromBech32(accBech)
-	s.Require().Nil(err)
+	s.Require().NotNil(err)
 	_, err = types.ValAddressFromBech32(valBech)
-	s.Require().Nil(err)
+	s.Require().NotNil(err)
 	_, err = types.ConsAddressFromBech32(consBech)
-	s.Require().Nil(err)
+	s.Require().NotNil(err)
+
+	// Reinitialize the global config to default address verifier (nil)
+	types.GetConfig().SetAddressVerifier(nil)
 }
 
 func (s *addressTestSuite) TestBech32ifyAddressBytes() {
diff --git a/types/coin_benchmark_test.go b/types/coin_benchmark_test.go
index fc73afe87aaa..c6e040112115 100644
--- a/types/coin_benchmark_test.go
+++ b/types/coin_benchmark_test.go
@@ -6,10 +6,11 @@ import (
 )
 
 func coinName(suffix int) string {
-	return fmt.Sprintf("COINZ_%d", suffix)
+	return fmt.Sprintf("coinz%d", suffix)
 }
 
 func BenchmarkCoinsAdditionIntersect(b *testing.B) {
+	b.ReportAllocs()
 	benchmarkingFunc := func(numCoinsA int, numCoinsB int) func(b *testing.B) {
 		return func(b *testing.B) {
 			coinsA := Coins(make([]Coin, numCoinsA))
@@ -39,6 +40,7 @@ func BenchmarkCoinsAdditionIntersect(b *testing.B) {
 }
 
 func BenchmarkCoinsAdditionNoIntersect(b *testing.B) {
+	b.ReportAllocs()
 	benchmarkingFunc := func(numCoinsA int, numCoinsB int) func(b *testing.B) {
 		return func(b *testing.B) {
 			coinsA := Coins(make([]Coin, numCoinsA))
diff --git a/types/decimal_test.go b/types/decimal_test.go
index ffd09afc2707..8e62275a0eba 100644
--- a/types/decimal_test.go
+++ b/types/decimal_test.go
@@ -487,6 +487,7 @@ func (s *decimalTestSuite) TestOperationOrders() {
 }
 
 func BenchmarkMarshalTo(b *testing.B) {
+	b.ReportAllocs()
 	bis := []struct {
 		in   sdk.Dec
 		want []byte
diff --git a/types/query/filtered_pagination_test.go b/types/query/filtered_pagination_test.go
index dbd2057da473..2622f7b8e7c8 100644
--- a/types/query/filtered_pagination_test.go
+++ b/types/query/filtered_pagination_test.go
@@ -6,6 +6,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 	"github.com/cosmos/cosmos-sdk/types/query"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/cosmos/cosmos-sdk/x/bank/types"
@@ -111,7 +112,7 @@ func ExampleFilteredPaginate() {
 	pageReq := &query.PageRequest{Key: nil, Limit: 1, CountTotal: true}
 	store := ctx.KVStore(app.GetKey(authtypes.StoreKey))
 	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr1.Bytes())
+	accountStore := prefix.NewStore(balancesStore, address.MustLengthPrefix(addr1))
 
 	var balResult sdk.Coins
 	pageRes, err := query.FilteredPaginate(accountStore, pageReq, func(key []byte, value []byte, accumulate bool) (bool, error) {
@@ -143,7 +144,7 @@ func ExampleFilteredPaginate() {
 
 func execFilterPaginate(store sdk.KVStore, pageReq *query.PageRequest, appCodec codec.Marshaler) (balances sdk.Coins, res *query.PageResponse, err error) {
 	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr1.Bytes())
+	accountStore := prefix.NewStore(balancesStore, address.MustLengthPrefix(addr1))
 
 	var balResult sdk.Coins
 	res, err = query.FilteredPaginate(accountStore, pageReq, func(key []byte, value []byte, accumulate bool) (bool, error) {
diff --git a/types/query/pagination_test.go b/types/query/pagination_test.go
index f0e1377a1e91..18853e97cc69 100644
--- a/types/query/pagination_test.go
+++ b/types/query/pagination_test.go
@@ -17,6 +17,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/store"
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 	"github.com/cosmos/cosmos-sdk/types/query"
 	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
@@ -193,7 +194,7 @@ func ExamplePaginate() {
 	balResult := sdk.NewCoins()
 	authStore := ctx.KVStore(app.GetKey(authtypes.StoreKey))
 	balancesStore := prefix.NewStore(authStore, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr1.Bytes())
+	accountStore := prefix.NewStore(balancesStore, address.MustLengthPrefix(addr1))
 	pageRes, err := query.Paginate(accountStore, request.Pagination, func(key []byte, value []byte) error {
 		var tempRes sdk.Coin
 		err := app.AppCodec().UnmarshalBinaryBare(value, &tempRes)
diff --git a/x/auth/client/cli/query.go b/x/auth/client/cli/query.go
index 2590858b4c20..a236e900fbe5 100644
--- a/x/auth/client/cli/query.go
+++ b/x/auth/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -58,7 +57,7 @@ $ <appd> query auth params
 			}
 
 			queryClient := types.NewQueryClient(clientCtx)
-			res, err := queryClient.Params(context.Background(), &types.QueryParamsRequest{})
+			res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
 			if err != nil {
 				return err
 			}
@@ -90,7 +89,7 @@ func GetAccountCmd() *cobra.Command {
 			}
 
 			queryClient := types.NewQueryClient(clientCtx)
-			res, err := queryClient.Account(context.Background(), &types.QueryAccountRequest{Address: key.String()})
+			res, err := queryClient.Account(cmd.Context(), &types.QueryAccountRequest{Address: key.String()})
 			if err != nil {
 				return err
 			}
diff --git a/x/auth/keeper/keeper_bench_test.go b/x/auth/keeper/keeper_bench_test.go
index a217eddacae3..1a18dff84557 100644
--- a/x/auth/keeper/keeper_bench_test.go
+++ b/x/auth/keeper/keeper_bench_test.go
@@ -7,6 +7,7 @@ import (
 )
 
 func BenchmarkAccountMapperGetAccountFound(b *testing.B) {
+	b.ReportAllocs()
 	app, ctx := createTestApp(false)
 
 	// assumes b.N < 2**24
diff --git a/x/auth/legacy/legacytx/stdtx_builder.go b/x/auth/legacy/legacytx/stdtx_builder.go
index 153c4b2bbbc1..ae0e97a3f34c 100644
--- a/x/auth/legacy/legacytx/stdtx_builder.go
+++ b/x/auth/legacy/legacytx/stdtx_builder.go
@@ -84,6 +84,9 @@ func (s *StdTxBuilder) SetTimeoutHeight(height uint64) {
 	s.TimeoutHeight = height
 }
 
+// SetFeeGranter does nothing for stdtx
+func (s *StdTxBuilder) SetFeeGranter(_ sdk.AccAddress) {}
+
 // StdTxConfig is a context.TxConfig for StdTx
 type StdTxConfig struct {
 	Cdc *codec.LegacyAmino
diff --git a/x/authz/types/keys.go b/x/authz/types/keys.go
index 3be659c5aeb8..7ee571b27f74 100644
--- a/x/authz/types/keys.go
+++ b/x/authz/types/keys.go
@@ -2,6 +2,7 @@ package types
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -21,7 +22,7 @@ const (
 // Keys for authz store
 // Items are stored with the following key: values
 //
-// - 0x01<granterAddress_Bytes><granteeAddress_Bytes><msgType_Bytes>: Grant
+// - 0x01<granterAddressLen (1 Byte)><granterAddress_Bytes><granteeAddressLen (1 Byte)><granteeAddress_Bytes><msgType_Bytes>: Grant
 
 var (
 	// Keys for store prefixes
@@ -30,12 +31,22 @@ var (
 
 // GetAuthorizationStoreKey - return authorization store key
 func GetAuthorizationStoreKey(grantee sdk.AccAddress, granter sdk.AccAddress, msgType string) []byte {
-	return append(append(append(GrantKey, granter.Bytes()...), grantee.Bytes()...), []byte(msgType)...)
+	return append(append(append(
+		GrantKey,
+		address.MustLengthPrefix(granter)...),
+		address.MustLengthPrefix(grantee)...),
+		[]byte(msgType)...,
+	)
 }
 
 // ExtractAddressesFromGrantKey - split granter & grantee address from the authorization key
 func ExtractAddressesFromGrantKey(key []byte) (granterAddr, granteeAddr sdk.AccAddress) {
-	granterAddr = sdk.AccAddress(key[1 : sdk.AddrLen+1])
-	granteeAddr = sdk.AccAddress(key[sdk.AddrLen+1 : sdk.AddrLen*2+1])
+	// key if of format:
+	// 0x01<granterAddressLen (1 Byte)><granterAddress_Bytes><granteeAddressLen (1 Byte)><granteeAddress_Bytes><msgType_Bytes>
+	granterAddrLen := key[1] // remove prefix key
+	granterAddr = sdk.AccAddress(key[2 : 2+granterAddrLen])
+	granteeAddrLen := int(key[2+granterAddrLen])
+	granteeAddr = sdk.AccAddress(key[3+granterAddrLen : 3+granterAddrLen+byte(granteeAddrLen)])
+
 	return granterAddr, granteeAddr
 }
diff --git a/x/bank/bench_test.go b/x/bank/bench_test.go
index f1affb9d99b8..0648b3b62725 100644
--- a/x/bank/bench_test.go
+++ b/x/bank/bench_test.go
@@ -18,6 +18,7 @@ import (
 var moduleAccAddr = authtypes.NewModuleAddress(stakingtypes.BondedPoolName)
 
 func BenchmarkOneBankSendTxPerBlock(b *testing.B) {
+	b.ReportAllocs()
 	// Add an account at genesis
 	acc := authtypes.BaseAccount{
 		Address: addr1.String(),
diff --git a/x/bank/client/cli/query.go b/x/bank/client/cli/query.go
index fbb9ba43825d..a192c8deba1b 100644
--- a/x/bank/client/cli/query.go
+++ b/x/bank/client/cli/query.go
@@ -74,11 +74,10 @@ Example:
 			if err != nil {
 				return err
 			}
-
+			ctx := cmd.Context()
 			if denom == "" {
 				params := types.NewQueryAllBalancesRequest(addr, pageReq)
-
-				res, err := queryClient.AllBalances(cmd.Context(), params)
+				res, err := queryClient.AllBalances(ctx, params)
 				if err != nil {
 					return err
 				}
@@ -86,7 +85,7 @@ Example:
 			}
 
 			params := types.NewQueryBalanceRequest(addr, denom)
-			res, err := queryClient.Balance(cmd.Context(), params)
+			res, err := queryClient.Balance(ctx, params)
 			if err != nil {
 				return err
 			}
@@ -183,9 +182,9 @@ To query for the total supply of a specific coin denomination use:
 			}
 
 			queryClient := types.NewQueryClient(clientCtx)
-
+			ctx := cmd.Context()
 			if denom == "" {
-				res, err := queryClient.TotalSupply(cmd.Context(), &types.QueryTotalSupplyRequest{})
+				res, err := queryClient.TotalSupply(ctx, &types.QueryTotalSupplyRequest{})
 				if err != nil {
 					return err
 				}
@@ -193,7 +192,7 @@ To query for the total supply of a specific coin denomination use:
 				return clientCtx.PrintProto(res)
 			}
 
-			res, err := queryClient.SupplyOf(cmd.Context(), &types.QuerySupplyOfRequest{Denom: denom})
+			res, err := queryClient.SupplyOf(ctx, &types.QuerySupplyOfRequest{Denom: denom})
 			if err != nil {
 				return err
 			}
diff --git a/x/bank/client/testutil/cli_helpers.go b/x/bank/client/testutil/cli_helpers.go
index 0f1b848cb755..e36f3744a6b9 100644
--- a/x/bank/client/testutil/cli_helpers.go
+++ b/x/bank/client/testutil/cli_helpers.go
@@ -1,7 +1,6 @@
 package testutil
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -59,7 +58,7 @@ ignored as it is implied from [from_key_or_address].`,
 			msg := types.NewMsgSend(clientCtx.GetFromAddress(), toAddr, coins)
 			svcMsgClientConn := &msgservice.ServiceMsgClientConn{}
 			bankMsgClient := types.NewMsgClient(svcMsgClientConn)
-			_, err = bankMsgClient.Send(context.Background(), msg)
+			_, err = bankMsgClient.Send(cmd.Context(), msg)
 			if err != nil {
 				return err
 			}
diff --git a/x/bank/keeper/grpc_query.go b/x/bank/keeper/grpc_query.go
index ae00d1b8734a..b8f69ef1275b 100644
--- a/x/bank/keeper/grpc_query.go
+++ b/x/bank/keeper/grpc_query.go
@@ -57,9 +57,7 @@ func (k BaseKeeper) AllBalances(ctx context.Context, req *types.QueryAllBalances
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 
 	balances := sdk.NewCoins()
-	store := sdkCtx.KVStore(k.storeKey)
-	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr.Bytes())
+	accountStore := k.getAccountStore(sdkCtx, addr)
 
 	pageRes, err := query.Paginate(accountStore, req.Pagination, func(_, value []byte) error {
 		var result sdk.Coin
diff --git a/x/bank/keeper/send.go b/x/bank/keeper/send.go
index c1000b7d3025..694c43211e07 100644
--- a/x/bank/keeper/send.go
+++ b/x/bank/keeper/send.go
@@ -2,7 +2,6 @@ package keeper
 
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/store/prefix"
 	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -233,9 +232,7 @@ func (k BaseSendKeeper) ClearBalances(ctx sdk.Context, addr sdk.AccAddress) {
 		return false
 	})
 
-	store := ctx.KVStore(k.storeKey)
-	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr.Bytes())
+	accountStore := k.getAccountStore(ctx, addr)
 
 	for _, key := range keys {
 		accountStore.Delete(key)
@@ -264,9 +261,7 @@ func (k BaseSendKeeper) SetBalance(ctx sdk.Context, addr sdk.AccAddress, balance
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, balance.String())
 	}
 
-	store := ctx.KVStore(k.storeKey)
-	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr.Bytes())
+	accountStore := k.getAccountStore(ctx, addr)
 
 	bz := k.cdc.MustMarshalBinaryBare(&balance)
 	accountStore.Set([]byte(balance.Denom), bz)
diff --git a/x/bank/keeper/view.go b/x/bank/keeper/view.go
index d4bcabad2b62..1b50fb81d3aa 100644
--- a/x/bank/keeper/view.go
+++ b/x/bank/keeper/view.go
@@ -97,9 +97,7 @@ func (k BaseViewKeeper) GetAccountsBalances(ctx sdk.Context) []types.Balance {
 // GetBalance returns the balance of a specific denomination for a given account
 // by address.
 func (k BaseViewKeeper) GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin {
-	store := ctx.KVStore(k.storeKey)
-	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr.Bytes())
+	accountStore := k.getAccountStore(ctx, addr)
 
 	bz := accountStore.Get([]byte(denom))
 	if bz == nil {
@@ -116,9 +114,7 @@ func (k BaseViewKeeper) GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom s
 // provides the token balance to a callback. If true is returned from the
 // callback, iteration is halted.
 func (k BaseViewKeeper) IterateAccountBalances(ctx sdk.Context, addr sdk.AccAddress, cb func(sdk.Coin) bool) {
-	store := ctx.KVStore(k.storeKey)
-	balancesStore := prefix.NewStore(store, types.BalancesPrefix)
-	accountStore := prefix.NewStore(balancesStore, addr.Bytes())
+	accountStore := k.getAccountStore(ctx, addr)
 
 	iterator := accountStore.Iterator(nil, nil)
 	defer iterator.Close()
@@ -214,3 +210,10 @@ func (k BaseViewKeeper) ValidateBalance(ctx sdk.Context, addr sdk.AccAddress) er
 
 	return nil
 }
+
+// getAccountStore gets the account store of the given address.
+func (k BaseViewKeeper) getAccountStore(ctx sdk.Context, addr sdk.AccAddress) prefix.Store {
+	store := ctx.KVStore(k.storeKey)
+
+	return prefix.NewStore(store, types.CreateAccountBalancesPrefix(addr))
+}
diff --git a/x/bank/types/key.go b/x/bank/types/key.go
index ec8619d00185..858fd2480ac9 100644
--- a/x/bank/types/key.go
+++ b/x/bank/types/key.go
@@ -1,9 +1,8 @@
 package types
 
 import (
-	"fmt"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -22,7 +21,9 @@ const (
 
 // KVStore keys
 var (
-	BalancesPrefix      = []byte("balances")
+	// BalancesPrefix is the for the account balances store. We use a byte
+	// (instead of say `[]]byte("balances")` to save some disk space).
+	BalancesPrefix      = []byte{0x02}
 	SupplyKey           = []byte{0x00}
 	DenomMetadataPrefix = []byte{0x1}
 )
@@ -37,10 +38,13 @@ func DenomMetadataKey(denom string) []byte {
 // store. The key must not contain the perfix BalancesPrefix as the prefix store
 // iterator discards the actual prefix.
 func AddressFromBalancesStore(key []byte) sdk.AccAddress {
-	addr := key[:sdk.AddrLen]
-	if len(addr) != sdk.AddrLen {
-		panic(fmt.Sprintf("unexpected account address key length; got: %d, expected: %d", len(addr), sdk.AddrLen))
-	}
+	addrLen := key[0]
+	addr := key[1 : addrLen+1]
 
 	return sdk.AccAddress(addr)
 }
+
+// CreateAccountBalancesPrefix creates the prefix for an account's balances.
+func CreateAccountBalancesPrefix(addr []byte) []byte {
+	return append(BalancesPrefix, address.MustLengthPrefix(addr)...)
+}
diff --git a/x/bank/types/key_test.go b/x/bank/types/key_test.go
index f3b5717fbecb..206ef8335c91 100644
--- a/x/bank/types/key_test.go
+++ b/x/bank/types/key_test.go
@@ -6,6 +6,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 	"github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
@@ -19,8 +20,10 @@ func cloneAppend(bz []byte, tail []byte) (res []byte) {
 func TestAddressFromBalancesStore(t *testing.T) {
 	addr, err := sdk.AccAddressFromBech32("cosmos1n88uc38xhjgxzw9nwre4ep2c8ga4fjxcar6mn7")
 	require.NoError(t, err)
+	addrLen := len(addr)
+	require.Equal(t, 20, addrLen)
 
-	key := cloneAppend(addr.Bytes(), []byte("stake"))
+	key := cloneAppend(address.MustLengthPrefix(addr), []byte("stake"))
 	res := types.AddressFromBalancesStore(key)
 	require.Equal(t, res, addr)
 }
diff --git a/x/bank/types/metadata.go b/x/bank/types/metadata.go
index 5106964e994e..ce7794053d93 100644
--- a/x/bank/types/metadata.go
+++ b/x/bank/types/metadata.go
@@ -1,13 +1,19 @@
 package types
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// Validate performs a basic validation of the coin metadata fields
+// Validate performs a basic validation of the coin metadata fields. It checks:
+//  - Base and Display denominations are valid coin denominations
+//  - Base and Display denominations are present in the DenomUnit slice
+//  - Base denomination has exponent 0
+//  - Denomination units are sorted in ascending order
+//  - Denomination units not duplicated
 func (m Metadata) Validate() error {
 	if err := sdk.ValidateDenom(m.Base); err != nil {
 		return fmt.Errorf("invalid metadata base denom: %w", err)
@@ -17,12 +23,37 @@ func (m Metadata) Validate() error {
 		return fmt.Errorf("invalid metadata display denom: %w", err)
 	}
 
+	var (
+		hasDisplay      bool
+		currentExponent uint32 // check that the exponents are increasing
+	)
+
 	seenUnits := make(map[string]bool)
-	for _, denomUnit := range m.DenomUnits {
+
+	for i, denomUnit := range m.DenomUnits {
+		// The first denomination unit MUST be the base
+		if i == 0 {
+			// validate denomination and exponent
+			if denomUnit.Denom != m.Base {
+				return fmt.Errorf("metadata's first denomination unit must be the one with base denom '%s'", m.Base)
+			}
+			if denomUnit.Exponent != 0 {
+				return fmt.Errorf("the exponent for base denomination unit %s must be 0", m.Base)
+			}
+		} else if currentExponent >= denomUnit.Exponent {
+			return errors.New("denom units should be sorted asc by exponent")
+		}
+
+		currentExponent = denomUnit.Exponent
+
 		if seenUnits[denomUnit.Denom] {
 			return fmt.Errorf("duplicate denomination unit %s", denomUnit.Denom)
 		}
 
+		if denomUnit.Denom == m.Display {
+			hasDisplay = true
+		}
+
 		if err := denomUnit.Validate(); err != nil {
 			return err
 		}
@@ -30,6 +61,10 @@ func (m Metadata) Validate() error {
 		seenUnits[denomUnit.Denom] = true
 	}
 
+	if !hasDisplay {
+		return fmt.Errorf("metadata must contain a denomination unit with display denom '%s'", m.Display)
+	}
+
 	return nil
 }
 
diff --git a/x/bank/types/metadata_test.go b/x/bank/types/metadata_test.go
index 29f4d220f95f..64241e6098e0 100644
--- a/x/bank/types/metadata_test.go
+++ b/x/bank/types/metadata_test.go
@@ -51,7 +51,7 @@ func TestMetadataValidate(t *testing.T) {
 				Description: "The native staking token of the Cosmos Hub.",
 				DenomUnits: []*types.DenomUnit{
 					{"uatom", uint32(0), []string{"microatom"}},
-					{"uatom", uint32(0), []string{"microatom"}},
+					{"uatom", uint32(1), []string{"microatom"}},
 				},
 				Base:    "uatom",
 				Display: "atom",
@@ -94,6 +94,59 @@ func TestMetadataValidate(t *testing.T) {
 			},
 			true,
 		},
+		{
+			"no base denom unit",
+			types.Metadata{
+				Description: "The native staking token of the Cosmos Hub.",
+				DenomUnits: []*types.DenomUnit{
+					{"matom", uint32(3), []string{"milliatom"}},
+					{"atom", uint32(6), nil},
+				},
+				Base:    "uatom",
+				Display: "atom",
+			},
+			true,
+		},
+		{
+			"base denom exponent not zero",
+			types.Metadata{
+				Description: "The native staking token of the Cosmos Hub.",
+				DenomUnits: []*types.DenomUnit{
+					{"uatom", uint32(1), []string{"microatom"}},
+					{"matom", uint32(3), []string{"milliatom"}},
+					{"atom", uint32(6), nil},
+				},
+				Base:    "uatom",
+				Display: "atom",
+			},
+			true,
+		},
+		{
+			"no display denom unit",
+			types.Metadata{
+				Description: "The native staking token of the Cosmos Hub.",
+				DenomUnits: []*types.DenomUnit{
+					{"uatom", uint32(0), []string{"microatom"}},
+				},
+				Base:    "uatom",
+				Display: "atom",
+			},
+			true,
+		},
+		{
+			"denom units not sorted",
+			types.Metadata{
+				Description: "The native staking token of the Cosmos Hub.",
+				DenomUnits: []*types.DenomUnit{
+					{"uatom", uint32(0), []string{"microatom"}},
+					{"atom", uint32(6), nil},
+					{"matom", uint32(3), []string{"milliatom"}},
+				},
+				Base:    "uatom",
+				Display: "atom",
+			},
+			true,
+		},
 	}
 
 	for _, tc := range testCases {
diff --git a/x/bank/types/msgs_test.go b/x/bank/types/msgs_test.go
index 96132150ad4f..334d72c13243 100644
--- a/x/bank/types/msgs_test.go
+++ b/x/bank/types/msgs_test.go
@@ -23,7 +23,7 @@ func TestMsgSendValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("from________________"))
 	addr2 := sdk.AccAddress([]byte("to__________________"))
 	addrEmpty := sdk.AccAddress([]byte(""))
-	addrTooLong := sdk.AccAddress([]byte("Accidentally used 33 bytes pubkey"))
+	addrLong := sdk.AccAddress([]byte("Purposefully long address"))
 
 	atom123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
 	atom0 := sdk.NewCoins(sdk.NewInt64Coin("atom", 0))
@@ -36,12 +36,12 @@ func TestMsgSendValidation(t *testing.T) {
 	}{
 		{"", NewMsgSend(addr1, addr2, atom123)},                                // valid send
 		{"", NewMsgSend(addr1, addr2, atom123eth123)},                          // valid send with multiple coins
+		{"", NewMsgSend(addrLong, addr2, atom123)},                             // valid send with long addr sender
+		{"", NewMsgSend(addr1, addrLong, atom123)},                             // valid send with long addr recipient
 		{": invalid coins", NewMsgSend(addr1, addr2, atom0)},                   // non positive coin
 		{"123atom,0eth: invalid coins", NewMsgSend(addr1, addr2, atom123eth0)}, // non positive coin in multicoins
 		{"Invalid sender address (empty address string is not allowed): invalid address", NewMsgSend(addrEmpty, addr2, atom123)},
-		{"Invalid sender address (incorrect address length (expected: 20, actual: 33)): invalid address", NewMsgSend(addrTooLong, addr2, atom123)},
 		{"Invalid recipient address (empty address string is not allowed): invalid address", NewMsgSend(addr1, addrEmpty, atom123)},
-		{"Invalid recipient address (incorrect address length (expected: 20, actual: 33)): invalid address", NewMsgSend(addr1, addrTooLong, atom123)},
 	}
 
 	for _, tc := range cases {
@@ -91,7 +91,7 @@ func TestInputValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("_______alice________"))
 	addr2 := sdk.AccAddress([]byte("________bob_________"))
 	addrEmpty := sdk.AccAddress([]byte(""))
-	addrTooLong := sdk.AccAddress([]byte("Accidentally used 33 bytes pubkey"))
+	addrLong := sdk.AccAddress([]byte("Purposefully long address"))
 
 	someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
 	multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
@@ -109,9 +109,9 @@ func TestInputValidation(t *testing.T) {
 		{"", NewInput(addr1, someCoins)},
 		{"", NewInput(addr2, someCoins)},
 		{"", NewInput(addr2, multiCoins)},
+		{"", NewInput(addrLong, someCoins)},
 
 		{"empty address string is not allowed", NewInput(addrEmpty, someCoins)},
-		{"incorrect address length (expected: 20, actual: 33)", NewInput(addrTooLong, someCoins)},
 		{": invalid coins", NewInput(addr1, emptyCoins)},                // invalid coins
 		{": invalid coins", NewInput(addr1, emptyCoins2)},               // invalid coins
 		{"10eth,0atom: invalid coins", NewInput(addr1, someEmptyCoins)}, // invalid coins
@@ -132,7 +132,7 @@ func TestOutputValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("_______alice________"))
 	addr2 := sdk.AccAddress([]byte("________bob_________"))
 	addrEmpty := sdk.AccAddress([]byte(""))
-	addrTooLong := sdk.AccAddress([]byte("Accidentally used 33 bytes pubkey"))
+	addrLong := sdk.AccAddress([]byte("Purposefully long address"))
 
 	someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
 	multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
@@ -150,9 +150,9 @@ func TestOutputValidation(t *testing.T) {
 		{"", NewOutput(addr1, someCoins)},
 		{"", NewOutput(addr2, someCoins)},
 		{"", NewOutput(addr2, multiCoins)},
+		{"", NewOutput(addrLong, someCoins)},
 
 		{"Invalid output address (empty address string is not allowed): invalid address", NewOutput(addrEmpty, someCoins)},
-		{"Invalid output address (incorrect address length (expected: 20, actual: 33)): invalid address", NewOutput(addrTooLong, someCoins)},
 		{": invalid coins", NewOutput(addr1, emptyCoins)},                // invalid coins
 		{": invalid coins", NewOutput(addr1, emptyCoins2)},               // invalid coins
 		{"10eth,0atom: invalid coins", NewOutput(addr1, someEmptyCoins)}, // invalid coins
@@ -251,8 +251,6 @@ func TestMsgMultiSendGetSigners(t *testing.T) {
 	require.Equal(t, "[696E707574313131313131313131313131313131 696E707574323232323232323232323232323232 696E707574333333333333333333333333333333]", fmt.Sprintf("%v", res))
 }
 
-/*
-// what to do w/ this test?
 func TestMsgSendSigners(t *testing.T) {
 	signers := []sdk.AccAddress{
 		{1, 2, 3},
@@ -265,8 +263,7 @@ func TestMsgSendSigners(t *testing.T) {
 	for i, signer := range signers {
 		inputs[i] = NewInput(signer, someCoins)
 	}
-	tx := NewMsgSend(inputs, nil)
+	tx := NewMsgMultiSend(inputs, nil)
 
-	require.Equal(t, signers, tx.Signers())
+	require.Equal(t, signers, tx.GetSigners())
 }
-*/
diff --git a/x/distribution/client/cli/query.go b/x/distribution/client/cli/query.go
index 3b6032ce7b99..aa087f5f8b27 100644
--- a/x/distribution/client/cli/query.go
+++ b/x/distribution/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -50,7 +49,7 @@ func GetCmdQueryParams() *cobra.Command {
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, err := queryClient.Params(context.Background(), &types.QueryParamsRequest{})
+			res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
 			if err != nil {
 				return err
 			}
@@ -94,7 +93,7 @@ $ %s query distribution validator-outstanding-rewards %s1lwjmdnks33xwnmfayc64ycp
 			}
 
 			res, err := queryClient.ValidatorOutstandingRewards(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryValidatorOutstandingRewardsRequest{ValidatorAddress: validatorAddr.String()},
 			)
 			if err != nil {
@@ -139,7 +138,7 @@ $ %s query distribution commission %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 			}
 
 			res, err := queryClient.ValidatorCommission(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryValidatorCommissionRequest{ValidatorAddress: validatorAddr.String()},
 			)
 			if err != nil {
@@ -199,7 +198,7 @@ $ %s query distribution slashes %svaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 			}
 
 			res, err := queryClient.ValidatorSlashes(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryValidatorSlashesRequest{
 					ValidatorAddress: validatorAddr.String(),
 					StartingHeight:   startHeight,
@@ -252,6 +251,7 @@ $ %s query distribution rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p %s1ggh
 			}
 
 			// query for rewards from a particular delegation
+			ctx := cmd.Context()
 			if len(args) == 2 {
 				validatorAddr, err := sdk.ValAddressFromBech32(args[1])
 				if err != nil {
@@ -259,7 +259,7 @@ $ %s query distribution rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p %s1ggh
 				}
 
 				res, err := queryClient.DelegationRewards(
-					context.Background(),
+					ctx,
 					&types.QueryDelegationRewardsRequest{DelegatorAddress: delegatorAddr.String(), ValidatorAddress: validatorAddr.String()},
 				)
 				if err != nil {
@@ -270,7 +270,7 @@ $ %s query distribution rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p %s1ggh
 			}
 
 			res, err := queryClient.DelegationTotalRewards(
-				context.Background(),
+				ctx,
 				&types.QueryDelegationTotalRewardsRequest{DelegatorAddress: delegatorAddr.String()},
 			)
 			if err != nil {
@@ -307,7 +307,7 @@ $ %s query distribution community-pool
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, err := queryClient.CommunityPool(context.Background(), &types.QueryCommunityPoolRequest{})
+			res, err := queryClient.CommunityPool(cmd.Context(), &types.QueryCommunityPoolRequest{})
 			if err != nil {
 				return err
 			}
diff --git a/x/distribution/client/cli/tx.go b/x/distribution/client/cli/tx.go
index d62bcd21fa07..dcf5a3b057ad 100644
--- a/x/distribution/client/cli/tx.go
+++ b/x/distribution/client/cli/tx.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
@@ -155,7 +154,7 @@ $ %s tx distribution withdraw-all-rewards --from mykey
 			}
 
 			queryClient := types.NewQueryClient(clientCtx)
-			delValsRes, err := queryClient.DelegatorValidators(context.Background(), &types.QueryDelegatorValidatorsRequest{DelegatorAddress: delAddr.String()})
+			delValsRes, err := queryClient.DelegatorValidators(cmd.Context(), &types.QueryDelegatorValidatorsRequest{DelegatorAddress: delAddr.String()})
 			if err != nil {
 				return err
 			}
diff --git a/x/distribution/types/keys.go b/x/distribution/types/keys.go
index 12fe9b17b9ff..4f0f37f82303 100644
--- a/x/distribution/types/keys.go
+++ b/x/distribution/types/keys.go
@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -27,19 +28,19 @@ const (
 //
 // - 0x01: sdk.ConsAddress
 //
-// - 0x02<valAddr_Bytes>: ValidatorOutstandingRewards
+// - 0x02<valAddrLen (1 Byte)><valAddr_Bytes>: ValidatorOutstandingRewards
 //
-// - 0x03<accAddr_Bytes>: sdk.AccAddress
+// - 0x03<accAddrLen (1 Byte)><accAddr_Bytes>: sdk.AccAddress
 //
-// - 0x04<valAddr_Bytes><accAddr_Bytes>: DelegatorStartingInfo
+// - 0x04<valAddrLen (1 Byte)><valAddr_Bytes><accAddrLen (1 Byte)><accAddr_Bytes>: DelegatorStartingInfo
 //
-// - 0x05<valAddr_Bytes><period_Bytes>: ValidatorHistoricalRewards
+// - 0x05<valAddrLen (1 Byte)><valAddr_Bytes><period_Bytes>: ValidatorHistoricalRewards
 //
-// - 0x06<valAddr_Bytes>: ValidatorCurrentRewards
+// - 0x06<valAddrLen (1 Byte)><valAddr_Bytes>: ValidatorCurrentRewards
 //
-// - 0x07<valAddr_Bytes>: ValidatorCurrentRewards
+// - 0x07<valAddrLen (1 Byte)><valAddr_Bytes>: ValidatorCurrentRewards
 //
-// - 0x08<valAddr_Bytes><height>: ValidatorSlashEvent
+// - 0x08<valAddrLen (1 Byte)><valAddr_Bytes><height>: ValidatorSlashEvent
 var (
 	FeePoolKey                        = []byte{0x00} // key for global distribution state
 	ProposerKey                       = []byte{0x01} // key for the proposer operator address
@@ -53,47 +54,56 @@ var (
 	ValidatorSlashEventPrefix            = []byte{0x08} // key for validator slash fraction
 )
 
-// gets an address from a validator's outstanding rewards key
+// GetValidatorOutstandingRewardsAddress creates an address from a validator's outstanding rewards key.
 func GetValidatorOutstandingRewardsAddress(key []byte) (valAddr sdk.ValAddress) {
-	addr := key[1:]
-	if len(addr) != sdk.AddrLen {
+	// key is in the format:
+	// 0x02<valAddrLen (1 Byte)><valAddr_Bytes>
+
+	// Remove prefix and address length.
+	addr := key[2:]
+	if len(addr) != int(key[1]) {
 		panic("unexpected key length")
 	}
+
 	return sdk.ValAddress(addr)
 }
 
-// gets an address from a delegator's withdraw info key
+// GetDelegatorWithdrawInfoAddress creates an address from a delegator's withdraw info key.
 func GetDelegatorWithdrawInfoAddress(key []byte) (delAddr sdk.AccAddress) {
-	addr := key[1:]
-	if len(addr) != sdk.AddrLen {
+	// key is in the format:
+	// 0x03<accAddrLen (1 Byte)><accAddr_Bytes>
+
+	// Remove prefix and address length.
+	addr := key[2:]
+	if len(addr) != int(key[1]) {
 		panic("unexpected key length")
 	}
+
 	return sdk.AccAddress(addr)
 }
 
-// gets the addresses from a delegator starting info key
+// GetDelegatorStartingInfoAddresses creates the addresses from a delegator starting info key.
 func GetDelegatorStartingInfoAddresses(key []byte) (valAddr sdk.ValAddress, delAddr sdk.AccAddress) {
-	addr := key[1 : 1+sdk.AddrLen]
-	if len(addr) != sdk.AddrLen {
+	// key is in the format:
+	// 0x04<valAddrLen (1 Byte)><valAddr_Bytes><accAddrLen (1 Byte)><accAddr_Bytes>
+	valAddrLen := int(key[1])
+	valAddr = sdk.ValAddress(key[2 : 2+valAddrLen])
+	delAddrLen := int(key[2+valAddrLen])
+	delAddr = sdk.AccAddress(key[3+valAddrLen:])
+	if len(delAddr.Bytes()) != delAddrLen {
 		panic("unexpected key length")
 	}
-	valAddr = sdk.ValAddress(addr)
-	addr = key[1+sdk.AddrLen:]
-	if len(addr) != sdk.AddrLen {
-		panic("unexpected key length")
-	}
-	delAddr = sdk.AccAddress(addr)
+
 	return
 }
 
-// gets the address & period from a validator's historical rewards key
+// GetValidatorHistoricalRewardsAddressPeriod creates the address & period from a validator's historical rewards key.
 func GetValidatorHistoricalRewardsAddressPeriod(key []byte) (valAddr sdk.ValAddress, period uint64) {
-	addr := key[1 : 1+sdk.AddrLen]
-	if len(addr) != sdk.AddrLen {
-		panic("unexpected key length")
-	}
-	valAddr = sdk.ValAddress(addr)
-	b := key[1+sdk.AddrLen:]
+	// key is in the format:
+	// 0x05<valAddrLen (1 Byte)><valAddr_Bytes><period_Bytes>
+	valAddrLen := int(key[1])
+	valAddr = sdk.ValAddress(key[2 : 2+valAddrLen])
+	b := key[2+valAddrLen:]
 	if len(b) != 8 {
 		panic("unexpected key length")
 	}
@@ -101,93 +111,104 @@ func GetValidatorHistoricalRewardsAddressPeriod(key []byte) (valAddr sdk.ValAddr
 	return
 }
 
-// gets the address from a validator's current rewards key
+// GetValidatorCurrentRewardsAddress creates the address from a validator's current rewards key.
 func GetValidatorCurrentRewardsAddress(key []byte) (valAddr sdk.ValAddress) {
-	addr := key[1:]
-	if len(addr) != sdk.AddrLen {
+	// key is in the format:
+	// 0x06<valAddrLen (1 Byte)><valAddr_Bytes>: ValidatorCurrentRewards
+
+	// Remove prefix and address length.
+	addr := key[2:]
+	if len(addr) != int(key[1]) {
 		panic("unexpected key length")
 	}
+
 	return sdk.ValAddress(addr)
 }
 
-// gets the address from a validator's accumulated commission key
+// GetValidatorAccumulatedCommissionAddress creates the address from a validator's accumulated commission key.
 func GetValidatorAccumulatedCommissionAddress(key []byte) (valAddr sdk.ValAddress) {
-	addr := key[1:]
-	if len(addr) != sdk.AddrLen {
+	// key is in the format:
+	// 0x07<valAddrLen (1 Byte)><valAddr_Bytes>: ValidatorCurrentRewards
+
+	// Remove prefix and address length.
+	addr := key[2:]
+	if len(addr) != int(key[1]) {
 		panic("unexpected key length")
 	}
+
 	return sdk.ValAddress(addr)
 }
 
-// gets the height from a validator's slash event key
+// GetValidatorSlashEventAddressHeight creates the height from a validator's slash event key.
 func GetValidatorSlashEventAddressHeight(key []byte) (valAddr sdk.ValAddress, height uint64) {
-	addr := key[1 : 1+sdk.AddrLen]
-	if len(addr) != sdk.AddrLen {
-		panic("unexpected key length")
-	}
-	valAddr = sdk.ValAddress(addr)
-	startB := 1 + sdk.AddrLen
+	// key is in the format:
+	// 0x08<valAddrLen (1 Byte)><valAddr_Bytes><height>: ValidatorSlashEvent
+	valAddrLen := int(key[1])
+	valAddr = key[2 : 2+valAddrLen]
+	startB := 2 + valAddrLen
 	b := key[startB : startB+8] // the next 8 bytes represent the height
 	height = binary.BigEndian.Uint64(b)
 	return
 }
 
-// gets the outstanding rewards key for a validator
+// GetValidatorOutstandingRewardsKey creates the outstanding rewards key for a validator.
 func GetValidatorOutstandingRewardsKey(valAddr sdk.ValAddress) []byte {
-	return append(ValidatorOutstandingRewardsPrefix, valAddr.Bytes()...)
+	return append(ValidatorOutstandingRewardsPrefix, address.MustLengthPrefix(valAddr.Bytes())...)
 }
 
-// gets the key for a delegator's withdraw addr
+// GetDelegatorWithdrawAddrKey creates the key for a delegator's withdraw addr.
 func GetDelegatorWithdrawAddrKey(delAddr sdk.AccAddress) []byte {
-	return append(DelegatorWithdrawAddrPrefix, delAddr.Bytes()...)
+	return append(DelegatorWithdrawAddrPrefix, address.MustLengthPrefix(delAddr.Bytes())...)
 }
 
-// gets the key for a delegator's starting info
+// GetDelegatorStartingInfoKey creates the key for a delegator's starting info.
 func GetDelegatorStartingInfoKey(v sdk.ValAddress, d sdk.AccAddress) []byte {
-	return append(append(DelegatorStartingInfoPrefix, v.Bytes()...), d.Bytes()...)
+	return append(append(DelegatorStartingInfoPrefix, address.MustLengthPrefix(v.Bytes())...), address.MustLengthPrefix(d.Bytes())...)
 }
 
-// gets the prefix key for a validator's historical rewards
+// GetValidatorHistoricalRewardsPrefix creates the prefix key for a validator's historical rewards.
 func GetValidatorHistoricalRewardsPrefix(v sdk.ValAddress) []byte {
-	return append(ValidatorHistoricalRewardsPrefix, v.Bytes()...)
+	return append(ValidatorHistoricalRewardsPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
-// gets the key for a validator's historical rewards
+// GetValidatorHistoricalRewardsKey creates the key for a validator's historical rewards.
 func GetValidatorHistoricalRewardsKey(v sdk.ValAddress, k uint64) []byte {
 	b := make([]byte, 8)
 	binary.LittleEndian.PutUint64(b, k)
-	return append(append(ValidatorHistoricalRewardsPrefix, v.Bytes()...), b...)
+	return append(append(ValidatorHistoricalRewardsPrefix, address.MustLengthPrefix(v.Bytes())...), b...)
 }
 
-// gets the key for a validator's current rewards
+// GetValidatorCurrentRewardsKey creates the key for a validator's current rewards.
 func GetValidatorCurrentRewardsKey(v sdk.ValAddress) []byte {
-	return append(ValidatorCurrentRewardsPrefix, v.Bytes()...)
+	return append(ValidatorCurrentRewardsPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
-// gets the key for a validator's current commission
+// GetValidatorAccumulatedCommissionKey creates the key for a validator's current commission.
 func GetValidatorAccumulatedCommissionKey(v sdk.ValAddress) []byte {
-	return append(ValidatorAccumulatedCommissionPrefix, v.Bytes()...)
+	return append(ValidatorAccumulatedCommissionPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
-// gets the prefix key for a validator's slash fractions
+// GetValidatorSlashEventPrefix creates the prefix key for a validator's slash fractions.
 func GetValidatorSlashEventPrefix(v sdk.ValAddress) []byte {
-	return append(ValidatorSlashEventPrefix, v.Bytes()...)
+	return append(ValidatorSlashEventPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
-// gets the prefix key for a validator's slash fraction (ValidatorSlashEventPrefix + height)
+// GetValidatorSlashEventKeyPrefix creates the prefix key for a validator's slash fraction (ValidatorSlashEventPrefix + height).
 func GetValidatorSlashEventKeyPrefix(v sdk.ValAddress, height uint64) []byte {
 	heightBz := make([]byte, 8)
 	binary.BigEndian.PutUint64(heightBz, height)
+
 	return append(
 		ValidatorSlashEventPrefix,
-		append(v.Bytes(), heightBz...)...,
+		append(address.MustLengthPrefix(v.Bytes()), heightBz...)...,
 	)
 }
 
-// gets the key for a validator's slash fraction
+// GetValidatorSlashEventKey creates the key for a validator's slash fraction.
 func GetValidatorSlashEventKey(v sdk.ValAddress, height, period uint64) []byte {
 	periodBz := make([]byte, 8)
 	binary.BigEndian.PutUint64(periodBz, period)
 	prefix := GetValidatorSlashEventKeyPrefix(v, height)
+
 	return append(prefix, periodBz...)
 }
diff --git a/x/evidence/types/evidence.go b/x/evidence/types/evidence.go
index 95705cc5b937..fca6126ec36f 100644
--- a/x/evidence/types/evidence.go
+++ b/x/evidence/types/evidence.go
@@ -88,7 +88,8 @@ func (e Equivocation) GetTotalPower() int64 { return 0 }
 // FromABCIEvidence converts a Tendermint concrete Evidence type to
 // SDK Evidence using Equivocation as the concrete type.
 func FromABCIEvidence(e abci.Evidence) exported.Evidence {
-	consAddr, err := sdk.Bech32ifyAddressBytes(sdk.Bech32PrefixConsAddr, e.Validator.Address)
+	bech32PrefixConsAddr := sdk.GetConfig().GetBech32ConsensusAddrPrefix()
+	consAddr, err := sdk.Bech32ifyAddressBytes(bech32PrefixConsAddr, e.Validator.Address)
 	if err != nil {
 		panic(err)
 	}
diff --git a/x/evidence/types/evidence_test.go b/x/evidence/types/evidence_test.go
index 07b9352f574d..c78f0b059cc9 100644
--- a/x/evidence/types/evidence_test.go
+++ b/x/evidence/types/evidence_test.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
+	abci "github.com/tendermint/tendermint/abci/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
@@ -57,3 +58,22 @@ func TestEquivocationValidateBasic(t *testing.T) {
 		})
 	}
 }
+
+func TestEvidenceAddressConversion(t *testing.T) {
+	sdk.GetConfig().SetBech32PrefixForConsensusNode("testcnclcons", "testcnclconspub")
+	tmEvidence := abci.Evidence{
+		Type: abci.EvidenceType_DUPLICATE_VOTE,
+		Validator: abci.Validator{
+			Address: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+			Power:   100,
+		},
+		Height:           1,
+		Time:             time.Now(),
+		TotalVotingPower: 100,
+	}
+	evidence := types.FromABCIEvidence(tmEvidence).(*types.Equivocation)
+	consAddr := evidence.GetConsensusAddress()
+	// Check the address is the same after conversion
+	require.Equal(t, tmEvidence.Validator.Address, consAddr.Bytes())
+	sdk.GetConfig().SetBech32PrefixForConsensusNode(sdk.Bech32PrefixConsAddr, sdk.Bech32PrefixConsPub)
+}
diff --git a/x/feegrant/ante/ante.go b/x/feegrant/ante/ante.go
new file mode 100644
index 000000000000..483868c23e16
--- /dev/null
+++ b/x/feegrant/ante/ante.go
@@ -0,0 +1,35 @@
+package ante
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	"github.com/cosmos/cosmos-sdk/x/auth/signing"
+	feegrantkeeper "github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	feegranttypes "github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// NewAnteHandler returns an AnteHandler that checks and increments sequence
+// numbers, checks signatures & account numbers, and deducts fees from the
+// fee_payer or from fee_granter (if valid grant exist).
+func NewAnteHandler(
+	ak authkeeper.AccountKeeper, bankKeeper feegranttypes.BankKeeper, feeGrantKeeper feegrantkeeper.Keeper,
+	sigGasConsumer authante.SignatureVerificationGasConsumer, signModeHandler signing.SignModeHandler,
+) sdk.AnteHandler {
+
+	return sdk.ChainAnteDecorators(
+		authante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
+		authante.NewRejectExtensionOptionsDecorator(),
+		authante.NewMempoolFeeDecorator(),
+		authante.NewValidateBasicDecorator(),
+		authante.TxTimeoutHeightDecorator{},
+		authante.NewValidateMemoDecorator(ak),
+		authante.NewConsumeGasForTxSizeDecorator(ak),
+		NewDeductGrantedFeeDecorator(ak, bankKeeper, feeGrantKeeper),
+		authante.NewSetPubKeyDecorator(ak), // SetPubKeyDecorator must be called before all signature verification decorators
+		authante.NewValidateSigCountDecorator(ak),
+		authante.NewSigGasConsumeDecorator(ak, sigGasConsumer),
+		authante.NewSigVerificationDecorator(ak, signModeHandler),
+		authante.NewIncrementSequenceDecorator(ak), // innermost AnteDecorator
+	)
+}
diff --git a/x/feegrant/ante/fee.go b/x/feegrant/ante/fee.go
new file mode 100644
index 000000000000..52cbda7210eb
--- /dev/null
+++ b/x/feegrant/ante/fee.go
@@ -0,0 +1,82 @@
+package ante
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// DeductGrantedFeeDecorator deducts fees from fee_payer or fee_granter (if exists a valid fee allowance) of the tx
+// If the fee_payer or fee_granter does not have the funds to pay for the fees, return with InsufficientFunds error
+// Call next AnteHandler if fees successfully deducted
+// CONTRACT: Tx must implement GrantedFeeTx interface to use DeductGrantedFeeDecorator
+type DeductGrantedFeeDecorator struct {
+	ak types.AccountKeeper
+	k  keeper.Keeper
+	bk types.BankKeeper
+}
+
+func NewDeductGrantedFeeDecorator(ak types.AccountKeeper, bk types.BankKeeper, k keeper.Keeper) DeductGrantedFeeDecorator {
+	return DeductGrantedFeeDecorator{
+		ak: ak,
+		k:  k,
+		bk: bk,
+	}
+}
+
+// AnteHandle performs a decorated ante-handler responsible for deducting transaction
+// fees. Fees will be deducted from the account designated by the FeePayer on a
+// transaction by default. However, if the fee payer differs from the transaction
+// signer, the handler will check if a fee grant has been authorized. If the
+// transaction's signer does not exist, it will be created.
+func (d DeductGrantedFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
+	feeTx, ok := tx.(sdk.FeeTx)
+	if !ok {
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a GrantedFeeTx")
+	}
+
+	// sanity check from DeductFeeDecorator
+	if addr := d.ak.GetModuleAddress(authtypes.FeeCollectorName); addr == nil {
+		panic(fmt.Sprintf("%s module account has not been set", authtypes.FeeCollectorName))
+	}
+
+	fee := feeTx.GetFee()
+	feePayer := feeTx.FeePayer()
+	feeGranter := feeTx.FeeGranter()
+
+	deductFeesFrom := feePayer
+
+	// ensure the grant is allowed, if we request a different fee payer
+	if feeGranter != nil && !feeGranter.Equals(feePayer) {
+		err := d.k.UseGrantedFees(ctx, feeGranter, feePayer, fee)
+		if err != nil {
+			return ctx, sdkerrors.Wrapf(err, "%s not allowed to pay fees from %s", feeGranter, feePayer)
+		}
+
+		deductFeesFrom = feeGranter
+	}
+
+	// now, either way, we know that we are authorized to deduct the fees from the deductFeesFrom account
+	deductFeesFromAcc := d.ak.GetAccount(ctx, deductFeesFrom)
+	if deductFeesFromAcc == nil {
+		return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "fee payer address: %s does not exist", deductFeesFrom)
+	}
+
+	// move on if there is no fee to deduct
+	if fee.IsZero() {
+		return next(ctx, tx, simulate)
+	}
+
+	// deduct fee if non-zero
+	err = authante.DeductFees(d.bk, ctx, deductFeesFromAcc, fee)
+	if err != nil {
+		return ctx, err
+	}
+
+	return next(ctx, tx, simulate)
+}
diff --git a/x/feegrant/ante/fee_test.go b/x/feegrant/ante/fee_test.go
new file mode 100644
index 000000000000..293f448d73f8
--- /dev/null
+++ b/x/feegrant/ante/fee_test.go
@@ -0,0 +1,287 @@
+package ante_test
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/stretchr/testify/suite"
+	"github.com/tendermint/tendermint/crypto"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+	"github.com/cosmos/cosmos-sdk/simapp/helpers"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+	authsign "github.com/cosmos/cosmos-sdk/x/auth/signing"
+	"github.com/cosmos/cosmos-sdk/x/auth/tx"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/ante"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// AnteTestSuite is a test suite to be used with ante handler tests.
+type AnteTestSuite struct {
+	suite.Suite
+
+	app         *simapp.SimApp
+	anteHandler sdk.AnteHandler
+	ctx         sdk.Context
+	clientCtx   client.Context
+	txBuilder   client.TxBuilder
+}
+
+// SetupTest setups a new test, with new app, context, and anteHandler.
+func (suite *AnteTestSuite) SetupTest(isCheckTx bool) {
+	suite.app, suite.ctx = createTestApp(isCheckTx)
+	suite.ctx = suite.ctx.WithBlockHeight(1)
+
+	// Set up TxConfig.
+	encodingConfig := simapp.MakeTestEncodingConfig()
+	// We're using TestMsg encoding in some tests, so register it here.
+	encodingConfig.Amino.RegisterConcrete(&testdata.TestMsg{}, "testdata.TestMsg", nil)
+	testdata.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+
+	suite.clientCtx = client.Context{}.
+		WithTxConfig(encodingConfig.TxConfig)
+
+	suite.anteHandler = ante.NewAnteHandler(suite.app.AccountKeeper, suite.app.BankKeeper, suite.app.FeeGrantKeeper, authante.DefaultSigVerificationGasConsumer, encodingConfig.TxConfig.SignModeHandler())
+}
+
+func (suite *AnteTestSuite) TestDeductFeesNoDelegation() {
+	suite.SetupTest(true)
+	// setup
+	app, ctx := suite.app, suite.ctx
+
+	protoTxCfg := tx.NewTxConfig(codec.NewProtoCodec(app.InterfaceRegistry()), tx.DefaultSignModes)
+
+	// this just tests our handler
+	dfd := ante.NewDeductGrantedFeeDecorator(app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper)
+	ourAnteHandler := sdk.ChainAnteDecorators(dfd)
+
+	// this tests the whole stack
+	anteHandlerStack := suite.anteHandler
+
+	// keys and addresses
+	priv1, _, addr1 := testdata.KeyTestPubAddr()
+	priv2, _, addr2 := testdata.KeyTestPubAddr()
+	priv3, _, addr3 := testdata.KeyTestPubAddr()
+	priv4, _, addr4 := testdata.KeyTestPubAddr()
+	priv5, _, addr5 := testdata.KeyTestPubAddr()
+
+	// Set addr1 with insufficient funds
+	acc1 := app.AccountKeeper.NewAccountWithAddress(ctx, addr1)
+	app.AccountKeeper.SetAccount(ctx, acc1)
+	app.BankKeeper.SetBalances(ctx, addr1, []sdk.Coin{sdk.NewCoin("atom", sdk.NewInt(10))})
+
+	// Set addr2 with more funds
+	acc2 := app.AccountKeeper.NewAccountWithAddress(ctx, addr2)
+	app.AccountKeeper.SetAccount(ctx, acc2)
+	app.BankKeeper.SetBalances(ctx, addr2, []sdk.Coin{sdk.NewCoin("atom", sdk.NewInt(99999))})
+
+	// grant fee allowance from `addr2` to `addr3` (plenty to pay)
+	err := app.FeeGrantKeeper.GrantFeeAllowance(ctx, addr2, addr3, &types.BasicFeeAllowance{
+		SpendLimit: sdk.NewCoins(sdk.NewInt64Coin("atom", 500)),
+	})
+	suite.Require().NoError(err)
+
+	// grant low fee allowance (20atom), to check the tx requesting more than allowed.
+	err = app.FeeGrantKeeper.GrantFeeAllowance(ctx, addr2, addr4, &types.BasicFeeAllowance{
+		SpendLimit: sdk.NewCoins(sdk.NewInt64Coin("atom", 20)),
+	})
+	suite.Require().NoError(err)
+
+	cases := map[string]struct {
+		signerKey     cryptotypes.PrivKey
+		signer        sdk.AccAddress
+		feeAccount    sdk.AccAddress
+		feeAccountKey cryptotypes.PrivKey
+		handler       sdk.AnteHandler
+		fee           int64
+		valid         bool
+	}{
+		"paying with low funds (only ours)": {
+			signerKey: priv1,
+			signer:    addr1,
+			fee:       50,
+			handler:   ourAnteHandler,
+			valid:     false,
+		},
+		"paying with good funds (only ours)": {
+			signerKey: priv2,
+			signer:    addr2,
+			fee:       50,
+			handler:   ourAnteHandler,
+			valid:     true,
+		},
+		"paying with no account (only ours)": {
+			signerKey: priv3,
+			signer:    addr3,
+			fee:       1,
+			handler:   ourAnteHandler,
+			valid:     false,
+		},
+		"no fee with real account (only ours)": {
+			signerKey: priv1,
+			signer:    addr1,
+			fee:       0,
+			handler:   ourAnteHandler,
+			valid:     true,
+		},
+		"no fee with no account (only ours)": {
+			signerKey: priv5,
+			signer:    addr5,
+			fee:       0,
+			handler:   ourAnteHandler,
+			valid:     false,
+		},
+		"valid fee grant without account (only ours)": {
+			signerKey:  priv3,
+			signer:     addr3,
+			feeAccount: addr2,
+			fee:        50,
+			handler:    ourAnteHandler,
+			valid:      true,
+		},
+		"no fee grant (only ours)": {
+			signerKey:  priv3,
+			signer:     addr3,
+			feeAccount: addr1,
+			fee:        2,
+			handler:    ourAnteHandler,
+			valid:      false,
+		},
+		"allowance smaller than requested fee (only ours)": {
+			signerKey:  priv4,
+			signer:     addr4,
+			feeAccount: addr2,
+			fee:        50,
+			handler:    ourAnteHandler,
+			valid:      false,
+		},
+		"granter cannot cover allowed fee grant (only ours)": {
+			signerKey:  priv4,
+			signer:     addr4,
+			feeAccount: addr1,
+			fee:        50,
+			handler:    ourAnteHandler,
+			valid:      false,
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		suite.T().Run(name, func(t *testing.T) {
+			fee := sdk.NewCoins(sdk.NewInt64Coin("atom", tc.fee))
+			msgs := []sdk.Msg{testdata.NewTestMsg(tc.signer)}
+
+			acc := app.AccountKeeper.GetAccount(ctx, tc.signer)
+			privs, accNums, seqs := []cryptotypes.PrivKey{tc.signerKey}, []uint64{0}, []uint64{0}
+			if acc != nil {
+				accNums, seqs = []uint64{acc.GetAccountNumber()}, []uint64{acc.GetSequence()}
+			}
+
+			tx, err := genTxWithFeeGranter(protoTxCfg, msgs, fee, helpers.DefaultGenTxGas, ctx.ChainID(), accNums, seqs, tc.feeAccount, privs...)
+			suite.Require().NoError(err)
+			_, err = ourAnteHandler(ctx, tx, false)
+			if tc.valid {
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().Error(err)
+			}
+
+			_, err = anteHandlerStack(ctx, tx, false)
+			if tc.valid {
+				suite.Require().NoError(err)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+// returns context and app with params set on account keeper
+func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
+	app := simapp.Setup(isCheckTx)
+	ctx := app.BaseApp.NewContext(isCheckTx, tmproto.Header{})
+	app.AccountKeeper.SetParams(ctx, authtypes.DefaultParams())
+
+	return app, ctx
+}
+
+// don't consume any gas
+func SigGasNoConsumer(meter sdk.GasMeter, sig []byte, pubkey crypto.PubKey, params authtypes.Params) error {
+	return nil
+}
+
+func genTxWithFeeGranter(gen client.TxConfig, msgs []sdk.Msg, feeAmt sdk.Coins, gas uint64, chainID string, accNums,
+	accSeqs []uint64, feeGranter sdk.AccAddress, priv ...cryptotypes.PrivKey) (sdk.Tx, error) {
+	sigs := make([]signing.SignatureV2, len(priv))
+
+	// create a random length memo
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	memo := simulation.RandStringOfLength(r, simulation.RandIntBetween(r, 0, 100))
+
+	signMode := gen.SignModeHandler().DefaultMode()
+
+	// 1st round: set SignatureV2 with empty signatures, to set correct
+	// signer infos.
+	for i, p := range priv {
+		sigs[i] = signing.SignatureV2{
+			PubKey: p.PubKey(),
+			Data: &signing.SingleSignatureData{
+				SignMode: signMode,
+			},
+			Sequence: accSeqs[i],
+		}
+	}
+
+	tx := gen.NewTxBuilder()
+	err := tx.SetMsgs(msgs...)
+	if err != nil {
+		return nil, err
+	}
+	err = tx.SetSignatures(sigs...)
+	if err != nil {
+		return nil, err
+	}
+	tx.SetMemo(memo)
+	tx.SetFeeAmount(feeAmt)
+	tx.SetGasLimit(gas)
+	tx.SetFeeGranter(feeGranter)
+
+	// 2nd round: once all signer infos are set, every signer can sign.
+	for i, p := range priv {
+		signerData := authsign.SignerData{
+			ChainID:       chainID,
+			AccountNumber: accNums[i],
+			Sequence:      accSeqs[i],
+		}
+		signBytes, err := gen.SignModeHandler().GetSignBytes(signMode, signerData, tx.GetTx())
+		if err != nil {
+			panic(err)
+		}
+		sig, err := p.Sign(signBytes)
+		if err != nil {
+			panic(err)
+		}
+		sigs[i].Data.(*signing.SingleSignatureData).Signature = sig
+		err = tx.SetSignatures(sigs...)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	return tx.GetTx(), nil
+}
+
+func TestAnteTestSuite(t *testing.T) {
+	suite.Run(t, new(AnteTestSuite))
+}
diff --git a/x/feegrant/client/cli/cli_test.go b/x/feegrant/client/cli/cli_test.go
new file mode 100644
index 000000000000..224e7282a80a
--- /dev/null
+++ b/x/feegrant/client/cli/cli_test.go
@@ -0,0 +1,621 @@
+// +build norace
+
+package cli_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/client/cli"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	govtestutil "github.com/cosmos/cosmos-sdk/x/gov/client/testutil"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+	"github.com/gogo/protobuf/proto"
+	"github.com/stretchr/testify/suite"
+	tmcli "github.com/tendermint/tendermint/libs/cli"
+)
+
+type IntegrationTestSuite struct {
+	suite.Suite
+
+	cfg          network.Config
+	network      *network.Network
+	addedGranter sdk.AccAddress
+	addedGrantee sdk.AccAddress
+	addedGrant   types.FeeAllowanceGrant
+}
+
+func (s *IntegrationTestSuite) SetupSuite() {
+	s.T().Log("setting up integration test suite")
+
+	if testing.Short() {
+		s.T().Skip("skipping test in unit-tests mode.")
+	}
+
+	cfg := network.DefaultConfig()
+	cfg.NumValidators = 2
+
+	s.cfg = cfg
+	s.network = network.New(s.T(), cfg)
+
+	_, err := s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+
+	val := s.network.Validators[0]
+	granter := val.Address
+	grantee := s.network.Validators[1].Address
+
+	clientCtx := val.ClientCtx
+	commonFlags := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	}
+
+	fee := sdk.NewCoin("stake", sdk.NewInt(100))
+	duration := 365 * 24 * 60 * 60
+
+	args := append(
+		[]string{
+			granter.String(),
+			grantee.String(),
+			fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, fee.String()),
+			fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+			fmt.Sprintf("--%s=%v", cli.FlagExpiration, duration),
+		},
+		commonFlags...,
+	)
+
+	cmd := cli.NewCmdFeeGrant()
+
+	_, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	s.Require().NoError(err)
+	_, err = s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+
+	s.addedGranter = granter
+	s.addedGrantee = grantee
+
+	grant, err := types.NewFeeAllowanceGrant(granter, grantee, &types.BasicFeeAllowance{
+		SpendLimit: sdk.NewCoins(fee),
+	})
+	s.Require().NoError(err)
+
+	s.addedGrant = grant
+}
+
+func (s *IntegrationTestSuite) TearDownSuite() {
+	s.T().Log("tearing down integration test suite")
+	s.network.Cleanup()
+}
+
+func (s *IntegrationTestSuite) TestCmdGetFeeGrant() {
+	val := s.network.Validators[0]
+	granter := val.Address
+	grantee := s.addedGrantee
+	clientCtx := val.ClientCtx
+
+	testCases := []struct {
+		name         string
+		args         []string
+		expectErrMsg string
+		expectErr    bool
+		respType     *types.FeeAllowanceGrant
+		resp         *types.FeeAllowanceGrant
+	}{
+		{
+			"wrong granter",
+			[]string{
+				"wrong_granter",
+				grantee.String(),
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			"decoding bech32 failed",
+			true, nil, nil,
+		},
+		{
+			"wrong grantee",
+			[]string{
+				granter.String(),
+				"wrong_grantee",
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			"decoding bech32 failed",
+			true, nil, nil,
+		},
+		{
+			"non existed grant",
+			[]string{
+				"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+				grantee.String(),
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			"no fee allowance found",
+			true, nil, nil,
+		},
+		{
+			"valid req",
+			[]string{
+				granter.String(),
+				grantee.String(),
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			"",
+			false,
+			&types.FeeAllowanceGrant{},
+			&s.addedGrant,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			cmd := cli.GetCmdQueryFeeGrant()
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+
+			if tc.expectErr {
+				s.Require().Error(err)
+				s.Require().Contains(err.Error(), tc.expectErrMsg)
+			} else {
+				s.Require().NoError(err)
+				s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), tc.respType), out.String())
+				s.Require().Equal(tc.respType.Grantee, tc.respType.Grantee)
+				s.Require().Equal(tc.respType.Granter, tc.respType.Granter)
+				s.Require().Equal(
+					tc.respType.GetFeeGrant().(*types.BasicFeeAllowance).SpendLimit,
+					tc.resp.GetFeeGrant().(*types.BasicFeeAllowance).SpendLimit,
+				)
+			}
+		})
+	}
+}
+
+func (s *IntegrationTestSuite) TestCmdGetFeeGrants() {
+	val := s.network.Validators[0]
+	grantee := s.addedGrantee
+	clientCtx := val.ClientCtx
+
+	testCases := []struct {
+		name         string
+		args         []string
+		expectErr    bool
+		resp         *types.QueryFeeAllowancesResponse
+		expectLength int
+	}{
+		{
+			"wrong grantee",
+			[]string{
+				"wrong_grantee",
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			true, nil, 0,
+		},
+		{
+			"non existed grantee",
+			[]string{
+				"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			false, &types.QueryFeeAllowancesResponse{}, 0,
+		},
+		{
+			"valid req",
+			[]string{
+				grantee.String(),
+				fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+			},
+			false, &types.QueryFeeAllowancesResponse{}, 1,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			cmd := cli.GetCmdQueryFeeGrants()
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+
+			if tc.expectErr {
+				s.Require().Error(err)
+			} else {
+				s.Require().NoError(err)
+				s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), tc.resp), out.String())
+				s.Require().Len(tc.resp.FeeAllowances, tc.expectLength)
+			}
+		})
+	}
+}
+
+func (s *IntegrationTestSuite) TestNewCmdFeeGrant() {
+	val := s.network.Validators[0]
+	granter := val.Address
+	alreadyExistedGrantee := s.addedGrantee
+	clientCtx := val.ClientCtx
+
+	commonFlags := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	}
+
+	testCases := []struct {
+		name         string
+		args         []string
+		expectErr    bool
+		respType     proto.Message
+		expectedCode uint32
+	}{
+		{
+			"wrong granter address",
+			append(
+				[]string{
+					"wrong_granter",
+					"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			true, nil, 0,
+		},
+		{
+			"wrong grantee address",
+			append(
+				[]string{
+					granter.String(),
+					"wrong_grantee",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			true, nil, 0,
+		},
+		{
+			"valid basic fee grant",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid basic fee grant without spend limit",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos17h5lzptx3ghvsuhk7wx4c4hnl7rsswxjer97em",
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid basic fee grant without expiration",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos16dlc38dcqt0uralyd8hksxyrny6kaeqfjvjwp5",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid basic fee grant without spend-limit and expiration",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1ku40qup9vwag4wtf8cls9mkszxfthaklxkp3c8",
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"try to add existed grant",
+			append(
+				[]string{
+					granter.String(),
+					alreadyExistedGrantee.String(),
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 18,
+		},
+		{
+			"invalid number of args(periodic fee grant)",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+					fmt.Sprintf("--%s=%d", cli.FlagExpiration, 10*60*60),
+				},
+				commonFlags...,
+			),
+			true, nil, 0,
+		},
+		{
+			"period mentioned and period limit omitted, invalid periodic grant",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 10*60*60),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+					fmt.Sprintf("--%s=%d", cli.FlagExpiration, 60*60),
+				},
+				commonFlags...,
+			),
+			true, nil, 0,
+		},
+		{
+			"period cannot be greater than the actual expiration(periodic fee grant)",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1nph3cfzk6trsmfxkeu943nvach5qw4vwstnvkl",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 10*60*60),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+					fmt.Sprintf("--%s=%d", cli.FlagExpiration, 60*60),
+				},
+				commonFlags...,
+			),
+			true, nil, 0,
+		},
+		{
+			"valid periodic fee grant",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1w55kgcf3ltaqdy4ww49nge3klxmrdavrr6frmp",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 60*60),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+					fmt.Sprintf("--%s=%d", cli.FlagExpiration, 10*60*60),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid periodic fee grant without spend-limit",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1vevyks8pthkscvgazc97qyfjt40m6g9xe85ry8",
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 60*60),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+					fmt.Sprintf("--%s=%d", cli.FlagExpiration, 10*60*60),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid periodic fee grant without expiration",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos14cm33pvnrv2497tyt8sp9yavhmw83nwej3m0e8",
+					fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, "100stake"),
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 60*60),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+		{
+			"valid periodic fee grant without spend-limit and expiration",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos12nyk4pcf4arshznkpz882e4l4ts0lt0ap8ce54",
+					fmt.Sprintf("--%s=%d", cli.FlagPeriod, 60*60),
+					fmt.Sprintf("--%s=%s", cli.FlagPeriodLimit, "10stake"),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false, &sdk.TxResponse{}, 0,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			cmd := cli.NewCmdFeeGrant()
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+
+			if tc.expectErr {
+				s.Require().Error(err)
+			} else {
+				s.Require().NoError(err)
+				s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), tc.respType), out.String())
+
+				txResp := tc.respType.(*sdk.TxResponse)
+				s.Require().Equal(tc.expectedCode, txResp.Code, out.String())
+			}
+		})
+	}
+}
+
+func (s *IntegrationTestSuite) TestNewCmdRevokeFeegrant() {
+	val := s.network.Validators[0]
+	granter := s.addedGranter
+	grantee := s.addedGrantee
+	clientCtx := val.ClientCtx
+
+	commonFlags := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	}
+
+	testCases := []struct {
+		name         string
+		args         []string
+		expectErr    bool
+		respType     proto.Message
+		expectedCode uint32
+	}{
+		{
+			"invalid grantee",
+			append(
+				[]string{
+					"wrong_granter",
+					grantee.String(),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			true,
+			nil,
+			0,
+		},
+		{
+			"invalid grantee",
+			append(
+				[]string{
+					granter.String(),
+					"wrong_grantee",
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			true,
+			nil,
+			0,
+		},
+		{
+			"Non existed grant",
+			append(
+				[]string{
+					granter.String(),
+					"cosmos1aeuqja06474dfrj7uqsvukm6rael982kk89mqr",
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false,
+			&sdk.TxResponse{},
+			4,
+		},
+		{
+			"Valid revoke",
+			append(
+				[]string{
+					granter.String(),
+					grantee.String(),
+					fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+				},
+				commonFlags...,
+			),
+			false,
+			&sdk.TxResponse{},
+			0,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			cmd := cli.NewCmdRevokeFeegrant()
+			out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args)
+
+			if tc.expectErr {
+				s.Require().Error(err)
+			} else {
+				s.Require().NoError(err)
+				s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), tc.respType), out.String())
+
+				txResp := tc.respType.(*sdk.TxResponse)
+				s.Require().Equal(tc.expectedCode, txResp.Code, out.String())
+			}
+		})
+	}
+}
+
+func (s *IntegrationTestSuite) TestTxWithFeeGrant() {
+	val := s.network.Validators[0]
+	clientCtx := val.ClientCtx
+	granter := val.Address
+
+	// creating an account manually (This account won't be exist in state)
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic("grantee", keyring.English, sdk.FullFundraiserPath, hd.Secp256k1)
+	s.Require().NoError(err)
+	grantee := sdk.AccAddress(info.GetPubKey().Address())
+
+	commonFlags := []string{
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	}
+
+	fee := sdk.NewCoin("stake", sdk.NewInt(100))
+	duration := 365 * 24 * 60 * 60
+
+	args := append(
+		[]string{
+			granter.String(),
+			grantee.String(),
+			fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, fee.String()),
+			fmt.Sprintf("--%s=%s", flags.FlagFrom, granter),
+			fmt.Sprintf("--%s=%v", cli.FlagExpiration, duration),
+		},
+		commonFlags...,
+	)
+
+	cmd := cli.NewCmdFeeGrant()
+
+	_, err = clitestutil.ExecTestCLICmd(clientCtx, cmd, args)
+	s.Require().NoError(err)
+	_, err = s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+
+	// granted fee allowance for an account which is not in state and creating
+	// any tx with it by using --fee-account shouldn't fail
+	out, err := govtestutil.MsgSubmitProposal(val.ClientCtx, grantee.String(),
+		"Text Proposal", "No desc", govtypes.ProposalTypeText,
+		fmt.Sprintf("--%s=%s", flags.FlagFeeAccount, granter.String()),
+	)
+
+	s.Require().NoError(err)
+	var resp sdk.TxResponse
+	s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), &resp), out.String())
+	s.Require().Equal(uint32(0), resp.Code)
+}
+
+func TestIntegrationTestSuite(t *testing.T) {
+	suite.Run(t, new(IntegrationTestSuite))
+}
diff --git a/x/feegrant/client/cli/query.go b/x/feegrant/client/cli/query.go
new file mode 100644
index 000000000000..c3a488ab5536
--- /dev/null
+++ b/x/feegrant/client/cli/query.go
@@ -0,0 +1,129 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/version"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/spf13/cobra"
+)
+
+// GetQueryCmd returns the cli query commands for this module
+func GetQueryCmd() *cobra.Command {
+	feegrantQueryCmd := &cobra.Command{
+		Use:                        types.ModuleName,
+		Short:                      "Querying commands for the feegrant module",
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	feegrantQueryCmd.AddCommand(
+		GetCmdQueryFeeGrant(),
+		GetCmdQueryFeeGrants(),
+	)
+
+	return feegrantQueryCmd
+}
+
+// GetCmdQueryFeeGrant returns cmd to query for a grant between granter and grantee.
+func GetCmdQueryFeeGrant() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "grant [granter] [grantee]",
+		Args:  cobra.ExactArgs(2),
+		Short: "Query details of a single grant",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query details for a grant. 
+You can find the fee-grant of a granter and grantee.
+
+Example:
+$ %s query feegrant grant [granter] [grantee]
+`, version.AppName),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			queryClient := types.NewQueryClient(clientCtx)
+
+			granterAddr, err := sdk.AccAddressFromBech32(args[0])
+			if err != nil {
+				return err
+			}
+
+			granteeAddr, err := sdk.AccAddressFromBech32(args[1])
+			if err != nil {
+				return err
+			}
+
+			res, err := queryClient.FeeAllowance(
+				cmd.Context(),
+				&types.QueryFeeAllowanceRequest{
+					Granter: granterAddr.String(),
+					Grantee: granteeAddr.String(),
+				},
+			)
+
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res.FeeAllowance)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
+// GetCmdQueryFeeGrants returns cmd to query for all grants for a grantee.
+func GetCmdQueryFeeGrants() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "grants [grantee]",
+		Args:  cobra.ExactArgs(1),
+		Short: "Query all grants of a grantee",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Queries all the grants for a grantee address.
+
+Example:
+$ %s query feegrant grants [grantee]
+`, version.AppName),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			queryClient := types.NewQueryClient(clientCtx)
+
+			granteeAddr, err := sdk.AccAddressFromBech32(args[0])
+			if err != nil {
+				return err
+			}
+
+			pageReq, err := client.ReadPageRequest(cmd.Flags())
+			if err != nil {
+				return err
+			}
+
+			res, err := queryClient.FeeAllowances(
+				cmd.Context(),
+				&types.QueryFeeAllowancesRequest{
+					Grantee:    granteeAddr.String(),
+					Pagination: pageReq,
+				},
+			)
+
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	flags.AddPaginationFlagsToCmd(cmd, "grants")
+
+	return cmd
+}
diff --git a/x/feegrant/client/cli/tx.go b/x/feegrant/client/cli/tx.go
new file mode 100644
index 000000000000..a28ddb976cc1
--- /dev/null
+++ b/x/feegrant/client/cli/tx.go
@@ -0,0 +1,211 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/msgservice"
+	"github.com/cosmos/cosmos-sdk/version"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// flag for feegrant module
+const (
+	FlagExpiration  = "expiration"
+	FlagPeriod      = "period"
+	FlagPeriodLimit = "period-limit"
+	FlagSpendLimit  = "spend-limit"
+)
+
+// GetTxCmd returns the transaction commands for this module
+func GetTxCmd() *cobra.Command {
+	feegrantTxCmd := &cobra.Command{
+		Use:                        types.ModuleName,
+		Short:                      "Feegrant transactions subcommands",
+		Long:                       "Grant and revoke fee allowance for a grantee by a granter",
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	feegrantTxCmd.AddCommand(
+		NewCmdFeeGrant(),
+		NewCmdRevokeFeegrant(),
+	)
+
+	return feegrantTxCmd
+}
+
+// NewCmdFeeGrant returns a CLI command handler for creating a MsgGrantFeeAllowance transaction.
+func NewCmdFeeGrant() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "grant [granter] [grantee]",
+		Short: "Grant Fee allowance to an address",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(
+				`Grant authorization to pay fees from your address. Note, the'--from' flag is
+				ignored as it is implied from [granter].
+
+Examples:
+%s tx %s grant cosmos1skjw... cosmos1skjw... --spend-limit 100stake --expiration 36000 or
+%s tx %s grant cosmos1skjw... cosmos1skjw... --spend-limit 100stake --period 3600 --period-limit 10stake --expiration 36000
+				`, version.AppName, types.ModuleName, version.AppName, types.ModuleName,
+			),
+		),
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			_, err := sdk.AccAddressFromBech32(args[0])
+			if err != nil {
+				return err
+			}
+
+			cmd.Flags().Set(flags.FlagFrom, args[0])
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			grantee, err := sdk.AccAddressFromBech32(args[1])
+			if err != nil {
+				return err
+			}
+
+			granter := clientCtx.GetFromAddress()
+			sl, err := cmd.Flags().GetString(FlagSpendLimit)
+			if err != nil {
+				return err
+			}
+
+			// if `FlagSpendLimit` isn't set, limit will be nil
+			limit, err := sdk.ParseCoinsNormalized(sl)
+			if err != nil {
+				return err
+			}
+
+			exp, err := cmd.Flags().GetInt64(FlagExpiration)
+			if err != nil {
+				return err
+			}
+
+			basic := types.BasicFeeAllowance{
+				SpendLimit: limit,
+			}
+
+			if exp != 0 {
+				expDuration := time.Duration(exp) * time.Second
+				basic.Expiration = types.ExpiresAtTime(time.Now().Add(expDuration))
+			}
+
+			var grant types.FeeAllowanceI
+			grant = &basic
+
+			periodClock, err := cmd.Flags().GetInt64(FlagPeriod)
+			if err != nil {
+				return err
+			}
+
+			periodLimitVal, err := cmd.Flags().GetString(FlagPeriodLimit)
+			if err != nil {
+				return err
+			}
+
+			// Check any of period or periodLimit flags set, If set consider it as periodic fee allowance.
+			if periodClock > 0 || periodLimitVal != "" {
+				periodLimit, err := sdk.ParseCoinsNormalized(periodLimitVal)
+				if err != nil {
+					return err
+				}
+
+				if periodClock > 0 && periodLimit != nil {
+					if exp > 0 && periodClock > exp {
+						return fmt.Errorf("period(%d) cannot be greater than the expiration(%d)", periodClock, exp)
+					}
+
+					periodic := types.PeriodicFeeAllowance{
+						Basic:            basic,
+						Period:           types.ClockDuration(time.Duration(periodClock) * time.Second),
+						PeriodReset:      types.ExpiresAtTime(time.Now().Add(time.Duration(periodClock) * time.Second)),
+						PeriodSpendLimit: periodLimit,
+						PeriodCanSpend:   periodLimit,
+					}
+
+					grant = &periodic
+
+				} else {
+					return fmt.Errorf("invalid number of args %d", len(args))
+				}
+			}
+
+			msg, err := types.NewMsgGrantFeeAllowance(grant, granter, grantee)
+			if err != nil {
+				return err
+			}
+
+			svcMsgClientConn := &msgservice.ServiceMsgClientConn{}
+			feeGrantMsgClient := types.NewMsgClient(svcMsgClientConn)
+			_, err = feeGrantMsgClient.GrantFeeAllowance(cmd.Context(), msg)
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), svcMsgClientConn.GetMsgs()...)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	cmd.Flags().Int64(FlagExpiration, 0, "The second unit of time duration which the grant is active for the user")
+	cmd.Flags().String(FlagSpendLimit, "", "Spend limit specifies the max limit can be used, if not mentioned there is no limit")
+	cmd.Flags().Int64(FlagPeriod, 0, "period specifies the time duration in which period_spend_limit coins can be spent before that allowance is reset")
+	cmd.Flags().String(FlagPeriodLimit, "", "// period limit specifies the maximum number of coins that can be spent in the period")
+
+	return cmd
+}
+
+// NewCmdRevokeFeegrant returns a CLI command handler for creating a MsgRevokeFeeAllowance transaction.
+func NewCmdRevokeFeegrant() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "revoke [granter_address] [grantee_address]",
+		Short: "revoke fee-grant",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`revoke fee grant from a granter to a grantee. Note, the'--from' flag is
+			ignored as it is implied from [granter_address].
+
+Example:
+ $ %s tx %s revoke cosmos1skj.. cosmos1skj..
+			`, version.AppName, types.ModuleName),
+		),
+		Args: cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cmd.Flags().Set(flags.FlagFrom, args[0])
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			grantee, err := sdk.AccAddressFromBech32(args[1])
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgRevokeFeeAllowance(clientCtx.GetFromAddress(), grantee)
+			svcMsgClientConn := &msgservice.ServiceMsgClientConn{}
+			feeGrantMsgClient := types.NewMsgClient(svcMsgClientConn)
+			_, err = feeGrantMsgClient.RevokeFeeAllowance(cmd.Context(), &msg)
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), svcMsgClientConn.GetMsgs()...)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}
diff --git a/x/feegrant/client/rest/grpc_query_test.go b/x/feegrant/client/rest/grpc_query_test.go
new file mode 100644
index 000000000000..10d77a1e4c1f
--- /dev/null
+++ b/x/feegrant/client/rest/grpc_query_test.go
@@ -0,0 +1,209 @@
+package rest_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	banktestutil "github.com/cosmos/cosmos-sdk/x/bank/client/testutil"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/client/cli"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/suite"
+)
+
+type IntegrationTestSuite struct {
+	suite.Suite
+	cfg     network.Config
+	network *network.Network
+	grantee sdk.AccAddress
+}
+
+func (s *IntegrationTestSuite) SetupSuite() {
+	s.T().Log("setting up integration test suite")
+
+	cfg := network.DefaultConfig()
+
+	cfg.NumValidators = 1
+	s.cfg = cfg
+	s.network = network.New(s.T(), cfg)
+
+	val := s.network.Validators[0]
+	// Create new account in the keyring.
+	info, _, err := val.ClientCtx.Keyring.NewMnemonic("grantee", keyring.English, sdk.FullFundraiserPath, hd.Secp256k1)
+	s.Require().NoError(err)
+	newAddr := sdk.AccAddress(info.GetPubKey().Address())
+
+	// Send some funds to the new account.
+	_, err = banktestutil.MsgSendExec(
+		val.ClientCtx,
+		val.Address,
+		newAddr,
+		sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(200))), fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	)
+	s.Require().NoError(err)
+
+	s.grantee = newAddr
+	_, err = s.network.WaitForHeight(1)
+	s.Require().NoError(err)
+}
+
+func (s *IntegrationTestSuite) TearDownSuite() {
+	s.T().Log("tearing down integration test suite")
+	s.network.Cleanup()
+}
+
+func (s *IntegrationTestSuite) TestQueryFeeAllowance() {
+	val := s.network.Validators[0]
+	baseURL := val.APIAddress
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func()
+		postRun   func(_ types.QueryFeeAllowanceResponse)
+	}{
+		{
+			"fail: invalid granter",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowance/%s/%s", baseURL, "invalid_granter", s.grantee.String()),
+			true,
+			"decoding bech32 failed: invalid index of 1: invalid request",
+			func() {},
+			func(types.QueryFeeAllowanceResponse) {},
+		},
+		{
+			"fail: invalid grantee",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowance/%s/%s", baseURL, val.Address.String(), "invalid_grantee"),
+			true,
+			"decoding bech32 failed: invalid index of 1: invalid request",
+			func() {},
+			func(types.QueryFeeAllowanceResponse) {},
+		},
+		{
+			"fail: no grants",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowance/%s/%s", baseURL, val.Address.String(), s.grantee.String()),
+			true,
+			"no fee allowance found",
+			func() {},
+			func(types.QueryFeeAllowanceResponse) {},
+		},
+		{
+			"valid query: expect single grant",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowance/%s/%s", baseURL, val.Address.String(), s.grantee.String()),
+			false,
+			"",
+			func() {
+				execFeeAllowance(val, s)
+			},
+			func(allowance types.QueryFeeAllowanceResponse) {
+				s.Require().Equal(allowance.FeeAllowance.Granter, val.Address.String())
+				s.Require().Equal(allowance.FeeAllowance.Grantee, s.grantee.String())
+			},
+		},
+	}
+	for _, tc := range testCases {
+		s.Run(tc.name, func() {
+			tc.preRun()
+			resp, _ := rest.GetRequest(tc.url)
+			if tc.expectErr {
+				s.Require().Contains(string(resp), tc.errorMsg)
+			} else {
+				var allowance types.QueryFeeAllowanceResponse
+				err := val.ClientCtx.JSONMarshaler.UnmarshalJSON(resp, &allowance)
+				s.Require().NoError(err)
+				tc.postRun(allowance)
+			}
+		})
+	}
+}
+
+func (s *IntegrationTestSuite) TestQueryGranteeAllowances() {
+	val := s.network.Validators[0]
+	baseURL := val.APIAddress
+	testCases := []struct {
+		name      string
+		url       string
+		expectErr bool
+		errorMsg  string
+		preRun    func()
+		postRun   func(_ types.QueryFeeAllowancesResponse)
+	}{
+		{
+			"fail: invalid grantee",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowances/%s", baseURL, "invalid_grantee"),
+			true,
+			"decoding bech32 failed: invalid index of 1: invalid request",
+			func() {},
+			func(types.QueryFeeAllowancesResponse) {},
+		},
+		{
+			"success: no grants",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowances/%s?pagination.offset=1", baseURL, s.grantee.String()),
+			false,
+			"",
+			func() {},
+			func(allowances types.QueryFeeAllowancesResponse) {
+				s.Require().Equal(len(allowances.FeeAllowances), 0)
+			},
+		},
+		{
+			"valid query: expect single grant",
+			fmt.Sprintf("%s/cosmos/feegrant/v1beta1/fee_allowances/%s", baseURL, s.grantee.String()),
+			false,
+			"",
+			func() {
+				execFeeAllowance(val, s)
+			},
+			func(allowances types.QueryFeeAllowancesResponse) {
+				s.Require().Equal(len(allowances.FeeAllowances), 1)
+				s.Require().Equal(allowances.FeeAllowances[0].Granter, val.Address.String())
+				s.Require().Equal(allowances.FeeAllowances[0].Grantee, s.grantee.String())
+			},
+		},
+	}
+	for _, tc := range testCases {
+		s.Run(tc.name, func() {
+			tc.preRun()
+			resp, _ := rest.GetRequest(tc.url)
+			if tc.expectErr {
+				s.Require().Contains(string(resp), tc.errorMsg)
+			} else {
+				var allowance types.QueryFeeAllowancesResponse
+				err := val.ClientCtx.JSONMarshaler.UnmarshalJSON(resp, &allowance)
+				s.Require().NoError(err)
+				tc.postRun(allowance)
+			}
+		})
+	}
+}
+
+func execFeeAllowance(val *network.Validator, s *IntegrationTestSuite) {
+	fee := sdk.NewCoin("steak", sdk.NewInt(100))
+	duration := 365 * 24 * 60 * 60
+	args := []string{
+		val.Address.String(),
+		s.grantee.String(),
+		fmt.Sprintf("--%s=%s", cli.FlagSpendLimit, fee.String()),
+		fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()),
+		fmt.Sprintf("--%s=%v", cli.FlagExpiration, duration),
+		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+	}
+
+	cmd := cli.NewCmdFeeGrant()
+	_, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, args)
+	s.Require().NoError(err)
+}
+
+func TestIntegrationTestSuite(t *testing.T) {
+	suite.Run(t, new(IntegrationTestSuite))
+}
diff --git a/x/feegrant/doc.go b/x/feegrant/doc.go
new file mode 100644
index 000000000000..4f190e3140c7
--- /dev/null
+++ b/x/feegrant/doc.go
@@ -0,0 +1,29 @@
+/*
+Package feegrant provides functionality for authorizing the payment of transaction
+fees from one account (key) to another account (key).
+
+Effectively, this allows for a user to pay fees using the balance of an account
+different from their own. Example use cases would be allowing a key on a device to
+pay for fees using a master wallet, or a third party service allowing users to
+pay for transactions without ever really holding their own tokens. This package
+provides ways for specifying fee allowances such that authorizing fee payment to
+another account can be done with clear and safe restrictions.
+
+A user would authorize granting fee payment to another user using
+MsgDelegateFeeAllowance and revoke that delegation using MsgRevokeFeeAllowance.
+In both cases, Granter is the one who is authorizing fee payment and Grantee is
+the one who is receiving the fee payment authorization. So grantee would correspond
+to the one who is signing a transaction and the granter would be the address that
+pays the fees.
+
+The fee allowance that a grantee receives is specified by an implementation of
+the FeeAllowance interface. Two FeeAllowance implementations are provided in
+this package: BasicFeeAllowance and PeriodicFeeAllowance.
+
+In order to integrate this into an application, we must use the DeductGrantedFeeDecorator
+ante handler from this package instead of the default DeductFeeDecorator from x/auth.
+
+To allow handling txs from empty accounts (with fees paid from an existing account),
+we have to re-order the decorators as well.
+*/
+package feegrant
diff --git a/x/feegrant/genesis.go b/x/feegrant/genesis.go
new file mode 100644
index 000000000000..f65cfdb57825
--- /dev/null
+++ b/x/feegrant/genesis.go
@@ -0,0 +1,61 @@
+package feegrant
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// GenesisState contains a set of fee allowances, persisted from the store
+type GenesisState []types.FeeAllowanceGrant
+
+// ValidateBasic ensures all grants in the genesis state are valid
+func (g GenesisState) ValidateBasic() error {
+	for _, f := range g {
+		err := f.GetFeeGrant().ValidateBasic()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// InitGenesis will initialize the keeper from a *previously validated* GenesisState
+func InitGenesis(ctx sdk.Context, k keeper.Keeper, data *types.GenesisState) {
+	for _, f := range data.FeeAllowances {
+		granter, err := sdk.AccAddressFromBech32(f.Granter)
+		if err != nil {
+			panic(err)
+		}
+		grantee, err := sdk.AccAddressFromBech32(f.Grantee)
+		if err != nil {
+			panic(err)
+		}
+
+		err = k.GrantFeeAllowance(ctx, granter, grantee, f.GetFeeGrant())
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
+// ExportGenesis will dump the contents of the keeper into a serializable GenesisState
+//
+// All expiration heights will be thrown off if we dump state and start at a new
+// chain at height 0. Thus, we allow the Allowances to "prepare themselves"
+// for export, like if they have expiry at 5000 and current is 4000, they export with
+// expiry of 1000. Every FeeAllowance has a method `PrepareForExport` that allows
+// them to perform any changes needed prior to export.
+func ExportGenesis(ctx sdk.Context, k keeper.Keeper) (*types.GenesisState, error) {
+	time, height := ctx.BlockTime(), ctx.BlockHeight()
+	var grants []types.FeeAllowanceGrant
+
+	err := k.IterateAllFeeAllowances(ctx, func(grant types.FeeAllowanceGrant) bool {
+		grants = append(grants, grant.PrepareForExport(time, height))
+		return false
+	})
+
+	return &types.GenesisState{
+		FeeAllowances: grants,
+	}, err
+}
diff --git a/x/feegrant/genesis_test.go b/x/feegrant/genesis_test.go
new file mode 100644
index 000000000000..d086daac077f
--- /dev/null
+++ b/x/feegrant/genesis_test.go
@@ -0,0 +1,56 @@
+package feegrant_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	feegrant "github.com/cosmos/cosmos-sdk/x/feegrant"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/suite"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+)
+
+type GenesisTestSuite struct {
+	suite.Suite
+	ctx    sdk.Context
+	keeper keeper.Keeper
+}
+
+func (suite *GenesisTestSuite) SetupTest() {
+	checkTx := false
+	app := simapp.Setup(checkTx)
+	suite.ctx = app.BaseApp.NewContext(checkTx, tmproto.Header{Height: 1})
+	suite.keeper = app.FeeGrantKeeper
+}
+
+var (
+	granteePub  = secp256k1.GenPrivKey().PubKey()
+	granterPub  = secp256k1.GenPrivKey().PubKey()
+	granteeAddr = sdk.AccAddress(granteePub.Address())
+	granterAddr = sdk.AccAddress(granterPub.Address())
+)
+
+func (suite *GenesisTestSuite) TestImportExportGenesis() {
+	coins := sdk.NewCoins(sdk.NewCoin("foo", sdk.NewInt(1_000)))
+	now := suite.ctx.BlockHeader().Time
+
+	allowance := &types.BasicFeeAllowance{SpendLimit: coins, Expiration: types.ExpiresAtTime(now.AddDate(1, 0, 0))}
+	err := suite.keeper.GrantFeeAllowance(suite.ctx, granterAddr, granteeAddr, allowance)
+	suite.Require().NoError(err)
+
+	genesis, err := feegrant.ExportGenesis(suite.ctx, suite.keeper)
+	suite.Require().NoError(err)
+	// Clear keeper
+	suite.keeper.RevokeFeeAllowance(suite.ctx, granterAddr, granteeAddr)
+	feegrant.InitGenesis(suite.ctx, suite.keeper, genesis)
+	newGenesis, err := feegrant.ExportGenesis(suite.ctx, suite.keeper)
+	suite.Require().NoError(err)
+	suite.Require().Equal(genesis, newGenesis)
+}
+
+func TestGenesisTestSuite(t *testing.T) {
+	suite.Run(t, new(GenesisTestSuite))
+}
diff --git a/x/feegrant/keeper/grpc_query.go b/x/feegrant/keeper/grpc_query.go
new file mode 100644
index 000000000000..0fce084f90ba
--- /dev/null
+++ b/x/feegrant/keeper/grpc_query.go
@@ -0,0 +1,94 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/gogo/protobuf/proto"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+var _ types.QueryServer = Keeper{}
+
+// FeeAllowance returns fee granted to the grantee by the granter.
+func (q Keeper) FeeAllowance(c context.Context, req *types.QueryFeeAllowanceRequest) (*types.QueryFeeAllowanceResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	granterAddr, err := sdk.AccAddressFromBech32(req.Granter)
+	if err != nil {
+		return nil, err
+	}
+
+	granteeAddr, err := sdk.AccAddressFromBech32(req.Grantee)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	feeAllowance := q.GetFeeAllowance(ctx, granterAddr, granteeAddr)
+	if feeAllowance == nil {
+		return nil, status.Errorf(codes.NotFound, "no fee allowance found")
+	}
+
+	msg, ok := feeAllowance.(proto.Message)
+	if !ok {
+		return nil, status.Errorf(codes.Internal, "can't proto marshal %T", msg)
+	}
+
+	feeAllowanceAny, err := codectypes.NewAnyWithValue(msg)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	return &types.QueryFeeAllowanceResponse{
+		FeeAllowance: &types.FeeAllowanceGrant{
+			Granter:   granterAddr.String(),
+			Grantee:   granteeAddr.String(),
+			Allowance: feeAllowanceAny,
+		},
+	}, nil
+}
+
+func (q Keeper) FeeAllowances(c context.Context, req *types.QueryFeeAllowancesRequest) (*types.QueryFeeAllowancesResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	granteeAddr, err := sdk.AccAddressFromBech32(req.Grantee)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	var grants []*types.FeeAllowanceGrant
+
+	store := ctx.KVStore(q.storeKey)
+	grantsStore := prefix.NewStore(store, types.FeeAllowancePrefixByGrantee(granteeAddr))
+
+	pageRes, err := query.Paginate(grantsStore, req.Pagination, func(key []byte, value []byte) error {
+		var grant types.FeeAllowanceGrant
+
+		if err := q.cdc.UnmarshalBinaryBare(value, &grant); err != nil {
+			return err
+		}
+
+		grants = append(grants, &grant)
+		return nil
+	})
+
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	return &types.QueryFeeAllowancesResponse{FeeAllowances: grants, Pagination: pageRes}, nil
+}
diff --git a/x/feegrant/keeper/keeper.go b/x/feegrant/keeper/keeper.go
new file mode 100644
index 000000000000..e6606bf0ca55
--- /dev/null
+++ b/x/feegrant/keeper/keeper.go
@@ -0,0 +1,190 @@
+package keeper
+
+import (
+	"fmt"
+
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// Keeper manages state of all fee grants, as well as calculating approval.
+// It must have a codec with all available allowances registered.
+type Keeper struct {
+	cdc        codec.BinaryMarshaler
+	storeKey   sdk.StoreKey
+	authKeeper types.AccountKeeper
+}
+
+// NewKeeper creates a fee grant Keeper
+func NewKeeper(cdc codec.BinaryMarshaler, storeKey sdk.StoreKey, ak types.AccountKeeper) Keeper {
+	return Keeper{
+		cdc:        cdc,
+		storeKey:   storeKey,
+		authKeeper: ak,
+	}
+}
+
+// Logger returns a module-specific logger.
+func (k Keeper) Logger(ctx sdk.Context) log.Logger {
+	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
+}
+
+// GrantFeeAllowance creates a new grant
+func (k Keeper) GrantFeeAllowance(ctx sdk.Context, granter, grantee sdk.AccAddress, feeAllowance types.FeeAllowanceI) error {
+
+	// create the account if it is not in account state
+	granteeAcc := k.authKeeper.GetAccount(ctx, grantee)
+	if granteeAcc == nil {
+		granteeAcc = k.authKeeper.NewAccountWithAddress(ctx, grantee)
+		k.authKeeper.SetAccount(ctx, granteeAcc)
+	}
+
+	store := ctx.KVStore(k.storeKey)
+	key := types.FeeAllowanceKey(granter, grantee)
+	grant, err := types.NewFeeAllowanceGrant(granter, grantee, feeAllowance)
+	if err != nil {
+		return err
+	}
+
+	bz, err := k.cdc.MarshalBinaryBare(&grant)
+	if err != nil {
+		return err
+	}
+
+	store.Set(key, bz)
+
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeSetFeeGrant,
+			sdk.NewAttribute(types.AttributeKeyGranter, grant.Granter),
+			sdk.NewAttribute(types.AttributeKeyGrantee, grant.Grantee),
+		),
+	)
+
+	return nil
+}
+
+// RevokeFeeAllowance removes an existing grant
+func (k Keeper) RevokeFeeAllowance(ctx sdk.Context, granter, grantee sdk.AccAddress) error {
+	store := ctx.KVStore(k.storeKey)
+	key := types.FeeAllowanceKey(granter, grantee)
+	_, found := k.GetFeeGrant(ctx, granter, grantee)
+	if !found {
+		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "fee-grant not found")
+	}
+
+	store.Delete(key)
+
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeRevokeFeeGrant,
+			sdk.NewAttribute(types.AttributeKeyGranter, granter.String()),
+			sdk.NewAttribute(types.AttributeKeyGrantee, grantee.String()),
+		),
+	)
+	return nil
+}
+
+// GetFeeAllowance returns the allowance between the granter and grantee.
+// If there is none, it returns nil, nil.
+// Returns an error on parsing issues
+func (k Keeper) GetFeeAllowance(ctx sdk.Context, granter, grantee sdk.AccAddress) types.FeeAllowanceI {
+	grant, found := k.GetFeeGrant(ctx, granter, grantee)
+	if !found {
+		return nil
+	}
+
+	return grant.GetFeeGrant()
+}
+
+// GetFeeGrant returns entire grant between both accounts
+func (k Keeper) GetFeeGrant(ctx sdk.Context, granter sdk.AccAddress, grantee sdk.AccAddress) (types.FeeAllowanceGrant, bool) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.FeeAllowanceKey(granter, grantee)
+	bz := store.Get(key)
+	if len(bz) == 0 {
+		return types.FeeAllowanceGrant{}, false
+	}
+
+	var feegrant types.FeeAllowanceGrant
+	k.cdc.MustUnmarshalBinaryBare(bz, &feegrant)
+
+	return feegrant, true
+}
+
+// IterateAllGranteeFeeAllowances iterates over all the grants from anyone to the given grantee.
+// Callback to get all data, returns true to stop, false to keep reading
+func (k Keeper) IterateAllGranteeFeeAllowances(ctx sdk.Context, grantee sdk.AccAddress, cb func(types.FeeAllowanceGrant) bool) error {
+	store := ctx.KVStore(k.storeKey)
+	prefix := types.FeeAllowancePrefixByGrantee(grantee)
+	iter := sdk.KVStorePrefixIterator(store, prefix)
+	defer iter.Close()
+
+	stop := false
+	for ; iter.Valid() && !stop; iter.Next() {
+		bz := iter.Value()
+
+		var feeGrant types.FeeAllowanceGrant
+		k.cdc.MustUnmarshalBinaryBare(bz, &feeGrant)
+
+		stop = cb(feeGrant)
+	}
+
+	return nil
+}
+
+// IterateAllFeeAllowances iterates over all the grants in the store.
+// Callback to get all data, returns true to stop, false to keep reading
+// Calling this without pagination is very expensive and only designed for export genesis
+func (k Keeper) IterateAllFeeAllowances(ctx sdk.Context, cb func(types.FeeAllowanceGrant) bool) error {
+	store := ctx.KVStore(k.storeKey)
+	iter := sdk.KVStorePrefixIterator(store, types.FeeAllowanceKeyPrefix)
+	defer iter.Close()
+
+	stop := false
+	for ; iter.Valid() && !stop; iter.Next() {
+		bz := iter.Value()
+		var feeGrant types.FeeAllowanceGrant
+		k.cdc.MustUnmarshalBinaryBare(bz, &feeGrant)
+
+		stop = cb(feeGrant)
+	}
+
+	return nil
+}
+
+// UseGrantedFees will try to pay the given fee from the granter's account as requested by the grantee
+func (k Keeper) UseGrantedFees(ctx sdk.Context, granter, grantee sdk.AccAddress, fee sdk.Coins) error {
+	grant, found := k.GetFeeGrant(ctx, granter, grantee)
+	if !found || grant.GetFeeGrant() == nil {
+		return sdkerrors.Wrapf(types.ErrNoAllowance, "grant missing")
+	}
+
+	remove, err := grant.GetFeeGrant().Accept(fee, ctx.BlockTime(), ctx.BlockHeight())
+	if err == nil {
+		ctx.EventManager().EmitEvent(
+			sdk.NewEvent(
+				types.EventTypeUseFeeGrant,
+				sdk.NewAttribute(types.AttributeKeyGranter, granter.String()),
+				sdk.NewAttribute(types.AttributeKeyGrantee, grantee.String()),
+			),
+		)
+	}
+
+	if remove {
+		k.RevokeFeeAllowance(ctx, granter, grantee)
+		// note this returns nil if err == nil
+		return sdkerrors.Wrap(err, "removed grant")
+	}
+
+	if err != nil {
+		return sdkerrors.Wrap(err, "invalid grant")
+	}
+
+	// if we accepted, store the updated state of the allowance
+	return k.GrantFeeAllowance(ctx, granter, grantee, grant.GetFeeGrant())
+}
diff --git a/x/feegrant/keeper/keeper_test.go b/x/feegrant/keeper/keeper_test.go
new file mode 100644
index 000000000000..c14e141d31f0
--- /dev/null
+++ b/x/feegrant/keeper/keeper_test.go
@@ -0,0 +1,257 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+type KeeperTestSuite struct {
+	suite.Suite
+
+	app   *simapp.SimApp
+	ctx   sdk.Context
+	addrs []sdk.AccAddress
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+	suite.Run(t, new(KeeperTestSuite))
+}
+
+func (suite *KeeperTestSuite) SetupTest() {
+	app := simapp.Setup(false)
+	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
+
+	suite.app = app
+	suite.ctx = ctx
+	suite.addrs = simapp.AddTestAddrsIncremental(app, ctx, 4, sdk.NewInt(30000000))
+}
+
+func (suite *KeeperTestSuite) TestKeeperCrud() {
+	ctx := suite.ctx
+	k := suite.app.FeeGrantKeeper
+
+	// some helpers
+	atom := sdk.NewCoins(sdk.NewInt64Coin("atom", 555))
+	eth := sdk.NewCoins(sdk.NewInt64Coin("eth", 123))
+	basic := &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(334455),
+	}
+
+	basic2 := &types.BasicFeeAllowance{
+		SpendLimit: eth,
+		Expiration: types.ExpiresAtHeight(172436),
+	}
+
+	// let's set up some initial state here
+	err := k.GrantFeeAllowance(ctx, suite.addrs[0], suite.addrs[1], basic)
+	suite.Require().NoError(err)
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[0], suite.addrs[2], basic2)
+	suite.Require().NoError(err)
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[1], suite.addrs[2], basic)
+	suite.Require().NoError(err)
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[1], suite.addrs[3], basic)
+	suite.Require().NoError(err)
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[3], suite.addrs[0], basic2)
+	suite.Require().NoError(err)
+
+	// remove some, overwrite other
+	k.RevokeFeeAllowance(ctx, suite.addrs[0], suite.addrs[1])
+	k.RevokeFeeAllowance(ctx, suite.addrs[0], suite.addrs[2])
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[0], suite.addrs[2], basic)
+	suite.Require().NoError(err)
+
+	err = k.GrantFeeAllowance(ctx, suite.addrs[1], suite.addrs[2], basic2)
+	suite.Require().NoError(err)
+
+	// end state:
+	// addr -> addr3 (basic)
+	// addr2 -> addr3 (basic2), addr4(basic)
+	// addr4 -> addr (basic2)
+
+	// then lots of queries
+	cases := map[string]struct {
+		grantee   sdk.AccAddress
+		granter   sdk.AccAddress
+		allowance types.FeeAllowanceI
+	}{
+		"addr revoked": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[1],
+		},
+		"addr revoked and added": {
+			granter:   suite.addrs[0],
+			grantee:   suite.addrs[2],
+			allowance: basic,
+		},
+		"addr never there": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[3],
+		},
+		"addr modified": {
+			granter:   suite.addrs[1],
+			grantee:   suite.addrs[2],
+			allowance: basic2,
+		},
+	}
+
+	for name, tc := range cases {
+		tc := tc
+		suite.Run(name, func() {
+			allow := k.GetFeeAllowance(ctx, tc.granter, tc.grantee)
+			if tc.allowance == nil {
+				suite.Nil(allow)
+				return
+			}
+			suite.NotNil(allow)
+			suite.Equal(tc.allowance, allow)
+		})
+	}
+
+	grant1, err := types.NewFeeAllowanceGrant(suite.addrs[3], suite.addrs[0], basic2)
+	suite.NoError(err)
+
+	grant2, err := types.NewFeeAllowanceGrant(suite.addrs[1], suite.addrs[2], basic2)
+	suite.NoError(err)
+
+	grant3, err := types.NewFeeAllowanceGrant(suite.addrs[0], suite.addrs[2], basic)
+	suite.NoError(err)
+
+	allCases := map[string]struct {
+		grantee sdk.AccAddress
+		grants  []types.FeeAllowanceGrant
+	}{
+		"addr2 has none": {
+			grantee: suite.addrs[1],
+		},
+		"addr has one": {
+			grantee: suite.addrs[0],
+			grants: []types.FeeAllowanceGrant{
+				grant1,
+			},
+		},
+		"addr3 has two": {
+			grantee: suite.addrs[2],
+			grants: []types.FeeAllowanceGrant{
+				grant3,
+				grant2,
+			},
+		},
+	}
+
+	for name, tc := range allCases {
+		tc := tc
+		suite.Run(name, func() {
+			var grants []types.FeeAllowanceGrant
+			err := k.IterateAllGranteeFeeAllowances(ctx, tc.grantee, func(grant types.FeeAllowanceGrant) bool {
+				grants = append(grants, grant)
+				return false
+			})
+			suite.NoError(err)
+			suite.Equal(tc.grants, grants)
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestUseGrantedFee() {
+	ctx := suite.ctx
+	k := suite.app.FeeGrantKeeper
+
+	// some helpers
+	atom := sdk.NewCoins(sdk.NewInt64Coin("atom", 555))
+	eth := sdk.NewCoins(sdk.NewInt64Coin("eth", 123))
+	future := &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(5678),
+	}
+
+	expired := &types.BasicFeeAllowance{
+		SpendLimit: eth,
+		Expiration: types.ExpiresAtHeight(55),
+	}
+
+	// for testing limits of the contract
+	hugeAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 9999))
+	_ = hugeAtom
+	smallAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 1))
+	_ = smallAtom
+	futureAfterSmall := &types.BasicFeeAllowance{
+		SpendLimit: sdk.NewCoins(sdk.NewInt64Coin("atom", 554)),
+		Expiration: types.ExpiresAtHeight(5678),
+	}
+
+	// then lots of queries
+	cases := map[string]struct {
+		grantee sdk.AccAddress
+		granter sdk.AccAddress
+		fee     sdk.Coins
+		allowed bool
+		final   types.FeeAllowanceI
+	}{
+		"use entire pot": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[1],
+			fee:     atom,
+			allowed: true,
+			final:   nil,
+		},
+		"expired and removed": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[2],
+			fee:     eth,
+			allowed: false,
+			final:   nil,
+		},
+		"too high": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[1],
+			fee:     hugeAtom,
+			allowed: false,
+			final:   future,
+		},
+		"use a little": {
+			granter: suite.addrs[0],
+			grantee: suite.addrs[1],
+			fee:     smallAtom,
+			allowed: true,
+			final:   futureAfterSmall,
+		},
+	}
+
+	for name, tc := range cases {
+		tc := tc
+		suite.Run(name, func() {
+			// let's set up some initial state here
+			// addr -> addr2 (future)
+			// addr -> addr3 (expired)
+
+			err := k.GrantFeeAllowance(ctx, suite.addrs[0], suite.addrs[1], future)
+			suite.Require().NoError(err)
+
+			err = k.GrantFeeAllowance(ctx, suite.addrs[0], suite.addrs[3], expired)
+			suite.Require().NoError(err)
+
+			err = k.UseGrantedFees(ctx, tc.granter, tc.grantee, tc.fee)
+			if tc.allowed {
+				suite.NoError(err)
+			} else {
+				suite.Error(err)
+			}
+
+			loaded := k.GetFeeAllowance(ctx, tc.granter, tc.grantee)
+
+			suite.Equal(tc.final, loaded)
+		})
+	}
+}
diff --git a/x/feegrant/keeper/msg_server.go b/x/feegrant/keeper/msg_server.go
new file mode 100644
index 000000000000..3cd96e79ba88
--- /dev/null
+++ b/x/feegrant/keeper/msg_server.go
@@ -0,0 +1,72 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+type msgServer struct {
+	Keeper
+}
+
+// NewMsgServerImpl returns an implementation of the feegrant MsgServer interface
+// for the provided Keeper.
+func NewMsgServerImpl(k Keeper) types.MsgServer {
+	return &msgServer{
+		Keeper: k,
+	}
+}
+
+var _ types.MsgServer = msgServer{}
+
+func (k msgServer) GrantFeeAllowance(goCtx context.Context, msg *types.MsgGrantFeeAllowance) (*types.MsgGrantFeeAllowanceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	grantee, err := sdk.AccAddressFromBech32(msg.Grantee)
+	if err != nil {
+		return nil, err
+	}
+
+	granter, err := sdk.AccAddressFromBech32(msg.Granter)
+	if err != nil {
+		return nil, err
+	}
+
+	// Checking for duplicate entry
+	f := k.Keeper.GetFeeAllowance(ctx, granter, grantee)
+	if f != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "fee allowance already exists")
+	}
+
+	err = k.Keeper.GrantFeeAllowance(ctx, granter, grantee, msg.GetFeeAllowanceI())
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.MsgGrantFeeAllowanceResponse{}, nil
+}
+
+func (k msgServer) RevokeFeeAllowance(goCtx context.Context, msg *types.MsgRevokeFeeAllowance) (*types.MsgRevokeFeeAllowanceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	grantee, err := sdk.AccAddressFromBech32(msg.Grantee)
+	if err != nil {
+		return nil, err
+	}
+
+	granter, err := sdk.AccAddressFromBech32(msg.Granter)
+	if err != nil {
+		return nil, err
+	}
+
+	err = k.Keeper.RevokeFeeAllowance(ctx, granter, grantee)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.MsgRevokeFeeAllowanceResponse{}, nil
+}
diff --git a/x/feegrant/module.go b/x/feegrant/module.go
new file mode 100644
index 000000000000..5f4ba807d895
--- /dev/null
+++ b/x/feegrant/module.go
@@ -0,0 +1,210 @@
+package feegrant
+
+import (
+	"context"
+	"encoding/json"
+	"math/rand"
+
+	"github.com/gorilla/mux"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/spf13/cobra"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	sdkclient "github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/client/cli"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+var (
+	_ module.AppModule           = AppModule{}
+	_ module.AppModuleBasic      = AppModuleBasic{}
+	_ module.AppModuleSimulation = AppModule{}
+)
+
+// ----------------------------------------------------------------------------
+// AppModuleBasic
+// ----------------------------------------------------------------------------
+
+// AppModuleBasic defines the basic application module used by the feegrant module.
+type AppModuleBasic struct {
+	cdc codec.Marshaler
+}
+
+// Name returns the feegrant module's name.
+func (AppModuleBasic) Name() string {
+	return types.ModuleName
+}
+
+// RegisterServices registers a gRPC query service to respond to the
+// module-specific gRPC queries.
+func (am AppModule) RegisterServices(cfg module.Configurator) {
+	types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper))
+	types.RegisterQueryServer(cfg.QueryServer(), am.keeper)
+}
+
+// RegisterLegacyAminoCodec registers the feegrant module's types for the given codec.
+func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+}
+
+// RegisterInterfaces registers the feegrant module's interface types
+func (AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+	types.RegisterInterfaces(registry)
+}
+
+// LegacyQuerierHandler returns the feegrant module sdk.Querier.
+func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
+	return nil
+}
+
+// DefaultGenesis returns default genesis state as raw bytes for the feegrant
+// module.
+func (AppModuleBasic) DefaultGenesis(cdc codec.JSONMarshaler) json.RawMessage {
+	return cdc.MustMarshalJSON(types.DefaultGenesisState())
+}
+
+// ValidateGenesis performs genesis state validation for the feegrant module.
+func (a AppModuleBasic) ValidateGenesis(cdc codec.JSONMarshaler, config sdkclient.TxEncodingConfig, bz json.RawMessage) error {
+	var data types.GenesisState
+	if err := cdc.UnmarshalJSON(bz, &data); err != nil {
+		sdkerrors.Wrapf(err, "failed to unmarshal %s genesis state", types.ModuleName)
+	}
+
+	return types.ValidateGenesis(data)
+}
+
+// RegisterRESTRoutes registers the REST routes for the feegrant module.
+func (AppModuleBasic) RegisterRESTRoutes(ctx sdkclient.Context, rtr *mux.Router) {}
+
+// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the feegrant module.
+func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx sdkclient.Context, mux *runtime.ServeMux) {
+	types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx))
+}
+
+// GetTxCmd returns the root tx command for the feegrant module.
+func (AppModuleBasic) GetTxCmd() *cobra.Command {
+	return cli.GetTxCmd()
+}
+
+// GetQueryCmd returns no root query command for the feegrant module.
+func (AppModuleBasic) GetQueryCmd() *cobra.Command {
+	return cli.GetQueryCmd()
+}
+
+// ----------------------------------------------------------------------------
+// AppModule
+// ----------------------------------------------------------------------------
+
+// AppModule implements an application module for the feegrant module.
+type AppModule struct {
+	AppModuleBasic
+	keeper        keeper.Keeper
+	accountKeeper types.AccountKeeper
+	bankKeeper    types.BankKeeper
+	registry      cdctypes.InterfaceRegistry
+}
+
+// NewAppModule creates a new AppModule object
+func NewAppModule(cdc codec.Marshaler, ak types.AccountKeeper, bk types.BankKeeper, keeper keeper.Keeper, registry cdctypes.InterfaceRegistry) AppModule {
+	return AppModule{
+		AppModuleBasic: AppModuleBasic{cdc: cdc},
+		keeper:         keeper,
+		accountKeeper:  ak,
+		bankKeeper:     bk,
+		registry:       registry,
+	}
+}
+
+// Name returns the feegrant module's name.
+func (AppModule) Name() string {
+	return types.ModuleName
+}
+
+// RegisterInvariants registers the feegrant module invariants.
+func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {}
+
+// Route returns the message routing key for the feegrant module.
+func (am AppModule) Route() sdk.Route {
+	return sdk.NewRoute(types.RouterKey, nil)
+}
+
+// NewHandler returns an sdk.Handler for the feegrant module.
+func (am AppModule) NewHandler() sdk.Handler {
+	return nil
+}
+
+// QuerierRoute returns the feegrant module's querier route name.
+func (AppModule) QuerierRoute() string {
+	return ""
+}
+
+// InitGenesis performs genesis initialization for the feegrant module. It returns
+// no validator updates.
+func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONMarshaler, bz json.RawMessage) []abci.ValidatorUpdate {
+	var gs types.GenesisState
+	cdc.MustUnmarshalJSON(bz, &gs)
+
+	InitGenesis(ctx, am.keeper, &gs)
+	return []abci.ValidatorUpdate{}
+}
+
+// ExportGenesis returns the exported genesis state as raw bytes for the feegrant
+// module.
+func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONMarshaler) json.RawMessage {
+	gs, err := ExportGenesis(ctx, am.keeper)
+	if err != nil {
+		panic(err)
+	}
+
+	return cdc.MustMarshalJSON(gs)
+}
+
+// BeginBlock returns the begin blocker for the feegrant module.
+func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+
+// EndBlock returns the end blocker for the feegrant module. It returns no validator
+// updates.
+func (AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+	return []abci.ValidatorUpdate{}
+}
+
+//____________________________________________________________________________
+
+// AppModuleSimulation functions
+
+// GenerateGenesisState creates a randomized GenState of the feegrant module.
+func (AppModule) GenerateGenesisState(simState *module.SimulationState) {
+	simulation.RandomizedGenState(simState)
+}
+
+// ProposalContents returns all the feegrant content functions used to
+// simulate governance proposals.
+func (AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent {
+	return nil
+}
+
+// RandomizedParams creates randomized feegrant param changes for the simulator.
+func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange {
+	return nil
+}
+
+// RegisterStoreDecoder registers a decoder for feegrant module's types
+func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) {
+	sdr[types.StoreKey] = simulation.NewDecodeStore(am.cdc)
+}
+
+// WeightedOperations returns all the feegrant module operations with their respective weights.
+func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation {
+	protoCdc := codec.NewProtoCodec(am.registry)
+	return simulation.WeightedOperations(
+		simState.AppParams, simState.Cdc, am.accountKeeper, am.bankKeeper, am.keeper, protoCdc,
+	)
+}
diff --git a/x/feegrant/simulation/decoder.go b/x/feegrant/simulation/decoder.go
new file mode 100644
index 000000000000..46e35594fdf8
--- /dev/null
+++ b/x/feegrant/simulation/decoder.go
@@ -0,0 +1,26 @@
+package simulation
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/kv"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
+// Value to the corresponding feegrant type.
+func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
+	return func(kvA, kvB kv.Pair) string {
+		switch {
+		case bytes.Equal(kvA.Key[:1], types.FeeAllowanceKeyPrefix):
+			var grantA, grantB types.FeeAllowanceGrant
+			cdc.MustUnmarshalBinaryBare(kvA.Value, &grantA)
+			cdc.MustUnmarshalBinaryBare(kvB.Value, &grantB)
+			return fmt.Sprintf("%v\n%v", grantA, grantB)
+		default:
+			panic(fmt.Sprintf("invalid feegrant key %X", kvA.Key))
+		}
+	}
+}
diff --git a/x/feegrant/simulation/decoder_test.go b/x/feegrant/simulation/decoder_test.go
new file mode 100644
index 000000000000..0087e5eba117
--- /dev/null
+++ b/x/feegrant/simulation/decoder_test.go
@@ -0,0 +1,62 @@
+package simulation_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/kv"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	granterPk   = ed25519.GenPrivKey().PubKey()
+	granterAddr = sdk.AccAddress(granterPk.Address())
+	granteePk   = ed25519.GenPrivKey().PubKey()
+	granteeAddr = sdk.AccAddress(granterPk.Address())
+)
+
+func TestDecodeStore(t *testing.T) {
+	cdc := simapp.MakeTestEncodingConfig().Marshaler
+	dec := simulation.NewDecodeStore(cdc)
+
+	grant, err := types.NewFeeAllowanceGrant(granterAddr, granteeAddr, &types.BasicFeeAllowance{
+		SpendLimit: sdk.NewCoins(sdk.NewCoin("foo", sdk.NewInt(100))),
+	})
+
+	require.NoError(t, err)
+
+	grantBz, err := cdc.MarshalBinaryBare(&grant)
+	require.NoError(t, err)
+
+	kvPairs := kv.Pairs{
+		Pairs: []kv.Pair{
+			{Key: []byte(types.FeeAllowanceKeyPrefix), Value: grantBz},
+			{Key: []byte{0x99}, Value: []byte{0x99}},
+		},
+	}
+
+	tests := []struct {
+		name        string
+		expectedLog string
+	}{
+		{"Grant", fmt.Sprintf("%v\n%v", grant, grant)},
+		{"other", ""},
+	}
+
+	for i, tt := range tests {
+		i, tt := i, tt
+		t.Run(tt.name, func(t *testing.T) {
+			switch i {
+			case len(tests) - 1:
+				require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
+			default:
+				require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
+			}
+		})
+	}
+}
diff --git a/x/feegrant/simulation/genesis.go b/x/feegrant/simulation/genesis.go
new file mode 100644
index 000000000000..f9f4c7e12748
--- /dev/null
+++ b/x/feegrant/simulation/genesis.go
@@ -0,0 +1,38 @@
+package simulation
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/rand"
+
+	"github.com/cosmos/cosmos-sdk/types/module"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+// Simulation parameter constants
+const feegrant = "feegrant"
+
+// GenFeeGrants returns an empty slice of evidences.
+func GenFeeGrants(_ *rand.Rand, _ []simtypes.Account) []types.FeeAllowanceGrant {
+	return []types.FeeAllowanceGrant{}
+}
+
+// RandomizedGenState generates a random GenesisState for feegrant
+func RandomizedGenState(simState *module.SimulationState) {
+	var feegrants []types.FeeAllowanceGrant
+
+	simState.AppParams.GetOrGenerate(
+		simState.Cdc, feegrant, &feegrants, simState.Rand,
+		func(r *rand.Rand) { feegrants = GenFeeGrants(r, simState.Accounts) },
+	)
+	feegrantGenesis := types.NewGenesisState(feegrants)
+
+	bz, err := json.MarshalIndent(&feegrantGenesis, "", " ")
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Selected randomly generated %s parameters:\n%s\n", types.ModuleName, bz)
+	simState.GenState[types.ModuleName] = simState.Cdc.MustMarshalJSON(feegrantGenesis)
+}
diff --git a/x/feegrant/simulation/genesis_test.go b/x/feegrant/simulation/genesis_test.go
new file mode 100644
index 000000000000..4f3ae74b56be
--- /dev/null
+++ b/x/feegrant/simulation/genesis_test.go
@@ -0,0 +1,39 @@
+package simulation_test
+
+import (
+	"encoding/json"
+	"math/rand"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRandomizedGenState(t *testing.T) {
+	interfaceRegistry := codectypes.NewInterfaceRegistry()
+	cdc := codec.NewProtoCodec(interfaceRegistry)
+
+	s := rand.NewSource(1)
+	r := rand.New(s)
+
+	simState := module.SimulationState{
+		AppParams:    make(simtypes.AppParams),
+		Cdc:          cdc,
+		Rand:         r,
+		NumBonded:    3,
+		Accounts:     simtypes.RandomAccounts(r, 3),
+		InitialStake: 1000,
+		GenState:     make(map[string]json.RawMessage),
+	}
+
+	simulation.RandomizedGenState(&simState)
+	var feegrantGenesis types.GenesisState
+	simState.Cdc.MustUnmarshalJSON(simState.GenState[types.ModuleName], &feegrantGenesis)
+
+	require.Len(t, feegrantGenesis.FeeAllowances, 0)
+}
diff --git a/x/feegrant/simulation/operations.go b/x/feegrant/simulation/operations.go
new file mode 100644
index 000000000000..54821873b6b6
--- /dev/null
+++ b/x/feegrant/simulation/operations.go
@@ -0,0 +1,200 @@
+package simulation
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/simapp/helpers"
+	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/msgservice"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/keeper"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
+)
+
+// Simulation operation weights constants
+const (
+	OpWeightMsgGrantFeeAllowance  = "op_weight_msg_grant_fee_allowance"
+	OpWeightMsgRevokeFeeAllowance = "op_weight_msg_grant_revoke_allowance"
+	TypeMsgGrantFeeAllowance      = "/cosmos.feegrant.v1beta1.Msg/GrantFeeAllowance"
+	TypeMsgRevokeFeeAllowance     = "/cosmos.feegrant.v1beta1.Msg/RevokeFeeAllowance"
+)
+
+func WeightedOperations(
+	appParams simtypes.AppParams, cdc codec.JSONMarshaler,
+	ak types.AccountKeeper, bk types.BankKeeper, k keeper.Keeper,
+	protoCdc *codec.ProtoCodec,
+) simulation.WeightedOperations {
+
+	var (
+		weightMsgGrantFeeAllowance  int
+		weightMsgRevokeFeeAllowance int
+	)
+
+	appParams.GetOrGenerate(cdc, OpWeightMsgGrantFeeAllowance, &weightMsgGrantFeeAllowance, nil,
+		func(_ *rand.Rand) {
+			weightMsgGrantFeeAllowance = simappparams.DefaultWeightGrantFeeAllowance
+		},
+	)
+
+	appParams.GetOrGenerate(cdc, OpWeightMsgRevokeFeeAllowance, &weightMsgRevokeFeeAllowance, nil,
+		func(_ *rand.Rand) {
+			weightMsgRevokeFeeAllowance = simappparams.DefaultWeightRevokeFeeAllowance
+		},
+	)
+
+	return simulation.WeightedOperations{
+		simulation.NewWeightedOperation(
+			weightMsgGrantFeeAllowance,
+			SimulateMsgGrantFeeAllowance(ak, bk, k, protoCdc),
+		),
+		simulation.NewWeightedOperation(
+			weightMsgRevokeFeeAllowance,
+			SimulateMsgRevokeFeeAllowance(ak, bk, k, protoCdc),
+		),
+	}
+}
+
+// SimulateMsgGrantFeeAllowance generates MsgGrantFeeAllowance with random values.
+func SimulateMsgGrantFeeAllowance(ak types.AccountKeeper, bk types.BankKeeper, k keeper.Keeper, protoCdc *codec.ProtoCodec) simtypes.Operation {
+	return func(
+		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
+	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+		granter, _ := simtypes.RandomAcc(r, accs)
+		grantee, _ := simtypes.RandomAcc(r, accs)
+		if grantee.Address.String() == granter.Address.String() {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, "grantee and granter cannot be same"), nil, nil
+		}
+
+		f := k.GetFeeAllowance(ctx, granter.Address, grantee.Address)
+		if f != nil {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, "fee allowance exists"), nil, nil
+		}
+
+		account := ak.GetAccount(ctx, granter.Address)
+
+		spendableCoins := bk.SpendableCoins(ctx, account.GetAddress())
+		fees, err := simtypes.RandomFees(r, ctx, spendableCoins)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, err.Error()), nil, err
+		}
+
+		spendableCoins = spendableCoins.Sub(fees)
+		if spendableCoins.Empty() {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, "unable to grant empty coins as SpendLimit"), nil, nil
+		}
+
+		msg, err := types.NewMsgGrantFeeAllowance(&types.BasicFeeAllowance{
+			SpendLimit: spendableCoins,
+			Expiration: types.ExpiresAtTime(ctx.BlockTime().Add(30 * time.Hour)),
+		}, granter.Address, grantee.Address)
+
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, err.Error()), nil, err
+		}
+		txGen := simappparams.MakeTestEncodingConfig().TxConfig
+		svcMsgClientConn := &msgservice.ServiceMsgClientConn{}
+		feegrantMsgClient := types.NewMsgClient(svcMsgClientConn)
+		_, err = feegrantMsgClient.GrantFeeAllowance(context.Background(), msg)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, err.Error()), nil, err
+		}
+		tx, err := helpers.GenTx(
+			txGen,
+			svcMsgClientConn.GetMsgs(),
+			fees,
+			helpers.DefaultGenTxGas,
+			chainID,
+			[]uint64{account.GetAccountNumber()},
+			[]uint64{account.GetSequence()},
+			granter.PrivKey,
+		)
+
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, TypeMsgGrantFeeAllowance, "unable to generate mock tx"), nil, err
+		}
+
+		_, _, err = app.Deliver(txGen.TxEncoder(), tx)
+
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, svcMsgClientConn.GetMsgs()[0].Type(), "unable to deliver tx"), nil, err
+		}
+		return simtypes.NewOperationMsg(svcMsgClientConn.GetMsgs()[0], true, "", protoCdc), nil, err
+	}
+}
+
+// SimulateMsgRevokeFeeAllowance generates a MsgRevokeFeeAllowance with random values.
+func SimulateMsgRevokeFeeAllowance(ak types.AccountKeeper, bk types.BankKeeper, k keeper.Keeper, protoCdc *codec.ProtoCodec) simtypes.Operation {
+	return func(
+		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
+	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+
+		hasGrant := false
+		var granterAddr sdk.AccAddress
+		var granteeAddr sdk.AccAddress
+		k.IterateAllFeeAllowances(ctx, func(grant types.FeeAllowanceGrant) bool {
+
+			granter, err := sdk.AccAddressFromBech32(grant.Granter)
+			if err != nil {
+				panic(err)
+			}
+			grantee, err := sdk.AccAddressFromBech32(grant.Grantee)
+			if err != nil {
+				panic(err)
+			}
+			granterAddr = granter
+			granteeAddr = grantee
+			hasGrant = true
+			return true
+		})
+
+		if !hasGrant {
+			return simtypes.NoOpMsg(types.ModuleName, TypeMsgRevokeFeeAllowance, "no grants"), nil, nil
+		}
+		granter, ok := simtypes.FindAccount(accs, granterAddr)
+
+		if !ok {
+			return simtypes.NoOpMsg(types.ModuleName, TypeMsgRevokeFeeAllowance, "Account not found"), nil, nil
+		}
+
+		account := ak.GetAccount(ctx, granter.Address)
+		spendableCoins := bk.SpendableCoins(ctx, account.GetAddress())
+		fees, err := simtypes.RandomFees(r, ctx, spendableCoins)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, TypeMsgRevokeFeeAllowance, err.Error()), nil, err
+		}
+
+		msg := types.NewMsgRevokeFeeAllowance(granterAddr, granteeAddr)
+
+		txGen := simappparams.MakeTestEncodingConfig().TxConfig
+		svcMsgClientConn := &msgservice.ServiceMsgClientConn{}
+		feegrantMsgClient := types.NewMsgClient(svcMsgClientConn)
+		_, err = feegrantMsgClient.RevokeFeeAllowance(context.Background(), &msg)
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgGrantFeeAllowance, err.Error()), nil, err
+		}
+
+		tx, err := helpers.GenTx(
+			txGen,
+			svcMsgClientConn.GetMsgs(),
+			fees,
+			helpers.DefaultGenTxGas,
+			chainID,
+			[]uint64{account.GetAccountNumber()},
+			[]uint64{account.GetSequence()},
+			granter.PrivKey,
+		)
+
+		if err != nil {
+			return simtypes.NoOpMsg(types.ModuleName, TypeMsgRevokeFeeAllowance, err.Error()), nil, err
+		}
+
+		_, _, err = app.Deliver(txGen.TxEncoder(), tx)
+		return simtypes.NewOperationMsg(svcMsgClientConn.GetMsgs()[0], true, "", protoCdc), nil, err
+	}
+}
diff --git a/x/feegrant/simulation/operations_test.go b/x/feegrant/simulation/operations_test.go
new file mode 100644
index 000000000000..d72e0c2e01e0
--- /dev/null
+++ b/x/feegrant/simulation/operations_test.go
@@ -0,0 +1,173 @@
+package simulation_test
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/simulation"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+)
+
+type SimTestSuite struct {
+	suite.Suite
+
+	ctx      sdk.Context
+	app      *simapp.SimApp
+	protoCdc *codec.ProtoCodec
+}
+
+func (suite *SimTestSuite) SetupTest() {
+	checkTx := false
+	app := simapp.Setup(checkTx)
+	suite.app = app
+	suite.ctx = app.BaseApp.NewContext(checkTx, tmproto.Header{})
+	suite.protoCdc = codec.NewProtoCodec(suite.app.InterfaceRegistry())
+
+}
+
+func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
+	app, ctx := suite.app, suite.ctx
+	accounts := simtypes.RandomAccounts(r, n)
+	require := suite.Require()
+
+	initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
+	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
+
+	// add coins to the accounts
+	for _, account := range accounts {
+		acc := app.AccountKeeper.NewAccountWithAddress(ctx, account.Address)
+		app.AccountKeeper.SetAccount(ctx, acc)
+		err := app.BankKeeper.SetBalances(ctx, account.Address, initCoins)
+		require.NoError(err)
+	}
+
+	return accounts
+}
+
+func (suite *SimTestSuite) TestWeightedOperations() {
+	app, ctx := suite.app, suite.ctx
+	require := suite.Require()
+
+	ctx.WithChainID("test-chain")
+
+	cdc := app.AppCodec()
+	appParams := make(simtypes.AppParams)
+
+	weightesOps := simulation.WeightedOperations(
+		appParams, cdc, app.AccountKeeper,
+		app.BankKeeper, app.FeeGrantKeeper,
+		suite.protoCdc,
+	)
+
+	s := rand.NewSource(1)
+	r := rand.New(s)
+	accs := suite.getTestingAccounts(r, 3)
+
+	expected := []struct {
+		weight     int
+		opMsgRoute string
+		opMsgName  string
+	}{
+		{
+			simappparams.DefaultWeightGrantFeeAllowance,
+			types.ModuleName,
+			simulation.TypeMsgGrantFeeAllowance,
+		},
+		{
+			simappparams.DefaultWeightRevokeFeeAllowance,
+			types.ModuleName,
+			simulation.TypeMsgRevokeFeeAllowance,
+		},
+	}
+
+	for i, w := range weightesOps {
+		operationMsg, _, _ := w.Op()(r, app.BaseApp, ctx, accs, ctx.ChainID())
+		// the following checks are very much dependent from the ordering of the output given
+		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
+		// will fail
+		require.Equal(expected[i].weight, w.Weight(), "weight should be the same")
+		require.Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
+		require.Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
+	}
+}
+
+func (suite *SimTestSuite) TestSimulateMsgGrantFeeAllowance() {
+	app, ctx := suite.app, suite.ctx
+	require := suite.Require()
+
+	s := rand.NewSource(1)
+	r := rand.New(s)
+	accounts := suite.getTestingAccounts(r, 3)
+
+	// begin a new block
+	app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: app.LastBlockHeight() + 1, AppHash: app.LastCommitID().Hash}})
+
+	// execute operation
+	op := simulation.SimulateMsgGrantFeeAllowance(app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, suite.protoCdc)
+	operationMsg, futureOperations, err := op(r, app.BaseApp, ctx, accounts, "")
+	require.NoError(err)
+
+	var msg types.MsgGrantFeeAllowance
+	suite.app.AppCodec().UnmarshalJSON(operationMsg.Msg, &msg)
+
+	require.True(operationMsg.OK)
+	require.Equal("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Granter)
+	require.Equal("cosmos1p8wcgrjr4pjju90xg6u9cgq55dxwq8j7u4x9a0", msg.Grantee)
+	require.Len(futureOperations, 0)
+}
+
+func (suite *SimTestSuite) TestSimulateMsgRevokeFeeAllowance() {
+	app, ctx := suite.app, suite.ctx
+	require := suite.Require()
+
+	s := rand.NewSource(1)
+	r := rand.New(s)
+	accounts := suite.getTestingAccounts(r, 3)
+
+	// begin a new block
+	app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: suite.app.LastBlockHeight() + 1, AppHash: suite.app.LastCommitID().Hash}})
+
+	feeAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200000)
+	feeCoins := sdk.NewCoins(sdk.NewCoin("foo", feeAmt))
+
+	granter, grantee := accounts[0], accounts[1]
+
+	err := app.FeeGrantKeeper.GrantFeeAllowance(
+		ctx,
+		granter.Address,
+		grantee.Address,
+		&types.BasicFeeAllowance{
+			SpendLimit: feeCoins,
+			Expiration: types.ExpiresAtTime(ctx.BlockTime().Add(30 * time.Hour)),
+		},
+	)
+	require.NoError(err)
+
+	// execute operation
+	op := simulation.SimulateMsgRevokeFeeAllowance(app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, suite.protoCdc)
+	operationMsg, futureOperations, err := op(r, app.BaseApp, ctx, accounts, "")
+	require.NoError(err)
+
+	var msg types.MsgRevokeFeeAllowance
+	suite.app.AppCodec().UnmarshalJSON(operationMsg.Msg, &msg)
+
+	require.True(operationMsg.OK)
+	require.Equal(granter.Address.String(), msg.Granter)
+	require.Equal(grantee.Address.String(), msg.Grantee)
+	require.Len(futureOperations, 0)
+}
+
+func TestSimTestSuite(t *testing.T) {
+	suite.Run(t, new(SimTestSuite))
+}
diff --git a/x/feegrant/types/basic_fee.go b/x/feegrant/types/basic_fee.go
new file mode 100644
index 000000000000..6d970680510f
--- /dev/null
+++ b/x/feegrant/types/basic_fee.go
@@ -0,0 +1,61 @@
+package types
+
+import (
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var _ FeeAllowanceI = (*BasicFeeAllowance)(nil)
+
+// Accept can use fee payment requested as well as timestamp/height of the current block
+// to determine whether or not to process this. This is checked in
+// Keeper.UseGrantedFees and the return values should match how it is handled there.
+//
+// If it returns an error, the fee payment is rejected, otherwise it is accepted.
+// The FeeAllowance implementation is expected to update it's internal state
+// and will be saved again after an acceptance.
+//
+// If remove is true (regardless of the error), the FeeAllowance will be deleted from storage
+// (eg. when it is used up). (See call to RevokeFeeAllowance in Keeper.UseGrantedFees)
+func (a *BasicFeeAllowance) Accept(fee sdk.Coins, blockTime time.Time, blockHeight int64) (bool, error) {
+	if a.Expiration.IsExpired(&blockTime, blockHeight) {
+		return true, sdkerrors.Wrap(ErrFeeLimitExpired, "basic allowance")
+	}
+
+	if a.SpendLimit != nil {
+		left, invalid := a.SpendLimit.SafeSub(fee)
+		if invalid {
+			return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "basic allowance")
+		}
+
+		a.SpendLimit = left
+		return left.IsZero(), nil
+	}
+
+	return false, nil
+}
+
+// PrepareForExport will adjust the expiration based on export time. In particular,
+// it will subtract the dumpHeight from any height-based expiration to ensure that
+// the elapsed number of blocks this allowance is valid for is fixed.
+func (a *BasicFeeAllowance) PrepareForExport(dumpTime time.Time, dumpHeight int64) FeeAllowanceI {
+	return &BasicFeeAllowance{
+		SpendLimit: a.SpendLimit,
+		Expiration: a.Expiration.PrepareForExport(dumpTime, dumpHeight),
+	}
+}
+
+// ValidateBasic implements FeeAllowance and enforces basic sanity checks
+func (a BasicFeeAllowance) ValidateBasic() error {
+	if a.SpendLimit != nil {
+		if !a.SpendLimit.IsValid() {
+			return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "send amount is invalid: %s", a.SpendLimit)
+		}
+		if !a.SpendLimit.IsAllPositive() {
+			return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive")
+		}
+	}
+	return a.Expiration.ValidateBasic()
+}
diff --git a/x/feegrant/types/basic_fee_test.go b/x/feegrant/types/basic_fee_test.go
new file mode 100644
index 000000000000..a5669e99ada4
--- /dev/null
+++ b/x/feegrant/types/basic_fee_test.go
@@ -0,0 +1,140 @@
+package types_test
+
+import (
+	"testing"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBasicFeeValidAllow(t *testing.T) {
+	eth := sdk.NewCoins(sdk.NewInt64Coin("eth", 10))
+	atom := sdk.NewCoins(sdk.NewInt64Coin("atom", 555))
+	smallAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 43))
+	bigAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 1000))
+	leftAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 512))
+
+	cases := map[string]struct {
+		allow *types.BasicFeeAllowance
+		// all other checks are ignored if valid=false
+		fee         sdk.Coins
+		blockTime   time.Time
+		blockHeight int64
+		valid       bool
+		accept      bool
+		remove      bool
+		remains     sdk.Coins
+	}{
+		"empty": {
+			allow:  &types.BasicFeeAllowance{},
+			valid:  true,
+			accept: true,
+		},
+		"small fee without expire": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: atom,
+			},
+			valid:   true,
+			fee:     smallAtom,
+			accept:  true,
+			remove:  false,
+			remains: leftAtom,
+		},
+		"all fee without expire": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: smallAtom,
+			},
+			valid:  true,
+			fee:    smallAtom,
+			accept: true,
+			remove: true,
+		},
+		"wrong fee": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: smallAtom,
+			},
+			valid:  true,
+			fee:    eth,
+			accept: false,
+		},
+		"non-expired": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: atom,
+				Expiration: types.ExpiresAtHeight(100),
+			},
+			valid:       true,
+			fee:         smallAtom,
+			blockHeight: 85,
+			accept:      true,
+			remove:      false,
+			remains:     leftAtom,
+		},
+		"expired": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: atom,
+				Expiration: types.ExpiresAtHeight(100),
+			},
+			valid:       true,
+			fee:         smallAtom,
+			blockHeight: 121,
+			accept:      false,
+			remove:      true,
+		},
+		"fee more than allowed": {
+			allow: &types.BasicFeeAllowance{
+				SpendLimit: atom,
+				Expiration: types.ExpiresAtHeight(100),
+			},
+			valid:       true,
+			fee:         bigAtom,
+			blockHeight: 85,
+			accept:      false,
+		},
+		"with out spend limit": {
+			allow: &types.BasicFeeAllowance{
+				Expiration: types.ExpiresAtHeight(100),
+			},
+			valid:       true,
+			fee:         bigAtom,
+			blockHeight: 85,
+			accept:      true,
+		},
+		"expired no spend limit": {
+			allow: &types.BasicFeeAllowance{
+				Expiration: types.ExpiresAtHeight(100),
+			},
+			valid:       true,
+			fee:         bigAtom,
+			blockHeight: 120,
+			accept:      false,
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		t.Run(name, func(t *testing.T) {
+			err := tc.allow.ValidateBasic()
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// now try to deduct
+			remove, err := tc.allow.Accept(tc.fee, tc.blockTime, tc.blockHeight)
+			if !tc.accept {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			require.Equal(t, tc.remove, remove)
+			if !remove {
+				assert.Equal(t, tc.allow.SpendLimit, tc.remains)
+			}
+		})
+	}
+}
diff --git a/x/feegrant/types/codec.go b/x/feegrant/types/codec.go
new file mode 100644
index 000000000000..686187cd7510
--- /dev/null
+++ b/x/feegrant/types/codec.go
@@ -0,0 +1,24 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/msgservice"
+)
+
+// RegisterInterfaces registers the interfaces types with the interface registry
+func RegisterInterfaces(registry types.InterfaceRegistry) {
+	registry.RegisterImplementations((*sdk.MsgRequest)(nil),
+		&MsgGrantFeeAllowance{},
+		&MsgRevokeFeeAllowance{},
+	)
+
+	registry.RegisterInterface(
+		"cosmos.feegrant.v1beta1.FeeAllowanceI",
+		(*FeeAllowanceI)(nil),
+		&BasicFeeAllowance{},
+		&PeriodicFeeAllowance{},
+	)
+
+	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
diff --git a/x/feegrant/types/errors.go b/x/feegrant/types/errors.go
new file mode 100644
index 000000000000..183f681ca5dc
--- /dev/null
+++ b/x/feegrant/types/errors.go
@@ -0,0 +1,21 @@
+package types
+
+import (
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// Codes for governance errors
+const (
+	DefaultCodespace = ModuleName
+)
+
+var (
+	// ErrFeeLimitExceeded error if there are not enough allowance to cover the fees
+	ErrFeeLimitExceeded = sdkerrors.Register(DefaultCodespace, 2, "fee limit exceeded")
+	// ErrFeeLimitExpired error if the allowance has expired
+	ErrFeeLimitExpired = sdkerrors.Register(DefaultCodespace, 3, "fee allowance expired")
+	// ErrInvalidDuration error if the Duration is invalid or doesn't match the expiration
+	ErrInvalidDuration = sdkerrors.Register(DefaultCodespace, 4, "invalid duration")
+	// ErrNoAllowance error if there is no allowance for that pair
+	ErrNoAllowance = sdkerrors.Register(DefaultCodespace, 5, "no allowance")
+)
diff --git a/x/feegrant/types/events.go b/x/feegrant/types/events.go
new file mode 100644
index 000000000000..b82ccb7b1cd8
--- /dev/null
+++ b/x/feegrant/types/events.go
@@ -0,0 +1,13 @@
+package types
+
+// evidence module events
+const (
+	EventTypeUseFeeGrant    = "use_feegrant"
+	EventTypeRevokeFeeGrant = "revoke_feegrant"
+	EventTypeSetFeeGrant    = "set_feegrant"
+
+	AttributeKeyGranter = "granter"
+	AttributeKeyGrantee = "grantee"
+
+	AttributeValueCategory = ModuleName
+)
diff --git a/x/feegrant/types/expected_keepers.go b/x/feegrant/types/expected_keepers.go
new file mode 100644
index 000000000000..40966b06d47f
--- /dev/null
+++ b/x/feegrant/types/expected_keepers.go
@@ -0,0 +1,23 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	auth "github.com/cosmos/cosmos-sdk/x/auth/types"
+	// supply "github.com/cosmos/cosmos-sdk/x/supply/exported"
+)
+
+// AccountKeeper defines the expected auth Account Keeper (noalias)
+type AccountKeeper interface {
+	GetModuleAddress(moduleName string) sdk.AccAddress
+	GetModuleAccount(ctx sdk.Context, moduleName string) auth.ModuleAccountI
+
+	NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) auth.AccountI
+	GetAccount(ctx sdk.Context, addr sdk.AccAddress) auth.AccountI
+	SetAccount(ctx sdk.Context, acc auth.AccountI)
+}
+
+// BankKeeper defines the expected supply Keeper (noalias)
+type BankKeeper interface {
+	SpendableCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
+	SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+}
diff --git a/x/feegrant/types/expiration.go b/x/feegrant/types/expiration.go
new file mode 100644
index 000000000000..4922b6d481d0
--- /dev/null
+++ b/x/feegrant/types/expiration.go
@@ -0,0 +1,138 @@
+package types
+
+import (
+	"time"
+
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// ExpiresAtTime creates an expiration at the given time
+func ExpiresAtTime(t time.Time) ExpiresAt {
+	return ExpiresAt{
+		Sum: &ExpiresAt_Time{
+			Time: &t,
+		},
+	}
+}
+
+// ExpiresAtHeight creates an expiration at the given height
+func ExpiresAtHeight(h int64) ExpiresAt {
+	return ExpiresAt{
+		&ExpiresAt_Height{
+			Height: h,
+		},
+	}
+}
+
+// ValidateBasic performs basic sanity checks.
+// Note that empty expiration is allowed
+func (e ExpiresAt) ValidateBasic() error {
+	if e.HasDefinedTime() && e.GetHeight() != 0 {
+		return sdkerrors.Wrap(ErrInvalidDuration, "both time and height are set")
+	}
+	if e.GetHeight() < 0 {
+		return sdkerrors.Wrap(ErrInvalidDuration, "negative height")
+	}
+	return nil
+}
+
+// Undefined returns true for an uninitialized struct
+func (e ExpiresAt) Undefined() bool {
+	return (e.GetTime() == nil || e.GetTime().Unix() <= 0) && e.GetHeight() == 0
+}
+
+// HasDefinedTime returns true if `ExpiresAt` has valid time
+func (e ExpiresAt) HasDefinedTime() bool {
+	t := e.GetTime()
+	return t != nil && t.Unix() > 0
+}
+
+// FastForward produces a new Expiration with the time or height set to the
+// new value, depending on what was set on the original expiration
+func (e ExpiresAt) FastForward(t time.Time, h int64) ExpiresAt {
+	if e.HasDefinedTime() {
+		return ExpiresAtTime(t)
+	}
+	return ExpiresAtHeight(h)
+}
+
+// IsExpired returns if the time or height is *equal to* or greater
+// than the defined expiration point. Note that it is expired upon
+// an exact match.
+//
+// Note a "zero" ExpiresAt is never expired
+func (e ExpiresAt) IsExpired(t *time.Time, h int64) bool {
+	if e.HasDefinedTime() && t.After(*e.GetTime()) {
+		return true
+	}
+
+	return e.GetHeight() != 0 && h >= e.GetHeight()
+}
+
+// IsCompatible returns true iff the two use the same units.
+// If false, they cannot be added.
+func (e ExpiresAt) IsCompatible(d Duration) bool {
+	if e.HasDefinedTime() {
+		return d.GetDuration() != nil && d.GetDuration().Seconds() > float64(0)
+	}
+	return d.GetBlocks() > 0
+}
+
+// Step will increase the expiration point by one Duration
+// It returns an error if the Duration is incompatible
+func (e ExpiresAt) Step(d Duration) (ExpiresAt, error) {
+	if !e.IsCompatible(d) {
+		return ExpiresAt{}, sdkerrors.Wrap(ErrInvalidDuration, "expiration time and provided duration have different units")
+	}
+	if e.HasDefinedTime() {
+		return ExpiresAtTime(e.GetTime().Add(*d.GetDuration())), nil
+	}
+	return ExpiresAtHeight(e.GetHeight() + int64(d.GetBlocks())), nil
+}
+
+// MustStep is like Step, but panics on error
+func (e ExpiresAt) MustStep(d Duration) ExpiresAt {
+	res, err := e.Step(d)
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+// PrepareForExport will deduct the dumpHeight from the expiration, so when this is
+// reloaded after a hard fork, the actual number of allowed blocks is constant
+func (e ExpiresAt) PrepareForExport(dumpTime time.Time, dumpHeight int64) ExpiresAt {
+	if e.GetHeight() != 0 {
+		return ExpiresAtHeight(e.GetHeight() - dumpHeight)
+	}
+	return ExpiresAt{}
+}
+
+// ClockDuration creates an Duration by clock time
+func ClockDuration(d time.Duration) Duration {
+	return Duration{Sum: &Duration_Duration{
+		Duration: &d,
+	}}
+}
+
+// BlockDuration creates an Duration by block height
+func BlockDuration(h uint64) Duration {
+	return Duration{Sum: &Duration_Blocks{
+		Blocks: h,
+	}}
+}
+
+// ValidateBasic performs basic sanity checks
+// Note that exactly one must be set and it must be positive
+func (d Duration) ValidateBasic() error {
+	if d.GetBlocks() == 0 && d.GetDuration() == nil {
+		return sdkerrors.Wrap(ErrInvalidDuration, "neither time and height are set")
+	}
+	if d.GetBlocks() != 0 && d.GetDuration() != nil && d.GetDuration().Seconds() != float64(0) {
+		return sdkerrors.Wrap(ErrInvalidDuration, "both time and height are set")
+	}
+	if d.GetDuration() != nil && d.GetDuration().Seconds() < 0 {
+		return sdkerrors.Wrap(ErrInvalidDuration, "negative clock step")
+	}
+	return nil
+}
diff --git a/x/feegrant/types/expiration_test.go b/x/feegrant/types/expiration_test.go
new file mode 100644
index 000000000000..60b1753bcbc1
--- /dev/null
+++ b/x/feegrant/types/expiration_test.go
@@ -0,0 +1,161 @@
+package types_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExpiresAt(t *testing.T) {
+	now := time.Now()
+
+	cases := map[string]struct {
+		example types.ExpiresAt
+		valid   bool
+		zero    bool
+		before  types.ExpiresAt
+		after   types.ExpiresAt
+	}{
+		"basic": {
+			example: types.ExpiresAtHeight(100),
+			valid:   true,
+			before:  types.ExpiresAtHeight(50),
+			after:   types.ExpiresAtHeight(122),
+		},
+		"zero": {
+			example: types.ExpiresAt{},
+			zero:    true,
+			valid:   true,
+			before:  types.ExpiresAtHeight(1),
+		},
+		"match height": {
+			example: types.ExpiresAtHeight(1000),
+			valid:   true,
+			before:  types.ExpiresAtHeight(999),
+			after:   types.ExpiresAtHeight(1000),
+		},
+		"match time": {
+			example: types.ExpiresAtTime(now),
+			valid:   true,
+			before:  types.ExpiresAtTime(now.Add(-1 * time.Second)),
+			after:   types.ExpiresAtTime(now.Add(1 * time.Second)),
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		t.Run(name, func(t *testing.T) {
+			err := tc.example.ValidateBasic()
+			assert.Equal(t, tc.zero, tc.example.Undefined())
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			if !tc.before.Undefined() {
+				assert.Equal(t, false, tc.example.IsExpired(tc.before.GetTime(), tc.before.GetHeight()))
+			}
+			if !tc.after.Undefined() {
+				assert.Equal(t, true, tc.example.IsExpired(tc.after.GetTime(), tc.after.GetHeight()))
+			}
+		})
+	}
+}
+
+func TestDurationValid(t *testing.T) {
+	now := time.Now()
+
+	cases := map[string]struct {
+		period       types.Duration
+		valid        bool
+		compatible   types.ExpiresAt
+		incompatible types.ExpiresAt
+	}{
+		"basic height": {
+			period:       types.BlockDuration(100),
+			valid:        true,
+			compatible:   types.ExpiresAtHeight(50),
+			incompatible: types.ExpiresAtTime(now),
+		},
+		"basic time": {
+			period:       types.ClockDuration(time.Hour),
+			valid:        true,
+			compatible:   types.ExpiresAtTime(now),
+			incompatible: types.ExpiresAtHeight(50),
+		},
+		"zero": {
+			period: types.Duration{},
+			valid:  false,
+		},
+		"negative clock": {
+			period: types.ClockDuration(-1 * time.Hour),
+			valid:  false,
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		t.Run(name, func(t *testing.T) {
+			err := tc.period.ValidateBasic()
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			assert.Equal(t, true, tc.compatible.IsCompatible(tc.period))
+			assert.Equal(t, false, tc.incompatible.IsCompatible(tc.period))
+		})
+	}
+}
+
+func TestDurationStep(t *testing.T) {
+	now := time.Now()
+
+	cases := map[string]struct {
+		expires types.ExpiresAt
+		period  types.Duration
+		valid   bool
+		result  types.ExpiresAt
+	}{
+		"add height": {
+			expires: types.ExpiresAtHeight(789),
+			period:  types.BlockDuration(100),
+			valid:   true,
+			result:  types.ExpiresAtHeight(889),
+		},
+		"add time": {
+			expires: types.ExpiresAtTime(now),
+			period:  types.ClockDuration(time.Hour),
+			valid:   true,
+			result:  types.ExpiresAtTime(now.Add(time.Hour)),
+		},
+		"mismatch": {
+			expires: types.ExpiresAtHeight(789),
+			period:  types.ClockDuration(time.Hour),
+			valid:   false,
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		t.Run(name, func(t *testing.T) {
+			err := tc.period.ValidateBasic()
+			require.NoError(t, err)
+			err = tc.expires.ValidateBasic()
+			require.NoError(t, err)
+
+			next, err := tc.expires.Step(tc.period)
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tc.result, next)
+		})
+	}
+}
diff --git a/x/feegrant/types/feegrant.pb.go b/x/feegrant/types/feegrant.pb.go
new file mode 100644
index 000000000000..2897bcc392d6
--- /dev/null
+++ b/x/feegrant/types/feegrant.pb.go
@@ -0,0 +1,1701 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/feegrant/v1beta1/feegrant.proto
+
+package types
+
+import (
+	fmt "fmt"
+	types1 "github.com/cosmos/cosmos-sdk/codec/types"
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	types "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	_ "github.com/golang/protobuf/ptypes/duration"
+	_ "github.com/golang/protobuf/ptypes/timestamp"
+	_ "github.com/regen-network/cosmos-proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+	time "time"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+var _ = time.Kitchen
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// BasicFeeAllowance implements FeeAllowance with a one-time grant of tokens
+// that optionally expires. The delegatee can use up to SpendLimit to cover fees.
+type BasicFeeAllowance struct {
+	// spend_limit specifies the maximum amount of tokens that can be spent
+	// by this allowance and will be updated as tokens are spent. If it is
+	// empty, there is no spend limit and any amount of coins can be spent.
+	SpendLimit github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=spend_limit,json=spendLimit,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"spend_limit"`
+	// expiration specifies an optional time when this allowance expires
+	Expiration ExpiresAt `protobuf:"bytes,2,opt,name=expiration,proto3" json:"expiration"`
+}
+
+func (m *BasicFeeAllowance) Reset()         { *m = BasicFeeAllowance{} }
+func (m *BasicFeeAllowance) String() string { return proto.CompactTextString(m) }
+func (*BasicFeeAllowance) ProtoMessage()    {}
+func (*BasicFeeAllowance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7279582900c30aea, []int{0}
+}
+func (m *BasicFeeAllowance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BasicFeeAllowance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BasicFeeAllowance.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BasicFeeAllowance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BasicFeeAllowance.Merge(m, src)
+}
+func (m *BasicFeeAllowance) XXX_Size() int {
+	return m.Size()
+}
+func (m *BasicFeeAllowance) XXX_DiscardUnknown() {
+	xxx_messageInfo_BasicFeeAllowance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BasicFeeAllowance proto.InternalMessageInfo
+
+func (m *BasicFeeAllowance) GetSpendLimit() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.SpendLimit
+	}
+	return nil
+}
+
+func (m *BasicFeeAllowance) GetExpiration() ExpiresAt {
+	if m != nil {
+		return m.Expiration
+	}
+	return ExpiresAt{}
+}
+
+// PeriodicFeeAllowance extends FeeAllowance to allow for both a maximum cap,
+// as well as a limit per time period.
+type PeriodicFeeAllowance struct {
+	// basic specifies a struct of `BasicFeeAllowance`
+	Basic BasicFeeAllowance `protobuf:"bytes,1,opt,name=basic,proto3" json:"basic"`
+	// period specifies the time duration in which period_spend_limit coins can
+	// be spent before that allowance is reset
+	Period Duration `protobuf:"bytes,2,opt,name=period,proto3" json:"period"`
+	// period_spend_limit specifies the maximum number of coins that can be spent
+	// in the period
+	PeriodSpendLimit github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=period_spend_limit,json=periodSpendLimit,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"period_spend_limit"`
+	// period_can_spend is the number of coins left to be spent before the period_reset time
+	PeriodCanSpend github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,4,rep,name=period_can_spend,json=periodCanSpend,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"period_can_spend"`
+	// period_reset is the time at which this period resets and a new one begins,
+	// it is calculated from the start time of the first transaction after the
+	// last period ended
+	PeriodReset ExpiresAt `protobuf:"bytes,5,opt,name=period_reset,json=periodReset,proto3" json:"period_reset"`
+}
+
+func (m *PeriodicFeeAllowance) Reset()         { *m = PeriodicFeeAllowance{} }
+func (m *PeriodicFeeAllowance) String() string { return proto.CompactTextString(m) }
+func (*PeriodicFeeAllowance) ProtoMessage()    {}
+func (*PeriodicFeeAllowance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7279582900c30aea, []int{1}
+}
+func (m *PeriodicFeeAllowance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *PeriodicFeeAllowance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_PeriodicFeeAllowance.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *PeriodicFeeAllowance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PeriodicFeeAllowance.Merge(m, src)
+}
+func (m *PeriodicFeeAllowance) XXX_Size() int {
+	return m.Size()
+}
+func (m *PeriodicFeeAllowance) XXX_DiscardUnknown() {
+	xxx_messageInfo_PeriodicFeeAllowance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PeriodicFeeAllowance proto.InternalMessageInfo
+
+func (m *PeriodicFeeAllowance) GetBasic() BasicFeeAllowance {
+	if m != nil {
+		return m.Basic
+	}
+	return BasicFeeAllowance{}
+}
+
+func (m *PeriodicFeeAllowance) GetPeriod() Duration {
+	if m != nil {
+		return m.Period
+	}
+	return Duration{}
+}
+
+func (m *PeriodicFeeAllowance) GetPeriodSpendLimit() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.PeriodSpendLimit
+	}
+	return nil
+}
+
+func (m *PeriodicFeeAllowance) GetPeriodCanSpend() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.PeriodCanSpend
+	}
+	return nil
+}
+
+func (m *PeriodicFeeAllowance) GetPeriodReset() ExpiresAt {
+	if m != nil {
+		return m.PeriodReset
+	}
+	return ExpiresAt{}
+}
+
+// Duration is a span of a clock time or number of blocks.
+// This is designed to be added to an ExpiresAt struct.
+type Duration struct {
+	// sum is the oneof that represents either duration or block
+	//
+	// Types that are valid to be assigned to Sum:
+	//	*Duration_Duration
+	//	*Duration_Blocks
+	Sum isDuration_Sum `protobuf_oneof:"sum"`
+}
+
+func (m *Duration) Reset()         { *m = Duration{} }
+func (m *Duration) String() string { return proto.CompactTextString(m) }
+func (*Duration) ProtoMessage()    {}
+func (*Duration) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7279582900c30aea, []int{2}
+}
+func (m *Duration) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Duration) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Duration.Merge(m, src)
+}
+func (m *Duration) XXX_Size() int {
+	return m.Size()
+}
+func (m *Duration) XXX_DiscardUnknown() {
+	xxx_messageInfo_Duration.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Duration proto.InternalMessageInfo
+
+type isDuration_Sum interface {
+	isDuration_Sum()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type Duration_Duration struct {
+	Duration *time.Duration `protobuf:"bytes,1,opt,name=duration,proto3,oneof,stdduration" json:"duration,omitempty"`
+}
+type Duration_Blocks struct {
+	Blocks uint64 `protobuf:"varint,2,opt,name=blocks,proto3,oneof" json:"blocks,omitempty"`
+}
+
+func (*Duration_Duration) isDuration_Sum() {}
+func (*Duration_Blocks) isDuration_Sum()   {}
+
+func (m *Duration) GetSum() isDuration_Sum {
+	if m != nil {
+		return m.Sum
+	}
+	return nil
+}
+
+func (m *Duration) GetDuration() *time.Duration {
+	if x, ok := m.GetSum().(*Duration_Duration); ok {
+		return x.Duration
+	}
+	return nil
+}
+
+func (m *Duration) GetBlocks() uint64 {
+	if x, ok := m.GetSum().(*Duration_Blocks); ok {
+		return x.Blocks
+	}
+	return 0
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Duration) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*Duration_Duration)(nil),
+		(*Duration_Blocks)(nil),
+	}
+}
+
+// ExpiresAt is a point in time where something expires.
+// It may be *either* block time or block height
+type ExpiresAt struct {
+	// sum is the oneof that represents either time or height
+	//
+	// Types that are valid to be assigned to Sum:
+	//	*ExpiresAt_Time
+	//	*ExpiresAt_Height
+	Sum isExpiresAt_Sum `protobuf_oneof:"sum"`
+}
+
+func (m *ExpiresAt) Reset()         { *m = ExpiresAt{} }
+func (m *ExpiresAt) String() string { return proto.CompactTextString(m) }
+func (*ExpiresAt) ProtoMessage()    {}
+func (*ExpiresAt) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7279582900c30aea, []int{3}
+}
+func (m *ExpiresAt) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ExpiresAt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ExpiresAt.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ExpiresAt) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExpiresAt.Merge(m, src)
+}
+func (m *ExpiresAt) XXX_Size() int {
+	return m.Size()
+}
+func (m *ExpiresAt) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExpiresAt.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExpiresAt proto.InternalMessageInfo
+
+type isExpiresAt_Sum interface {
+	isExpiresAt_Sum()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type ExpiresAt_Time struct {
+	Time *time.Time `protobuf:"bytes,1,opt,name=time,proto3,oneof,stdtime" json:"time,omitempty"`
+}
+type ExpiresAt_Height struct {
+	Height int64 `protobuf:"varint,2,opt,name=height,proto3,oneof" json:"height,omitempty"`
+}
+
+func (*ExpiresAt_Time) isExpiresAt_Sum()   {}
+func (*ExpiresAt_Height) isExpiresAt_Sum() {}
+
+func (m *ExpiresAt) GetSum() isExpiresAt_Sum {
+	if m != nil {
+		return m.Sum
+	}
+	return nil
+}
+
+func (m *ExpiresAt) GetTime() *time.Time {
+	if x, ok := m.GetSum().(*ExpiresAt_Time); ok {
+		return x.Time
+	}
+	return nil
+}
+
+func (m *ExpiresAt) GetHeight() int64 {
+	if x, ok := m.GetSum().(*ExpiresAt_Height); ok {
+		return x.Height
+	}
+	return 0
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*ExpiresAt) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*ExpiresAt_Time)(nil),
+		(*ExpiresAt_Height)(nil),
+	}
+}
+
+// FeeAllowanceGrant is stored in the KVStore to record a grant with full context
+type FeeAllowanceGrant struct {
+	Granter   string      `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
+	Grantee   string      `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
+	Allowance *types1.Any `protobuf:"bytes,3,opt,name=allowance,proto3" json:"allowance,omitempty"`
+}
+
+func (m *FeeAllowanceGrant) Reset()         { *m = FeeAllowanceGrant{} }
+func (m *FeeAllowanceGrant) String() string { return proto.CompactTextString(m) }
+func (*FeeAllowanceGrant) ProtoMessage()    {}
+func (*FeeAllowanceGrant) Descriptor() ([]byte, []int) {
+	return fileDescriptor_7279582900c30aea, []int{4}
+}
+func (m *FeeAllowanceGrant) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FeeAllowanceGrant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FeeAllowanceGrant.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *FeeAllowanceGrant) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FeeAllowanceGrant.Merge(m, src)
+}
+func (m *FeeAllowanceGrant) XXX_Size() int {
+	return m.Size()
+}
+func (m *FeeAllowanceGrant) XXX_DiscardUnknown() {
+	xxx_messageInfo_FeeAllowanceGrant.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FeeAllowanceGrant proto.InternalMessageInfo
+
+func (m *FeeAllowanceGrant) GetGranter() string {
+	if m != nil {
+		return m.Granter
+	}
+	return ""
+}
+
+func (m *FeeAllowanceGrant) GetGrantee() string {
+	if m != nil {
+		return m.Grantee
+	}
+	return ""
+}
+
+func (m *FeeAllowanceGrant) GetAllowance() *types1.Any {
+	if m != nil {
+		return m.Allowance
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*BasicFeeAllowance)(nil), "cosmos.feegrant.v1beta1.BasicFeeAllowance")
+	proto.RegisterType((*PeriodicFeeAllowance)(nil), "cosmos.feegrant.v1beta1.PeriodicFeeAllowance")
+	proto.RegisterType((*Duration)(nil), "cosmos.feegrant.v1beta1.Duration")
+	proto.RegisterType((*ExpiresAt)(nil), "cosmos.feegrant.v1beta1.ExpiresAt")
+	proto.RegisterType((*FeeAllowanceGrant)(nil), "cosmos.feegrant.v1beta1.FeeAllowanceGrant")
+}
+
+func init() {
+	proto.RegisterFile("cosmos/feegrant/v1beta1/feegrant.proto", fileDescriptor_7279582900c30aea)
+}
+
+var fileDescriptor_7279582900c30aea = []byte{
+	// 599 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x4f, 0x6e, 0xd3, 0x40,
+	0x14, 0xc6, 0x6d, 0x9c, 0x96, 0x76, 0x02, 0x88, 0x8c, 0x22, 0xe1, 0x64, 0xe1, 0x94, 0x2c, 0x50,
+	0x84, 0x14, 0x9b, 0x16, 0x89, 0x05, 0x12, 0x42, 0x71, 0x69, 0x1b, 0x04, 0x0b, 0x64, 0x58, 0xb1,
+	0x89, 0x6c, 0x67, 0xea, 0x0c, 0xb5, 0x3d, 0x96, 0x67, 0x02, 0xcd, 0x25, 0x50, 0x97, 0x9c, 0x81,
+	0x35, 0x87, 0xa8, 0x58, 0x55, 0xac, 0x58, 0xb5, 0x28, 0x39, 0x01, 0x37, 0x40, 0xf3, 0xc7, 0x4e,
+	0x94, 0x10, 0x24, 0xa4, 0xae, 0xe2, 0x99, 0x79, 0xef, 0xfb, 0xbd, 0xf7, 0xbd, 0x99, 0x80, 0x07,
+	0x21, 0xa1, 0x09, 0xa1, 0xce, 0x31, 0x42, 0x51, 0xee, 0xa7, 0xcc, 0xf9, 0xb8, 0x1b, 0x20, 0xe6,
+	0xef, 0x96, 0x1b, 0x76, 0x96, 0x13, 0x46, 0xe0, 0x3d, 0x19, 0x67, 0x97, 0xdb, 0x2a, 0xae, 0x59,
+	0x8f, 0x48, 0x44, 0x44, 0x8c, 0xc3, 0xbf, 0x64, 0x78, 0xb3, 0x11, 0x11, 0x12, 0xc5, 0xc8, 0x11,
+	0xab, 0x60, 0x7c, 0xec, 0xf8, 0xe9, 0xa4, 0x38, 0x92, 0x4a, 0x03, 0x99, 0xa3, 0x64, 0xe5, 0x91,
+	0xa5, 0x8a, 0x09, 0x7c, 0x8a, 0xca, 0x42, 0x42, 0x82, 0x53, 0x75, 0xde, 0x5a, 0x56, 0x65, 0x38,
+	0x41, 0x94, 0xf9, 0x49, 0x56, 0x08, 0x2c, 0x07, 0x0c, 0xc7, 0xb9, 0xcf, 0x30, 0x51, 0x02, 0xed,
+	0x4b, 0x1d, 0xd4, 0x5c, 0x9f, 0xe2, 0xf0, 0x10, 0xa1, 0x5e, 0x1c, 0x93, 0x4f, 0x7e, 0x1a, 0x22,
+	0x18, 0x83, 0x2a, 0xcd, 0x50, 0x3a, 0x1c, 0xc4, 0x38, 0xc1, 0xcc, 0xd4, 0x77, 0x8c, 0x4e, 0x75,
+	0xaf, 0x61, 0xab, 0xd2, 0x78, 0x31, 0x45, 0xb7, 0xf6, 0x3e, 0xc1, 0xa9, 0xfb, 0xe8, 0xfc, 0xb2,
+	0xa5, 0x7d, 0xbd, 0x6a, 0x75, 0x22, 0xcc, 0x46, 0xe3, 0xc0, 0x0e, 0x49, 0xa2, 0xfa, 0x50, 0x3f,
+	0x5d, 0x3a, 0x3c, 0x71, 0xd8, 0x24, 0x43, 0x54, 0x24, 0x50, 0x0f, 0x08, 0xfd, 0xd7, 0x5c, 0x1e,
+	0xf6, 0x01, 0x40, 0xa7, 0x19, 0x96, 0x75, 0x99, 0x37, 0x76, 0xf4, 0x4e, 0x75, 0xaf, 0x6d, 0xaf,
+	0xb1, 0xd7, 0x3e, 0xe0, 0xa1, 0x88, 0xf6, 0x98, 0x5b, 0xe1, 0x54, 0x6f, 0x21, 0xf7, 0x69, 0xed,
+	0xc7, 0xb7, 0xee, 0xed, 0xc5, 0x4e, 0x5e, 0xb6, 0x7f, 0x1b, 0xa0, 0xfe, 0x06, 0xe5, 0x98, 0x0c,
+	0x97, 0x7a, 0x3c, 0x04, 0x1b, 0x01, 0x6f, 0xdc, 0xd4, 0x05, 0xf0, 0xe1, 0x5a, 0xe0, 0x8a, 0x3d,
+	0x0a, 0x2c, 0xd3, 0xe1, 0x73, 0xb0, 0x99, 0x09, 0x7d, 0x55, 0xf9, 0xfd, 0xb5, 0x42, 0x2f, 0x94,
+	0xf5, 0x2a, 0x5f, 0xa5, 0xc1, 0x09, 0x80, 0xf2, 0x6b, 0xb0, 0xe8, 0xb9, 0x71, 0xfd, 0x9e, 0xdf,
+	0x95, 0x98, 0xb7, 0x73, 0xe7, 0xc7, 0x40, 0xed, 0x0d, 0x42, 0x3f, 0x95, 0x78, 0xb3, 0x72, 0xfd,
+	0xe0, 0x3b, 0x12, 0xb2, 0xef, 0xa7, 0x82, 0x0d, 0x5f, 0x81, 0x5b, 0x0a, 0x9b, 0x23, 0x8a, 0x98,
+	0xb9, 0xf1, 0x9f, 0x23, 0xaf, 0xca, 0x6c, 0x8f, 0x27, 0xff, 0x6d, 0xe6, 0x1f, 0xc0, 0x56, 0xe1,
+	0x35, 0x7c, 0x06, 0xb6, 0x8a, 0x2b, 0xaf, 0x26, 0xdd, 0xb0, 0xe5, 0x9b, 0xb0, 0x8b, 0x37, 0xb1,
+	0x30, 0x98, 0x2f, 0x57, 0x2d, 0xbd, 0xaf, 0x79, 0x65, 0x0a, 0x34, 0xc1, 0x66, 0x10, 0x93, 0xf0,
+	0x84, 0x8a, 0xe9, 0x56, 0xfa, 0x9a, 0xa7, 0xd6, 0xee, 0x06, 0x30, 0xe8, 0x38, 0x69, 0x0f, 0xc1,
+	0x76, 0x59, 0x1e, 0x7c, 0x02, 0x2a, 0xfc, 0x01, 0x2a, 0x50, 0x73, 0x05, 0xf4, 0xae, 0x78, 0x9d,
+	0x6e, 0xe5, 0x4c, 0x92, 0x44, 0x3c, 0xa7, 0x8c, 0x10, 0x8e, 0x46, 0x4c, 0x50, 0x0c, 0x4e, 0x91,
+	0xeb, 0x82, 0xf2, 0x59, 0x07, 0xb5, 0xc5, 0x1e, 0x8f, 0xb8, 0x3f, 0xd0, 0x04, 0x37, 0x85, 0x51,
+	0x28, 0x17, 0xc4, 0x6d, 0xaf, 0x58, 0xce, 0x4f, 0x90, 0x50, 0x2c, 0x4f, 0x10, 0x3c, 0x00, 0xdb,
+	0x7e, 0xa1, 0x62, 0x1a, 0xa2, 0xce, 0xfa, 0x4a, 0x9d, 0xbd, 0x74, 0xe2, 0xd6, 0xbe, 0x2f, 0xfb,
+	0xea, 0xcd, 0x33, 0xdd, 0xa3, 0xf3, 0xa9, 0xa5, 0x5f, 0x4c, 0x2d, 0xfd, 0xd7, 0xd4, 0xd2, 0xcf,
+	0x66, 0x96, 0x76, 0x31, 0xb3, 0xb4, 0x9f, 0x33, 0x4b, 0x7b, 0xdf, 0xfd, 0xe7, 0xb5, 0x38, 0x9d,
+	0xff, 0xaf, 0x8a, 0x1b, 0x12, 0x6c, 0x0a, 0xe8, 0xe3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x74,
+	0x27, 0xe6, 0x00, 0x77, 0x05, 0x00, 0x00,
+}
+
+func (m *BasicFeeAllowance) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BasicFeeAllowance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BasicFeeAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Expiration.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintFeegrant(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.SpendLimit) > 0 {
+		for iNdEx := len(m.SpendLimit) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.SpendLimit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintFeegrant(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *PeriodicFeeAllowance) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PeriodicFeeAllowance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PeriodicFeeAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.PeriodReset.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintFeegrant(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x2a
+	if len(m.PeriodCanSpend) > 0 {
+		for iNdEx := len(m.PeriodCanSpend) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.PeriodCanSpend[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintFeegrant(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.PeriodSpendLimit) > 0 {
+		for iNdEx := len(m.PeriodSpendLimit) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.PeriodSpendLimit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintFeegrant(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	{
+		size, err := m.Period.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintFeegrant(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Basic.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintFeegrant(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Duration) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Duration) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Duration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Duration_Duration) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Duration_Duration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Duration != nil {
+		n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration):])
+		if err5 != nil {
+			return 0, err5
+		}
+		i -= n5
+		i = encodeVarintFeegrant(dAtA, i, uint64(n5))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Duration_Blocks) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Duration_Blocks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintFeegrant(dAtA, i, uint64(m.Blocks))
+	i--
+	dAtA[i] = 0x10
+	return len(dAtA) - i, nil
+}
+func (m *ExpiresAt) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ExpiresAt) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExpiresAt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ExpiresAt_Time) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExpiresAt_Time) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Time != nil {
+		n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Time):])
+		if err6 != nil {
+			return 0, err6
+		}
+		i -= n6
+		i = encodeVarintFeegrant(dAtA, i, uint64(n6))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func (m *ExpiresAt_Height) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExpiresAt_Height) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintFeegrant(dAtA, i, uint64(m.Height))
+	i--
+	dAtA[i] = 0x10
+	return len(dAtA) - i, nil
+}
+func (m *FeeAllowanceGrant) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FeeAllowanceGrant) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FeeAllowanceGrant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Allowance != nil {
+		{
+			size, err := m.Allowance.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintFeegrant(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Grantee) > 0 {
+		i -= len(m.Grantee)
+		copy(dAtA[i:], m.Grantee)
+		i = encodeVarintFeegrant(dAtA, i, uint64(len(m.Grantee)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Granter) > 0 {
+		i -= len(m.Granter)
+		copy(dAtA[i:], m.Granter)
+		i = encodeVarintFeegrant(dAtA, i, uint64(len(m.Granter)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintFeegrant(dAtA []byte, offset int, v uint64) int {
+	offset -= sovFeegrant(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *BasicFeeAllowance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.SpendLimit) > 0 {
+		for _, e := range m.SpendLimit {
+			l = e.Size()
+			n += 1 + l + sovFeegrant(uint64(l))
+		}
+	}
+	l = m.Expiration.Size()
+	n += 1 + l + sovFeegrant(uint64(l))
+	return n
+}
+
+func (m *PeriodicFeeAllowance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Basic.Size()
+	n += 1 + l + sovFeegrant(uint64(l))
+	l = m.Period.Size()
+	n += 1 + l + sovFeegrant(uint64(l))
+	if len(m.PeriodSpendLimit) > 0 {
+		for _, e := range m.PeriodSpendLimit {
+			l = e.Size()
+			n += 1 + l + sovFeegrant(uint64(l))
+		}
+	}
+	if len(m.PeriodCanSpend) > 0 {
+		for _, e := range m.PeriodCanSpend {
+			l = e.Size()
+			n += 1 + l + sovFeegrant(uint64(l))
+		}
+	}
+	l = m.PeriodReset.Size()
+	n += 1 + l + sovFeegrant(uint64(l))
+	return n
+}
+
+func (m *Duration) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *Duration_Duration) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Duration != nil {
+		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration)
+		n += 1 + l + sovFeegrant(uint64(l))
+	}
+	return n
+}
+func (m *Duration_Blocks) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovFeegrant(uint64(m.Blocks))
+	return n
+}
+func (m *ExpiresAt) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *ExpiresAt_Time) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Time != nil {
+		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Time)
+		n += 1 + l + sovFeegrant(uint64(l))
+	}
+	return n
+}
+func (m *ExpiresAt_Height) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovFeegrant(uint64(m.Height))
+	return n
+}
+func (m *FeeAllowanceGrant) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Granter)
+	if l > 0 {
+		n += 1 + l + sovFeegrant(uint64(l))
+	}
+	l = len(m.Grantee)
+	if l > 0 {
+		n += 1 + l + sovFeegrant(uint64(l))
+	}
+	if m.Allowance != nil {
+		l = m.Allowance.Size()
+		n += 1 + l + sovFeegrant(uint64(l))
+	}
+	return n
+}
+
+func sovFeegrant(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozFeegrant(x uint64) (n int) {
+	return sovFeegrant(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *BasicFeeAllowance) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BasicFeeAllowance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BasicFeeAllowance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SpendLimit", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SpendLimit = append(m.SpendLimit, types.Coin{})
+			if err := m.SpendLimit[len(m.SpendLimit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Expiration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeegrant(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PeriodicFeeAllowance) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PeriodicFeeAllowance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PeriodicFeeAllowance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Basic", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Basic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Period.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeriodSpendLimit", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeriodSpendLimit = append(m.PeriodSpendLimit, types.Coin{})
+			if err := m.PeriodSpendLimit[len(m.PeriodSpendLimit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeriodCanSpend", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeriodCanSpend = append(m.PeriodCanSpend, types.Coin{})
+			if err := m.PeriodCanSpend[len(m.PeriodCanSpend)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeriodReset", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PeriodReset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeegrant(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Duration) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Duration: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := new(time.Duration)
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Duration_Duration{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
+			}
+			var v uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Sum = &Duration_Blocks{v}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeegrant(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ExpiresAt) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ExpiresAt: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ExpiresAt: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := new(time.Time)
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &ExpiresAt_Time{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Sum = &ExpiresAt_Height{v}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeegrant(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FeeAllowanceGrant) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FeeAllowanceGrant: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FeeAllowanceGrant: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Granter", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Granter = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Grantee = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Allowance", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Allowance == nil {
+				m.Allowance = &types1.Any{}
+			}
+			if err := m.Allowance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFeegrant(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFeegrant
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipFeegrant(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowFeegrant
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowFeegrant
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthFeegrant
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupFeegrant
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthFeegrant
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthFeegrant        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowFeegrant          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupFeegrant = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/feegrant/types/fees.go b/x/feegrant/types/fees.go
new file mode 100644
index 000000000000..cc526628f5f9
--- /dev/null
+++ b/x/feegrant/types/fees.go
@@ -0,0 +1,32 @@
+package types
+
+import (
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// FeeAllowance implementations are tied to a given fee delegator and delegatee,
+// and are used to enforce fee grant limits.
+type FeeAllowanceI interface {
+	// Accept can use fee payment requested as well as timestamp/height of the current block
+	// to determine whether or not to process this. This is checked in
+	// Keeper.UseGrantedFees and the return values should match how it is handled there.
+	//
+	// If it returns an error, the fee payment is rejected, otherwise it is accepted.
+	// The FeeAllowance implementation is expected to update it's internal state
+	// and will be saved again after an acceptance.
+	//
+	// If remove is true (regardless of the error), the FeeAllowance will be deleted from storage
+	// (eg. when it is used up). (See call to RevokeFeeAllowance in Keeper.UseGrantedFees)
+	Accept(fee sdk.Coins, blockTime time.Time, blockHeight int64) (remove bool, err error)
+
+	// If we export fee allowances the timing info will be quite off (eg. go from height 100000 to 0)
+	// This callback allows the fee-allowance to change it's state and return a copy that is adjusted
+	// given the time and height of the actual dump (may safely return self if no changes needed)
+	PrepareForExport(dumpTime time.Time, dumpHeight int64) FeeAllowanceI
+
+	// ValidateBasic should evaluate this FeeAllowance for internal consistency.
+	// Don't allow negative amounts, or negative periods for example.
+	ValidateBasic() error
+}
diff --git a/x/feegrant/types/genesis.go b/x/feegrant/types/genesis.go
new file mode 100644
index 000000000000..57ade9b43de2
--- /dev/null
+++ b/x/feegrant/types/genesis.go
@@ -0,0 +1,40 @@
+package types
+
+import "github.com/cosmos/cosmos-sdk/codec/types"
+
+var _ types.UnpackInterfacesMessage = GenesisState{}
+
+// NewGenesisState creates new GenesisState object
+func NewGenesisState(entries []FeeAllowanceGrant) *GenesisState {
+	return &GenesisState{
+		FeeAllowances: entries,
+	}
+}
+
+// ValidateGenesis ensures all grants in the genesis state are valid
+func ValidateGenesis(data GenesisState) error {
+	for _, f := range data.FeeAllowances {
+		err := f.GetFeeGrant().ValidateBasic()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// DefaultGenesisState returns default state for feegrant module.
+func DefaultGenesisState() *GenesisState {
+	return &GenesisState{}
+}
+
+// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
+func (data GenesisState) UnpackInterfaces(unpacker types.AnyUnpacker) error {
+	for _, f := range data.FeeAllowances {
+		err := f.UnpackInterfaces(unpacker)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/x/feegrant/types/genesis.pb.go b/x/feegrant/types/genesis.pb.go
new file mode 100644
index 000000000000..499f57d626d6
--- /dev/null
+++ b/x/feegrant/types/genesis.pb.go
@@ -0,0 +1,333 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/feegrant/v1beta1/genesis.proto
+
+package types
+
+import (
+	fmt "fmt"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// GenesisState contains a set of fee allowances, persisted from the store
+type GenesisState struct {
+	FeeAllowances []FeeAllowanceGrant `protobuf:"bytes,1,rep,name=fee_allowances,json=feeAllowances,proto3" json:"fee_allowances"`
+}
+
+func (m *GenesisState) Reset()         { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage()    {}
+func (*GenesisState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ac719d2d0954d1bf, []int{0}
+}
+func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *GenesisState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GenesisState.Merge(m, src)
+}
+func (m *GenesisState) XXX_Size() int {
+	return m.Size()
+}
+func (m *GenesisState) XXX_DiscardUnknown() {
+	xxx_messageInfo_GenesisState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+
+func (m *GenesisState) GetFeeAllowances() []FeeAllowanceGrant {
+	if m != nil {
+		return m.FeeAllowances
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*GenesisState)(nil), "cosmos.feegrant.v1beta1.GenesisState")
+}
+
+func init() {
+	proto.RegisterFile("cosmos/feegrant/v1beta1/genesis.proto", fileDescriptor_ac719d2d0954d1bf)
+}
+
+var fileDescriptor_ac719d2d0954d1bf = []byte{
+	// 221 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4d, 0xce, 0x2f, 0xce,
+	0xcd, 0x2f, 0xd6, 0x4f, 0x4b, 0x4d, 0x4d, 0x2f, 0x4a, 0xcc, 0x2b, 0xd1, 0x2f, 0x33, 0x4c, 0x4a,
+	0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f,
+	0xc9, 0x17, 0x12, 0x87, 0x28, 0xd3, 0x83, 0x29, 0xd3, 0x83, 0x2a, 0x93, 0x12, 0x49, 0xcf, 0x4f,
+	0xcf, 0x07, 0xab, 0xd1, 0x07, 0xb1, 0x20, 0xca, 0xa5, 0xd4, 0x70, 0x99, 0x0a, 0xd7, 0x0f, 0x56,
+	0xa7, 0x94, 0xce, 0xc5, 0xe3, 0x0e, 0xb1, 0x27, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0x28, 0x9c, 0x8b,
+	0x2f, 0x2d, 0x35, 0x35, 0x3e, 0x31, 0x27, 0x27, 0xbf, 0x3c, 0x31, 0x2f, 0x39, 0xb5, 0x58, 0x82,
+	0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x4b, 0x0f, 0x87, 0xfd, 0x7a, 0x6e, 0xa9, 0xa9, 0x8e, 0x30,
+	0xd5, 0xee, 0x20, 0x19, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0x78, 0xd3, 0x90, 0x24, 0x8a,
+	0x9d, 0xdc, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09,
+	0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x37, 0x3d, 0xb3,
+	0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xea, 0x6a, 0x08, 0xa5, 0x5b, 0x9c, 0x92,
+	0xad, 0x5f, 0x81, 0xf0, 0x42, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0xe1, 0xc6, 0x80,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0xaf, 0x53, 0x6e, 0xc5, 0x38, 0x01, 0x00, 0x00,
+}
+
+func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.FeeAllowances) > 0 {
+		for iNdEx := len(m.FeeAllowances) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.FeeAllowances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenesis(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GenesisState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.FeeAllowances) > 0 {
+		for _, e := range m.FeeAllowances {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovGenesis(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FeeAllowances", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FeeAllowances = append(m.FeeAllowances, FeeAllowanceGrant{})
+			if err := m.FeeAllowances[len(m.FeeAllowances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthGenesis
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupGenesis
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthGenesis
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/feegrant/types/grant.go b/x/feegrant/types/grant.go
new file mode 100644
index 000000000000..ca2c93d9efb2
--- /dev/null
+++ b/x/feegrant/types/grant.go
@@ -0,0 +1,92 @@
+package types
+
+import (
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	proto "github.com/gogo/protobuf/proto"
+)
+
+var (
+	_ types.UnpackInterfacesMessage = &FeeAllowanceGrant{}
+)
+
+// NewFeeAllowanceGrant creates a new FeeAllowanceGrant.
+//nolint:interfacer
+func NewFeeAllowanceGrant(granter, grantee sdk.AccAddress, feeAllowance FeeAllowanceI) (FeeAllowanceGrant, error) {
+	msg, ok := feeAllowance.(proto.Message)
+	if !ok {
+		return FeeAllowanceGrant{}, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", feeAllowance)
+	}
+
+	any, err := types.NewAnyWithValue(msg)
+	if err != nil {
+		return FeeAllowanceGrant{}, err
+	}
+
+	return FeeAllowanceGrant{
+		Granter:   granter.String(),
+		Grantee:   grantee.String(),
+		Allowance: any,
+	}, nil
+}
+
+// ValidateBasic performs basic validation on
+// FeeAllowanceGrant
+func (a FeeAllowanceGrant) ValidateBasic() error {
+	if a.Granter == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address")
+	}
+	if a.Grantee == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address")
+	}
+	if a.Grantee == a.Granter {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization")
+	}
+
+	return a.GetFeeGrant().ValidateBasic()
+}
+
+// GetFeeGrant unpacks allowance
+func (a FeeAllowanceGrant) GetFeeGrant() FeeAllowanceI {
+	allowance, ok := a.Allowance.GetCachedValue().(FeeAllowanceI)
+	if !ok {
+		return nil
+	}
+
+	return allowance
+}
+
+// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
+func (a FeeAllowanceGrant) UnpackInterfaces(unpacker types.AnyUnpacker) error {
+	var allowance FeeAllowanceI
+	return unpacker.UnpackAny(a.Allowance, &allowance)
+}
+
+// PrepareForExport will make all needed changes to the allowance to prepare to be
+// re-imported at height 0, and return a copy of this grant.
+func (a FeeAllowanceGrant) PrepareForExport(dumpTime time.Time, dumpHeight int64) FeeAllowanceGrant {
+	feegrant := a.GetFeeGrant().PrepareForExport(dumpTime, dumpHeight)
+	if feegrant == nil {
+		return FeeAllowanceGrant{}
+	}
+
+	granter, err := sdk.AccAddressFromBech32(a.Granter)
+	if err != nil {
+		return FeeAllowanceGrant{}
+	}
+
+	grantee, err := sdk.AccAddressFromBech32(a.Grantee)
+	if err != nil {
+		return FeeAllowanceGrant{}
+	}
+
+	grant, err := NewFeeAllowanceGrant(granter, grantee, feegrant)
+	if err != nil {
+		return FeeAllowanceGrant{}
+	}
+
+	return grant
+}
diff --git a/x/feegrant/types/grant_test.go b/x/feegrant/types/grant_test.go
new file mode 100644
index 000000000000..a4819b102cb2
--- /dev/null
+++ b/x/feegrant/types/grant_test.go
@@ -0,0 +1,99 @@
+package types_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGrant(t *testing.T) {
+	app := simapp.Setup(false)
+	addr, err := sdk.AccAddressFromBech32("cosmos1qk93t4j0yyzgqgt6k5qf8deh8fq6smpn3ntu3x")
+	require.NoError(t, err)
+	addr2, err := sdk.AccAddressFromBech32("cosmos1p9qh4ldfd6n0qehujsal4k7g0e37kel90rc4ts")
+	require.NoError(t, err)
+	atom := sdk.NewCoins(sdk.NewInt64Coin("atom", 555))
+
+	goodGrant, err := types.NewFeeAllowanceGrant(addr2, addr, &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(100),
+	})
+	require.NoError(t, err)
+
+	noGranteeGrant, err := types.NewFeeAllowanceGrant(addr2, nil, &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(100),
+	})
+	require.NoError(t, err)
+
+	noGranterGrant, err := types.NewFeeAllowanceGrant(nil, addr, &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(100),
+	})
+	require.NoError(t, err)
+
+	selfGrant, err := types.NewFeeAllowanceGrant(addr2, addr2, &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(100),
+	})
+	require.NoError(t, err)
+
+	badAllowanceGrant, err := types.NewFeeAllowanceGrant(addr2, addr, &types.BasicFeeAllowance{
+		SpendLimit: atom,
+		Expiration: types.ExpiresAtHeight(-1),
+	})
+	require.NoError(t, err)
+
+	cdc := app.AppCodec()
+	// RegisterLegacyAminoCodec(cdc)
+
+	cases := map[string]struct {
+		grant types.FeeAllowanceGrant
+		valid bool
+	}{
+		"good": {
+			grant: goodGrant,
+			valid: true,
+		},
+		"no grantee": {
+			grant: noGranteeGrant,
+		},
+		"no granter": {
+			grant: noGranterGrant,
+		},
+		"self-grant": {
+			grant: selfGrant,
+		},
+		"bad allowance": {
+			grant: badAllowanceGrant,
+		},
+	}
+
+	for name, tc := range cases {
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			err := tc.grant.ValidateBasic()
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// if it is valid, let's try to serialize, deserialize, and make sure it matches
+			bz, err := cdc.MarshalBinaryBare(&tc.grant)
+			require.NoError(t, err)
+			var loaded types.FeeAllowanceGrant
+			err = cdc.UnmarshalBinaryBare(bz, &loaded)
+			require.NoError(t, err)
+
+			err = loaded.ValidateBasic()
+			require.NoError(t, err)
+
+			assert.Equal(t, tc.grant, loaded)
+		})
+	}
+}
diff --git a/x/feegrant/types/key.go b/x/feegrant/types/key.go
new file mode 100644
index 000000000000..7cd1ce4f8c8f
--- /dev/null
+++ b/x/feegrant/types/key.go
@@ -0,0 +1,36 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
+)
+
+const (
+	// ModuleName is the module name constant used in many places
+	ModuleName = "feegrant"
+
+	// StoreKey is the store key string for supply
+	StoreKey = ModuleName
+
+	// RouterKey is the message route for supply
+	RouterKey = ModuleName
+
+	// QuerierRoute is the querier route for supply
+	QuerierRoute = ModuleName
+)
+
+var (
+	// FeeAllowanceKeyPrefix is the set of the kvstore for fee allowance data
+	FeeAllowanceKeyPrefix = []byte{0x00}
+)
+
+// FeeAllowanceKey is the canonical key to store a grant from granter to grantee
+// We store by grantee first to allow searching by everyone who granted to you
+func FeeAllowanceKey(granter sdk.AccAddress, grantee sdk.AccAddress) []byte {
+	return append(FeeAllowancePrefixByGrantee(grantee), address.MustLengthPrefix(granter.Bytes())...)
+}
+
+// FeeAllowancePrefixByGrantee returns a prefix to scan for all grants to this given address.
+func FeeAllowancePrefixByGrantee(grantee sdk.AccAddress) []byte {
+	return append(FeeAllowanceKeyPrefix, address.MustLengthPrefix(grantee.Bytes())...)
+}
diff --git a/x/feegrant/types/msgs.go b/x/feegrant/types/msgs.go
new file mode 100644
index 000000000000..5a25016f87e0
--- /dev/null
+++ b/x/feegrant/types/msgs.go
@@ -0,0 +1,101 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/gogo/protobuf/proto"
+)
+
+var (
+	_, _ sdk.MsgRequest                = &MsgGrantFeeAllowance{}, &MsgRevokeFeeAllowance{}
+	_    types.UnpackInterfacesMessage = &MsgGrantFeeAllowance{}
+)
+
+// feegrant message types
+const (
+	TypeMsgGrantFeeAllowance  = "grant_fee_allowance"
+	TypeMsgRevokeFeeAllowance = "revoke_fee_allowance"
+)
+
+// NewMsgGrantFeeAllowance creates a new MsgGrantFeeAllowance.
+//nolint:interfacer
+func NewMsgGrantFeeAllowance(feeAllowance FeeAllowanceI, granter, grantee sdk.AccAddress) (*MsgGrantFeeAllowance, error) {
+	msg, ok := feeAllowance.(proto.Message)
+	if !ok {
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", msg)
+	}
+	any, err := types.NewAnyWithValue(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MsgGrantFeeAllowance{
+		Granter:   granter.String(),
+		Grantee:   grantee.String(),
+		Allowance: any,
+	}, nil
+}
+
+// ValidateBasic implements the sdk.Msg interface.
+func (msg MsgGrantFeeAllowance) ValidateBasic() error {
+	if msg.Granter == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address")
+	}
+	if msg.Grantee == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address")
+	}
+	if msg.Grantee == msg.Granter {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization")
+	}
+
+	return msg.GetFeeAllowanceI().ValidateBasic()
+}
+
+func (msg MsgGrantFeeAllowance) GetSigners() []sdk.AccAddress {
+	granter, err := sdk.AccAddressFromBech32(msg.Granter)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{granter}
+}
+
+// GetFeeAllowanceI returns unpacked FeeAllowance
+func (msg MsgGrantFeeAllowance) GetFeeAllowanceI() FeeAllowanceI {
+	allowance, ok := msg.Allowance.GetCachedValue().(FeeAllowanceI)
+	if !ok {
+		return nil
+	}
+
+	return allowance
+}
+
+// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
+func (msg MsgGrantFeeAllowance) UnpackInterfaces(unpacker types.AnyUnpacker) error {
+	var allowance FeeAllowanceI
+	return unpacker.UnpackAny(msg.Allowance, &allowance)
+}
+
+//nolint:interfacer
+func NewMsgRevokeFeeAllowance(granter sdk.AccAddress, grantee sdk.AccAddress) MsgRevokeFeeAllowance {
+	return MsgRevokeFeeAllowance{Granter: granter.String(), Grantee: grantee.String()}
+}
+
+func (msg MsgRevokeFeeAllowance) ValidateBasic() error {
+	if msg.Granter == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address")
+	}
+	if msg.Grantee == "" {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address")
+	}
+
+	return nil
+}
+
+func (msg MsgRevokeFeeAllowance) GetSigners() []sdk.AccAddress {
+	granter, err := sdk.AccAddressFromBech32(msg.Granter)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{granter}
+}
diff --git a/x/feegrant/types/periodic_fee.go b/x/feegrant/types/periodic_fee.go
new file mode 100644
index 000000000000..61c9ba2ffe2d
--- /dev/null
+++ b/x/feegrant/types/periodic_fee.go
@@ -0,0 +1,120 @@
+package types
+
+import (
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var _ FeeAllowanceI = (*PeriodicFeeAllowance)(nil)
+
+// Accept can use fee payment requested as well as timestamp/height of the current block
+// to determine whether or not to process this. This is checked in
+// Keeper.UseGrantedFees and the return values should match how it is handled there.
+//
+// If it returns an error, the fee payment is rejected, otherwise it is accepted.
+// The FeeAllowance implementation is expected to update it's internal state
+// and will be saved again after an acceptance.
+//
+// If remove is true (regardless of the error), the FeeAllowance will be deleted from storage
+// (eg. when it is used up). (See call to RevokeFeeAllowance in Keeper.UseGrantedFees)
+func (a *PeriodicFeeAllowance) Accept(fee sdk.Coins, blockTime time.Time, blockHeight int64) (bool, error) {
+	if a.Basic.Expiration.IsExpired(&blockTime, blockHeight) {
+		return true, sdkerrors.Wrap(ErrFeeLimitExpired, "absolute limit")
+	}
+
+	a.tryResetPeriod(blockTime, blockHeight)
+
+	// deduct from both the current period and the max amount
+	var isNeg bool
+	a.PeriodCanSpend, isNeg = a.PeriodCanSpend.SafeSub(fee)
+	if isNeg {
+		return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "period limit")
+	}
+
+	if a.Basic.SpendLimit != nil {
+		a.Basic.SpendLimit, isNeg = a.Basic.SpendLimit.SafeSub(fee)
+		if isNeg {
+			return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "absolute limit")
+		}
+
+		return a.Basic.SpendLimit.IsZero(), nil
+	}
+
+	return false, nil
+}
+
+// tryResetPeriod will check if the PeriodReset has been hit. If not, it is a no-op.
+// If we hit the reset period, it will top up the PeriodCanSpend amount to
+// min(PeriodicSpendLimit, a.Basic.SpendLimit) so it is never more than the maximum allowed.
+// It will also update the PeriodReset. If we are within one Period, it will update from the
+// last PeriodReset (eg. if you always do one tx per day, it will always reset the same time)
+// If we are more then one period out (eg. no activity in a week), reset is one Period from the execution of this method
+func (a *PeriodicFeeAllowance) tryResetPeriod(blockTime time.Time, blockHeight int64) {
+	if !a.PeriodReset.Undefined() && !a.PeriodReset.IsExpired(&blockTime, blockHeight) {
+		return
+	}
+	// set CanSpend to the lesser of PeriodSpendLimit and the TotalLimit
+	if _, isNeg := a.Basic.SpendLimit.SafeSub(a.PeriodSpendLimit); isNeg {
+		a.PeriodCanSpend = a.Basic.SpendLimit
+	} else {
+		a.PeriodCanSpend = a.PeriodSpendLimit
+	}
+
+	// If we are within the period, step from expiration (eg. if you always do one tx per day, it will always reset the same time)
+	// If we are more then one period out (eg. no activity in a week), reset is one period from this time
+	a.PeriodReset = a.PeriodReset.MustStep(a.Period)
+	if a.PeriodReset.IsExpired(&blockTime, blockHeight) {
+		a.PeriodReset = a.PeriodReset.FastForward(blockTime, blockHeight).MustStep(a.Period)
+	}
+}
+
+// PrepareForExport will adjust the expiration based on export time. In particular,
+// it will subtract the dumpHeight from any height-based expiration to ensure that
+// the elapsed number of blocks this allowance is valid for is fixed.
+// (For PeriodReset and Basic.Expiration)
+func (a *PeriodicFeeAllowance) PrepareForExport(dumpTime time.Time, dumpHeight int64) FeeAllowanceI {
+	return &PeriodicFeeAllowance{
+		Basic: BasicFeeAllowance{
+			SpendLimit: a.Basic.SpendLimit,
+			Expiration: a.Basic.Expiration.PrepareForExport(dumpTime, dumpHeight),
+		},
+		PeriodSpendLimit: a.PeriodSpendLimit,
+		PeriodCanSpend:   a.PeriodCanSpend,
+		Period:           a.Period,
+		PeriodReset:      a.PeriodReset.PrepareForExport(dumpTime, dumpHeight),
+	}
+}
+
+// ValidateBasic implements FeeAllowance and enforces basic sanity checks
+func (a PeriodicFeeAllowance) ValidateBasic() error {
+	if err := a.Basic.ValidateBasic(); err != nil {
+		return err
+	}
+
+	if !a.PeriodSpendLimit.IsValid() {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "spend amount is invalid: %s", a.PeriodSpendLimit)
+	}
+	if !a.PeriodSpendLimit.IsAllPositive() {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive")
+	}
+	if !a.PeriodCanSpend.IsValid() {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "can spend amount is invalid: %s", a.PeriodCanSpend)
+	}
+	// We allow 0 for CanSpend
+	if a.PeriodCanSpend.IsAnyNegative() {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "can spend must not be negative")
+	}
+
+	// ensure PeriodSpendLimit can be subtracted from total (same coin types)
+	if a.Basic.SpendLimit != nil && !a.PeriodSpendLimit.DenomsSubsetOf(a.Basic.SpendLimit) {
+		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "period spend limit has different currency than basic spend limit")
+	}
+
+	// check times
+	if err := a.Period.ValidateBasic(); err != nil {
+		return err
+	}
+	return a.PeriodReset.ValidateBasic()
+}
diff --git a/x/feegrant/types/periodic_fee_test.go b/x/feegrant/types/periodic_fee_test.go
new file mode 100644
index 000000000000..cc54f4080878
--- /dev/null
+++ b/x/feegrant/types/periodic_fee_test.go
@@ -0,0 +1,205 @@
+package types_test
+
+import (
+	"testing"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/feegrant/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPeriodicFeeValidAllow(t *testing.T) {
+	atom := sdk.NewCoins(sdk.NewInt64Coin("atom", 555))
+	smallAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 43))
+	leftAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 512))
+	oneAtom := sdk.NewCoins(sdk.NewInt64Coin("atom", 1))
+	eth := sdk.NewCoins(sdk.NewInt64Coin("eth", 1))
+
+	cases := map[string]struct {
+		allow types.PeriodicFeeAllowance
+		// all other checks are ignored if valid=false
+		fee           sdk.Coins
+		blockTime     time.Time
+		blockHeight   int64
+		valid         bool
+		accept        bool
+		remove        bool
+		remains       sdk.Coins
+		remainsPeriod sdk.Coins
+		periodReset   types.ExpiresAt
+	}{
+		"empty": {
+			allow: types.PeriodicFeeAllowance{},
+			valid: false,
+		},
+		"only basic": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+			},
+			valid: false,
+		},
+		"empty basic": {
+			allow: types.PeriodicFeeAllowance{
+				Period:           types.BlockDuration(10),
+				PeriodSpendLimit: smallAtom,
+				PeriodReset:      types.ExpiresAtHeight(70),
+			},
+			blockHeight: 75,
+			valid:       true,
+			accept:      true,
+			remove:      false,
+			periodReset: types.ExpiresAtHeight(80),
+		},
+		"mismatched currencies": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodSpendLimit: eth,
+			},
+			valid: false,
+		},
+		"first time": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodSpendLimit: smallAtom,
+			},
+			valid:         true,
+			fee:           smallAtom,
+			blockHeight:   75,
+			accept:        true,
+			remove:        false,
+			remainsPeriod: nil,
+			remains:       leftAtom,
+			periodReset:   types.ExpiresAtHeight(85),
+		},
+		"same period": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodReset:      types.ExpiresAtHeight(80),
+				PeriodSpendLimit: leftAtom,
+				PeriodCanSpend:   smallAtom,
+			},
+			valid:         true,
+			fee:           smallAtom,
+			blockHeight:   75,
+			accept:        true,
+			remove:        false,
+			remainsPeriod: nil,
+			remains:       leftAtom,
+			periodReset:   types.ExpiresAtHeight(80),
+		},
+		"step one period": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodReset:      types.ExpiresAtHeight(70),
+				PeriodSpendLimit: leftAtom,
+			},
+			valid:         true,
+			fee:           leftAtom,
+			blockHeight:   75,
+			accept:        true,
+			remove:        false,
+			remainsPeriod: nil,
+			remains:       smallAtom,
+			periodReset:   types.ExpiresAtHeight(80), // one step from last reset, not now
+		},
+		"step limited by global allowance": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: smallAtom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodReset:      types.ExpiresAtHeight(70),
+				PeriodSpendLimit: atom,
+			},
+			valid:         true,
+			fee:           oneAtom,
+			blockHeight:   75,
+			accept:        true,
+			remove:        false,
+			remainsPeriod: smallAtom.Sub(oneAtom),
+			remains:       smallAtom.Sub(oneAtom),
+			periodReset:   types.ExpiresAtHeight(80), // one step from last reset, not now
+		},
+		"expired": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodSpendLimit: smallAtom,
+			},
+			valid:       true,
+			fee:         smallAtom,
+			blockHeight: 101,
+			accept:      false,
+			remove:      true,
+		},
+		"over period limit": {
+			allow: types.PeriodicFeeAllowance{
+				Basic: types.BasicFeeAllowance{
+					SpendLimit: atom,
+					Expiration: types.ExpiresAtHeight(100),
+				},
+				Period:           types.BlockDuration(10),
+				PeriodReset:      types.ExpiresAtHeight(80),
+				PeriodSpendLimit: leftAtom,
+				PeriodCanSpend:   smallAtom,
+			},
+			valid:       true,
+			fee:         leftAtom,
+			blockHeight: 70,
+			accept:      false,
+			remove:      true,
+		},
+	}
+
+	for name, stc := range cases {
+		tc := stc // to make scopelint happy
+		t.Run(name, func(t *testing.T) {
+			err := tc.allow.ValidateBasic()
+			if !tc.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// now try to deduct
+			remove, err := tc.allow.Accept(tc.fee, tc.blockTime, tc.blockHeight)
+			if !tc.accept {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			require.Equal(t, tc.remove, remove)
+			if !remove {
+				assert.Equal(t, tc.remains, tc.allow.Basic.SpendLimit)
+				assert.Equal(t, tc.remainsPeriod, tc.allow.PeriodCanSpend)
+				assert.Equal(t, tc.periodReset, tc.allow.PeriodReset)
+			}
+		})
+	}
+}
diff --git a/x/feegrant/types/query.pb.go b/x/feegrant/types/query.pb.go
new file mode 100644
index 000000000000..e2597c3bc833
--- /dev/null
+++ b/x/feegrant/types/query.pb.go
@@ -0,0 +1,1172 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/feegrant/v1beta1/query.proto
+
+package types
+
+import (
+	context "context"
+	fmt "fmt"
+	query "github.com/cosmos/cosmos-sdk/types/query"
+	_ "github.com/gogo/protobuf/gogoproto"
+	grpc1 "github.com/gogo/protobuf/grpc"
+	proto "github.com/gogo/protobuf/proto"
+	_ "google.golang.org/genproto/googleapis/api/annotations"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// QueryFeeAllowanceRequest is the request type for the Query/FeeAllowance RPC method.
+type QueryFeeAllowanceRequest struct {
+	Granter string `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
+	Grantee string `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
+}
+
+func (m *QueryFeeAllowanceRequest) Reset()         { *m = QueryFeeAllowanceRequest{} }
+func (m *QueryFeeAllowanceRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryFeeAllowanceRequest) ProtoMessage()    {}
+func (*QueryFeeAllowanceRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_59efc303945de53f, []int{0}
+}
+func (m *QueryFeeAllowanceRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFeeAllowanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFeeAllowanceRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryFeeAllowanceRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFeeAllowanceRequest.Merge(m, src)
+}
+func (m *QueryFeeAllowanceRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFeeAllowanceRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFeeAllowanceRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFeeAllowanceRequest proto.InternalMessageInfo
+
+func (m *QueryFeeAllowanceRequest) GetGranter() string {
+	if m != nil {
+		return m.Granter
+	}
+	return ""
+}
+
+func (m *QueryFeeAllowanceRequest) GetGrantee() string {
+	if m != nil {
+		return m.Grantee
+	}
+	return ""
+}
+
+// QueryFeeAllowanceResponse is the response type for the Query/FeeAllowance RPC method.
+type QueryFeeAllowanceResponse struct {
+	// fee_allowance is a fee_allowance granted for grantee by granter.
+	FeeAllowance *FeeAllowanceGrant `protobuf:"bytes,1,opt,name=fee_allowance,json=feeAllowance,proto3" json:"fee_allowance,omitempty"`
+}
+
+func (m *QueryFeeAllowanceResponse) Reset()         { *m = QueryFeeAllowanceResponse{} }
+func (m *QueryFeeAllowanceResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryFeeAllowanceResponse) ProtoMessage()    {}
+func (*QueryFeeAllowanceResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_59efc303945de53f, []int{1}
+}
+func (m *QueryFeeAllowanceResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFeeAllowanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFeeAllowanceResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryFeeAllowanceResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFeeAllowanceResponse.Merge(m, src)
+}
+func (m *QueryFeeAllowanceResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFeeAllowanceResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFeeAllowanceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFeeAllowanceResponse proto.InternalMessageInfo
+
+func (m *QueryFeeAllowanceResponse) GetFeeAllowance() *FeeAllowanceGrant {
+	if m != nil {
+		return m.FeeAllowance
+	}
+	return nil
+}
+
+// QueryFeeAllowancesRequest is the request type for the Query/FeeAllowances RPC method.
+type QueryFeeAllowancesRequest struct {
+	Grantee string `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
+	// pagination defines an pagination for the request.
+	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (m *QueryFeeAllowancesRequest) Reset()         { *m = QueryFeeAllowancesRequest{} }
+func (m *QueryFeeAllowancesRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryFeeAllowancesRequest) ProtoMessage()    {}
+func (*QueryFeeAllowancesRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_59efc303945de53f, []int{2}
+}
+func (m *QueryFeeAllowancesRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFeeAllowancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFeeAllowancesRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryFeeAllowancesRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFeeAllowancesRequest.Merge(m, src)
+}
+func (m *QueryFeeAllowancesRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFeeAllowancesRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFeeAllowancesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFeeAllowancesRequest proto.InternalMessageInfo
+
+func (m *QueryFeeAllowancesRequest) GetGrantee() string {
+	if m != nil {
+		return m.Grantee
+	}
+	return ""
+}
+
+func (m *QueryFeeAllowancesRequest) GetPagination() *query.PageRequest {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
+// QueryFeeAllowancesResponse is the response type for the Query/FeeAllowances RPC method.
+type QueryFeeAllowancesResponse struct {
+	// fee_allowances are fee_allowance's granted for grantee by granter.
+	FeeAllowances []*FeeAllowanceGrant `protobuf:"bytes,1,rep,name=fee_allowances,json=feeAllowances,proto3" json:"fee_allowances,omitempty"`
+	// pagination defines an pagination for the response.
+	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (m *QueryFeeAllowancesResponse) Reset()         { *m = QueryFeeAllowancesResponse{} }
+func (m *QueryFeeAllowancesResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryFeeAllowancesResponse) ProtoMessage()    {}
+func (*QueryFeeAllowancesResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_59efc303945de53f, []int{3}
+}
+func (m *QueryFeeAllowancesResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFeeAllowancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFeeAllowancesResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryFeeAllowancesResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFeeAllowancesResponse.Merge(m, src)
+}
+func (m *QueryFeeAllowancesResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFeeAllowancesResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFeeAllowancesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFeeAllowancesResponse proto.InternalMessageInfo
+
+func (m *QueryFeeAllowancesResponse) GetFeeAllowances() []*FeeAllowanceGrant {
+	if m != nil {
+		return m.FeeAllowances
+	}
+	return nil
+}
+
+func (m *QueryFeeAllowancesResponse) GetPagination() *query.PageResponse {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*QueryFeeAllowanceRequest)(nil), "cosmos.feegrant.v1beta1.QueryFeeAllowanceRequest")
+	proto.RegisterType((*QueryFeeAllowanceResponse)(nil), "cosmos.feegrant.v1beta1.QueryFeeAllowanceResponse")
+	proto.RegisterType((*QueryFeeAllowancesRequest)(nil), "cosmos.feegrant.v1beta1.QueryFeeAllowancesRequest")
+	proto.RegisterType((*QueryFeeAllowancesResponse)(nil), "cosmos.feegrant.v1beta1.QueryFeeAllowancesResponse")
+}
+
+func init() {
+	proto.RegisterFile("cosmos/feegrant/v1beta1/query.proto", fileDescriptor_59efc303945de53f)
+}
+
+var fileDescriptor_59efc303945de53f = []byte{
+	// 455 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x31, 0x8f, 0xd3, 0x30,
+	0x14, 0xc7, 0xeb, 0x22, 0x40, 0xf8, 0xae, 0x0c, 0x16, 0x12, 0x21, 0x42, 0xd1, 0x29, 0x48, 0x07,
+	0x3a, 0xe9, 0x62, 0x35, 0x9d, 0x40, 0x2c, 0xdc, 0x70, 0xdd, 0x80, 0xcb, 0xc8, 0x82, 0x9c, 0xf2,
+	0x6a, 0x22, 0x72, 0x71, 0x2e, 0x76, 0x81, 0x13, 0xea, 0xc2, 0x27, 0x40, 0xe2, 0xa3, 0xb0, 0xc0,
+	0x37, 0x60, 0x3c, 0x89, 0x85, 0x11, 0xb5, 0x7c, 0x09, 0x36, 0x14, 0x3b, 0x6e, 0x52, 0x91, 0x00,
+	0x99, 0xe2, 0xe4, 0xfd, 0xdf, 0x7b, 0xbf, 0xf7, 0xcf, 0x33, 0xbe, 0x33, 0x13, 0xf2, 0x54, 0x48,
+	0x3a, 0x07, 0xe0, 0x05, 0xcb, 0x14, 0x7d, 0x3d, 0x8e, 0x41, 0xb1, 0x31, 0x3d, 0x5b, 0x40, 0x71,
+	0x1e, 0xe4, 0x85, 0x50, 0x82, 0xdc, 0x34, 0xa2, 0xc0, 0x8a, 0x82, 0x4a, 0xe4, 0xde, 0xe0, 0x82,
+	0x0b, 0xad, 0xa1, 0xe5, 0xc9, 0xc8, 0xdd, 0xfd, 0xae, 0x9a, 0x9b, 0x7c, 0xa3, 0x3b, 0xa8, 0x74,
+	0x31, 0x93, 0x60, 0xfa, 0x6d, 0x94, 0x39, 0xe3, 0x49, 0xc6, 0x54, 0x22, 0xb2, 0x4a, 0x7b, 0x9b,
+	0x0b, 0xc1, 0x53, 0xa0, 0x2c, 0x4f, 0x28, 0xcb, 0x32, 0xa1, 0x74, 0x50, 0x9a, 0xa8, 0xff, 0x18,
+	0x3b, 0x27, 0x65, 0xfe, 0x31, 0xc0, 0xa3, 0x34, 0x15, 0x6f, 0x58, 0x36, 0x83, 0x08, 0xce, 0x16,
+	0x20, 0x15, 0x71, 0xf0, 0x55, 0xdd, 0x14, 0x0a, 0x07, 0xed, 0xa1, 0x7b, 0xd7, 0x22, 0xfb, 0x5a,
+	0x47, 0xc0, 0x19, 0x36, 0x23, 0xe0, 0xa7, 0xf8, 0x56, 0x4b, 0x3d, 0x99, 0x8b, 0x4c, 0x02, 0x79,
+	0x82, 0x47, 0x73, 0x80, 0xe7, 0xcc, 0x06, 0x74, 0xd9, 0x9d, 0xf0, 0x20, 0xe8, 0x70, 0x29, 0x68,
+	0x56, 0x99, 0x96, 0x91, 0x68, 0x77, 0xde, 0xf8, 0xe4, 0x2f, 0x5b, 0xba, 0xc9, 0x3f, 0xf0, 0x61,
+	0x1b, 0x1f, 0xc8, 0x31, 0xc6, 0xb5, 0x4d, 0x7a, 0x82, 0x9d, 0x70, 0xdf, 0x42, 0x94, 0x9e, 0x06,
+	0xe6, 0x1f, 0x5a, 0x8c, 0xa7, 0x8c, 0x5b, 0x53, 0xa2, 0x46, 0xa6, 0xff, 0x19, 0x61, 0xb7, 0xad,
+	0x7f, 0x35, 0xee, 0x09, 0xbe, 0xbe, 0x35, 0xae, 0x74, 0xd0, 0xde, 0xa5, 0x9e, 0xf3, 0x8e, 0x9a,
+	0xf3, 0x4a, 0x32, 0x6d, 0x21, 0xbf, 0xfb, 0x4f, 0x72, 0xc3, 0xd3, 0x44, 0x0f, 0x7f, 0x0d, 0xf1,
+	0x65, 0x8d, 0x4e, 0xbe, 0x20, 0xbc, 0xdb, 0xec, 0x4b, 0xc6, 0x9d, 0x78, 0x5d, 0x9b, 0xe2, 0x86,
+	0x7d, 0x52, 0x0c, 0x8d, 0x7f, 0xf4, 0xfe, 0xdb, 0xcf, 0x8f, 0xc3, 0x87, 0xe4, 0x01, 0xfd, 0xcb,
+	0xd2, 0xd7, 0xe6, 0xd1, 0x77, 0xd5, 0xf2, 0x2d, 0xed, 0x09, 0x96, 0xe4, 0x13, 0xc2, 0xa3, 0x2d,
+	0xef, 0x49, 0x0f, 0x12, 0xbb, 0x28, 0xee, 0xa4, 0x57, 0x4e, 0x85, 0x7f, 0x5f, 0xe3, 0x4f, 0xc8,
+	0xf8, 0xff, 0xf0, 0x65, 0x4d, 0x7d, 0x34, 0xfd, 0xba, 0xf2, 0xd0, 0xc5, 0xca, 0x43, 0x3f, 0x56,
+	0x1e, 0xfa, 0xb0, 0xf6, 0x06, 0x17, 0x6b, 0x6f, 0xf0, 0x7d, 0xed, 0x0d, 0x9e, 0x1d, 0xf2, 0x44,
+	0xbd, 0x5c, 0xc4, 0xc1, 0x4c, 0x9c, 0xda, 0xb2, 0xe6, 0x71, 0x28, 0x5f, 0xbc, 0xa2, 0x6f, 0xeb,
+	0x1e, 0xea, 0x3c, 0x07, 0x19, 0x5f, 0xd1, 0x77, 0x78, 0xf2, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xb8,
+	0x46, 0x4c, 0xba, 0x8b, 0x04, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type QueryClient interface {
+	// FeeAllowance returns fee granted to the grantee by the granter.
+	FeeAllowance(ctx context.Context, in *QueryFeeAllowanceRequest, opts ...grpc.CallOption) (*QueryFeeAllowanceResponse, error)
+	// FeeAllowances returns all the grants for address.
+	FeeAllowances(ctx context.Context, in *QueryFeeAllowancesRequest, opts ...grpc.CallOption) (*QueryFeeAllowancesResponse, error)
+}
+
+type queryClient struct {
+	cc grpc1.ClientConn
+}
+
+func NewQueryClient(cc grpc1.ClientConn) QueryClient {
+	return &queryClient{cc}
+}
+
+func (c *queryClient) FeeAllowance(ctx context.Context, in *QueryFeeAllowanceRequest, opts ...grpc.CallOption) (*QueryFeeAllowanceResponse, error) {
+	out := new(QueryFeeAllowanceResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.feegrant.v1beta1.Query/FeeAllowance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) FeeAllowances(ctx context.Context, in *QueryFeeAllowancesRequest, opts ...grpc.CallOption) (*QueryFeeAllowancesResponse, error) {
+	out := new(QueryFeeAllowancesResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.feegrant.v1beta1.Query/FeeAllowances", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// QueryServer is the server API for Query service.
+type QueryServer interface {
+	// FeeAllowance returns fee granted to the grantee by the granter.
+	FeeAllowance(context.Context, *QueryFeeAllowanceRequest) (*QueryFeeAllowanceResponse, error)
+	// FeeAllowances returns all the grants for address.
+	FeeAllowances(context.Context, *QueryFeeAllowancesRequest) (*QueryFeeAllowancesResponse, error)
+}
+
+// UnimplementedQueryServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (*UnimplementedQueryServer) FeeAllowance(ctx context.Context, req *QueryFeeAllowanceRequest) (*QueryFeeAllowanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method FeeAllowance not implemented")
+}
+func (*UnimplementedQueryServer) FeeAllowances(ctx context.Context, req *QueryFeeAllowancesRequest) (*QueryFeeAllowancesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method FeeAllowances not implemented")
+}
+
+func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
+	s.RegisterService(&_Query_serviceDesc, srv)
+}
+
+func _Query_FeeAllowance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryFeeAllowanceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).FeeAllowance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.feegrant.v1beta1.Query/FeeAllowance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).FeeAllowance(ctx, req.(*QueryFeeAllowanceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_FeeAllowances_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryFeeAllowancesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).FeeAllowances(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.feegrant.v1beta1.Query/FeeAllowances",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).FeeAllowances(ctx, req.(*QueryFeeAllowancesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Query_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "cosmos.feegrant.v1beta1.Query",
+	HandlerType: (*QueryServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "FeeAllowance",
+			Handler:    _Query_FeeAllowance_Handler,
+		},
+		{
+			MethodName: "FeeAllowances",
+			Handler:    _Query_FeeAllowances_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "cosmos/feegrant/v1beta1/query.proto",
+}
+
+func (m *QueryFeeAllowanceRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryFeeAllowanceRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFeeAllowanceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Grantee) > 0 {
+		i -= len(m.Grantee)
+		copy(dAtA[i:], m.Grantee)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Grantee)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Granter) > 0 {
+		i -= len(m.Granter)
+		copy(dAtA[i:], m.Granter)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Granter)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryFeeAllowanceResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryFeeAllowanceResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFeeAllowanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.FeeAllowance != nil {
+		{
+			size, err := m.FeeAllowance.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryFeeAllowancesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryFeeAllowancesRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFeeAllowancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Grantee) > 0 {
+		i -= len(m.Grantee)
+		copy(dAtA[i:], m.Grantee)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Grantee)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryFeeAllowancesResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryFeeAllowancesResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFeeAllowancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.FeeAllowances) > 0 {
+		for iNdEx := len(m.FeeAllowances) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.FeeAllowances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
+	offset -= sovQuery(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *QueryFeeAllowanceRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Granter)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.Grantee)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryFeeAllowanceResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.FeeAllowance != nil {
+		l = m.FeeAllowance.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryFeeAllowancesRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Grantee)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryFeeAllowancesResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.FeeAllowances) > 0 {
+		for _, e := range m.FeeAllowances {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func sovQuery(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozQuery(x uint64) (n int) {
+	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *QueryFeeAllowanceRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryFeeAllowanceRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFeeAllowanceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Granter", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Granter = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Grantee = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryFeeAllowanceResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryFeeAllowanceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFeeAllowanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FeeAllowance", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.FeeAllowance == nil {
+				m.FeeAllowance = &FeeAllowanceGrant{}
+			}
+			if err := m.FeeAllowance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryFeeAllowancesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryFeeAllowancesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFeeAllowancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Grantee = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryFeeAllowancesResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryFeeAllowancesResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFeeAllowancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FeeAllowances", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FeeAllowances = append(m.FeeAllowances, &FeeAllowanceGrant{})
+			if err := m.FeeAllowances[len(m.FeeAllowances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipQuery(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthQuery
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupQuery
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthQuery
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/feegrant/types/query.pb.gw.go b/x/feegrant/types/query.pb.gw.go
new file mode 100644
index 000000000000..499e4a441d18
--- /dev/null
+++ b/x/feegrant/types/query.pb.gw.go
@@ -0,0 +1,322 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: cosmos/feegrant/v1beta1/query.proto
+
+/*
+Package types is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package types
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"github.com/golang/protobuf/descriptor"
+	"github.com/golang/protobuf/proto"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/grpc-ecosystem/grpc-gateway/utilities"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/status"
+)
+
+// Suppress "imported and not used" errors
+var _ codes.Code
+var _ io.Reader
+var _ status.Status
+var _ = runtime.String
+var _ = utilities.NewDoubleArray
+var _ = descriptor.ForMessage
+
+func request_Query_FeeAllowance_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFeeAllowanceRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["granter"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "granter")
+	}
+
+	protoReq.Granter, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "granter", err)
+	}
+
+	val, ok = pathParams["grantee"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "grantee")
+	}
+
+	protoReq.Grantee, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "grantee", err)
+	}
+
+	msg, err := client.FeeAllowance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_FeeAllowance_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFeeAllowanceRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["granter"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "granter")
+	}
+
+	protoReq.Granter, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "granter", err)
+	}
+
+	val, ok = pathParams["grantee"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "grantee")
+	}
+
+	protoReq.Grantee, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "grantee", err)
+	}
+
+	msg, err := server.FeeAllowance(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Query_FeeAllowances_0 = &utilities.DoubleArray{Encoding: map[string]int{"grantee": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Query_FeeAllowances_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFeeAllowancesRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["grantee"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "grantee")
+	}
+
+	protoReq.Grantee, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "grantee", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_FeeAllowances_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.FeeAllowances(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_FeeAllowances_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFeeAllowancesRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["grantee"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "grantee")
+	}
+
+	protoReq.Grantee, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "grantee", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_FeeAllowances_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.FeeAllowances(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
+// UnaryRPC     :call QueryServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
+func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
+
+	mux.Handle("GET", pattern_Query_FeeAllowance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_FeeAllowance_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FeeAllowance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_FeeAllowances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_FeeAllowances_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FeeAllowances_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+	conn, err := grpc.Dial(endpoint, opts...)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+			return
+		}
+		go func() {
+			<-ctx.Done()
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+		}()
+	}()
+
+	return RegisterQueryHandler(ctx, mux, conn)
+}
+
+// RegisterQueryHandler registers the http handlers for service Query to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+	return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn))
+}
+
+// RegisterQueryHandlerClient registers the http handlers for service Query
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "QueryClient" to call the correct interceptors.
+func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
+
+	mux.Handle("GET", pattern_Query_FeeAllowance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_FeeAllowance_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FeeAllowance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_FeeAllowances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_FeeAllowances_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FeeAllowances_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+var (
+	pattern_Query_FeeAllowance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "feegrant", "v1beta1", "fee_allowance", "granter", "grantee"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_FeeAllowances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "feegrant", "v1beta1", "fee_allowances", "grantee"}, "", runtime.AssumeColonVerbOpt(true)))
+)
+
+var (
+	forward_Query_FeeAllowance_0 = runtime.ForwardResponseMessage
+
+	forward_Query_FeeAllowances_0 = runtime.ForwardResponseMessage
+)
diff --git a/x/feegrant/types/tx.pb.go b/x/feegrant/types/tx.pb.go
new file mode 100644
index 000000000000..d3080f10e3df
--- /dev/null
+++ b/x/feegrant/types/tx.pb.go
@@ -0,0 +1,1033 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmos/feegrant/v1beta1/tx.proto
+
+package types
+
+import (
+	context "context"
+	fmt "fmt"
+	types "github.com/cosmos/cosmos-sdk/codec/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	grpc1 "github.com/gogo/protobuf/grpc"
+	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/regen-network/cosmos-proto"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// MsgGrantFeeAllowance adds permission for Grantee to spend up to Allowance
+// of fees from the account of Granter.
+type MsgGrantFeeAllowance struct {
+	Granter   string     `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
+	Grantee   string     `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
+	Allowance *types.Any `protobuf:"bytes,3,opt,name=allowance,proto3" json:"allowance,omitempty"`
+}
+
+func (m *MsgGrantFeeAllowance) Reset()         { *m = MsgGrantFeeAllowance{} }
+func (m *MsgGrantFeeAllowance) String() string { return proto.CompactTextString(m) }
+func (*MsgGrantFeeAllowance) ProtoMessage()    {}
+func (*MsgGrantFeeAllowance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_dd44ad7946dad783, []int{0}
+}
+func (m *MsgGrantFeeAllowance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgGrantFeeAllowance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgGrantFeeAllowance.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgGrantFeeAllowance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgGrantFeeAllowance.Merge(m, src)
+}
+func (m *MsgGrantFeeAllowance) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgGrantFeeAllowance) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgGrantFeeAllowance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgGrantFeeAllowance proto.InternalMessageInfo
+
+func (m *MsgGrantFeeAllowance) GetGranter() string {
+	if m != nil {
+		return m.Granter
+	}
+	return ""
+}
+
+func (m *MsgGrantFeeAllowance) GetGrantee() string {
+	if m != nil {
+		return m.Grantee
+	}
+	return ""
+}
+
+func (m *MsgGrantFeeAllowance) GetAllowance() *types.Any {
+	if m != nil {
+		return m.Allowance
+	}
+	return nil
+}
+
+// MsgGrantFeeAllowanceResponse defines the Msg/GrantFeeAllowanceResponse response type.
+type MsgGrantFeeAllowanceResponse struct {
+}
+
+func (m *MsgGrantFeeAllowanceResponse) Reset()         { *m = MsgGrantFeeAllowanceResponse{} }
+func (m *MsgGrantFeeAllowanceResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgGrantFeeAllowanceResponse) ProtoMessage()    {}
+func (*MsgGrantFeeAllowanceResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_dd44ad7946dad783, []int{1}
+}
+func (m *MsgGrantFeeAllowanceResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgGrantFeeAllowanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgGrantFeeAllowanceResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgGrantFeeAllowanceResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgGrantFeeAllowanceResponse.Merge(m, src)
+}
+func (m *MsgGrantFeeAllowanceResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgGrantFeeAllowanceResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgGrantFeeAllowanceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgGrantFeeAllowanceResponse proto.InternalMessageInfo
+
+// MsgRevokeFeeAllowance removes any existing FeeAllowance from Granter to Grantee.
+type MsgRevokeFeeAllowance struct {
+	Granter string `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
+	Grantee string `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
+}
+
+func (m *MsgRevokeFeeAllowance) Reset()         { *m = MsgRevokeFeeAllowance{} }
+func (m *MsgRevokeFeeAllowance) String() string { return proto.CompactTextString(m) }
+func (*MsgRevokeFeeAllowance) ProtoMessage()    {}
+func (*MsgRevokeFeeAllowance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_dd44ad7946dad783, []int{2}
+}
+func (m *MsgRevokeFeeAllowance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgRevokeFeeAllowance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgRevokeFeeAllowance.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgRevokeFeeAllowance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgRevokeFeeAllowance.Merge(m, src)
+}
+func (m *MsgRevokeFeeAllowance) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgRevokeFeeAllowance) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgRevokeFeeAllowance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgRevokeFeeAllowance proto.InternalMessageInfo
+
+func (m *MsgRevokeFeeAllowance) GetGranter() string {
+	if m != nil {
+		return m.Granter
+	}
+	return ""
+}
+
+func (m *MsgRevokeFeeAllowance) GetGrantee() string {
+	if m != nil {
+		return m.Grantee
+	}
+	return ""
+}
+
+// MsgRevokeFeeAllowanceResponse defines the Msg/RevokeFeeAllowanceResponse response type.
+type MsgRevokeFeeAllowanceResponse struct {
+}
+
+func (m *MsgRevokeFeeAllowanceResponse) Reset()         { *m = MsgRevokeFeeAllowanceResponse{} }
+func (m *MsgRevokeFeeAllowanceResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgRevokeFeeAllowanceResponse) ProtoMessage()    {}
+func (*MsgRevokeFeeAllowanceResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_dd44ad7946dad783, []int{3}
+}
+func (m *MsgRevokeFeeAllowanceResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgRevokeFeeAllowanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgRevokeFeeAllowanceResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgRevokeFeeAllowanceResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgRevokeFeeAllowanceResponse.Merge(m, src)
+}
+func (m *MsgRevokeFeeAllowanceResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgRevokeFeeAllowanceResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgRevokeFeeAllowanceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgRevokeFeeAllowanceResponse proto.InternalMessageInfo
+
+func init() {
+	proto.RegisterType((*MsgGrantFeeAllowance)(nil), "cosmos.feegrant.v1beta1.MsgGrantFeeAllowance")
+	proto.RegisterType((*MsgGrantFeeAllowanceResponse)(nil), "cosmos.feegrant.v1beta1.MsgGrantFeeAllowanceResponse")
+	proto.RegisterType((*MsgRevokeFeeAllowance)(nil), "cosmos.feegrant.v1beta1.MsgRevokeFeeAllowance")
+	proto.RegisterType((*MsgRevokeFeeAllowanceResponse)(nil), "cosmos.feegrant.v1beta1.MsgRevokeFeeAllowanceResponse")
+}
+
+func init() { proto.RegisterFile("cosmos/feegrant/v1beta1/tx.proto", fileDescriptor_dd44ad7946dad783) }
+
+var fileDescriptor_dd44ad7946dad783 = []byte{
+	// 345 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0xce, 0x2f, 0xce,
+	0xcd, 0x2f, 0xd6, 0x4f, 0x4b, 0x4d, 0x4d, 0x2f, 0x4a, 0xcc, 0x2b, 0xd1, 0x2f, 0x33, 0x4c, 0x4a,
+	0x2d, 0x49, 0x34, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x87, 0xa8,
+	0xd0, 0x83, 0xa9, 0xd0, 0x83, 0xaa, 0x90, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0xab, 0xd1, 0x07,
+	0xb1, 0x20, 0xca, 0xa5, 0x24, 0xd3, 0xf3, 0xf3, 0xd3, 0x73, 0x52, 0xf5, 0xc1, 0xbc, 0xa4, 0xd2,
+	0x34, 0xfd, 0xc4, 0xbc, 0x4a, 0x98, 0x14, 0xc4, 0xa4, 0x78, 0x88, 0x1e, 0xa8, 0xb1, 0x60, 0x8e,
+	0xd2, 0x44, 0x46, 0x2e, 0x11, 0xdf, 0xe2, 0x74, 0x77, 0x90, 0x05, 0x6e, 0xa9, 0xa9, 0x8e, 0x39,
+	0x39, 0xf9, 0xe5, 0x89, 0x79, 0xc9, 0xa9, 0x42, 0x12, 0x5c, 0xec, 0x60, 0x5b, 0x53, 0x8b, 0x24,
+	0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x60, 0x5c, 0x84, 0x4c, 0xaa, 0x04, 0x13, 0xb2, 0x4c, 0xaa,
+	0x90, 0x2b, 0x17, 0x67, 0x22, 0xcc, 0x00, 0x09, 0x66, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x11, 0x3d,
+	0x88, 0xb3, 0xf4, 0x60, 0xce, 0xd2, 0x73, 0xcc, 0xab, 0x74, 0x12, 0x3c, 0xb5, 0x45, 0x97, 0x17,
+	0xd9, 0x3a, 0xcf, 0x20, 0x84, 0x4e, 0x25, 0x39, 0x2e, 0x19, 0x6c, 0x4e, 0x0a, 0x4a, 0x2d, 0x2e,
+	0xc8, 0xcf, 0x2b, 0x4e, 0x55, 0xf2, 0xe6, 0x12, 0xf5, 0x2d, 0x4e, 0x0f, 0x4a, 0x2d, 0xcb, 0xcf,
+	0x4e, 0xa5, 0xd4, 0xcd, 0x4a, 0xf2, 0x5c, 0xb2, 0x58, 0x0d, 0x83, 0xd9, 0x66, 0xf4, 0x8f, 0x91,
+	0x8b, 0xd9, 0xb7, 0x38, 0x5d, 0xa8, 0x92, 0x4b, 0x10, 0x33, 0x94, 0x74, 0xf5, 0x70, 0x44, 0x92,
+	0x1e, 0x36, 0x1f, 0x48, 0x99, 0x92, 0xa4, 0x1c, 0xe6, 0x04, 0xa1, 0x1a, 0x2e, 0x21, 0x2c, 0xbe,
+	0xd5, 0xc3, 0x67, 0x18, 0xa6, 0x7a, 0x29, 0x33, 0xd2, 0xd4, 0xc3, 0x6c, 0x77, 0x72, 0x3f, 0xf1,
+	0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8,
+	0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xdd, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24,
+	0xbd, 0xe4, 0xfc, 0x5c, 0x68, 0xaa, 0x82, 0x52, 0xba, 0xc5, 0x29, 0xd9, 0xfa, 0x15, 0x88, 0xb4,
+	0x5d, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x4e, 0x03, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x7b, 0xbe, 0x24, 0x15, 0xfb, 0x02, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MsgClient interface {
+	// GrantFeeAllowance grants fee allowance to the grantee on the granter's
+	// account with the provided expiration time.
+	GrantFeeAllowance(ctx context.Context, in *MsgGrantFeeAllowance, opts ...grpc.CallOption) (*MsgGrantFeeAllowanceResponse, error)
+	// RevokeFeeAllowance revokes any fee allowance of granter's account that
+	// has been granted to the grantee.
+	RevokeFeeAllowance(ctx context.Context, in *MsgRevokeFeeAllowance, opts ...grpc.CallOption) (*MsgRevokeFeeAllowanceResponse, error)
+}
+
+type msgClient struct {
+	cc grpc1.ClientConn
+}
+
+func NewMsgClient(cc grpc1.ClientConn) MsgClient {
+	return &msgClient{cc}
+}
+
+func (c *msgClient) GrantFeeAllowance(ctx context.Context, in *MsgGrantFeeAllowance, opts ...grpc.CallOption) (*MsgGrantFeeAllowanceResponse, error) {
+	out := new(MsgGrantFeeAllowanceResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.feegrant.v1beta1.Msg/GrantFeeAllowance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) RevokeFeeAllowance(ctx context.Context, in *MsgRevokeFeeAllowance, opts ...grpc.CallOption) (*MsgRevokeFeeAllowanceResponse, error) {
+	out := new(MsgRevokeFeeAllowanceResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.feegrant.v1beta1.Msg/RevokeFeeAllowance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+type MsgServer interface {
+	// GrantFeeAllowance grants fee allowance to the grantee on the granter's
+	// account with the provided expiration time.
+	GrantFeeAllowance(context.Context, *MsgGrantFeeAllowance) (*MsgGrantFeeAllowanceResponse, error)
+	// RevokeFeeAllowance revokes any fee allowance of granter's account that
+	// has been granted to the grantee.
+	RevokeFeeAllowance(context.Context, *MsgRevokeFeeAllowance) (*MsgRevokeFeeAllowanceResponse, error)
+}
+
+// UnimplementedMsgServer can be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (*UnimplementedMsgServer) GrantFeeAllowance(ctx context.Context, req *MsgGrantFeeAllowance) (*MsgGrantFeeAllowanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GrantFeeAllowance not implemented")
+}
+func (*UnimplementedMsgServer) RevokeFeeAllowance(ctx context.Context, req *MsgRevokeFeeAllowance) (*MsgRevokeFeeAllowanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RevokeFeeAllowance not implemented")
+}
+
+func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
+	s.RegisterService(&_Msg_serviceDesc, srv)
+}
+
+func _Msg_GrantFeeAllowance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgGrantFeeAllowance)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).GrantFeeAllowance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.feegrant.v1beta1.Msg/GrantFeeAllowance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).GrantFeeAllowance(ctx, req.(*MsgGrantFeeAllowance))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_RevokeFeeAllowance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgRevokeFeeAllowance)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).RevokeFeeAllowance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.feegrant.v1beta1.Msg/RevokeFeeAllowance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).RevokeFeeAllowance(ctx, req.(*MsgRevokeFeeAllowance))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Msg_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "cosmos.feegrant.v1beta1.Msg",
+	HandlerType: (*MsgServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GrantFeeAllowance",
+			Handler:    _Msg_GrantFeeAllowance_Handler,
+		},
+		{
+			MethodName: "RevokeFeeAllowance",
+			Handler:    _Msg_RevokeFeeAllowance_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "cosmos/feegrant/v1beta1/tx.proto",
+}
+
+func (m *MsgGrantFeeAllowance) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgGrantFeeAllowance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgGrantFeeAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Allowance != nil {
+		{
+			size, err := m.Allowance.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTx(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Grantee) > 0 {
+		i -= len(m.Grantee)
+		copy(dAtA[i:], m.Grantee)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Grantee)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Granter) > 0 {
+		i -= len(m.Granter)
+		copy(dAtA[i:], m.Granter)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Granter)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgGrantFeeAllowanceResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgGrantFeeAllowanceResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgGrantFeeAllowanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgRevokeFeeAllowance) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgRevokeFeeAllowance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgRevokeFeeAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Grantee) > 0 {
+		i -= len(m.Grantee)
+		copy(dAtA[i:], m.Grantee)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Grantee)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Granter) > 0 {
+		i -= len(m.Granter)
+		copy(dAtA[i:], m.Granter)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Granter)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgRevokeFeeAllowanceResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgRevokeFeeAllowanceResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgRevokeFeeAllowanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTx(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *MsgGrantFeeAllowance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Granter)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Grantee)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.Allowance != nil {
+		l = m.Allowance.Size()
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgGrantFeeAllowanceResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *MsgRevokeFeeAllowance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Granter)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Grantee)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgRevokeFeeAllowanceResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func sovTx(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTx(x uint64) (n int) {
+	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MsgGrantFeeAllowance) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgGrantFeeAllowance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgGrantFeeAllowance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Granter", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Granter = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Grantee = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Allowance", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Allowance == nil {
+				m.Allowance = &types.Any{}
+			}
+			if err := m.Allowance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgGrantFeeAllowanceResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgGrantFeeAllowanceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgGrantFeeAllowanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgRevokeFeeAllowance) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgRevokeFeeAllowance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgRevokeFeeAllowance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Granter", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Granter = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Grantee = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgRevokeFeeAllowanceResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgRevokeFeeAllowanceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgRevokeFeeAllowanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTx(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthTx
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupTx
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthTx
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/gov/client/cli/query.go b/x/gov/client/cli/query.go
index 8c67cd96e5e1..b382f540e26b 100644
--- a/x/gov/client/cli/query.go
+++ b/x/gov/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -74,7 +73,7 @@ $ %s query gov proposal 1
 
 			// Query the proposal
 			res, err := queryClient.Proposal(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -149,7 +148,7 @@ $ %s query gov proposals --page=2 --limit=100
 			}
 
 			res, err := queryClient.Proposals(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryProposalsRequest{
 					ProposalStatus: proposalStatus,
 					Voter:          bechVoterAddr,
@@ -208,8 +207,9 @@ $ %s query gov vote 1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk
 			}
 
 			// check to see if the proposal is in the store
+			ctx := cmd.Context()
 			_, err = queryClient.Proposal(
-				context.Background(),
+				ctx,
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -222,7 +222,7 @@ $ %s query gov vote 1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk
 			}
 
 			res, err := queryClient.Vote(
-				context.Background(),
+				ctx,
 				&types.QueryVoteRequest{ProposalId: proposalID, Voter: args[1]},
 			)
 			if err != nil {
@@ -282,8 +282,9 @@ $ %[1]s query gov votes 1 --page=2 --limit=100
 			}
 
 			// check to see if the proposal is in the store
+			ctx := cmd.Context()
 			proposalRes, err := queryClient.Proposal(
-				context.Background(),
+				ctx,
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -315,7 +316,7 @@ $ %[1]s query gov votes 1 --page=2 --limit=100
 			}
 
 			res, err := queryClient.Votes(
-				context.Background(),
+				ctx,
 				&types.QueryVotesRequest{ProposalId: proposalID, Pagination: pageReq},
 			)
 
@@ -364,8 +365,9 @@ $ %s query gov deposit 1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk
 			}
 
 			// check to see if the proposal is in the store
+			ctx := cmd.Context()
 			_, err = queryClient.Proposal(
-				context.Background(),
+				ctx,
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -378,7 +380,7 @@ $ %s query gov deposit 1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk
 			}
 
 			res, err := queryClient.Deposit(
-				context.Background(),
+				ctx,
 				&types.QueryDepositRequest{ProposalId: proposalID, Depositor: args[1]},
 			)
 			if err != nil {
@@ -434,8 +436,9 @@ $ %s query gov deposits 1
 			}
 
 			// check to see if the proposal is in the store
+			ctx := cmd.Context()
 			proposalRes, err := queryClient.Proposal(
-				context.Background(),
+				ctx,
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -464,7 +467,7 @@ $ %s query gov deposits 1
 			}
 
 			res, err := queryClient.Deposits(
-				context.Background(),
+				ctx,
 				&types.QueryDepositsRequest{ProposalId: proposalID, Pagination: pageReq},
 			)
 
@@ -512,8 +515,9 @@ $ %s query gov tally 1
 			}
 
 			// check to see if the proposal is in the store
+			ctx := cmd.Context()
 			_, err = queryClient.Proposal(
-				context.Background(),
+				ctx,
 				&types.QueryProposalRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -522,7 +526,7 @@ $ %s query gov tally 1
 
 			// Query store
 			res, err := queryClient.TallyResult(
-				context.Background(),
+				ctx,
 				&types.QueryTallyResultRequest{ProposalId: proposalID},
 			)
 			if err != nil {
@@ -561,8 +565,9 @@ $ %s query gov params
 			queryClient := types.NewQueryClient(clientCtx)
 
 			// Query store for all 3 params
+			ctx := cmd.Context()
 			votingRes, err := queryClient.Params(
-				context.Background(),
+				ctx,
 				&types.QueryParamsRequest{ParamsType: "voting"},
 			)
 			if err != nil {
@@ -570,7 +575,7 @@ $ %s query gov params
 			}
 
 			tallyRes, err := queryClient.Params(
-				context.Background(),
+				ctx,
 				&types.QueryParamsRequest{ParamsType: "tallying"},
 			)
 			if err != nil {
@@ -578,7 +583,7 @@ $ %s query gov params
 			}
 
 			depositRes, err := queryClient.Params(
-				context.Background(),
+				ctx,
 				&types.QueryParamsRequest{ParamsType: "deposit"},
 			)
 			if err != nil {
@@ -626,7 +631,7 @@ $ %s query gov param deposit
 
 			// Query store
 			res, err := queryClient.Params(
-				context.Background(),
+				cmd.Context(),
 				&types.QueryParamsRequest{ParamsType: args[0]},
 			)
 			if err != nil {
diff --git a/x/gov/types/keys.go b/x/gov/types/keys.go
index 7681116fc46a..fe98bcbf81c4 100644
--- a/x/gov/types/keys.go
+++ b/x/gov/types/keys.go
@@ -6,6 +6,7 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -33,9 +34,9 @@ const (
 //
 // - 0x03: nextProposalID
 //
-// - 0x10<proposalID_Bytes><depositorAddr_Bytes>: Deposit
+// - 0x10<proposalID_Bytes><depositorAddrLen (1 Byte)><depositorAddr_Bytes>: Deposit
 //
-// - 0x20<proposalID_Bytes><voterAddr_Bytes>: Voter
+// - 0x20<proposalID_Bytes><voterAddrLen (1 Byte)><voterAddr_Bytes>: Voter
 var (
 	ProposalsKeyPrefix          = []byte{0x00}
 	ActiveProposalQueuePrefix   = []byte{0x01}
@@ -93,7 +94,7 @@ func DepositsKey(proposalID uint64) []byte {
 
 // DepositKey key of a specific deposit from the store
 func DepositKey(proposalID uint64, depositorAddr sdk.AccAddress) []byte {
-	return append(DepositsKey(proposalID), depositorAddr.Bytes()...)
+	return append(DepositsKey(proposalID), address.MustLengthPrefix(depositorAddr.Bytes())...)
 }
 
 // VotesKey gets the first part of the votes key based on the proposalID
@@ -103,7 +104,7 @@ func VotesKey(proposalID uint64) []byte {
 
 // VoteKey key of a specific vote from the store
 func VoteKey(proposalID uint64, voterAddr sdk.AccAddress) []byte {
-	return append(VotesKey(proposalID), voterAddr.Bytes()...)
+	return append(VotesKey(proposalID), address.MustLengthPrefix(voterAddr.Bytes())...)
 }
 
 // Split keys function; used for iterators
@@ -154,11 +155,9 @@ func splitKeyWithTime(key []byte) (proposalID uint64, endTime time.Time) {
 }
 
 func splitKeyWithAddress(key []byte) (proposalID uint64, addr sdk.AccAddress) {
-	if len(key[1:]) != 8+sdk.AddrLen {
-		panic(fmt.Sprintf("unexpected key length (%d ≠ %d)", len(key), 8+sdk.AddrLen))
-	}
-
+	// Both Vote and Deposit store keys are of format:
+	// <prefix (1 Byte)><proposalID (8 bytes)><addrLen (1 Byte)><addr_Bytes>
 	proposalID = GetProposalIDFromBytes(key[1:9])
-	addr = sdk.AccAddress(key[9:])
+	addr = sdk.AccAddress(key[10:])
 	return
 }
diff --git a/x/gov/types/keys_test.go b/x/gov/types/keys_test.go
index 80dfa7d207a3..30266f8f4d78 100644
--- a/x/gov/types/keys_test.go
+++ b/x/gov/types/keys_test.go
@@ -46,11 +46,6 @@ func TestDepositKeys(t *testing.T) {
 	proposalID, depositorAddr := SplitKeyDeposit(key)
 	require.Equal(t, int(proposalID), 2)
 	require.Equal(t, addr, depositorAddr)
-
-	// invalid key
-	addr2 := sdk.AccAddress("test1")
-	key = DepositKey(5, addr2)
-	require.Panics(t, func() { SplitKeyDeposit(key) })
 }
 
 func TestVoteKeys(t *testing.T) {
@@ -63,9 +58,4 @@ func TestVoteKeys(t *testing.T) {
 	proposalID, voterAddr := SplitKeyDeposit(key)
 	require.Equal(t, int(proposalID), 2)
 	require.Equal(t, addr, voterAddr)
-
-	// invalid key
-	addr2 := sdk.AccAddress("test1")
-	key = VoteKey(5, addr2)
-	require.Panics(t, func() { SplitKeyVote(key) })
 }
diff --git a/x/ibc/applications/transfer/client/cli/query.go b/x/ibc/applications/transfer/client/cli/query.go
index 7d281bb4155f..b9658e05ae92 100644
--- a/x/ibc/applications/transfer/client/cli/query.go
+++ b/x/ibc/applications/transfer/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -31,7 +30,7 @@ func GetCmdQueryDenomTrace() *cobra.Command {
 				Hash: args[0],
 			}
 
-			res, err := queryClient.DenomTrace(context.Background(), req)
+			res, err := queryClient.DenomTrace(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -69,7 +68,7 @@ func GetCmdQueryDenomTraces() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.DenomTraces(context.Background(), req)
+			res, err := queryClient.DenomTraces(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -98,7 +97,7 @@ func GetCmdParams() *cobra.Command {
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, _ := queryClient.Params(context.Background(), &types.QueryParamsRequest{})
+			res, _ := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
 			return clientCtx.PrintProto(res.Params)
 		},
 	}
diff --git a/x/ibc/applications/transfer/module.go b/x/ibc/applications/transfer/module.go
index 039597afe5e4..67c736555b8a 100644
--- a/x/ibc/applications/transfer/module.go
+++ b/x/ibc/applications/transfer/module.go
@@ -202,8 +202,8 @@ func ValidateTransferChannelParams(
 	if err != nil {
 		return err
 	}
-	if channelSequence > math.MaxUint32 {
-		return sdkerrors.Wrapf(types.ErrMaxTransferChannels, "channel sequence %d is greater than max allowed transfer channels %d", channelSequence, math.MaxUint32)
+	if channelSequence > uint64(math.MaxUint32) {
+		return sdkerrors.Wrapf(types.ErrMaxTransferChannels, "channel sequence %d is greater than max allowed transfer channels %d", channelSequence, uint64(math.MaxUint32))
 	}
 	if order != channeltypes.UNORDERED {
 		return sdkerrors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order)
@@ -379,7 +379,7 @@ func (am AppModule) OnAcknowledgementPacket(
 			sdk.NewAttribute(types.AttributeKeyReceiver, data.Receiver),
 			sdk.NewAttribute(types.AttributeKeyDenom, data.Denom),
 			sdk.NewAttribute(types.AttributeKeyAmount, fmt.Sprintf("%d", data.Amount)),
-			sdk.NewAttribute(types.AttributeKeyAck, fmt.Sprintf("%v", ack)),
+			sdk.NewAttribute(types.AttributeKeyAck, ack.String()),
 		),
 	)
 
diff --git a/x/ibc/core/02-client/client/cli/query.go b/x/ibc/core/02-client/client/cli/query.go
index 7c49b12e0220..c1b5e51a050f 100644
--- a/x/ibc/core/02-client/client/cli/query.go
+++ b/x/ibc/core/02-client/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"errors"
 	"fmt"
 
@@ -44,7 +43,7 @@ func GetCmdQueryClientStates() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.ClientStates(context.Background(), req)
+			res, err := queryClient.ClientStates(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -118,7 +117,7 @@ func GetCmdQueryConsensusStates() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.ConsensusStates(context.Background(), req)
+			res, err := queryClient.ConsensusStates(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -250,7 +249,7 @@ func GetCmdParams() *cobra.Command {
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, _ := queryClient.ClientParams(context.Background(), &types.QueryClientParamsRequest{})
+			res, _ := queryClient.ClientParams(cmd.Context(), &types.QueryClientParamsRequest{})
 			return clientCtx.PrintProto(res.Params)
 		},
 	}
diff --git a/x/ibc/core/02-client/types/client.go b/x/ibc/core/02-client/types/client.go
index 1c44d6e2b9c2..6d51828af0f7 100644
--- a/x/ibc/core/02-client/types/client.go
+++ b/x/ibc/core/02-client/types/client.go
@@ -93,7 +93,7 @@ func ValidateClientType(clientType string) error {
 	}
 
 	smallestPossibleClientID := FormatClientIdentifier(clientType, 0)
-	largestPossibleClientID := FormatClientIdentifier(clientType, math.MaxUint64)
+	largestPossibleClientID := FormatClientIdentifier(clientType, uint64(math.MaxUint64))
 
 	// IsValidClientID will check client type format and if the sequence is a uint64
 	if !IsValidClientID(smallestPossibleClientID) {
diff --git a/x/ibc/core/03-connection/client/cli/query.go b/x/ibc/core/03-connection/client/cli/query.go
index 071410398db5..21c4bd8f578e 100644
--- a/x/ibc/core/03-connection/client/cli/query.go
+++ b/x/ibc/core/03-connection/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -39,7 +38,7 @@ func GetCmdQueryConnections() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.Connections(context.Background(), req)
+			res, err := queryClient.Connections(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
diff --git a/x/ibc/core/04-channel/client/cli/query.go b/x/ibc/core/04-channel/client/cli/query.go
index 5d059c08cf94..03df474f1e79 100644
--- a/x/ibc/core/04-channel/client/cli/query.go
+++ b/x/ibc/core/04-channel/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 
@@ -44,7 +43,7 @@ func GetCmdQueryChannels() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.Channels(context.Background(), req)
+			res, err := queryClient.Channels(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -118,7 +117,7 @@ func GetCmdQueryConnectionChannels() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.ConnectionChannels(context.Background(), req)
+			res, err := queryClient.ConnectionChannels(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -189,7 +188,7 @@ func GetCmdQueryPacketCommitments() *cobra.Command {
 				Pagination: pageReq,
 			}
 
-			res, err := queryClient.PacketCommitments(context.Background(), req)
+			res, err := queryClient.PacketCommitments(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -357,7 +356,7 @@ The return value represents:
 				PacketCommitmentSequences: seqs,
 			}
 
-			res, err := queryClient.UnreceivedPackets(context.Background(), req)
+			res, err := queryClient.UnreceivedPackets(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
@@ -407,7 +406,7 @@ The return value represents:
 				PacketAckSequences: seqs,
 			}
 
-			res, err := queryClient.UnreceivedAcks(context.Background(), req)
+			res, err := queryClient.UnreceivedAcks(cmd.Context(), req)
 			if err != nil {
 				return err
 			}
diff --git a/x/ibc/core/04-channel/keeper/packet.go b/x/ibc/core/04-channel/keeper/packet.go
index 9af59745d549..49b59733c5a3 100644
--- a/x/ibc/core/04-channel/keeper/packet.go
+++ b/x/ibc/core/04-channel/keeper/packet.go
@@ -129,6 +129,9 @@ func (k Keeper) SendPacket(
 			sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 			sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
 			sdk.NewAttribute(types.AttributeKeyChannelOrdering, channel.Ordering.String()),
+			// we only support 1-hop packets now, and that is the most important hop for a relayer
+			// (is it going to a chain I am connected to)
+			sdk.NewAttribute(types.AttributeKeyConnection, channel.ConnectionHops[0]),
 		),
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
@@ -289,6 +292,9 @@ func (k Keeper) RecvPacket(
 			sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 			sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
 			sdk.NewAttribute(types.AttributeKeyChannelOrdering, channel.Ordering.String()),
+			// we only support 1-hop packets now, and that is the most important hop for a relayer
+			// (is it going to a chain I am connected to)
+			sdk.NewAttribute(types.AttributeKeyConnection, channel.ConnectionHops[0]),
 		),
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
@@ -370,6 +376,9 @@ func (k Keeper) WriteAcknowledgement(
 			sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 			sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
 			sdk.NewAttribute(types.AttributeKeyAck, string(acknowledgement)),
+			// we only support 1-hop packets now, and that is the most important hop for a relayer
+			// (is it going to a chain I am connected to)
+			sdk.NewAttribute(types.AttributeKeyConnection, channel.ConnectionHops[0]),
 		),
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
@@ -505,6 +514,9 @@ func (k Keeper) AcknowledgePacket(
 			sdk.NewAttribute(types.AttributeKeyDstPort, packet.GetDestPort()),
 			sdk.NewAttribute(types.AttributeKeyDstChannel, packet.GetDestChannel()),
 			sdk.NewAttribute(types.AttributeKeyChannelOrdering, channel.Ordering.String()),
+			// we only support 1-hop packets now, and that is the most important hop for a relayer
+			// (is it going to a chain I am connected to)
+			sdk.NewAttribute(types.AttributeKeyConnection, channel.ConnectionHops[0]),
 		),
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
diff --git a/x/ibc/core/04-channel/types/events.go b/x/ibc/core/04-channel/types/events.go
index 923587d439d7..b9ddb3052c30 100644
--- a/x/ibc/core/04-channel/types/events.go
+++ b/x/ibc/core/04-channel/types/events.go
@@ -30,6 +30,7 @@ const (
 	AttributeKeyDstPort          = "packet_dst_port"
 	AttributeKeyDstChannel       = "packet_dst_channel"
 	AttributeKeyChannelOrdering  = "packet_channel_ordering"
+	AttributeKeyConnection       = "packet_connection"
 )
 
 // IBC channel events vars
diff --git a/x/mint/client/cli/query.go b/x/mint/client/cli/query.go
index cce0d7c12bbb..792fa8a6798f 100644
--- a/x/mint/client/cli/query.go
+++ b/x/mint/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -45,7 +44,7 @@ func GetCmdQueryParams() *cobra.Command {
 			queryClient := types.NewQueryClient(clientCtx)
 
 			params := &types.QueryParamsRequest{}
-			res, err := queryClient.Params(context.Background(), params)
+			res, err := queryClient.Params(cmd.Context(), params)
 
 			if err != nil {
 				return err
@@ -75,7 +74,7 @@ func GetCmdQueryInflation() *cobra.Command {
 			queryClient := types.NewQueryClient(clientCtx)
 
 			params := &types.QueryInflationRequest{}
-			res, err := queryClient.Inflation(context.Background(), params)
+			res, err := queryClient.Inflation(cmd.Context(), params)
 
 			if err != nil {
 				return err
@@ -105,7 +104,7 @@ func GetCmdQueryAnnualProvisions() *cobra.Command {
 			queryClient := types.NewQueryClient(clientCtx)
 
 			params := &types.QueryAnnualProvisionsRequest{}
-			res, err := queryClient.AnnualProvisions(context.Background(), params)
+			res, err := queryClient.AnnualProvisions(cmd.Context(), params)
 
 			if err != nil {
 				return err
diff --git a/x/mint/simulation/decoder.go b/x/mint/simulation/decoder.go
index 37d9930f7da5..f0a89be43965 100644
--- a/x/mint/simulation/decoder.go
+++ b/x/mint/simulation/decoder.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/mint/types"
 )
 
-// NewDecodeStore returns a decoder function closure that umarshals the KVPair's
+// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
 // Value to the corresponding mint type.
 func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
 	return func(kvA, kvB kv.Pair) string {
diff --git a/x/mint/types/minter_test.go b/x/mint/types/minter_test.go
index 8760a66f4466..4abedb51cd05 100644
--- a/x/mint/types/minter_test.go
+++ b/x/mint/types/minter_test.go
@@ -89,6 +89,7 @@ func TestBlockProvision(t *testing.T) {
 // using sdk.Dec operations: (current implementation)
 // BenchmarkBlockProvision-4 3000000 429 ns/op
 func BenchmarkBlockProvision(b *testing.B) {
+	b.ReportAllocs()
 	minter := InitialMinter(sdk.NewDecWithPrec(1, 1))
 	params := DefaultParams()
 
@@ -105,6 +106,7 @@ func BenchmarkBlockProvision(b *testing.B) {
 // Next inflation benchmarking
 // BenchmarkNextInflation-4 1000000 1828 ns/op
 func BenchmarkNextInflation(b *testing.B) {
+	b.ReportAllocs()
 	minter := InitialMinter(sdk.NewDecWithPrec(1, 1))
 	params := DefaultParams()
 	bondedRatio := sdk.NewDecWithPrec(1, 1)
@@ -119,6 +121,7 @@ func BenchmarkNextInflation(b *testing.B) {
 // Next annual provisions benchmarking
 // BenchmarkNextAnnualProvisions-4 5000000 251 ns/op
 func BenchmarkNextAnnualProvisions(b *testing.B) {
+	b.ReportAllocs()
 	minter := InitialMinter(sdk.NewDecWithPrec(1, 1))
 	params := DefaultParams()
 	totalSupply := sdk.NewInt(100000000000000)
diff --git a/x/params/client/cli/query.go b/x/params/client/cli/query.go
index 516ff3b6b474..ce7b45d0602d 100644
--- a/x/params/client/cli/query.go
+++ b/x/params/client/cli/query.go
@@ -1,8 +1,6 @@
 package cli
 
 import (
-	"context"
-
 	"github.com/spf13/cobra"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -41,7 +39,7 @@ func NewQuerySubspaceParamsCmd() *cobra.Command {
 			queryClient := proposal.NewQueryClient(clientCtx)
 
 			params := proposal.QueryParamsRequest{Subspace: args[0], Key: args[1]}
-			res, err := queryClient.Params(context.Background(), &params)
+			res, err := queryClient.Params(cmd.Context(), &params)
 			if err != nil {
 				return err
 			}
diff --git a/x/slashing/client/cli/query.go b/x/slashing/client/cli/query.go
index d55b33201b10..6cb2f803d085 100644
--- a/x/slashing/client/cli/query.go
+++ b/x/slashing/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -58,7 +57,7 @@ $ <appd> query slashing signing-info cosmosvalconspub1zcjduepqfhvwcmt7p06fvdgexx
 
 			consAddr := sdk.ConsAddress(pk.Address())
 			params := &types.QuerySigningInfoRequest{ConsAddress: consAddr.String()}
-			res, err := queryClient.SigningInfo(context.Background(), params)
+			res, err := queryClient.SigningInfo(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -95,7 +94,7 @@ $ <appd> query slashing signing-infos
 			}
 
 			params := &types.QuerySigningInfosRequest{Pagination: pageReq}
-			res, err := queryClient.SigningInfos(context.Background(), params)
+			res, err := queryClient.SigningInfos(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -128,7 +127,7 @@ $ <appd> query slashing params
 			queryClient := types.NewQueryClient(clientCtx)
 
 			params := &types.QueryParamsRequest{}
-			res, err := queryClient.Params(context.Background(), params)
+			res, err := queryClient.Params(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
diff --git a/x/slashing/types/keys.go b/x/slashing/types/keys.go
index c9792d22085f..f0049760f0a0 100644
--- a/x/slashing/types/keys.go
+++ b/x/slashing/types/keys.go
@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -23,11 +24,11 @@ const (
 // Keys for slashing store
 // Items are stored with the following key: values
 //
-// - 0x01<consAddress_Bytes>: ValidatorSigningInfo
+// - 0x01<consAddrLen (1 Byte)><consAddress_Bytes>: ValidatorSigningInfo
 //
-// - 0x02<consAddress_Bytes><period_Bytes>: bool
+// - 0x02<consAddrLen (1 Byte)><consAddress_Bytes><period_Bytes>: bool
 //
-// - 0x03<accAddr_Bytes>: crypto.PubKey
+// - 0x03<accAddrLen (1 Byte)><accAddr_Bytes>: cryptotypes.PubKey
 var (
 	ValidatorSigningInfoKeyPrefix         = []byte{0x01} // Prefix for signing info
 	ValidatorMissedBlockBitArrayKeyPrefix = []byte{0x02} // Prefix for missed block bit array
@@ -36,31 +37,31 @@ var (
 
 // ValidatorSigningInfoKey - stored by *Consensus* address (not operator address)
 func ValidatorSigningInfoKey(v sdk.ConsAddress) []byte {
-	return append(ValidatorSigningInfoKeyPrefix, v.Bytes()...)
+	return append(ValidatorSigningInfoKeyPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
 // ValidatorSigningInfoAddress - extract the address from a validator signing info key
 func ValidatorSigningInfoAddress(key []byte) (v sdk.ConsAddress) {
-	addr := key[1:]
-	if len(addr) != sdk.AddrLen {
-		panic("unexpected key length")
-	}
+	// Remove prefix and address length.
+	addr := key[2:]
+
 	return sdk.ConsAddress(addr)
 }
 
 // ValidatorMissedBlockBitArrayPrefixKey - stored by *Consensus* address (not operator address)
 func ValidatorMissedBlockBitArrayPrefixKey(v sdk.ConsAddress) []byte {
-	return append(ValidatorMissedBlockBitArrayKeyPrefix, v.Bytes()...)
+	return append(ValidatorMissedBlockBitArrayKeyPrefix, address.MustLengthPrefix(v.Bytes())...)
 }
 
 // ValidatorMissedBlockBitArrayKey - stored by *Consensus* address (not operator address)
 func ValidatorMissedBlockBitArrayKey(v sdk.ConsAddress, i int64) []byte {
 	b := make([]byte, 8)
 	binary.LittleEndian.PutUint64(b, uint64(i))
+
 	return append(ValidatorMissedBlockBitArrayPrefixKey(v), b...)
 }
 
 // AddrPubkeyRelationKey gets pubkey relation key used to get the pubkey from the address
-func AddrPubkeyRelationKey(address []byte) []byte {
-	return append(AddrPubkeyRelationKeyPrefix, address...)
+func AddrPubkeyRelationKey(addr []byte) []byte {
+	return append(AddrPubkeyRelationKeyPrefix, address.MustLengthPrefix(addr)...)
 }
diff --git a/x/staking/client/cli/query.go b/x/staking/client/cli/query.go
index 1e8b0a5c539a..7bf3ae41ccbe 100644
--- a/x/staking/client/cli/query.go
+++ b/x/staking/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -115,7 +114,7 @@ $ %s query staking validators
 				return err
 			}
 
-			result, err := queryClient.Validators(context.Background(), &types.QueryValidatorsRequest{
+			result, err := queryClient.Validators(cmd.Context(), &types.QueryValidatorsRequest{
 				// Leaving status empty on purpose to query all validators.
 				Pagination: pageReq,
 			})
@@ -172,7 +171,7 @@ $ %s query staking unbonding-delegations-from %s1gghjut3ccd8ay0zduzj64hwre2fxs9l
 				Pagination:    pageReq,
 			}
 
-			res, err := queryClient.ValidatorUnbondingDelegations(context.Background(), params)
+			res, err := queryClient.ValidatorUnbondingDelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -227,7 +226,7 @@ $ %s query staking redelegations-from %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 				Pagination:       pageReq,
 			}
 
-			res, err := queryClient.Redelegations(context.Background(), params)
+			res, err := queryClient.Redelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -282,7 +281,7 @@ $ %s query staking delegation %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p %s1gghju
 				ValidatorAddr: valAddr.String(),
 			}
 
-			res, err := queryClient.Delegation(context.Background(), params)
+			res, err := queryClient.Delegation(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -336,7 +335,7 @@ $ %s query staking delegations %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
 				Pagination:    pageReq,
 			}
 
-			res, err := queryClient.DelegatorDelegations(context.Background(), params)
+			res, err := queryClient.DelegatorDelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -391,7 +390,7 @@ $ %s query staking delegations-to %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 				Pagination:    pageReq,
 			}
 
-			res, err := queryClient.ValidatorDelegations(context.Background(), params)
+			res, err := queryClient.ValidatorDelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -447,7 +446,7 @@ $ %s query staking unbonding-delegation %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9
 				ValidatorAddr: valAddr.String(),
 			}
 
-			res, err := queryClient.UnbondingDelegation(context.Background(), params)
+			res, err := queryClient.UnbondingDelegation(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -501,7 +500,7 @@ $ %s query staking unbonding-delegations %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru
 				Pagination:    pageReq,
 			}
 
-			res, err := queryClient.DelegatorUnbondingDelegations(context.Background(), params)
+			res, err := queryClient.DelegatorUnbondingDelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -563,7 +562,7 @@ $ %s query staking redelegation %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p %s1l2r
 				SrcValidatorAddr: valSrcAddr.String(),
 			}
 
-			res, err := queryClient.Redelegations(context.Background(), params)
+			res, err := queryClient.Redelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -617,7 +616,7 @@ $ %s query staking redelegation %s1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
 				Pagination:    pageReq,
 			}
 
-			res, err := queryClient.Redelegations(context.Background(), params)
+			res, err := queryClient.Redelegations(cmd.Context(), params)
 			if err != nil {
 				return err
 			}
@@ -660,7 +659,7 @@ $ %s query staking historical-info 5
 			}
 
 			params := &types.QueryHistoricalInfoRequest{Height: height}
-			res, err := queryClient.HistoricalInfo(context.Background(), params)
+			res, err := queryClient.HistoricalInfo(cmd.Context(), params)
 
 			if err != nil {
 				return err
@@ -697,7 +696,7 @@ $ %s query staking pool
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, err := queryClient.Pool(context.Background(), &types.QueryPoolRequest{})
+			res, err := queryClient.Pool(cmd.Context(), &types.QueryPoolRequest{})
 			if err != nil {
 				return err
 			}
@@ -733,7 +732,7 @@ $ %s query staking params
 			}
 			queryClient := types.NewQueryClient(clientCtx)
 
-			res, err := queryClient.Params(context.Background(), &types.QueryParamsRequest{})
+			res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
 			if err != nil {
 				return err
 			}
diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go
index 20333d62ff11..4eece491d429 100644
--- a/x/staking/keeper/val_state_change.go
+++ b/x/staking/keeper/val_state_change.go
@@ -12,7 +12,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
-// Calculate the ValidatorUpdates for the current block
+// BlockValidatorUpdates calculates the ValidatorUpdates for the current block
 // Called in each EndBlock
 func (k Keeper) BlockValidatorUpdates(ctx sdk.Context) []abci.ValidatorUpdate {
 	// Calculate validator set changes.
@@ -97,7 +97,7 @@ func (k Keeper) BlockValidatorUpdates(ctx sdk.Context) []abci.ValidatorUpdate {
 	return validatorUpdates
 }
 
-// Apply and return accumulated updates to the bonded validator set. Also,
+// ApplyAndReturnValidatorSetUpdates applies and return accumulated updates to the bonded validator set. Also,
 // * Updates the active valset as keyed by LastValidatorPowerKey.
 // * Updates the total power as keyed by LastTotalPowerKey.
 // * Updates validator status' according to updated powers.
@@ -119,7 +119,10 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 	// Retrieve the last validator set.
 	// The persistent set is updated later in this function.
 	// (see LastValidatorPowerKey).
-	last := k.getLastValidatorsByAddr(ctx)
+	last, err := k.getLastValidatorsByAddr(ctx)
+	if err != nil {
+		return nil, err
+	}
 
 	// Iterate over validators, highest power to lowest.
 	iterator := k.ValidatorsPowerStoreIterator(ctx)
@@ -162,10 +165,11 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 		}
 
 		// fetch the old power bytes
-		var valAddrBytes [sdk.AddrLen]byte
-
-		copy(valAddrBytes[:], valAddr[:])
-		oldPowerBytes, found := last[valAddrBytes]
+		valAddrStr, err := sdk.Bech32ifyAddressBytes(sdk.Bech32PrefixValAddr, valAddr)
+		if err != nil {
+			return nil, err
+		}
+		oldPowerBytes, found := last[valAddrStr]
 		newPower := validator.ConsensusPower(powerReduction)
 		newPowerBytes := k.cdc.MustMarshalBinaryBare(&gogotypes.Int64Value{Value: newPower})
 
@@ -176,13 +180,17 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 			k.SetLastValidatorPower(ctx, valAddr, newPower)
 		}
 
-		delete(last, valAddrBytes)
+		delete(last, valAddrStr)
 		count++
 
 		totalPower = totalPower.Add(sdk.NewInt(newPower))
 	}
 
-	noLongerBonded := sortNoLongerBonded(last)
+	noLongerBonded, err := sortNoLongerBonded(last)
+	if err != nil {
+		return nil, err
+	}
+
 	for _, valAddrBytes := range noLongerBonded {
 		validator := k.mustGetValidator(ctx, sdk.ValAddress(valAddrBytes))
 		validator, err = k.bondedToUnbonding(ctx, validator)
@@ -341,39 +349,46 @@ func (k Keeper) completeUnbondingValidator(ctx sdk.Context, validator types.Vali
 	return validator
 }
 
-// map of operator addresses to serialized power
-type validatorsByAddr map[[sdk.AddrLen]byte][]byte
+// map of operator bech32-addresses to serialized power
+// We use bech32 strings here, because we can't have slices as keys: map[[]byte][]byte
+type validatorsByAddr map[string][]byte
 
 // get the last validator set
-func (k Keeper) getLastValidatorsByAddr(ctx sdk.Context) validatorsByAddr {
+func (k Keeper) getLastValidatorsByAddr(ctx sdk.Context) (validatorsByAddr, error) {
 	last := make(validatorsByAddr)
 
 	iterator := k.LastValidatorsIterator(ctx)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
-		var valAddr [sdk.AddrLen]byte
-		// extract the validator address from the key (prefix is 1-byte)
-		copy(valAddr[:], iterator.Key()[1:])
+		// extract the validator address from the key (prefix is 1-byte, addrLen is 1-byte)
+		valAddr := types.AddressFromLastValidatorPowerKey(iterator.Key())
+		valAddrStr, err := sdk.Bech32ifyAddressBytes(sdk.Bech32PrefixValAddr, valAddr)
+		if err != nil {
+			return nil, err
+		}
+
 		powerBytes := iterator.Value()
-		last[valAddr] = make([]byte, len(powerBytes))
-		copy(last[valAddr], powerBytes)
+		last[valAddrStr] = make([]byte, len(powerBytes))
+		copy(last[valAddrStr], powerBytes)
 	}
 
-	return last
+	return last, nil
 }
 
 // given a map of remaining validators to previous bonded power
 // returns the list of validators to be unbonded, sorted by operator address
-func sortNoLongerBonded(last validatorsByAddr) [][]byte {
+func sortNoLongerBonded(last validatorsByAddr) ([][]byte, error) {
 	// sort the map keys for determinism
 	noLongerBonded := make([][]byte, len(last))
 	index := 0
 
-	for valAddrBytes := range last {
-		valAddr := make([]byte, sdk.AddrLen)
-		copy(valAddr, valAddrBytes[:])
-		noLongerBonded[index] = valAddr
+	for valAddrStr := range last {
+		valAddrBytes, err := sdk.ValAddressFromBech32(valAddrStr)
+		if err != nil {
+			return nil, err
+		}
+		noLongerBonded[index] = valAddrBytes
 		index++
 	}
 	// sorted by address - order doesn't matter
@@ -382,5 +397,5 @@ func sortNoLongerBonded(last validatorsByAddr) [][]byte {
 		return bytes.Compare(noLongerBonded[i], noLongerBonded[j]) == -1
 	})
 
-	return noLongerBonded
+	return noLongerBonded, nil
 }
diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go
index 591ab374d7ab..28c0946e9540 100644
--- a/x/staking/keeper/validator.go
+++ b/x/staking/keeper/validator.go
@@ -327,7 +327,7 @@ func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context, handler func(operato
 	defer iter.Close()
 
 	for ; iter.Valid(); iter.Next() {
-		addr := sdk.ValAddress(iter.Key()[len(types.LastValidatorPowerKey):])
+		addr := sdk.ValAddress(types.AddressFromLastValidatorPowerKey(iter.Key()))
 		intV := &gogotypes.Int64Value{}
 
 		k.cdc.MustUnmarshalBinaryBare(iter.Value(), intV)
diff --git a/x/staking/spec/01_state.md b/x/staking/spec/01_state.md
index c0aae9943bc9..e090acb01541 100644
--- a/x/staking/spec/01_state.md
+++ b/x/staking/spec/01_state.md
@@ -8,24 +8,16 @@ order: 1
 
 LastTotalPower tracks the total amounts of bonded tokens recorded during the previous end block.
 
-- LastTotalPower: `0x12 -> amino(sdk.Int)`
+- LastTotalPower: `0x12 -> ProtocolBuffer(sdk.Int)`
 
 ## Params
 
 Params is a module-wide configuration structure that stores system parameters
 and defines overall functioning of the staking module.
 
-- Params: `Paramsspace("staking") -> amino(params)`
+- Params: `Paramsspace("staking") -> legacy_amino(params)`
 
-```go
-type Params struct {
-    UnbondingTime  time.Duration // time duration of unbonding
-    MaxValidators  uint16        // maximum number of validators
-    MaxEntries     uint16        // max entries for either unbonding delegation or redelegation (per pair/trio)
-    BondDenom      string        // bondable coin denomination
-    PowerReduction sdk.Int       // power reduction on-chain param
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/proto/cosmos/staking/v1beta1/staking.proto#L230-L241
 
 ## Validator
 
@@ -38,8 +30,8 @@ Validators can have one of three statuses
   They are signing blocks and receiving rewards. They can receive further delegations.
   They can be slashed for misbehavior. Delegators to this validator who unbond their delegation
   must wait the duration of the UnbondingTime, a chain-specific param. during which time
-  they are still slashable for offences of the source validator if those offences were committed 
-  during the period of time that the tokens were bonded. 
+  they are still slashable for offences of the source validator if those offences were committed
+  during the period of time that the tokens were bonded.
 - `Unbonding`: When a validator leaves the active set, either by choice or due to slashing or
   tombstoning, an unbonding of all their delegations begins. All delegations must then wait the UnbondingTime
   before moving receiving their tokens to their accounts from the `BondedPool`.
@@ -52,10 +44,10 @@ required lookups for slashing and validator-set updates. A third special index
 throughout each block, unlike the first two indices which mirror the validator
 records within a block.
 
-- Validators: `0x21 | OperatorAddr -> amino(validator)`
+- Validators: `0x21 | OperatorAddr -> ProtocolBuffer(validator)`
 - ValidatorsByConsAddr: `0x22 | ConsAddr -> OperatorAddr`
 - ValidatorsByPower: `0x23 | BigEndian(ConsensusPower) | OperatorAddr -> OperatorAddr`
-- LastValidatorsPower: `0x11 OperatorAddr -> amino(ConsensusPower)`
+- LastValidatorsPower: `0x11 OperatorAddr -> ProtocolBuffer(ConsensusPower)`
 
 `Validators` is the primary index - it ensures that each operator can have only one
 associated validator, where the public key of that validator can change in the
@@ -69,7 +61,7 @@ address which can be derived from the validator's `ConsPubKey`.
 
 `ValidatorsByPower` is an additional index that provides a sorted list o
 potential validators to quickly determine the current active set. Here
-ConsensusPower is validator.Tokens/10^6.  Note that all validators where
+ConsensusPower is validator.Tokens/10^6. Note that all validators where
 `Jailed` is true are not stored within this index.
 
 `LastValidatorsPower` is a special index that provides a historical list of the
@@ -78,60 +70,23 @@ is updated during the validator set update process which takes place in [`EndBlo
 
 Each validator's state is stored in a `Validator` struct:
 
-```go
-type Validator struct {
-    OperatorAddress         sdk.ValAddress  // address of the validator's operator; bech encoded in JSON
-    ConsPubKey              crypto.PubKey   // the consensus public key of the validator; bech encoded in JSON
-    Jailed                  bool            // has the validator been jailed from bonded status?
-    Status                  sdk.BondStatus  // validator status (bonded/unbonding/unbonded)
-    Tokens                  sdk.Int         // delegated tokens (incl. self-delegation)
-    DelegatorShares         sdk.Dec         // total shares issued to a validator's delegators
-    Description             Description     // description terms for the validator
-    UnbondingHeight         int64           // if unbonding, height at which this validator has begun unbonding
-    UnbondingCompletionTime time.Time       // if unbonding, min time for the validator to complete unbonding
-    Commission              Commission      // commission parameters
-    MinSelfDelegation       sdk.Int         // validator's self declared minimum self delegation
-}
-
-type Commission struct {
-    CommissionRates
-    UpdateTime time.Time // the last time the commission rate was changed
-}
-
-CommissionRates struct {
-    Rate          sdk.Dec // the commission rate charged to delegators, as a fraction
-    MaxRate       sdk.Dec // maximum commission rate which validator can ever charge, as a fraction
-    MaxChangeRate sdk.Dec // maximum daily increase of the validator commission, as a fraction
-}
-
-type Description struct {
-    Moniker          string // name
-    Identity         string // optional identity signature (ex. UPort or Keybase)
-    Website          string // optional website link
-    SecurityContact  string // optional email for security contact
-    Details          string // optional details
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L65-L99
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L24-L63
 
 ## Delegation
 
 Delegations are identified by combining `DelegatorAddr` (the address of the delegator)
 with the `ValidatorAddr` Delegators are indexed in the store as follows:
 
-- Delegation: `0x31 | DelegatorAddr | ValidatorAddr -> amino(delegation)`
+- Delegation: `0x31 | DelegatorAddr | ValidatorAddr -> ProtocolBuffer(delegation)`
 
 Stake holders may delegate coins to validators; under this circumstance their
 funds are held in a `Delegation` data structure. It is owned by one
 delegator, and is associated with the shares for one validator. The sender of
 the transaction is the owner of the bond.
 
-```go
-type Delegation struct {
-    DelegatorAddr sdk.AccAddress
-    ValidatorAddr sdk.ValAddress
-    Shares        sdk.Dec        // delegation shares received
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L159-L170
 
 ### Delegator Shares
 
@@ -160,10 +115,8 @@ detected.
 
 `UnbondingDelegation` are indexed in the store as:
 
-- UnbondingDelegation: `0x32 | DelegatorAddr | ValidatorAddr ->
-   amino(unbondingDelegation)`
-- UnbondingDelegationsFromValidator: `0x33 | ValidatorAddr | DelegatorAddr ->
-   nil`
+- UnbondingDelegation: `0x32 | DelegatorAddr | ValidatorAddr -> ProtocolBuffer(unbondingDelegation)`
+- UnbondingDelegationsFromValidator: `0x33 | ValidatorAddr | DelegatorAddr -> nil`
 
 The first map here is used in queries, to lookup all unbonding delegations for
 a given delegator, while the second map is used in slashing, to lookup all
@@ -172,20 +125,7 @@ slashed.
 
 A UnbondingDelegation object is created every time an unbonding is initiated.
 
-```go
-type UnbondingDelegation struct {
-    DelegatorAddr sdk.AccAddress             // delegator
-    ValidatorAddr sdk.ValAddress             // validator unbonding from operator addr
-    Entries       []UnbondingDelegationEntry // unbonding delegation entries
-}
-
-type UnbondingDelegationEntry struct {
-    CreationHeight int64     // height which the unbonding took place
-    CompletionTime time.Time // unix time for unbonding completion
-    InitialBalance sdk.Coin  // atoms initially scheduled to receive at completion
-    Balance        sdk.Coin  // atoms to receive at completion
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L172-L198
 
 ## Redelegation
 
@@ -197,7 +137,7 @@ committed by the source validator.
 
 `Redelegation` are indexed in the store as:
 
-- Redelegations: `0x34 | DelegatorAddr | ValidatorSrcAddr | ValidatorDstAddr -> amino(redelegation)`
+- Redelegations: `0x34 | DelegatorAddr | ValidatorSrcAddr | ValidatorDstAddr -> ProtocolBuffer(redelegation)`
 - RedelegationsBySrc: `0x35 | ValidatorSrcAddr | ValidatorDstAddr | DelegatorAddr -> nil`
 - RedelegationsByDst: `0x36 | ValidatorDstAddr | ValidatorSrcAddr | DelegatorAddr -> nil`
 
@@ -205,30 +145,15 @@ The first map here is used for queries, to lookup all redelegations for a given
 delegator. The second map is used for slashing based on the `ValidatorSrcAddr`,
 while the third map is for slashing based on the `ValidatorDstAddr`.
 
-A redelegation object is created every time a redelegation occurs.  To prevent
+A redelegation object is created every time a redelegation occurs. To prevent
 "redelegation hopping" redelegations may not occur under the situation that:
 
 - the (re)delegator already has another immature redelegation in progress
-with a destination to a validator (let's call it `Validator X`)
+  with a destination to a validator (let's call it `Validator X`)
 - and, the (re)delegator is attempting to create a _new_ redelegation
-where the source validator for this new redelegation is `Validator-X`.
-
-```go
-type Redelegation struct {
-    DelegatorAddr    sdk.AccAddress      // delegator
-    ValidatorSrcAddr sdk.ValAddress      // validator redelegation source operator addr
-    ValidatorDstAddr sdk.ValAddress      // validator redelegation destination operator addr
-    Entries          []RedelegationEntry // redelegation entries
-}
-
-type RedelegationEntry struct {
-    CreationHeight int64     // height which the redelegation took place
-    CompletionTime time.Time // unix time for redelegation completion
-    InitialBalance sdk.Coin  // initial balance when redelegation started
-    Balance        sdk.Coin  // current balance (current value held in destination validator)
-    SharesDst      sdk.Dec   // amount of destination-validator shares created by redelegation
-}
-```
+  where the source validator for this new redelegation is `Validator-X`.
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L200-L228
 
 ## Queues
 
@@ -250,12 +175,7 @@ delegations queue is kept.
 
 - UnbondingDelegation: `0x41 | format(time) -> []DVPair`
 
-```go
-type DVPair struct {
-    DelegatorAddr sdk.AccAddress
-    ValidatorAddr sdk.ValAddress
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L123-L133
 
 ### RedelegationQueue
 
@@ -264,13 +184,7 @@ kept.
 
 - UnbondingDelegation: `0x42 | format(time) -> []DVVTriplet`
 
-```go
-type DVVTriplet struct {
-    DelegatorAddr    sdk.AccAddress
-    ValidatorSrcAddr sdk.ValAddress
-    ValidatorDstAddr sdk.ValAddress
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L140-L152
 
 ### ValidatorQueue
 
@@ -280,7 +194,7 @@ queue is kept.
 - ValidatorQueueTime: `0x43 | format(time) -> []sdk.ValAddress`
 
 The stored object as each key is an array of validator operator addresses from
-which the validator object can be accessed.  Typically it is expected that only
+which the validator object can be accessed. Typically it is expected that only
 a single validator record will be associated with a given timestamp however it is possible
 that multiple validators exist in the queue at the same location.
 
@@ -289,15 +203,10 @@ that multiple validators exist in the queue at the same location.
 HistoricalInfo objects are stored and pruned at each block such that the staking keeper persists
 the `n` most recent historical info defined by staking module parameter: `HistoricalEntries`.
 
-```go
-type HistoricalInfo struct {
-    Header tmproto.Header
-    ValSet []types.Validator
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/staking.proto#L15-L22
 
 At each BeginBlock, the staking keeper will persist the current Header and the Validators that committed
-the current block in a `HistoricalInfo` object. The Validators are sorted on their address to ensure that 
+the current block in a `HistoricalInfo` object. The Validators are sorted on their address to ensure that
 they are in a determisnistic order.
-The oldest HistoricalEntries will be pruned to ensure that there only exist the parameter-defined number of 
+The oldest HistoricalEntries will be pruned to ensure that there only exist the parameter-defined number of
 historical entries.
diff --git a/x/staking/spec/02_state_transitions.md b/x/staking/spec/02_state_transitions.md
index c2766aa43b79..9e245719cc24 100644
--- a/x/staking/spec/02_state_transitions.md
+++ b/x/staking/spec/02_state_transitions.md
@@ -11,12 +11,13 @@ This document describes the state transition operations pertaining to:
 3. [Slashing](./02_state_transitions.md#slashing)
 
 ## Validators
-State transitions in validators are performed on every [`EndBlock`](./05_end_block.md#validator-set-changes) 
+
+State transitions in validators are performed on every [`EndBlock`](./05_end_block.md#validator-set-changes)
 in order to check for changes in the active `ValidatorSet`.
 
 ### Unbonded to Bonded
 
-The following transition occurs when a validator's ranking in the `ValidatorPowerIndex` surpasses 
+The following transition occurs when a validator's ranking in the `ValidatorPowerIndex` surpasses
 that of the `LastValidator`.
 
 - set `validator.Status` to `Bonded`
@@ -98,9 +99,9 @@ Redelegations affect the delegation, source and destination validators.
 
 - perform an `unbond` delegation from the source validator to retrieve the tokens worth of the unbonded shares
 - using the unbonded tokens, `Delegate` them to the destination validator
-- if the `sourceValidator.Status` is `Bonded`, and the `destinationValidator` is not, 
+- if the `sourceValidator.Status` is `Bonded`, and the `destinationValidator` is not,
   transfer the newly delegated tokens from the `BondedPool` to the `NotBondedPool` `ModuleAccount`
-- otherwise, if the `sourceValidator.Status` is not `Bonded`, and the `destinationValidator` 
+- otherwise, if the `sourceValidator.Status` is not `Bonded`, and the `destinationValidator`
   is `Bonded`, transfer the newly delegated tokens from the `NotBondedPool` to the `BondedPool` `ModuleAccount`
 - record the token amount in an new entry in the relevant `Redelegation`
 
@@ -116,20 +117,20 @@ When a redelegations complete the following occurs:
 
 When a Validator is slashed, the following occurs:
 
-- The total `slashAmount` is calculated as the `slashFactor` (a chain parameter) * `TokensFromConsensusPower`,
-the total number of tokens bonded to the validator at the time of the infraction.
+- The total `slashAmount` is calculated as the `slashFactor` (a chain parameter) \* `TokensFromConsensusPower`,
+  the total number of tokens bonded to the validator at the time of the infraction.
 - Every unbonding delegation and redelegation from the validator are slashed by the `slashFactor`
-percentage of the initialBalance.
+  percentage of the initialBalance.
 - Each amount slashed from redelegations and unbonding delegations is subtracted from the
-total slash amount.
+  total slash amount.
 - The `remaingSlashAmount` is then slashed from the validator's tokens in the `BondedPool` or
-`NonBondedPool` depending on the validator's status. This reduces the total supply of tokens.
+  `NonBondedPool` depending on the validator's status. This reduces the total supply of tokens.
 
 ### Slash Unbonding Delegation
 
-When a validator is slashed, so are those unbonding delegations from the validator that began unbonding 
-after the time of the infraction. Every entry in every unbonding delegation from the validator 
-is slashed by `slashFactor`. The amount slashed is calculated from the `InitialBalance` of the 
+When a validator is slashed, so are those unbonding delegations from the validator that began unbonding
+after the time of the infraction. Every entry in every unbonding delegation from the validator
+is slashed by `slashFactor`. The amount slashed is calculated from the `InitialBalance` of the
 delegation and is capped to prevent a resulting negative balance. Completed (or mature) unbondings are not slashed.
 
 ### Slash Redelegation
diff --git a/x/staking/spec/03_messages.md b/x/staking/spec/03_messages.md
index bd9f21e2ceb0..1155da93d97d 100644
--- a/x/staking/spec/03_messages.md
+++ b/x/staking/spec/03_messages.md
@@ -6,23 +6,15 @@ order: 3
 
 In this section we describe the processing of the staking messages and the corresponding updates to the state. All created/modified state objects specified by each message are defined within the [state](./02_state_transitions.md) section.
 
-## MsgCreateValidator
+## Msg/CreateValidator
 
-A validator is created using the `MsgCreateValidator` message.
+A validator is created using the `Msg/CreateValidator` service message.
 
-```go
-type MsgCreateValidator struct {
-    Description    Description
-    Commission     Commission
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L16-L17
 
-    DelegatorAddr  sdk.AccAddress
-    ValidatorAddr  sdk.ValAddress
-    PubKey         crypto.PubKey
-    Delegation     sdk.Coin
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L35-L51
 
-This message is expected to fail if:
+This service message is expected to fail if:
 
 - another validator with this operator address is already registered
 - another validator with this pubkey is already registered
@@ -33,71 +25,63 @@ This message is expected to fail if:
   - the initial `MaxChangeRate` is either negative or > `MaxRate`
 - the description fields are too large
 
-This message creates and stores the `Validator` object at appropriate indexes.
+This service message creates and stores the `Validator` object at appropriate indexes.
 Additionally a self-delegation is made with the initial tokens delegation
 tokens `Delegation`. The validator always starts as unbonded but may be bonded
 in the first end-block.
 
-## MsgEditValidator
+## Msg/EditValidator
 
 The `Description`, `CommissionRate` of a validator can be updated using the
-`MsgEditCandidacy`.  
+`Msg/EditCandidacy` service message.
 
-```go
-type MsgEditCandidacy struct {
-    Description     Description
-    ValidatorAddr   sdk.ValAddress
-    CommissionRate  sdk.Dec
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L19-L20
 
-This message is expected to fail if:
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L56-L76
+
+This service message is expected to fail if:
 
 - the initial `CommissionRate` is either negative or > `MaxRate`
 - the `CommissionRate` has already been updated within the previous 24 hours
 - the `CommissionRate` is > `MaxChangeRate`
 - the description fields are too large
 
-This message stores the updated `Validator` object.
+This service message stores the updated `Validator` object.
 
-## MsgDelegate
+## Msg/Delegate
 
-Within this message the delegator provides coins, and in return receives
+Within this service message the delegator provides coins, and in return receives
 some amount of their validator's (newly created) delegator-shares that are
 assigned to `Delegation.Shares`.
 
-```go
-type MsgDelegate struct {
-  DelegatorAddr sdk.AccAddress
-  ValidatorAddr sdk.ValAddress
-  Amount        sdk.Coin
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L22-L24
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L81-L90
 
-This message is expected to fail if:
+This service message is expected to fail if:
 
 - the validator is does not exist
 - the validator is jailed
 - the `Amount` `Coin` has a denomination different than one defined by `params.BondDenom`
 
 If an existing `Delegation` object for provided addresses does not already
-exist than it is created as part of this message otherwise the existing
+exist than it is created as part of this service message otherwise the existing
 `Delegation` is updated to include the newly received shares.
 
-## MsgBeginUnbonding
+## Msg/Undelegate
 
-The begin unbonding message allows delegators to undelegate their tokens from
+The `Msg/Undelegate` service message allows delegators to undelegate their tokens from
 validator.
 
-```go
-type MsgBeginUnbonding struct {
-  DelegatorAddr sdk.AccAddress
-  ValidatorAddr sdk.ValAddress
-  Amount         sdk.Coin
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L30-L32
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L112-L121
+
+This service message returns a response containing the completion time of the undelegation:
 
-This message is expected to fail if:
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L123-L126
+
+This service message is expected to fail if:
 
 - the delegation doesn't exist
 - the validator doesn't exist
@@ -105,7 +89,7 @@ This message is expected to fail if:
 - existing `UnbondingDelegation` has maximum entries as defined by `params.MaxEntries`
 - the `Amount` has a denomination different than one defined by `params.BondDenom`
 
-When this message is processed the following actions occur:
+When this service message is processed the following actions occur:
 
 - validator's `DelegatorShares` and the delegation's `Shares` are both reduced by the message `SharesAmount`
 - calculate the token worth of the shares remove that amount tokens held within the validator
@@ -116,22 +100,21 @@ When this message is processed the following actions occur:
 - if there are no more `Shares` in the delegation, then the delegation object is removed from the store
   - under this situation if the delegation is the validator's self-delegation then also jail the validator.
 
-## MsgBeginRedelegate
+## Msg/BeginRedelegate
 
 The redelegation command allows delegators to instantly switch validators. Once
 the unbonding period has passed, the redelegation is automatically completed in
 the EndBlocker.
 
-```go
-type MsgBeginRedelegate struct {
-  DelegatorAddr    sdk.AccAddress
-  ValidatorSrcAddr sdk.ValAddress
-  ValidatorDstAddr sdk.ValAddress
-  Amount           sdk.Coin
-}
-```
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L26-L28
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L95-L105
+
+This service message returns a response containing the completion time of the redelegation:
+
++++ https://github.com/cosmos/cosmos-sdk/blob/v0.40.0/proto/cosmos/staking/v1beta1/tx.proto#L107-L110
 
-This message is expected to fail if:
+This service message is expected to fail if:
 
 - the delegation doesn't exist
 - the source or destination validators don't exist
@@ -140,7 +123,7 @@ This message is expected to fail if:
 - existing `Redelegation` has maximum entries as defined by `params.MaxEntries`
 - the `Amount` `Coin` has a denomination different than one defined by `params.BondDenom`
 
-When this message is processed the following actions occur:
+When this service message is processed the following actions occur:
 
 - the source validator's `DelegatorShares` and the delegations `Shares` are both reduced by the message `SharesAmount`
 - calculate the token worth of the shares remove that amount tokens held within the source validator.
@@ -148,6 +131,6 @@ When this message is processed the following actions occur:
   - `Bonded` - add an entry to the `Redelegation` (create `Redelegation` if it doesn't exist) with a completion time a full unbonding period from the current time. Update pool shares to reduce BondedTokens and increase NotBondedTokens by token worth of the shares (this may be effectively reversed in the next step however).
   - `Unbonding` - add an entry to the `Redelegation` (create `Redelegation` if it doesn't exist) with the same completion time as the validator (`UnbondingMinTime`).
   - `Unbonded` - no action required in this step
-- Delegate the token worth to the destination validator, possibly moving  tokens back to the bonded state.
+- Delegate the token worth to the destination validator, possibly moving tokens back to the bonded state.
 - if there are no more `Shares` in the source delegation, then the source delegation object is removed from the store
   - under this situation if the delegation is the validator's self-delegation then also jail the validator.
diff --git a/x/staking/spec/07_events.md b/x/staking/spec/07_events.md
index d8255ca92b13..660319b3c1a4 100644
--- a/x/staking/spec/07_events.md
+++ b/x/staking/spec/07_events.md
@@ -18,9 +18,9 @@ The staking module emits the following events:
 | complete_redelegation | destination_validator | {dstValidatorAddress}     |
 | complete_redelegation | delegator             | {delegatorAddress}        |
 
-## Handlers
+## Service Messages
 
-### MsgCreateValidator
+### Msg/CreateValidator
 
 | Type             | Attribute Key | Attribute Value    |
 | ---------------- | ------------- | ------------------ |
@@ -30,7 +30,7 @@ The staking module emits the following events:
 | message          | action        | create_validator   |
 | message          | sender        | {senderAddress}    |
 
-### MsgEditValidator
+### Msg/EditValidator
 
 | Type           | Attribute Key       | Attribute Value     |
 | -------------- | ------------------- | ------------------- |
@@ -40,7 +40,7 @@ The staking module emits the following events:
 | message        | action              | edit_validator      |
 | message        | sender              | {senderAddress}     |
 
-### MsgDelegate
+### Msg/Delegate
 
 | Type     | Attribute Key | Attribute Value    |
 | -------- | ------------- | ------------------ |
@@ -50,7 +50,7 @@ The staking module emits the following events:
 | message  | action        | delegate           |
 | message  | sender        | {senderAddress}    |
 
-### MsgUndelegate
+### Msg/Undelegate
 
 | Type    | Attribute Key       | Attribute Value    |
 | ------- | ------------------- | ------------------ |
@@ -61,9 +61,9 @@ The staking module emits the following events:
 | message | action              | begin_unbonding    |
 | message | sender              | {senderAddress}    |
 
-* [0] Time is formatted in the RFC3339 standard
+- [0] Time is formatted in the RFC3339 standard
 
-### MsgBeginRedelegate
+### Msg/BeginRedelegate
 
 | Type       | Attribute Key         | Attribute Value       |
 | ---------- | --------------------- | --------------------- |
@@ -75,4 +75,4 @@ The staking module emits the following events:
 | message    | action                | begin_redelegate      |
 | message    | sender                | {senderAddress}       |
 
-* [0] Time is formatted in the RFC3339 standard
+- [0] Time is formatted in the RFC3339 standard
diff --git a/x/staking/spec/README.md b/x/staking/spec/README.md
index 0005088ae837..a2cb7cf3a8df 100644
--- a/x/staking/spec/README.md
+++ b/x/staking/spec/README.md
@@ -38,18 +38,18 @@ network.
     - [Delegations](02_state_transitions.md#delegations)
     - [Slashing](02_state_transitions.md#slashing)
 3. **[Messages](03_messages.md)**
-    - [MsgCreateValidator](03_messages.md#msgcreatevalidator)
-    - [MsgEditValidator](03_messages.md#msgeditvalidator)
-    - [MsgDelegate](03_messages.md#msgdelegate)
-    - [MsgBeginUnbonding](03_messages.md#msgbeginunbonding)
-    - [MsgBeginRedelegate](03_messages.md#msgbeginredelegate)
+    - [Msg/CreateValidator](03_messages.md#msgcreatevalidator)
+    - [Msg/EditValidator](03_messages.md#msgeditvalidator)
+    - [Msg/Delegate](03_messages.md#msgdelegate)
+    - [Msg/BeginUnbonding](03_messages.md#msgbeginunbonding)
+    - [Msg/BeginRedelegate](03_messages.md#msgbeginredelegate)
 4. **[Begin-Block](04_begin_block.md)**
     - [Historical Info Tracking](04_begin_block.md#historical-info-tracking)
-4. **[End-Block ](05_end_block.md)**
+5. **[End-Block ](05_end_block.md)**
     - [Validator Set Changes](05_end_block.md#validator-set-changes)
     - [Queues ](05_end_block.md#queues-)
-5. **[Hooks](06_hooks.md)**
-6. **[Events](07_events.md)**
+6. **[Hooks](06_hooks.md)**
+7. **[Events](07_events.md)**
     - [EndBlocker](07_events.md#endblocker)
     - [Handlers](07_events.md#handlers)
-7. **[Parameters](08_params.md)**
+8. **[Parameters](08_params.md)**
diff --git a/x/staking/types/keys.go b/x/staking/types/keys.go
index abdbe8ccff1b..584dba5684c3 100644
--- a/x/staking/types/keys.go
+++ b/x/staking/types/keys.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
 )
 
 const (
@@ -48,24 +49,29 @@ var (
 	HistoricalInfoKey = []byte{0x50} // prefix for the historical info
 )
 
-// gets the key for the validator with address
+// GetValidatorKey creates the key for the validator with address
 // VALUE: staking/Validator
 func GetValidatorKey(operatorAddr sdk.ValAddress) []byte {
-	return append(ValidatorsKey, operatorAddr.Bytes()...)
+	return append(ValidatorsKey, address.MustLengthPrefix(operatorAddr)...)
 }
 
-// gets the key for the validator with pubkey
+// GetValidatorByConsAddrKey creates the key for the validator with pubkey
 // VALUE: validator operator address ([]byte)
 func GetValidatorByConsAddrKey(addr sdk.ConsAddress) []byte {
-	return append(ValidatorsByConsAddrKey, addr.Bytes()...)
+	return append(ValidatorsByConsAddrKey, address.MustLengthPrefix(addr)...)
 }
 
-// Get the validator operator address from LastValidatorPowerKey
+// AddressFromValidatorsKey creates the validator operator address from ValidatorsKey
+func AddressFromValidatorsKey(key []byte) []byte {
+	return key[2:] // remove prefix bytes and address length
+}
+
+// AddressFromLastValidatorPowerKey creates the validator operator address from LastValidatorPowerKey
 func AddressFromLastValidatorPowerKey(key []byte) []byte {
-	return key[1:] // remove prefix bytes
+	return key[2:] // remove prefix bytes and address length
 }
 
-// get the validator by power index.
+// GetValidatorsByPowerIndexKey creates the validator by power index.
 // Power index is the key used in the power-store, and represents the relative
 // power ranking of the validator.
 // VALUE: validator operator address ([]byte)
@@ -80,39 +86,39 @@ func GetValidatorsByPowerIndexKey(validator Validator, powerReduction sdk.Int) [
 	powerBytes := consensusPowerBytes
 	powerBytesLen := len(powerBytes) // 8
 
-	// key is of format prefix || powerbytes || addrBytes
-	key := make([]byte, 1+powerBytesLen+sdk.AddrLen)
-
-	key[0] = ValidatorsByPowerIndexKey[0]
-	copy(key[1:powerBytesLen+1], powerBytes)
 	addr, err := sdk.ValAddressFromBech32(validator.OperatorAddress)
 	if err != nil {
 		panic(err)
 	}
 	operAddrInvr := sdk.CopyBytes(addr)
+	addrLen := len(operAddrInvr)
 
 	for i, b := range operAddrInvr {
 		operAddrInvr[i] = ^b
 	}
 
-	copy(key[powerBytesLen+1:], operAddrInvr)
+	// key is of format prefix || powerbytes || addrLen (1byte) || addrBytes
+	key := make([]byte, 1+powerBytesLen+1+addrLen)
+
+	key[0] = ValidatorsByPowerIndexKey[0]
+	copy(key[1:powerBytesLen+1], powerBytes)
+	key[powerBytesLen+1] = byte(addrLen)
+	copy(key[powerBytesLen+2:], operAddrInvr)
 
 	return key
 }
 
-// get the bonded validator index key for an operator address
+// GetLastValidatorPowerKey creates the bonded validator index key for an operator address
 func GetLastValidatorPowerKey(operator sdk.ValAddress) []byte {
-	return append(LastValidatorPowerKey, operator...)
+	return append(LastValidatorPowerKey, address.MustLengthPrefix(operator)...)
 }
 
-// parse the validators operator address from power rank key
+// ParseValidatorPowerRankKey parses the validators operator address from power rank key
 func ParseValidatorPowerRankKey(key []byte) (operAddr []byte) {
 	powerBytesLen := 8
-	if len(key) != 1+powerBytesLen+sdk.AddrLen {
-		panic("Invalid validator power rank key length")
-	}
 
-	operAddr = sdk.CopyBytes(key[powerBytesLen+1:])
+	// key is of format prefix (1 byte) || powerbytes || addrLen (1byte) || addrBytes
+	operAddr = sdk.CopyBytes(key[powerBytesLen+2:])
 
 	for i, b := range operAddr {
 		operAddr[i] = ^b
@@ -165,55 +171,51 @@ func ParseValidatorQueueKey(bz []byte) (time.Time, int64, error) {
 	return ts, int64(height), nil
 }
 
-// gets the key for delegator bond with validator
+// GetDelegationKey creates the key for delegator bond with validator
 // VALUE: staking/Delegation
 func GetDelegationKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
-	return append(GetDelegationsKey(delAddr), valAddr.Bytes()...)
+	return append(GetDelegationsKey(delAddr), address.MustLengthPrefix(valAddr)...)
 }
 
-// gets the prefix for a delegator for all validators
+// GetDelegationsKey creates the prefix for a delegator for all validators
 func GetDelegationsKey(delAddr sdk.AccAddress) []byte {
-	return append(DelegationKey, delAddr.Bytes()...)
+	return append(DelegationKey, address.MustLengthPrefix(delAddr)...)
 }
 
-// gets the key for an unbonding delegation by delegator and validator addr
+// GetUBDKey creates the key for an unbonding delegation by delegator and validator addr
 // VALUE: staking/UnbondingDelegation
 func GetUBDKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
-	return append(
-		GetUBDsKey(delAddr.Bytes()),
-		valAddr.Bytes()...)
+	return append(GetUBDsKey(delAddr.Bytes()), address.MustLengthPrefix(valAddr)...)
 }
 
-// gets the index-key for an unbonding delegation, stored by validator-index
+// GetUBDByValIndexKey creates the index-key for an unbonding delegation, stored by validator-index
 // VALUE: none (key rearrangement used)
 func GetUBDByValIndexKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
-	return append(GetUBDsByValIndexKey(valAddr), delAddr.Bytes()...)
+	return append(GetUBDsByValIndexKey(valAddr), address.MustLengthPrefix(delAddr)...)
 }
 
-// rearranges the ValIndexKey to get the UBDKey
+// GetUBDKeyFromValIndexKey rearranges the ValIndexKey to get the UBDKey
 func GetUBDKeyFromValIndexKey(indexKey []byte) []byte {
 	addrs := indexKey[1:] // remove prefix bytes
-	if len(addrs) != 2*sdk.AddrLen {
-		panic("unexpected key length")
-	}
 
-	valAddr := addrs[:sdk.AddrLen]
-	delAddr := addrs[sdk.AddrLen:]
+	valAddrLen := addrs[0]
+	valAddr := addrs[1 : 1+valAddrLen]
+	delAddr := addrs[valAddrLen+2:]
 
 	return GetUBDKey(delAddr, valAddr)
 }
 
-// gets the prefix for all unbonding delegations from a delegator
+// GetUBDsKey creates the prefix for all unbonding delegations from a delegator
 func GetUBDsKey(delAddr sdk.AccAddress) []byte {
-	return append(UnbondingDelegationKey, delAddr.Bytes()...)
+	return append(UnbondingDelegationKey, address.MustLengthPrefix(delAddr)...)
 }
 
-// gets the prefix keyspace for the indexes of unbonding delegations for a validator
+// GetUBDsByValIndexKey creates the prefix keyspace for the indexes of unbonding delegations for a validator
 func GetUBDsByValIndexKey(valAddr sdk.ValAddress) []byte {
-	return append(UnbondingDelegationByValIndexKey, valAddr.Bytes()...)
+	return append(UnbondingDelegationByValIndexKey, address.MustLengthPrefix(valAddr)...)
 }
 
-// gets the prefix for all unbonding delegations from a delegator
+// GetUnbondingDelegationTimeKey creates the prefix for all unbonding delegations from a delegator
 func GetUnbondingDelegationTimeKey(timestamp time.Time) []byte {
 	bz := sdk.FormatTimeBytes(timestamp)
 	return append(UnbondingQueueKey, bz...)
@@ -222,69 +224,76 @@ func GetUnbondingDelegationTimeKey(timestamp time.Time) []byte {
 // GetREDKey returns a key prefix for indexing a redelegation from a delegator
 // and source validator to a destination validator.
 func GetREDKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
-	key := make([]byte, 1+sdk.AddrLen*3)
+	// key is of the form GetREDsKey || valSrcAddrLen (1 byte) || valSrcAddr || valDstAddrLen (1 byte) || valDstAddr
+	key := make([]byte, 1+3+len(delAddr)+len(valSrcAddr)+len(valDstAddr))
 
-	copy(key[0:sdk.AddrLen+1], GetREDsKey(delAddr.Bytes()))
-	copy(key[sdk.AddrLen+1:2*sdk.AddrLen+1], valSrcAddr.Bytes())
-	copy(key[2*sdk.AddrLen+1:3*sdk.AddrLen+1], valDstAddr.Bytes())
+	copy(key[0:2+len(delAddr)], GetREDsKey(delAddr.Bytes()))
+	key[2+len(delAddr)] = byte(len(valSrcAddr))
+	copy(key[3+len(delAddr):3+len(delAddr)+len(valSrcAddr)], valSrcAddr.Bytes())
+	key[3+len(delAddr)+len(valSrcAddr)] = byte(len(valDstAddr))
+	copy(key[4+len(delAddr)+len(valSrcAddr):], valDstAddr.Bytes())
 
 	return key
 }
 
-// gets the index-key for a redelegation, stored by source-validator-index
+// GetREDByValSrcIndexKey creates the index-key for a redelegation, stored by source-validator-index
 // VALUE: none (key rearrangement used)
 func GetREDByValSrcIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	REDSFromValsSrcKey := GetREDsFromValSrcIndexKey(valSrcAddr)
 	offset := len(REDSFromValsSrcKey)
 
-	// key is of the form REDSFromValsSrcKey || delAddr || valDstAddr
-	key := make([]byte, len(REDSFromValsSrcKey)+2*sdk.AddrLen)
+	// key is of the form REDSFromValsSrcKey || delAddrLen (1 byte) || delAddr || valDstAddrLen (1 byte) || valDstAddr
+	key := make([]byte, offset+2+len(delAddr)+len(valDstAddr))
 	copy(key[0:offset], REDSFromValsSrcKey)
-	copy(key[offset:offset+sdk.AddrLen], delAddr.Bytes())
-	copy(key[offset+sdk.AddrLen:offset+2*sdk.AddrLen], valDstAddr.Bytes())
+	key[offset] = byte(len(delAddr))
+	copy(key[offset+1:offset+1+len(delAddr)], delAddr.Bytes())
+	key[offset+1+len(delAddr)] = byte(len(valDstAddr))
+	copy(key[offset+2+len(delAddr):], valDstAddr.Bytes())
 
 	return key
 }
 
-// gets the index-key for a redelegation, stored by destination-validator-index
+// GetREDByValDstIndexKey creates the index-key for a redelegation, stored by destination-validator-index
 // VALUE: none (key rearrangement used)
 func GetREDByValDstIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
 	REDSToValsDstKey := GetREDsToValDstIndexKey(valDstAddr)
 	offset := len(REDSToValsDstKey)
 
-	// key is of the form REDSToValsDstKey || delAddr || valSrcAddr
-	key := make([]byte, len(REDSToValsDstKey)+2*sdk.AddrLen)
+	// key is of the form REDSToValsDstKey || delAddrLen (1 byte) || delAddr || valSrcAddrLen (1 byte) || valSrcAddr
+	key := make([]byte, offset+2+len(delAddr)+len(valSrcAddr))
 	copy(key[0:offset], REDSToValsDstKey)
-	copy(key[offset:offset+sdk.AddrLen], delAddr.Bytes())
-	copy(key[offset+sdk.AddrLen:offset+2*sdk.AddrLen], valSrcAddr.Bytes())
+	key[offset] = byte(len(delAddr))
+	copy(key[offset+1:offset+1+len(delAddr)], delAddr.Bytes())
+	key[offset+1+len(delAddr)] = byte(len(valSrcAddr))
+	copy(key[offset+2+len(delAddr):], valSrcAddr.Bytes())
 
 	return key
 }
 
 // GetREDKeyFromValSrcIndexKey rearranges the ValSrcIndexKey to get the REDKey
 func GetREDKeyFromValSrcIndexKey(indexKey []byte) []byte {
-	// note that first byte is prefix byte
-	if len(indexKey) != 3*sdk.AddrLen+1 {
-		panic("unexpected key length")
-	}
+	// note that first byte is prefix byte, which we remove
+	addrs := indexKey[1:]
 
-	valSrcAddr := indexKey[1 : sdk.AddrLen+1]
-	delAddr := indexKey[sdk.AddrLen+1 : 2*sdk.AddrLen+1]
-	valDstAddr := indexKey[2*sdk.AddrLen+1 : 3*sdk.AddrLen+1]
+	valSrcAddrLen := addrs[0]
+	valSrcAddr := addrs[1 : valSrcAddrLen+1]
+	delAddrLen := addrs[valSrcAddrLen+1]
+	delAddr := addrs[valSrcAddrLen+2 : valSrcAddrLen+2+delAddrLen]
+	valDstAddr := addrs[valSrcAddrLen+delAddrLen+3:]
 
 	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
 }
 
 // GetREDKeyFromValDstIndexKey rearranges the ValDstIndexKey to get the REDKey
 func GetREDKeyFromValDstIndexKey(indexKey []byte) []byte {
-	// note that first byte is prefix byte
-	if len(indexKey) != 3*sdk.AddrLen+1 {
-		panic("unexpected key length")
-	}
+	// note that first byte is prefix byte, which we remove
+	addrs := indexKey[1:]
 
-	valDstAddr := indexKey[1 : sdk.AddrLen+1]
-	delAddr := indexKey[sdk.AddrLen+1 : 2*sdk.AddrLen+1]
-	valSrcAddr := indexKey[2*sdk.AddrLen+1 : 3*sdk.AddrLen+1]
+	valDstAddrLen := addrs[0]
+	valDstAddr := addrs[1 : valDstAddrLen+1]
+	delAddrLen := addrs[valDstAddrLen+1]
+	delAddr := addrs[valDstAddrLen+2 : valDstAddrLen+2+delAddrLen]
+	valSrcAddr := addrs[valDstAddrLen+delAddrLen+3:]
 
 	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
 }
@@ -299,25 +308,25 @@ func GetRedelegationTimeKey(timestamp time.Time) []byte {
 // GetREDsKey returns a key prefix for indexing a redelegation from a delegator
 // address.
 func GetREDsKey(delAddr sdk.AccAddress) []byte {
-	return append(RedelegationKey, delAddr.Bytes()...)
+	return append(RedelegationKey, address.MustLengthPrefix(delAddr)...)
 }
 
 // GetREDsFromValSrcIndexKey returns a key prefix for indexing a redelegation to
 // a source validator.
 func GetREDsFromValSrcIndexKey(valSrcAddr sdk.ValAddress) []byte {
-	return append(RedelegationByValSrcIndexKey, valSrcAddr.Bytes()...)
+	return append(RedelegationByValSrcIndexKey, address.MustLengthPrefix(valSrcAddr)...)
 }
 
 // GetREDsToValDstIndexKey returns a key prefix for indexing a redelegation to a
 // destination (target) validator.
 func GetREDsToValDstIndexKey(valDstAddr sdk.ValAddress) []byte {
-	return append(RedelegationByValDstIndexKey, valDstAddr.Bytes()...)
+	return append(RedelegationByValDstIndexKey, address.MustLengthPrefix(valDstAddr)...)
 }
 
 // GetREDsByDelToValDstIndexKey returns a key prefix for indexing a redelegation
 // from an address to a source validator.
 func GetREDsByDelToValDstIndexKey(delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) []byte {
-	return append(GetREDsToValDstIndexKey(valDstAddr), delAddr.Bytes()...)
+	return append(GetREDsToValDstIndexKey(valDstAddr), address.MustLengthPrefix(delAddr)...)
 }
 
 // GetHistoricalInfoKey returns a key prefix for indexing HistoricalInfo objects.
diff --git a/x/staking/types/keys_test.go b/x/staking/types/keys_test.go
index 0bd7a7c20bb7..35667f949da5 100644
--- a/x/staking/types/keys_test.go
+++ b/x/staking/types/keys_test.go
@@ -37,10 +37,10 @@ func TestGetValidatorPowerRank(t *testing.T) {
 		validator types.Validator
 		wantHex   string
 	}{
-		{val1, "2300000000000000009c288ede7df62742fc3b7d0962045a8cef0f79f6"},
-		{val2, "2300000000000000019c288ede7df62742fc3b7d0962045a8cef0f79f6"},
-		{val3, "23000000000000000a9c288ede7df62742fc3b7d0962045a8cef0f79f6"},
-		{val4, "2300000100000000009c288ede7df62742fc3b7d0962045a8cef0f79f6"},
+		{val1, "230000000000000000149c288ede7df62742fc3b7d0962045a8cef0f79f6"},
+		{val2, "230000000000000001149c288ede7df62742fc3b7d0962045a8cef0f79f6"},
+		{val3, "23000000000000000a149c288ede7df62742fc3b7d0962045a8cef0f79f6"},
+		{val4, "230000010000000000149c288ede7df62742fc3b7d0962045a8cef0f79f6"},
 	}
 	for i, tt := range tests {
 		got := hex.EncodeToString(types.GetValidatorsByPowerIndexKey(tt.validator, sdk.DefaultPowerReduction))
@@ -57,11 +57,11 @@ func TestGetREDByValDstIndexKey(t *testing.T) {
 		wantHex    string
 	}{
 		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr1),
-			"3663d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
+			"361463d771218209d8bd03c482f69dfba57310f086091463d771218209d8bd03c482f69dfba57310f086091463d771218209d8bd03c482f69dfba57310f08609"},
 		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr2), sdk.ValAddress(keysAddr3),
-			"363ab62f0d93849be495e21e3e9013a517038f45bd63d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f2"},
+			"36143ab62f0d93849be495e21e3e9013a517038f45bd1463d771218209d8bd03c482f69dfba57310f08609145ef3b5f25c54946d4a89fc0d09d2f126614540f2"},
 		{sdk.AccAddress(keysAddr2), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr3),
-			"363ab62f0d93849be495e21e3e9013a517038f45bd5ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f08609"},
+			"36143ab62f0d93849be495e21e3e9013a517038f45bd145ef3b5f25c54946d4a89fc0d09d2f126614540f21463d771218209d8bd03c482f69dfba57310f08609"},
 	}
 	for i, tt := range tests {
 		got := hex.EncodeToString(types.GetREDByValDstIndexKey(tt.delAddr, tt.valSrcAddr, tt.valDstAddr))
@@ -78,11 +78,11 @@ func TestGetREDByValSrcIndexKey(t *testing.T) {
 		wantHex    string
 	}{
 		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr1),
-			"3563d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
+			"351463d771218209d8bd03c482f69dfba57310f086091463d771218209d8bd03c482f69dfba57310f086091463d771218209d8bd03c482f69dfba57310f08609"},
 		{sdk.AccAddress(keysAddr1), sdk.ValAddress(keysAddr2), sdk.ValAddress(keysAddr3),
-			"355ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f086093ab62f0d93849be495e21e3e9013a517038f45bd"},
+			"35145ef3b5f25c54946d4a89fc0d09d2f126614540f21463d771218209d8bd03c482f69dfba57310f08609143ab62f0d93849be495e21e3e9013a517038f45bd"},
 		{sdk.AccAddress(keysAddr2), sdk.ValAddress(keysAddr1), sdk.ValAddress(keysAddr3),
-			"3563d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f23ab62f0d93849be495e21e3e9013a517038f45bd"},
+			"351463d771218209d8bd03c482f69dfba57310f08609145ef3b5f25c54946d4a89fc0d09d2f126614540f2143ab62f0d93849be495e21e3e9013a517038f45bd"},
 	}
 	for i, tt := range tests {
 		got := hex.EncodeToString(types.GetREDByValSrcIndexKey(tt.delAddr, tt.valSrcAddr, tt.valDstAddr))
diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go
index 81c4caf82145..91f7df583f95 100644
--- a/x/staking/types/staking.pb.go
+++ b/x/staking/types/staking.pb.go
@@ -135,8 +135,11 @@ func (m *HistoricalInfo) GetValset() []Validator {
 // CommissionRates defines the initial commission rates to be used for creating
 // a validator.
 type CommissionRates struct {
-	Rate          github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
-	MaxRate       github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
+	// rate is the commission rate charged to delegators, as a fraction.
+	Rate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
+	// max_rate defines the maximum commission rate which validator can ever charge, as a fraction.
+	MaxRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
+	// max_change_rate defines the maximum daily increase of the validator commission, as a fraction.
 	MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
 }
 
@@ -174,8 +177,10 @@ var xxx_messageInfo_CommissionRates proto.InternalMessageInfo
 
 // Commission defines commission parameters for a given validator.
 type Commission struct {
+	// commission_rates defines the initial commission rates to be used for creating a validator.
 	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
-	UpdateTime      time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
+	// update_time is the last time the commission rate was changed.
+	UpdateTime time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
 }
 
 func (m *Commission) Reset()      { *m = Commission{} }
@@ -219,11 +224,16 @@ func (m *Commission) GetUpdateTime() time.Time {
 
 // Description defines a validator description.
 type Description struct {
-	Moniker         string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
-	Identity        string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
-	Website         string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
+	// moniker defines a human-readable name for the validator.
+	Moniker string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
+	// identity defines an optional identity signature (ex. UPort or Keybase).
+	Identity string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
+	// website defines an optional website link.
+	Website string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
+	// security_contact defines an optional email for security contact.
 	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty" yaml:"security_contact"`
-	Details         string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
+	// details define other optional details.
+	Details string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
 }
 
 func (m *Description) Reset()      { *m = Description{} }
@@ -302,16 +312,27 @@ 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   *types1.Any                            `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"`
+	// operator_address defines the address of the validator's operator; bech encoded in JSON.
+	OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"`
+	// consensus_pubkey is the consensus public key of the validator, as a Protobuf Any.
+	ConsensusPubkey *types1.Any `protobuf:"bytes,2,opt,name=consensus_pubkey,json=consensusPubkey,proto3" json:"consensus_pubkey,omitempty" yaml:"consensus_pubkey"`
+	// jailed defined whether the validator has been jailed from bonded status or not.
+	Jailed bool `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed,omitempty"`
+	// status is the validator status (bonded/unbonding/unbonded).
+	Status BondStatus `protobuf:"varint,4,opt,name=status,proto3,enum=cosmos.staking.v1beta1.BondStatus" json:"status,omitempty"`
+	// tokens define the delegated tokens (incl. self-delegation).
+	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"`
+	// delegator_shares defines total shares issued to a validator's delegators.
+	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 defines the description terms for the validator.
+	Description Description `protobuf:"bytes,7,opt,name=description,proto3" json:"description"`
+	// unbonding_height defines, if unbonding, the height at which this validator has begun unbonding.
+	UnbondingHeight int64 `protobuf:"varint,8,opt,name=unbonding_height,json=unbondingHeight,proto3" json:"unbonding_height,omitempty" yaml:"unbonding_height"`
+	// unbonding_time defines, if unbonding, the min time for the validator to complete unbonding.
+	UnbondingTime time.Time `protobuf:"bytes,9,opt,name=unbonding_time,json=unbondingTime,proto3,stdtime" json:"unbonding_time" yaml:"unbonding_time"`
+	// commission defines the commission parameters.
+	Commission Commission `protobuf:"bytes,10,opt,name=commission,proto3" json:"commission"`
+	// min_self_delegation is the validator's self declared minimum self delegation.
 	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"`
 }
 
@@ -567,9 +588,12 @@ func (m *DVVTriplets) GetTriplets() []DVVTriplet {
 // owned by one delegator, and is associated with the voting power of one
 // validator.
 type Delegation struct {
-	DelegatorAddress string                                 `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorAddress string                                 `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
-	Shares           github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
+	// delegator_address is the bech32-encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	// validator_address is the bech32-encoded address of the validator.
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	// shares define the delegation shares received.
+	Shares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
 }
 
 func (m *Delegation) Reset()      { *m = Delegation{} }
@@ -607,9 +631,12 @@ var xxx_messageInfo_Delegation proto.InternalMessageInfo
 // UnbondingDelegation stores all of a single delegator's unbonding bonds
 // for a single validator in an time-ordered list.
 type UnbondingDelegation struct {
-	DelegatorAddress string                     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorAddress string                     `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
-	Entries          []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"`
+	// delegator_address is the bech32-encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	// validator_address is the bech32-encoded address of the validator.
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	// entries are the unbonding delegation entries.
+	Entries []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"`
 }
 
 func (m *UnbondingDelegation) Reset()      { *m = UnbondingDelegation{} }
@@ -646,10 +673,14 @@ var xxx_messageInfo_UnbondingDelegation proto.InternalMessageInfo
 
 // UnbondingDelegationEntry defines an unbonding object with relevant metadata.
 type UnbondingDelegationEntry struct {
-	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	// creation_height is the height which the unbonding took place.
+	CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	// completion_time is the unix time for unbonding completion.
+	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	// initial_balance defines the tokens initially scheduled to receive at completion.
 	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	Balance        github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
+	// balance defines the tokens to receive at completion.
+	Balance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
 }
 
 func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
@@ -700,10 +731,14 @@ func (m *UnbondingDelegationEntry) GetCompletionTime() time.Time {
 
 // RedelegationEntry defines a redelegation object with relevant metadata.
 type RedelegationEntry struct {
-	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	// creation_height  defines the height which the redelegation took place.
+	CreationHeight int64 `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	// completion_time defines the unix time for redelegation completion.
+	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	// initial_balance defines the initial balance when redelegation started.
 	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	SharesDst      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
+	// shares_dst is the amount of destination-validator shares created by redelegation.
+	SharesDst github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
 }
 
 func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
@@ -755,10 +790,14 @@ func (m *RedelegationEntry) GetCompletionTime() time.Time {
 // Redelegation contains the list of a particular delegator's redelegating bonds
 // from a particular source validator to a particular destination validator.
 type Redelegation struct {
-	DelegatorAddress    string              `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorSrcAddress string              `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
-	ValidatorDstAddress string              `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
-	Entries             []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"`
+	// delegator_address is the bech32-encoded address of the delegator.
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	// validator_src_address is the validator redelegation source operator address.
+	ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
+	// validator_dst_address is the validator redelegation destination operator address.
+	ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
+	// entries are the redelegation entries.
+	Entries []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"`
 }
 
 func (m *Redelegation) Reset()      { *m = Redelegation{} }
diff --git a/x/upgrade/client/cli/query.go b/x/upgrade/client/cli/query.go
index 675dba3a9e8d..39674cbc733a 100644
--- a/x/upgrade/client/cli/query.go
+++ b/x/upgrade/client/cli/query.go
@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -41,7 +40,7 @@ func GetCurrentPlanCmd() *cobra.Command {
 			queryClient := types.NewQueryClient(clientCtx)
 
 			params := types.QueryCurrentPlanRequest{}
-			res, err := queryClient.CurrentPlan(context.Background(), &params)
+			res, err := queryClient.CurrentPlan(cmd.Context(), &params)
 			if err != nil {
 				return err
 			}
@@ -74,9 +73,9 @@ func GetAppliedPlanCmd() *cobra.Command {
 				return err
 			}
 			queryClient := types.NewQueryClient(clientCtx)
-
+			ctx := cmd.Context()
 			params := types.QueryAppliedPlanRequest{Name: args[0]}
-			res, err := queryClient.AppliedPlan(context.Background(), &params)
+			res, err := queryClient.AppliedPlan(ctx, &params)
 			if err != nil {
 				return err
 			}
@@ -90,7 +89,7 @@ func GetAppliedPlanCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			headers, err := node.BlockchainInfo(context.Background(), res.Height, res.Height)
+			headers, err := node.BlockchainInfo(ctx, res.Height, res.Height)
 			if err != nil {
 				return err
 			}

From 71305449d612bceddfccda809a372131a1160997 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 22:43:27 +1000
Subject: [PATCH 11/23] regen staking.pb.go

---
 x/staking/types/staking.pb.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go
index 2823f4a57576..dfde1551a471 100644
--- a/x/staking/types/staking.pb.go
+++ b/x/staking/types/staking.pb.go
@@ -844,8 +844,8 @@ type Params struct {
 	HistoricalEntries uint32 `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
 	// bond_denom defines the bondable coin denomination.
 	BondDenom string `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
-  // power_reduction xxx
-	PowerReduction    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=power_reduction,json=powerReduction,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"power_reduction" yaml:"power_reduction"`
+	// power_reduction is the amount of staking tokens required for 1 unit of consensus-engine power
+	PowerReduction github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=power_reduction,json=powerReduction,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"power_reduction" yaml:"power_reduction"`
 }
 
 func (m *Params) Reset()      { *m = Params{} }

From 36bc29a993f81c099f5950afe7db1322a76ef592 Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 23:06:02 +1000
Subject: [PATCH 12/23] golang-ci lint

---
 x/staking/legacy/v040/genesis.pb.go |   7 +-
 x/staking/legacy/v040/staking.pb.go | 102 ++++++++++------------------
 x/staking/legacy/v040/validator.go  |   8 +--
 3 files changed, 40 insertions(+), 77 deletions(-)

diff --git a/x/staking/legacy/v040/genesis.pb.go b/x/staking/legacy/v040/genesis.pb.go
index 11649dfde948..2e21644f1747 100644
--- a/x/staking/legacy/v040/genesis.pb.go
+++ b/x/staking/legacy/v040/genesis.pb.go
@@ -6,13 +6,12 @@ import (
 	math_bits "math/bits"
 
 	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
-	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 )
 
 // GenesisState defines the staking module's genesis state.
 type GenesisState struct {
-	// params defines all the paramaters of related to deposit.
+	// params defines all the parameters of related to deposit.
 	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
 	// last_total_power tracks the total amounts of bonded tokens recorded during
 	// the previous end block.
@@ -281,9 +280,7 @@ func (m *LastValidatorPower) Size() (n int) {
 func sovGenesis(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
-func sozGenesis(x uint64) (n int) {
-	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
+
 func (m *GenesisState) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
index f5bd8fe5e7cd..5d49ab0af2a7 100644
--- a/x/staking/legacy/v040/staking.pb.go
+++ b/x/staking/legacy/v040/staking.pb.go
@@ -4,19 +4,13 @@ import (
 	fmt "fmt"
 	io "io"
 	math_bits "math/bits"
-	reflect "reflect"
 	strings "strings"
 	time "time"
 
 	types1 "github.com/cosmos/cosmos-sdk/codec/types"
-	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
-	types2 "github.com/cosmos/cosmos-sdk/types"
-	_ "github.com/gogo/protobuf/gogoproto"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/duration"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
-	_ "github.com/regen-network/cosmos-proto"
 )
 
 // BondStatus is the status of a validator.
@@ -33,30 +27,12 @@ const (
 	Bonded BondStatus = 3
 )
 
-var BondStatus_name = map[int32]string{
-	0: "BOND_STATUS_UNSPECIFIED",
-	1: "BOND_STATUS_UNBONDED",
-	2: "BOND_STATUS_UNBONDING",
-	3: "BOND_STATUS_BONDED",
-}
-
-var BondStatus_value = map[string]int32{
-	"BOND_STATUS_UNSPECIFIED": 0,
-	"BOND_STATUS_UNBONDED":    1,
-	"BOND_STATUS_UNBONDING":   2,
-	"BOND_STATUS_BONDED":      3,
-}
-
-func (x BondStatus) String() string {
-	return proto.EnumName(BondStatus_name, int32(x))
-}
-
 // CommissionRates defines the initial commission rates to be used for creating
 // a validator.
 type CommissionRates struct {
-	Rate          github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
-	MaxRate       github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
-	MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
+	Rate          sdk.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
+	MaxRate       sdk.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
+	MaxChangeRate sdk.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
 }
 
 func (m *CommissionRates) Reset()      { *m = CommissionRates{} }
@@ -92,17 +68,17 @@ func (*Description) ProtoMessage() {}
 // 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   *types1.Any                            `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"`
+	OperatorAddress   string      `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"`
+	ConsensusPubkey   *types1.Any `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            sdk.Int     `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"`
+	DelegatorShares   sdk.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 sdk.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{} }
@@ -120,9 +96,9 @@ func (*ValAddresses) ProtoMessage() {}
 // owned by one delegator, and is associated with the voting power of one
 // validator.
 type Delegation struct {
-	DelegatorAddress string                                 `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorAddress string                                 `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
-	Shares           github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
+	DelegatorAddress string  `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string  `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	Shares           sdk.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
 }
 
 func (m *Delegation) Reset()      { *m = Delegation{} }
@@ -141,10 +117,10 @@ func (*UnbondingDelegation) ProtoMessage() {}
 
 // UnbondingDelegationEntry defines an unbonding object with relevant metadata.
 type UnbondingDelegationEntry struct {
-	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
-	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	Balance        github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
+	CreationHeight int64     `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance sdk.Int   `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	Balance        sdk.Int   `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
 }
 
 func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
@@ -152,10 +128,10 @@ func (*UnbondingDelegationEntry) ProtoMessage() {}
 
 // RedelegationEntry defines a redelegation object with relevant metadata.
 type RedelegationEntry struct {
-	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
-	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	SharesDst      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
+	CreationHeight int64     `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance sdk.Int   `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	SharesDst      sdk.Dec   `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
 }
 
 func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
@@ -188,15 +164,15 @@ func (*Params) ProtoMessage() {}
 // DelegationResponse is equivalent to Delegation except that it contains a
 // balance in addition to shares which is more suitable for client responses.
 type DelegationResponse struct {
-	Delegation Delegation  `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
-	Balance    types2.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
+	Delegation Delegation `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
+	Balance    sdk.Coin   `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
 }
 
 // Pool is used for tracking bonded and not-bonded token supply of the bond
 // denomination.
 type Pool struct {
-	NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
-	BondedTokens    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"`
+	NotBondedTokens sdk.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
+	BondedTokens    sdk.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"`
 }
 
 func (m *Pool) Reset()         { *m = Pool{} }
@@ -1141,27 +1117,17 @@ func (m *Pool) Size() (n int) {
 func sovStaking(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
-func sozStaking(x uint64) (n int) {
-	return sovStaking(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (this *ValAddresses) String() string {
-	if this == nil {
+
+func (m *ValAddresses) String() string {
+	if m == nil {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ValAddresses{`,
-		`Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`,
+		`Addresses:` + fmt.Sprintf("%v", m.Addresses) + `,`,
 		`}`,
 	}, "")
 	return s
 }
-func valueToStringStaking(v interface{}) string {
-	rv := reflect.ValueOf(v)
-	if rv.IsNil() {
-		return "nil"
-	}
-	pv := reflect.Indirect(rv).Interface()
-	return fmt.Sprintf("*%v", pv)
-}
 
 func (m *CommissionRates) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
diff --git a/x/staking/legacy/v040/validator.go b/x/staking/legacy/v040/validator.go
index e68b3b6dd913..d43de847145b 100644
--- a/x/staking/legacy/v040/validator.go
+++ b/x/staking/legacy/v040/validator.go
@@ -7,10 +7,10 @@ import (
 )
 
 var (
-	BondStatusUnspecified = BondStatus_name[int32(Unspecified)]
-	BondStatusUnbonded    = BondStatus_name[int32(Unbonded)]
-	BondStatusUnbonding   = BondStatus_name[int32(Unbonding)]
-	BondStatusBonded      = BondStatus_name[int32(Bonded)]
+	BondStatusUnspecified = "BOND_STATUS_UNSPECIFIED"
+	BondStatusUnbonded    = "BOND_STATUS_UNBONDED"
+	BondStatusUnbonding   = "BOND_STATUS_UNBONDING"
+	BondStatusBonded      = "BOND_STATUS_BONDED"
 )
 
 // String implements the Stringer interface for a Validator object.

From 2a43a2d8a4ebaf76276fbb3c199dd573f004298d Mon Sep 17 00:00:00 2001
From: psaradev <psaradev058@gmail.com>
Date: Wed, 3 Feb 2021 23:15:42 +1000
Subject: [PATCH 13/23] reduce legacy code

---
 x/staking/legacy/v040/staking.pb.go | 160 ++--------------------------
 x/staking/legacy/v040/validator.go  |   8 +-
 2 files changed, 15 insertions(+), 153 deletions(-)

diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
index 5d49ab0af2a7..0146313d6d0c 100644
--- a/x/staking/legacy/v040/staking.pb.go
+++ b/x/staking/legacy/v040/staking.pb.go
@@ -4,7 +4,6 @@ import (
 	fmt "fmt"
 	io "io"
 	math_bits "math/bits"
-	strings "strings"
 	time "time"
 
 	types1 "github.com/cosmos/cosmos-sdk/codec/types"
@@ -27,6 +26,17 @@ const (
 	Bonded BondStatus = 3
 )
 
+var BondStatusName = map[int32]string{
+	0: "BOND_STATUS_UNSPECIFIED",
+	1: "BOND_STATUS_UNBONDED",
+	2: "BOND_STATUS_UNBONDING",
+	3: "BOND_STATUS_BONDED",
+}
+
+func (x BondStatus) String() string {
+	return proto.EnumName(BondStatusName, int32(x))
+}
+
 // CommissionRates defines the initial commission rates to be used for creating
 // a validator.
 type CommissionRates struct {
@@ -84,14 +94,6 @@ type Validator struct {
 func (m *Validator) Reset()      { *m = Validator{} }
 func (*Validator) ProtoMessage() {}
 
-// ValAddresses defines a repeated set of validator addresses.
-type ValAddresses struct {
-	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
-}
-
-func (m *ValAddresses) Reset()      { *m = ValAddresses{} }
-func (*ValAddresses) ProtoMessage() {}
-
 // Delegation represents the bond with tokens held by an account. It is
 // owned by one delegator, and is associated with the voting power of one
 // validator.
@@ -451,38 +453,6 @@ func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ValAddresses) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *ValAddresses) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ValAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Addresses) > 0 {
-		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Addresses[iNdEx])
-			copy(dAtA[i:], m.Addresses[iNdEx])
-			i = encodeVarintStaking(dAtA, i, uint64(len(m.Addresses[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-		}
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *Delegation) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -956,21 +926,6 @@ func (m *Validator) Size() (n int) {
 	return n
 }
 
-func (m *ValAddresses) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.Addresses) > 0 {
-		for _, s := range m.Addresses {
-			l = len(s)
-			n += 1 + l + sovStaking(uint64(l))
-		}
-	}
-	return n
-}
-
 func (m *Delegation) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1118,17 +1073,6 @@ func sovStaking(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
 
-func (m *ValAddresses) String() string {
-	if m == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&ValAddresses{`,
-		`Addresses:` + fmt.Sprintf("%v", m.Addresses) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-
 func (m *CommissionRates) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -1984,88 +1928,6 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValAddresses) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ValAddresses: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 
 func (m *Delegation) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
diff --git a/x/staking/legacy/v040/validator.go b/x/staking/legacy/v040/validator.go
index d43de847145b..9b4d569e850f 100644
--- a/x/staking/legacy/v040/validator.go
+++ b/x/staking/legacy/v040/validator.go
@@ -7,10 +7,10 @@ import (
 )
 
 var (
-	BondStatusUnspecified = "BOND_STATUS_UNSPECIFIED"
-	BondStatusUnbonded    = "BOND_STATUS_UNBONDED"
-	BondStatusUnbonding   = "BOND_STATUS_UNBONDING"
-	BondStatusBonded      = "BOND_STATUS_BONDED"
+	BondStatusUnspecified = BondStatusName[int32(Unspecified)]
+	BondStatusUnbonded    = BondStatusName[int32(Unbonded)]
+	BondStatusUnbonding   = BondStatusName[int32(Unbonding)]
+	BondStatusBonded      = BondStatusName[int32(Bonded)]
 )
 
 // String implements the Stringer interface for a Validator object.

From be27ec1d297ee00cefb1693f75aefa03b8b6d479 Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Sun, 21 Mar 2021 18:33:14 -0400
Subject: [PATCH 14/23] started fixing merge conflicts

---
 docs/core/proto-docs.md                    |    1 +
 x/ibc/core/02-client/keeper/keeper_test.go |  389 ---
 x/ibc/testing/chain.go                     |  910 ------
 x/staking/keeper/delegation_test.go        |    6 +-
 x/staking/legacy/v040/commission.go        |   17 -
 x/staking/legacy/v040/delegation.go        |  100 -
 x/staking/legacy/v040/genesis.pb.go        |  774 -----
 x/staking/legacy/v040/keys.go              |  325 ++
 x/staking/legacy/v040/migrate.go           |   49 +-
 x/staking/legacy/v040/params.go            |   11 -
 x/staking/legacy/v040/staking.pb.go        | 3121 --------------------
 x/staking/legacy/v040/validator.go         |   43 -
 x/staking/legacy/v042/migrate.go           |  117 -
 x/staking/legacy/v042/migrate_test.go      |  101 -
 x/staking/legacy/v042/types.go             |    5 -
 x/staking/types/staking.pb.go              | 1815 ++++--------
 16 files changed, 958 insertions(+), 6826 deletions(-)
 delete mode 100644 x/ibc/core/02-client/keeper/keeper_test.go
 delete mode 100644 x/ibc/testing/chain.go
 delete mode 100644 x/staking/legacy/v040/commission.go
 delete mode 100644 x/staking/legacy/v040/delegation.go
 delete mode 100644 x/staking/legacy/v040/genesis.pb.go
 delete mode 100644 x/staking/legacy/v040/params.go
 delete mode 100644 x/staking/legacy/v040/staking.pb.go
 delete mode 100644 x/staking/legacy/v040/validator.go
 delete mode 100644 x/staking/legacy/v042/migrate.go
 delete mode 100644 x/staking/legacy/v042/migrate_test.go
 delete mode 100644 x/staking/legacy/v042/types.go

diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index 4da3e3dd3758..7a2f00ef89a2 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -5901,6 +5901,7 @@ Params defines the parameters for the staking module.
 | `max_entries` | [uint32](#uint32) |  | max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). |
 | `historical_entries` | [uint32](#uint32) |  | historical_entries is the number of historical entries to persist. |
 | `bond_denom` | [string](#string) |  | bond_denom defines the bondable coin denomination. |
+| `power_reduction` | [string](#string) |  | power_reduction is the amount of staking tokens required for 1 unit of consensus-engine power |
 
 
 
diff --git a/x/ibc/core/02-client/keeper/keeper_test.go b/x/ibc/core/02-client/keeper/keeper_test.go
deleted file mode 100644
index 364a505c5044..000000000000
--- a/x/ibc/core/02-client/keeper/keeper_test.go
+++ /dev/null
@@ -1,389 +0,0 @@
-package keeper_test
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/suite"
-	tmbytes "github.com/tendermint/tendermint/libs/bytes"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
-	tmtypes "github.com/tendermint/tendermint/types"
-
-	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/codec"
-	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
-	"github.com/cosmos/cosmos-sdk/simapp"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/keeper"
-	"github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"
-	commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
-	"github.com/cosmos/cosmos-sdk/x/ibc/core/exported"
-	ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/07-tendermint/types"
-	localhosttypes "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/09-localhost/types"
-	ibctesting "github.com/cosmos/cosmos-sdk/x/ibc/testing"
-	ibctestingmock "github.com/cosmos/cosmos-sdk/x/ibc/testing/mock"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-)
-
-const (
-	testChainID          = "gaiahub-0"
-	testChainIDRevision1 = "gaiahub-1"
-
-	testClientID  = "tendermint-0"
-	testClientID2 = "tendermint-1"
-	testClientID3 = "tendermint-2"
-
-	height = 5
-
-	trustingPeriod time.Duration = time.Hour * 24 * 7 * 2
-	ubdPeriod      time.Duration = time.Hour * 24 * 7 * 3
-	maxClockDrift  time.Duration = time.Second * 10
-)
-
-var (
-	testClientHeight          = types.NewHeight(0, 5)
-	testClientHeightRevision1 = types.NewHeight(1, 5)
-	newClientHeight           = types.NewHeight(1, 1)
-)
-
-type KeeperTestSuite struct {
-	suite.Suite
-
-	coordinator *ibctesting.Coordinator
-
-	chainA *ibctesting.TestChain
-	chainB *ibctesting.TestChain
-
-	cdc            codec.Marshaler
-	ctx            sdk.Context
-	keeper         *keeper.Keeper
-	consensusState *ibctmtypes.ConsensusState
-	header         *ibctmtypes.Header
-	valSet         *tmtypes.ValidatorSet
-	valSetHash     tmbytes.HexBytes
-	privVal        tmtypes.PrivValidator
-	now            time.Time
-	past           time.Time
-
-	queryClient types.QueryClient
-}
-
-func (suite *KeeperTestSuite) SetupTest() {
-	suite.coordinator = ibctesting.NewCoordinator(suite.T(), 2)
-
-	suite.chainA = suite.coordinator.GetChain(ibctesting.GetChainID(0))
-	suite.chainB = suite.coordinator.GetChain(ibctesting.GetChainID(1))
-
-	isCheckTx := false
-	suite.now = time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
-	suite.past = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
-	now2 := suite.now.Add(time.Hour)
-	app := simapp.Setup(isCheckTx)
-
-	suite.cdc = app.AppCodec()
-	suite.ctx = app.BaseApp.NewContext(isCheckTx, tmproto.Header{Height: height, ChainID: testClientID, Time: now2})
-	suite.keeper = &app.IBCKeeper.ClientKeeper
-	suite.privVal = ibctestingmock.NewPV()
-
-	pubKey, err := suite.privVal.GetPubKey()
-	suite.Require().NoError(err)
-
-	testClientHeightMinus1 := types.NewHeight(0, height-1)
-
-	validator := tmtypes.NewValidator(pubKey, 1)
-	suite.valSet = tmtypes.NewValidatorSet([]*tmtypes.Validator{validator})
-	suite.valSetHash = suite.valSet.Hash()
-	suite.header = suite.chainA.CreateTMClientHeader(testChainID, int64(testClientHeight.RevisionHeight), testClientHeightMinus1, now2, suite.valSet, suite.valSet, []tmtypes.PrivValidator{suite.privVal})
-	suite.consensusState = ibctmtypes.NewConsensusState(suite.now, commitmenttypes.NewMerkleRoot([]byte("hash")), suite.valSetHash)
-
-	var validators stakingtypes.Validators
-	for i := 1; i < 11; i++ {
-		privVal := ibctestingmock.NewPV()
-		tmPk, err := privVal.GetPubKey()
-		suite.Require().NoError(err)
-		pk, err := cryptocodec.FromTmPubKeyInterface(tmPk)
-		suite.Require().NoError(err)
-		val, err := stakingtypes.NewValidator(sdk.ValAddress(pk.Address()), pk, stakingtypes.Description{})
-		suite.Require().NoError(err)
-
-		val.Status = stakingtypes.Bonded
-		val.Tokens = sdk.NewInt(rand.Int63())
-		validators = append(validators, val)
-
-		hi := stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators, app.StakingKeeper.PowerReduction(suite.ctx))
-		app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), &hi)
-	}
-
-	// add localhost client
-	revision := types.ParseChainID(suite.chainA.ChainID)
-	localHostClient := localhosttypes.NewClientState(
-		suite.chainA.ChainID, types.NewHeight(revision, uint64(suite.chainA.GetContext().BlockHeight())),
-	)
-	suite.chainA.App.IBCKeeper.ClientKeeper.SetClientState(suite.chainA.GetContext(), exported.Localhost, localHostClient)
-
-	queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, app.InterfaceRegistry())
-	types.RegisterQueryServer(queryHelper, app.IBCKeeper.ClientKeeper)
-	suite.queryClient = types.NewQueryClient(queryHelper)
-}
-
-func TestKeeperTestSuite(t *testing.T) {
-	suite.Run(t, new(KeeperTestSuite))
-}
-
-func (suite *KeeperTestSuite) TestSetClientState() {
-	clientState := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, types.ZeroHeight(), commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false)
-	suite.keeper.SetClientState(suite.ctx, testClientID, clientState)
-
-	retrievedState, found := suite.keeper.GetClientState(suite.ctx, testClientID)
-	suite.Require().True(found, "GetClientState failed")
-	suite.Require().Equal(clientState, retrievedState, "Client states are not equal")
-}
-
-func (suite *KeeperTestSuite) TestSetClientConsensusState() {
-	suite.keeper.SetClientConsensusState(suite.ctx, testClientID, testClientHeight, suite.consensusState)
-
-	retrievedConsState, found := suite.keeper.GetClientConsensusState(suite.ctx, testClientID, testClientHeight)
-	suite.Require().True(found, "GetConsensusState failed")
-
-	tmConsState, ok := retrievedConsState.(*ibctmtypes.ConsensusState)
-	suite.Require().True(ok)
-	suite.Require().Equal(suite.consensusState, tmConsState, "ConsensusState not stored correctly")
-}
-
-func (suite *KeeperTestSuite) TestValidateSelfClient() {
-	testClientHeight := types.NewHeight(0, uint64(suite.chainA.GetContext().BlockHeight()-1))
-
-	testCases := []struct {
-		name        string
-		clientState exported.ClientState
-		expPass     bool
-	}{
-		{
-			"success",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			true,
-		},
-		{
-			"success with nil UpgradePath",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), nil, false, false),
-			true,
-		},
-		{
-			"invalid client type",
-			localhosttypes.NewClientState(suite.chainA.ChainID, testClientHeight),
-			false,
-		},
-		{
-			"frozen client",
-			&ibctmtypes.ClientState{suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false},
-			false,
-		},
-		{
-			"incorrect chainID",
-			ibctmtypes.NewClientState("gaiatestnet", ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid client height",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, types.NewHeight(0, uint64(suite.chainA.GetContext().BlockHeight())), commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid client revision",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeightRevision1, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid proof specs",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, nil, ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid trust level",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.Fraction{0, 1}, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid unbonding period",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod+10, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid trusting period",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, ubdPeriod+10, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-			false,
-		},
-		{
-			"invalid upgrade path",
-			ibctmtypes.NewClientState(suite.chainA.ChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), []string{"bad", "upgrade", "path"}, false, false),
-			false,
-		},
-	}
-
-	for _, tc := range testCases {
-		err := suite.chainA.App.IBCKeeper.ClientKeeper.ValidateSelfClient(suite.chainA.GetContext(), tc.clientState)
-		if tc.expPass {
-			suite.Require().NoError(err, "expected valid client for case: %s", tc.name)
-		} else {
-			suite.Require().Error(err, "expected invalid client for case: %s", tc.name)
-		}
-	}
-}
-
-func (suite KeeperTestSuite) TestGetAllGenesisClients() {
-	clientIDs := []string{
-		testClientID2, testClientID3, testClientID,
-	}
-	expClients := []exported.ClientState{
-		ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, types.ZeroHeight(), commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-		ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, types.ZeroHeight(), commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-		ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, types.ZeroHeight(), commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false),
-	}
-
-	expGenClients := make(types.IdentifiedClientStates, len(expClients))
-
-	for i := range expClients {
-		suite.chainA.App.IBCKeeper.ClientKeeper.SetClientState(suite.chainA.GetContext(), clientIDs[i], expClients[i])
-		expGenClients[i] = types.NewIdentifiedClientState(clientIDs[i], expClients[i])
-	}
-
-	// add localhost client
-	localHostClient, found := suite.chainA.App.IBCKeeper.ClientKeeper.GetClientState(suite.chainA.GetContext(), exported.Localhost)
-	suite.Require().True(found)
-	expGenClients = append(expGenClients, types.NewIdentifiedClientState(exported.Localhost, localHostClient))
-
-	genClients := suite.chainA.App.IBCKeeper.ClientKeeper.GetAllGenesisClients(suite.chainA.GetContext())
-
-	suite.Require().Equal(expGenClients.Sort(), genClients)
-}
-
-func (suite KeeperTestSuite) TestGetAllGenesisMetadata() {
-	expectedGenMetadata := []types.IdentifiedGenesisMetadata{
-		types.NewIdentifiedGenesisMetadata(
-			"clientA",
-			[]types.GenesisMetadata{
-				types.NewGenesisMetadata(ibctmtypes.ProcessedTimeKey(types.NewHeight(0, 1)), []byte("foo")),
-				types.NewGenesisMetadata(ibctmtypes.ProcessedTimeKey(types.NewHeight(0, 2)), []byte("bar")),
-				types.NewGenesisMetadata(ibctmtypes.ProcessedTimeKey(types.NewHeight(0, 3)), []byte("baz")),
-			},
-		),
-		types.NewIdentifiedGenesisMetadata(
-			"clientB",
-			[]types.GenesisMetadata{
-				types.NewGenesisMetadata(ibctmtypes.ProcessedTimeKey(types.NewHeight(1, 100)), []byte("val1")),
-				types.NewGenesisMetadata(ibctmtypes.ProcessedTimeKey(types.NewHeight(2, 300)), []byte("val2")),
-			},
-		),
-	}
-
-	genClients := []types.IdentifiedClientState{
-		types.NewIdentifiedClientState("clientA", &ibctmtypes.ClientState{}), types.NewIdentifiedClientState("clientB", &ibctmtypes.ClientState{}),
-		types.NewIdentifiedClientState("clientC", &ibctmtypes.ClientState{}), types.NewIdentifiedClientState("clientD", &localhosttypes.ClientState{}),
-	}
-
-	suite.chainA.App.IBCKeeper.ClientKeeper.SetAllClientMetadata(suite.chainA.GetContext(), expectedGenMetadata)
-
-	actualGenMetadata, err := suite.chainA.App.IBCKeeper.ClientKeeper.GetAllClientMetadata(suite.chainA.GetContext(), genClients)
-	suite.Require().NoError(err, "get client metadata returned error unexpectedly")
-	suite.Require().Equal(expectedGenMetadata, actualGenMetadata, "retrieved metadata is unexpected")
-}
-
-func (suite KeeperTestSuite) TestGetConsensusState() {
-	suite.ctx = suite.ctx.WithBlockHeight(10)
-	cases := []struct {
-		name    string
-		height  types.Height
-		expPass bool
-	}{
-		{"zero height", types.ZeroHeight(), false},
-		{"height > latest height", types.NewHeight(0, uint64(suite.ctx.BlockHeight())+1), false},
-		{"latest height - 1", types.NewHeight(0, uint64(suite.ctx.BlockHeight())-1), true},
-		{"latest height", types.GetSelfHeight(suite.ctx), true},
-	}
-
-	for i, tc := range cases {
-		tc := tc
-		cs, found := suite.keeper.GetSelfConsensusState(suite.ctx, tc.height)
-		if tc.expPass {
-			suite.Require().True(found, "Case %d should have passed: %s", i, tc.name)
-			suite.Require().NotNil(cs, "Case %d should have passed: %s", i, tc.name)
-		} else {
-			suite.Require().False(found, "Case %d should have failed: %s", i, tc.name)
-			suite.Require().Nil(cs, "Case %d should have failed: %s", i, tc.name)
-		}
-	}
-}
-
-func (suite KeeperTestSuite) TestConsensusStateHelpers() {
-	// initial setup
-	clientState := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs(), ibctesting.UpgradePath, false, false)
-
-	suite.keeper.SetClientState(suite.ctx, testClientID, clientState)
-	suite.keeper.SetClientConsensusState(suite.ctx, testClientID, testClientHeight, suite.consensusState)
-
-	nextState := ibctmtypes.NewConsensusState(suite.now, commitmenttypes.NewMerkleRoot([]byte("next")), suite.valSetHash)
-
-	testClientHeightPlus5 := types.NewHeight(0, height+5)
-
-	header := suite.chainA.CreateTMClientHeader(testClientID, int64(testClientHeightPlus5.RevisionHeight), testClientHeight, suite.header.Header.Time.Add(time.Minute),
-		suite.valSet, suite.valSet, []tmtypes.PrivValidator{suite.privVal})
-
-	// mock update functionality
-	clientState.LatestHeight = header.GetHeight().(types.Height)
-	suite.keeper.SetClientConsensusState(suite.ctx, testClientID, header.GetHeight(), nextState)
-	suite.keeper.SetClientState(suite.ctx, testClientID, clientState)
-
-	latest, ok := suite.keeper.GetLatestClientConsensusState(suite.ctx, testClientID)
-	suite.Require().True(ok)
-	suite.Require().Equal(nextState, latest, "Latest client not returned correctly")
-}
-
-// 2 clients in total are created on chainA. The first client is updated so it contains an initial consensus state
-// and a consensus state at the update height.
-func (suite KeeperTestSuite) TestGetAllConsensusStates() {
-	clientA, _ := suite.coordinator.SetupClients(suite.chainA, suite.chainB, exported.Tendermint)
-
-	clientState := suite.chainA.GetClientState(clientA)
-	expConsensusHeight0 := clientState.GetLatestHeight()
-	consensusState0, ok := suite.chainA.GetConsensusState(clientA, expConsensusHeight0)
-	suite.Require().True(ok)
-
-	// update client to create a second consensus state
-	err := suite.coordinator.UpdateClient(suite.chainA, suite.chainB, clientA, exported.Tendermint)
-	suite.Require().NoError(err)
-
-	clientState = suite.chainA.GetClientState(clientA)
-	expConsensusHeight1 := clientState.GetLatestHeight()
-	suite.Require().True(expConsensusHeight1.GT(expConsensusHeight0))
-	consensusState1, ok := suite.chainA.GetConsensusState(clientA, expConsensusHeight1)
-	suite.Require().True(ok)
-
-	expConsensus := []exported.ConsensusState{
-		consensusState0,
-		consensusState1,
-	}
-
-	// create second client on chainA
-	clientA2, _ := suite.coordinator.SetupClients(suite.chainA, suite.chainB, exported.Tendermint)
-	clientState = suite.chainA.GetClientState(clientA2)
-
-	expConsensusHeight2 := clientState.GetLatestHeight()
-	consensusState2, ok := suite.chainA.GetConsensusState(clientA2, expConsensusHeight2)
-	suite.Require().True(ok)
-
-	expConsensus2 := []exported.ConsensusState{consensusState2}
-
-	expConsensusStates := types.ClientsConsensusStates{
-		types.NewClientConsensusStates(clientA, []types.ConsensusStateWithHeight{
-			types.NewConsensusStateWithHeight(expConsensusHeight0.(types.Height), expConsensus[0]),
-			types.NewConsensusStateWithHeight(expConsensusHeight1.(types.Height), expConsensus[1]),
-		}),
-		types.NewClientConsensusStates(clientA2, []types.ConsensusStateWithHeight{
-			types.NewConsensusStateWithHeight(expConsensusHeight2.(types.Height), expConsensus2[0]),
-		}),
-	}.Sort()
-
-	consStates := suite.chainA.App.IBCKeeper.ClientKeeper.GetAllConsensusStates(suite.chainA.GetContext())
-	suite.Require().Equal(expConsensusStates, consStates, "%s \n\n%s", expConsensusStates, consStates)
-}
diff --git a/x/ibc/testing/chain.go b/x/ibc/testing/chain.go
deleted file mode 100644
index edf77a7f2456..000000000000
--- a/x/ibc/testing/chain.go
+++ /dev/null
@@ -1,910 +0,0 @@
-package ibctesting
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto/tmhash"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
-	tmprotoversion "github.com/tendermint/tendermint/proto/tendermint/version"
-	tmtypes "github.com/tendermint/tendermint/types"
-	tmversion "github.com/tendermint/tendermint/version"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
-	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	"github.com/cosmos/cosmos-sdk/simapp"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
-	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
-	ibctransfertypes "github.com/cosmos/cosmos-sdk/x/ibc/applications/transfer/types"
-	clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/02-client/types"
-	connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/core/03-connection/types"
-	channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/core/04-channel/types"
-	commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/core/23-commitment/types"
-	host "github.com/cosmos/cosmos-sdk/x/ibc/core/24-host"
-	"github.com/cosmos/cosmos-sdk/x/ibc/core/exported"
-	"github.com/cosmos/cosmos-sdk/x/ibc/core/types"
-	ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/light-clients/07-tendermint/types"
-	"github.com/cosmos/cosmos-sdk/x/ibc/testing/mock"
-	"github.com/cosmos/cosmos-sdk/x/staking/teststaking"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-)
-
-const (
-	// Default params constants used to create a TM client
-	TrustingPeriod     time.Duration = time.Hour * 24 * 7 * 2
-	UnbondingPeriod    time.Duration = time.Hour * 24 * 7 * 3
-	MaxClockDrift      time.Duration = time.Second * 10
-	DefaultDelayPeriod uint64        = 0
-
-	DefaultChannelVersion = ibctransfertypes.Version
-	InvalidID             = "IDisInvalid"
-
-	ConnectionIDPrefix = "conn"
-	ChannelIDPrefix    = "chan"
-
-	TransferPort = ibctransfertypes.ModuleName
-	MockPort     = mock.ModuleName
-
-	// used for testing UpdateClientProposal
-	Title       = "title"
-	Description = "description"
-)
-
-var (
-	DefaultOpenInitVersion *connectiontypes.Version
-
-	// Default params variables used to create a TM client
-	DefaultTrustLevel ibctmtypes.Fraction = ibctmtypes.DefaultTrustLevel
-	TestHash                              = tmhash.Sum([]byte("TESTING HASH"))
-	TestCoin                              = sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100))
-
-	UpgradePath = []string{"upgrade", "upgradedIBCState"}
-
-	ConnectionVersion = connectiontypes.ExportedVersionsToProto(connectiontypes.GetCompatibleVersions())[0]
-
-	MockAcknowledgement = mock.MockAcknowledgement
-	MockCommitment      = mock.MockCommitment
-)
-
-// TestChain is a testing struct that wraps a simapp with the last TM Header, the current ABCI
-// header and the validators of the TestChain. It also contains a field called ChainID. This
-// is the clientID that *other* chains use to refer to this TestChain. The SenderAccount
-// is used for delivering transactions through the application state.
-// NOTE: the actual application uses an empty chain-id for ease of testing.
-type TestChain struct {
-	t *testing.T
-
-	App           *simapp.SimApp
-	ChainID       string
-	LastHeader    *ibctmtypes.Header // header for last block height committed
-	CurrentHeader tmproto.Header     // header for current block height
-	QueryServer   types.QueryServer
-	TxConfig      client.TxConfig
-	Codec         codec.BinaryMarshaler
-
-	Vals    *tmtypes.ValidatorSet
-	Signers []tmtypes.PrivValidator
-
-	senderPrivKey cryptotypes.PrivKey
-	SenderAccount authtypes.AccountI
-
-	// IBC specific helpers
-	ClientIDs   []string          // ClientID's used on this chain
-	Connections []*TestConnection // track connectionID's created for this chain
-}
-
-// NewTestChain initializes a new TestChain instance with a single validator set using a
-// generated private key. It also creates a sender account to be used for delivering transactions.
-//
-// The first block height is committed to state in order to allow for client creations on
-// counterparty chains. The TestChain will return with a block height starting at 2.
-//
-// Time management is handled by the Coordinator in order to ensure synchrony between chains.
-// Each update of any chain increments the block header time for all chains by 5 seconds.
-func NewTestChain(t *testing.T, chainID string) *TestChain {
-	// generate validator private/public key
-	privVal := mock.NewPV()
-	pubKey, err := privVal.GetPubKey()
-	require.NoError(t, err)
-
-	// create validator set with single validator
-	validator := tmtypes.NewValidator(pubKey, 1)
-	valSet := tmtypes.NewValidatorSet([]*tmtypes.Validator{validator})
-	signers := []tmtypes.PrivValidator{privVal}
-
-	// generate genesis account
-	senderPrivKey := secp256k1.GenPrivKey()
-	acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
-	balance := banktypes.Balance{
-		Address: acc.GetAddress().String(),
-		Coins:   sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000000000000))),
-	}
-
-	app := simapp.SetupWithGenesisValSet(t, valSet, []authtypes.GenesisAccount{acc}, balance)
-
-	// create current header and call begin block
-	header := tmproto.Header{
-		ChainID: chainID,
-		Height:  1,
-		Time:    globalStartTime,
-	}
-
-	txConfig := simapp.MakeTestEncodingConfig().TxConfig
-
-	// create an account to send transactions from
-	chain := &TestChain{
-		t:             t,
-		ChainID:       chainID,
-		App:           app,
-		CurrentHeader: header,
-		QueryServer:   app.IBCKeeper,
-		TxConfig:      txConfig,
-		Codec:         app.AppCodec(),
-		Vals:          valSet,
-		Signers:       signers,
-		senderPrivKey: senderPrivKey,
-		SenderAccount: acc,
-		ClientIDs:     make([]string, 0),
-		Connections:   make([]*TestConnection, 0),
-	}
-
-	cap := chain.App.IBCKeeper.PortKeeper.BindPort(chain.GetContext(), MockPort)
-	err = chain.App.ScopedIBCMockKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(MockPort))
-	require.NoError(t, err)
-
-	chain.NextBlock()
-
-	return chain
-}
-
-// GetContext returns the current context for the application.
-func (chain *TestChain) GetContext() sdk.Context {
-	return chain.App.BaseApp.NewContext(false, chain.CurrentHeader)
-}
-
-// QueryProof performs an abci query with the given key and returns the proto encoded merkle proof
-// for the query and the height at which the proof will succeed on a tendermint verifier.
-func (chain *TestChain) QueryProof(key []byte) ([]byte, clienttypes.Height) {
-	res := chain.App.Query(abci.RequestQuery{
-		Path:   fmt.Sprintf("store/%s/key", host.StoreKey),
-		Height: chain.App.LastBlockHeight() - 1,
-		Data:   key,
-		Prove:  true,
-	})
-
-	merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
-	require.NoError(chain.t, err)
-
-	proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
-	require.NoError(chain.t, err)
-
-	revision := clienttypes.ParseChainID(chain.ChainID)
-
-	// proof height + 1 is returned as the proof created corresponds to the height the proof
-	// was created in the IAVL tree. Tendermint and subsequently the clients that rely on it
-	// have heights 1 above the IAVL tree. Thus we return proof height + 1
-	return proof, clienttypes.NewHeight(revision, uint64(res.Height)+1)
-}
-
-// QueryUpgradeProof performs an abci query with the given key and returns the proto encoded merkle proof
-// for the query and the height at which the proof will succeed on a tendermint verifier.
-func (chain *TestChain) QueryUpgradeProof(key []byte, height uint64) ([]byte, clienttypes.Height) {
-	res := chain.App.Query(abci.RequestQuery{
-		Path:   "store/upgrade/key",
-		Height: int64(height - 1),
-		Data:   key,
-		Prove:  true,
-	})
-
-	merkleProof, err := commitmenttypes.ConvertProofs(res.ProofOps)
-	require.NoError(chain.t, err)
-
-	proof, err := chain.App.AppCodec().MarshalBinaryBare(&merkleProof)
-	require.NoError(chain.t, err)
-
-	revision := clienttypes.ParseChainID(chain.ChainID)
-
-	// proof height + 1 is returned as the proof created corresponds to the height the proof
-	// was created in the IAVL tree. Tendermint and subsequently the clients that rely on it
-	// have heights 1 above the IAVL tree. Thus we return proof height + 1
-	return proof, clienttypes.NewHeight(revision, uint64(res.Height+1))
-}
-
-// QueryClientStateProof performs and abci query for a client state
-// stored with a given clientID and returns the ClientState along with the proof
-func (chain *TestChain) QueryClientStateProof(clientID string) (exported.ClientState, []byte) {
-	// retrieve client state to provide proof for
-	clientState, found := chain.App.IBCKeeper.ClientKeeper.GetClientState(chain.GetContext(), clientID)
-	require.True(chain.t, found)
-
-	clientKey := host.FullClientStateKey(clientID)
-	proofClient, _ := chain.QueryProof(clientKey)
-
-	return clientState, proofClient
-}
-
-// QueryConsensusStateProof performs an abci query for a consensus state
-// stored on the given clientID. The proof and consensusHeight are returned.
-func (chain *TestChain) QueryConsensusStateProof(clientID string) ([]byte, clienttypes.Height) {
-	clientState := chain.GetClientState(clientID)
-
-	consensusHeight := clientState.GetLatestHeight().(clienttypes.Height)
-	consensusKey := host.FullConsensusStateKey(clientID, consensusHeight)
-	proofConsensus, _ := chain.QueryProof(consensusKey)
-
-	return proofConsensus, consensusHeight
-}
-
-// NextBlock sets the last header to the current header and increments the current header to be
-// at the next block height. It does not update the time as that is handled by the Coordinator.
-//
-// CONTRACT: this function must only be called after app.Commit() occurs
-func (chain *TestChain) NextBlock() {
-	// set the last header to the current header
-	// use nil trusted fields
-	chain.LastHeader = chain.CurrentTMClientHeader()
-
-	// increment the current header
-	chain.CurrentHeader = tmproto.Header{
-		ChainID: chain.ChainID,
-		Height:  chain.App.LastBlockHeight() + 1,
-		AppHash: chain.App.LastCommitID().Hash,
-		// NOTE: the time is increased by the coordinator to maintain time synchrony amongst
-		// chains.
-		Time:               chain.CurrentHeader.Time,
-		ValidatorsHash:     chain.Vals.Hash(),
-		NextValidatorsHash: chain.Vals.Hash(),
-	}
-
-	chain.App.BeginBlock(abci.RequestBeginBlock{Header: chain.CurrentHeader})
-
-}
-
-// sendMsgs delivers a transaction through the application without returning the result.
-func (chain *TestChain) sendMsgs(msgs ...sdk.Msg) error {
-	_, err := chain.SendMsgs(msgs...)
-	return err
-}
-
-// SendMsgs delivers a transaction through the application. It updates the senders sequence
-// number and updates the TestChain's headers. It returns the result and error if one
-// occurred.
-func (chain *TestChain) SendMsgs(msgs ...sdk.Msg) (*sdk.Result, error) {
-	_, r, err := simapp.SignCheckDeliver(
-		chain.t,
-		chain.TxConfig,
-		chain.App.BaseApp,
-		chain.GetContext().BlockHeader(),
-		msgs,
-		chain.ChainID,
-		[]uint64{chain.SenderAccount.GetAccountNumber()},
-		[]uint64{chain.SenderAccount.GetSequence()},
-		true, true, chain.senderPrivKey,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	// SignCheckDeliver calls app.Commit()
-	chain.NextBlock()
-
-	// increment sequence for successful transaction execution
-	chain.SenderAccount.SetSequence(chain.SenderAccount.GetSequence() + 1)
-
-	return r, nil
-}
-
-// GetClientState retrieves the client state for the provided clientID. The client is
-// expected to exist otherwise testing will fail.
-func (chain *TestChain) GetClientState(clientID string) exported.ClientState {
-	clientState, found := chain.App.IBCKeeper.ClientKeeper.GetClientState(chain.GetContext(), clientID)
-	require.True(chain.t, found)
-
-	return clientState
-}
-
-// GetConsensusState retrieves the consensus state for the provided clientID and height.
-// It will return a success boolean depending on if consensus state exists or not.
-func (chain *TestChain) GetConsensusState(clientID string, height exported.Height) (exported.ConsensusState, bool) {
-	return chain.App.IBCKeeper.ClientKeeper.GetClientConsensusState(chain.GetContext(), clientID, height)
-}
-
-// GetValsAtHeight will return the validator set of the chain at a given height. It will return
-// a success boolean depending on if the validator set exists or not at that height.
-func (chain *TestChain) GetValsAtHeight(height int64) (*tmtypes.ValidatorSet, bool) {
-	histInfo, ok := chain.App.StakingKeeper.GetHistoricalInfo(chain.GetContext(), height)
-	if !ok {
-		return nil, false
-	}
-
-	valSet := stakingtypes.Validators(histInfo.Valset)
-
-	tmValidators, err := teststaking.ToTmValidators(valSet, sdk.DefaultPowerReduction)
-	if err != nil {
-		panic(err)
-	}
-	return tmtypes.NewValidatorSet(tmValidators), true
-}
-
-// GetConnection retrieves an IBC Connection for the provided TestConnection. The
-// connection is expected to exist otherwise testing will fail.
-func (chain *TestChain) GetConnection(testConnection *TestConnection) connectiontypes.ConnectionEnd {
-	connection, found := chain.App.IBCKeeper.ConnectionKeeper.GetConnection(chain.GetContext(), testConnection.ID)
-	require.True(chain.t, found)
-
-	return connection
-}
-
-// GetChannel retrieves an IBC Channel for the provided TestChannel. The channel
-// is expected to exist otherwise testing will fail.
-func (chain *TestChain) GetChannel(testChannel TestChannel) channeltypes.Channel {
-	channel, found := chain.App.IBCKeeper.ChannelKeeper.GetChannel(chain.GetContext(), testChannel.PortID, testChannel.ID)
-	require.True(chain.t, found)
-
-	return channel
-}
-
-// GetAcknowledgement retrieves an acknowledgement for the provided packet. If the
-// acknowledgement does not exist then testing will fail.
-func (chain *TestChain) GetAcknowledgement(packet exported.PacketI) []byte {
-	ack, found := chain.App.IBCKeeper.ChannelKeeper.GetPacketAcknowledgement(chain.GetContext(), packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
-	require.True(chain.t, found)
-
-	return ack
-}
-
-// GetPrefix returns the prefix for used by a chain in connection creation
-func (chain *TestChain) GetPrefix() commitmenttypes.MerklePrefix {
-	return commitmenttypes.NewMerklePrefix(chain.App.IBCKeeper.ConnectionKeeper.GetCommitmentPrefix().Bytes())
-}
-
-// NewClientID appends a new clientID string in the format:
-// ClientFor<counterparty-chain-id><index>
-func (chain *TestChain) NewClientID(clientType string) string {
-	clientID := fmt.Sprintf("%s-%s", clientType, strconv.Itoa(len(chain.ClientIDs)))
-	chain.ClientIDs = append(chain.ClientIDs, clientID)
-	return clientID
-}
-
-// AddTestConnection appends a new TestConnection which contains references
-// to the connection id, client id and counterparty client id.
-func (chain *TestChain) AddTestConnection(clientID, counterpartyClientID string) *TestConnection {
-	conn := chain.ConstructNextTestConnection(clientID, counterpartyClientID)
-
-	chain.Connections = append(chain.Connections, conn)
-	return conn
-}
-
-// ConstructNextTestConnection constructs the next test connection to be
-// created given a clientID and counterparty clientID. The connection id
-// format: <chainID>-conn<index>
-func (chain *TestChain) ConstructNextTestConnection(clientID, counterpartyClientID string) *TestConnection {
-	connectionID := connectiontypes.FormatConnectionIdentifier(uint64(len(chain.Connections)))
-	return &TestConnection{
-		ID:                   connectionID,
-		ClientID:             clientID,
-		NextChannelVersion:   DefaultChannelVersion,
-		CounterpartyClientID: counterpartyClientID,
-	}
-}
-
-// GetFirstTestConnection returns the first test connection for a given clientID.
-// The connection may or may not exist in the chain state.
-func (chain *TestChain) GetFirstTestConnection(clientID, counterpartyClientID string) *TestConnection {
-	if len(chain.Connections) > 0 {
-		return chain.Connections[0]
-	}
-
-	return chain.ConstructNextTestConnection(clientID, counterpartyClientID)
-}
-
-// AddTestChannel appends a new TestChannel which contains references to the port and channel ID
-// used for channel creation and interaction. See 'NextTestChannel' for channel ID naming format.
-func (chain *TestChain) AddTestChannel(conn *TestConnection, portID string) TestChannel {
-	channel := chain.NextTestChannel(conn, portID)
-	conn.Channels = append(conn.Channels, channel)
-	return channel
-}
-
-// NextTestChannel returns the next test channel to be created on this connection, but does not
-// add it to the list of created channels. This function is expected to be used when the caller
-// has not created the associated channel in app state, but would still like to refer to the
-// non-existent channel usually to test for its non-existence.
-//
-// channel ID format: <connectionid>-chan<channel-index>
-//
-// The port is passed in by the caller.
-func (chain *TestChain) NextTestChannel(conn *TestConnection, portID string) TestChannel {
-	nextChanSeq := chain.App.IBCKeeper.ChannelKeeper.GetNextChannelSequence(chain.GetContext())
-	channelID := channeltypes.FormatChannelIdentifier(nextChanSeq)
-	return TestChannel{
-		PortID:               portID,
-		ID:                   channelID,
-		ClientID:             conn.ClientID,
-		CounterpartyClientID: conn.CounterpartyClientID,
-		Version:              conn.NextChannelVersion,
-	}
-}
-
-// ConstructMsgCreateClient constructs a message to create a new client state (tendermint or solomachine).
-// NOTE: a solo machine client will be created with an empty diversifier.
-func (chain *TestChain) ConstructMsgCreateClient(counterparty *TestChain, clientID string, clientType string) *clienttypes.MsgCreateClient {
-	var (
-		clientState    exported.ClientState
-		consensusState exported.ConsensusState
-	)
-
-	switch clientType {
-	case exported.Tendermint:
-		height := counterparty.LastHeader.GetHeight().(clienttypes.Height)
-		clientState = ibctmtypes.NewClientState(
-			counterparty.ChainID, DefaultTrustLevel, TrustingPeriod, UnbondingPeriod, MaxClockDrift,
-			height, commitmenttypes.GetSDKSpecs(), UpgradePath, false, false,
-		)
-		consensusState = counterparty.LastHeader.ConsensusState()
-	case exported.Solomachine:
-		solo := NewSolomachine(chain.t, chain.Codec, clientID, "", 1)
-		clientState = solo.ClientState()
-		consensusState = solo.ConsensusState()
-	default:
-		chain.t.Fatalf("unsupported client state type %s", clientType)
-	}
-
-	msg, err := clienttypes.NewMsgCreateClient(
-		clientState, consensusState, chain.SenderAccount.GetAddress(),
-	)
-	require.NoError(chain.t, err)
-	return msg
-}
-
-// CreateTMClient will construct and execute a 07-tendermint MsgCreateClient. A counterparty
-// client will be created on the (target) chain.
-func (chain *TestChain) CreateTMClient(counterparty *TestChain, clientID string) error {
-	// construct MsgCreateClient using counterparty
-	msg := chain.ConstructMsgCreateClient(counterparty, clientID, exported.Tendermint)
-	return chain.sendMsgs(msg)
-}
-
-// UpdateTMClient will construct and execute a 07-tendermint MsgUpdateClient. The counterparty
-// client will be updated on the (target) chain. UpdateTMClient mocks the relayer flow
-// necessary for updating a Tendermint client.
-func (chain *TestChain) UpdateTMClient(counterparty *TestChain, clientID string) error {
-	header, err := chain.ConstructUpdateTMClientHeader(counterparty, clientID)
-	require.NoError(chain.t, err)
-
-	msg, err := clienttypes.NewMsgUpdateClient(
-		clientID, header,
-		chain.SenderAccount.GetAddress(),
-	)
-	require.NoError(chain.t, err)
-
-	return chain.sendMsgs(msg)
-}
-
-// ConstructUpdateTMClientHeader will construct a valid 07-tendermint Header to update the
-// light client on the source chain.
-func (chain *TestChain) ConstructUpdateTMClientHeader(counterparty *TestChain, clientID string) (*ibctmtypes.Header, error) {
-	header := counterparty.LastHeader
-	// Relayer must query for LatestHeight on client to get TrustedHeight
-	trustedHeight := chain.GetClientState(clientID).GetLatestHeight().(clienttypes.Height)
-	var (
-		tmTrustedVals *tmtypes.ValidatorSet
-		ok            bool
-	)
-	// Once we get TrustedHeight from client, we must query the validators from the counterparty chain
-	// If the LatestHeight == LastHeader.Height, then TrustedValidators are current validators
-	// If LatestHeight < LastHeader.Height, we can query the historical validator set from HistoricalInfo
-	if trustedHeight == counterparty.LastHeader.GetHeight() {
-		tmTrustedVals = counterparty.Vals
-	} else {
-		// NOTE: We need to get validators from counterparty at height: trustedHeight+1
-		// since the last trusted validators for a header at height h
-		// is the NextValidators at h+1 committed to in header h by
-		// NextValidatorsHash
-		tmTrustedVals, ok = counterparty.GetValsAtHeight(int64(trustedHeight.RevisionHeight + 1))
-		if !ok {
-			return nil, sdkerrors.Wrapf(ibctmtypes.ErrInvalidHeaderHeight, "could not retrieve trusted validators at trustedHeight: %d", trustedHeight)
-		}
-	}
-	// inject trusted fields into last header
-	// for now assume revision number is 0
-	header.TrustedHeight = trustedHeight
-
-	trustedVals, err := tmTrustedVals.ToProto()
-	if err != nil {
-		return nil, err
-	}
-	header.TrustedValidators = trustedVals
-
-	return header, nil
-
-}
-
-// ExpireClient fast forwards the chain's block time by the provided amount of time which will
-// expire any clients with a trusting period less than or equal to this amount of time.
-func (chain *TestChain) ExpireClient(amount time.Duration) {
-	chain.CurrentHeader.Time = chain.CurrentHeader.Time.Add(amount)
-}
-
-// CurrentTMClientHeader creates a TM header using the current header parameters
-// on the chain. The trusted fields in the header are set to nil.
-func (chain *TestChain) CurrentTMClientHeader() *ibctmtypes.Header {
-	return chain.CreateTMClientHeader(chain.ChainID, chain.CurrentHeader.Height, clienttypes.Height{}, chain.CurrentHeader.Time, chain.Vals, nil, chain.Signers)
-}
-
-// CreateTMClientHeader creates a TM header to update the TM client. Args are passed in to allow
-// caller flexibility to use params that differ from the chain.
-func (chain *TestChain) CreateTMClientHeader(chainID string, blockHeight int64, trustedHeight clienttypes.Height, timestamp time.Time, tmValSet, tmTrustedVals *tmtypes.ValidatorSet, signers []tmtypes.PrivValidator) *ibctmtypes.Header {
-	var (
-		valSet      *tmproto.ValidatorSet
-		trustedVals *tmproto.ValidatorSet
-	)
-	require.NotNil(chain.t, tmValSet)
-
-	vsetHash := tmValSet.Hash()
-
-	tmHeader := tmtypes.Header{
-		Version:            tmprotoversion.Consensus{Block: tmversion.BlockProtocol, App: 2},
-		ChainID:            chainID,
-		Height:             blockHeight,
-		Time:               timestamp,
-		LastBlockID:        MakeBlockID(make([]byte, tmhash.Size), 10_000, make([]byte, tmhash.Size)),
-		LastCommitHash:     chain.App.LastCommitID().Hash,
-		DataHash:           tmhash.Sum([]byte("data_hash")),
-		ValidatorsHash:     vsetHash,
-		NextValidatorsHash: vsetHash,
-		ConsensusHash:      tmhash.Sum([]byte("consensus_hash")),
-		AppHash:            chain.CurrentHeader.AppHash,
-		LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
-		EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
-		ProposerAddress:    tmValSet.Proposer.Address, //nolint:staticcheck
-	}
-	hhash := tmHeader.Hash()
-	blockID := MakeBlockID(hhash, 3, tmhash.Sum([]byte("part_set")))
-	voteSet := tmtypes.NewVoteSet(chainID, blockHeight, 1, tmproto.PrecommitType, tmValSet)
-
-	commit, err := tmtypes.MakeCommit(blockID, blockHeight, 1, voteSet, signers, timestamp)
-	require.NoError(chain.t, err)
-
-	signedHeader := &tmproto.SignedHeader{
-		Header: tmHeader.ToProto(),
-		Commit: commit.ToProto(),
-	}
-
-	if tmValSet != nil {
-		valSet, err = tmValSet.ToProto()
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	if tmTrustedVals != nil {
-		trustedVals, err = tmTrustedVals.ToProto()
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	// The trusted fields may be nil. They may be filled before relaying messages to a client.
-	// The relayer is responsible for querying client and injecting appropriate trusted fields.
-	return &ibctmtypes.Header{
-		SignedHeader:      signedHeader,
-		ValidatorSet:      valSet,
-		TrustedHeight:     trustedHeight,
-		TrustedValidators: trustedVals,
-	}
-}
-
-// MakeBlockID copied unimported test functions from tmtypes to use them here
-func MakeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) tmtypes.BlockID {
-	return tmtypes.BlockID{
-		Hash: hash,
-		PartSetHeader: tmtypes.PartSetHeader{
-			Total: partSetSize,
-			Hash:  partSetHash,
-		},
-	}
-}
-
-// CreateSortedSignerArray takes two PrivValidators, and the corresponding Validator structs
-// (including voting power). It returns a signer array of PrivValidators that matches the
-// sorting of ValidatorSet.
-// The sorting is first by .VotingPower (descending), with secondary index of .Address (ascending).
-func CreateSortedSignerArray(altPrivVal, suitePrivVal tmtypes.PrivValidator,
-	altVal, suiteVal *tmtypes.Validator) []tmtypes.PrivValidator {
-
-	switch {
-	case altVal.VotingPower > suiteVal.VotingPower:
-		return []tmtypes.PrivValidator{altPrivVal, suitePrivVal}
-	case altVal.VotingPower < suiteVal.VotingPower:
-		return []tmtypes.PrivValidator{suitePrivVal, altPrivVal}
-	default:
-		if bytes.Compare(altVal.Address, suiteVal.Address) == -1 {
-			return []tmtypes.PrivValidator{altPrivVal, suitePrivVal}
-		}
-		return []tmtypes.PrivValidator{suitePrivVal, altPrivVal}
-	}
-}
-
-// ConnectionOpenInit will construct and execute a MsgConnectionOpenInit.
-func (chain *TestChain) ConnectionOpenInit(
-	counterparty *TestChain,
-	connection, counterpartyConnection *TestConnection,
-) error {
-	msg := connectiontypes.NewMsgConnectionOpenInit(
-		connection.ClientID,
-		connection.CounterpartyClientID,
-		counterparty.GetPrefix(), DefaultOpenInitVersion, DefaultDelayPeriod,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ConnectionOpenTry will construct and execute a MsgConnectionOpenTry.
-func (chain *TestChain) ConnectionOpenTry(
-	counterparty *TestChain,
-	connection, counterpartyConnection *TestConnection,
-) error {
-	counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID)
-
-	connectionKey := host.ConnectionKey(counterpartyConnection.ID)
-	proofInit, proofHeight := counterparty.QueryProof(connectionKey)
-
-	proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID)
-
-	msg := connectiontypes.NewMsgConnectionOpenTry(
-		"", connection.ClientID, // does not support handshake continuation
-		counterpartyConnection.ID, counterpartyConnection.ClientID,
-		counterpartyClient, counterparty.GetPrefix(), []*connectiontypes.Version{ConnectionVersion}, DefaultDelayPeriod,
-		proofInit, proofClient, proofConsensus,
-		proofHeight, consensusHeight,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ConnectionOpenAck will construct and execute a MsgConnectionOpenAck.
-func (chain *TestChain) ConnectionOpenAck(
-	counterparty *TestChain,
-	connection, counterpartyConnection *TestConnection,
-) error {
-	counterpartyClient, proofClient := counterparty.QueryClientStateProof(counterpartyConnection.ClientID)
-
-	connectionKey := host.ConnectionKey(counterpartyConnection.ID)
-	proofTry, proofHeight := counterparty.QueryProof(connectionKey)
-
-	proofConsensus, consensusHeight := counterparty.QueryConsensusStateProof(counterpartyConnection.ClientID)
-
-	msg := connectiontypes.NewMsgConnectionOpenAck(
-		connection.ID, counterpartyConnection.ID, counterpartyClient, // testing doesn't use flexible selection
-		proofTry, proofClient, proofConsensus,
-		proofHeight, consensusHeight,
-		ConnectionVersion,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ConnectionOpenConfirm will construct and execute a MsgConnectionOpenConfirm.
-func (chain *TestChain) ConnectionOpenConfirm(
-	counterparty *TestChain,
-	connection, counterpartyConnection *TestConnection,
-) error {
-	connectionKey := host.ConnectionKey(counterpartyConnection.ID)
-	proof, height := counterparty.QueryProof(connectionKey)
-
-	msg := connectiontypes.NewMsgConnectionOpenConfirm(
-		connection.ID,
-		proof, height,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// CreatePortCapability binds and claims a capability for the given portID if it does not
-// already exist. This function will fail testing on any resulting error.
-// NOTE: only creation of a capbility for a transfer or mock port is supported
-// Other applications must bind to the port in InitGenesis or modify this code.
-func (chain *TestChain) CreatePortCapability(portID string) {
-	// check if the portId is already binded, if not bind it
-	_, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), host.PortPath(portID))
-	if !ok {
-		// create capability using the IBC capability keeper
-		cap, err := chain.App.ScopedIBCKeeper.NewCapability(chain.GetContext(), host.PortPath(portID))
-		require.NoError(chain.t, err)
-
-		switch portID {
-		case MockPort:
-			// claim capability using the mock capability keeper
-			err = chain.App.ScopedIBCMockKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(portID))
-			require.NoError(chain.t, err)
-		case TransferPort:
-			// claim capability using the transfer capability keeper
-			err = chain.App.ScopedTransferKeeper.ClaimCapability(chain.GetContext(), cap, host.PortPath(portID))
-			require.NoError(chain.t, err)
-		default:
-			panic(fmt.Sprintf("unsupported ibc testing package port ID %s", portID))
-		}
-	}
-
-	chain.App.Commit()
-
-	chain.NextBlock()
-}
-
-// GetPortCapability returns the port capability for the given portID. The capability must
-// exist, otherwise testing will fail.
-func (chain *TestChain) GetPortCapability(portID string) *capabilitytypes.Capability {
-	cap, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), host.PortPath(portID))
-	require.True(chain.t, ok)
-
-	return cap
-}
-
-// CreateChannelCapability binds and claims a capability for the given portID and channelID
-// if it does not already exist. This function will fail testing on any resulting error.
-func (chain *TestChain) CreateChannelCapability(portID, channelID string) {
-	capName := host.ChannelCapabilityPath(portID, channelID)
-	// check if the portId is already binded, if not bind it
-	_, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), capName)
-	if !ok {
-		cap, err := chain.App.ScopedIBCKeeper.NewCapability(chain.GetContext(), capName)
-		require.NoError(chain.t, err)
-		err = chain.App.ScopedTransferKeeper.ClaimCapability(chain.GetContext(), cap, capName)
-		require.NoError(chain.t, err)
-	}
-
-	chain.App.Commit()
-
-	chain.NextBlock()
-}
-
-// GetChannelCapability returns the channel capability for the given portID and channelID.
-// The capability must exist, otherwise testing will fail.
-func (chain *TestChain) GetChannelCapability(portID, channelID string) *capabilitytypes.Capability {
-	cap, ok := chain.App.ScopedIBCKeeper.GetCapability(chain.GetContext(), host.ChannelCapabilityPath(portID, channelID))
-	require.True(chain.t, ok)
-
-	return cap
-}
-
-// ChanOpenInit will construct and execute a MsgChannelOpenInit.
-func (chain *TestChain) ChanOpenInit(
-	ch, counterparty TestChannel,
-	order channeltypes.Order,
-	connectionID string,
-) error {
-	msg := channeltypes.NewMsgChannelOpenInit(
-		ch.PortID,
-		ch.Version, order, []string{connectionID},
-		counterparty.PortID,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ChanOpenTry will construct and execute a MsgChannelOpenTry.
-func (chain *TestChain) ChanOpenTry(
-	counterparty *TestChain,
-	ch, counterpartyCh TestChannel,
-	order channeltypes.Order,
-	connectionID string,
-) error {
-	proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
-
-	msg := channeltypes.NewMsgChannelOpenTry(
-		ch.PortID, "", // does not support handshake continuation
-		ch.Version, order, []string{connectionID},
-		counterpartyCh.PortID, counterpartyCh.ID, counterpartyCh.Version,
-		proof, height,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ChanOpenAck will construct and execute a MsgChannelOpenAck.
-func (chain *TestChain) ChanOpenAck(
-	counterparty *TestChain,
-	ch, counterpartyCh TestChannel,
-) error {
-	proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
-
-	msg := channeltypes.NewMsgChannelOpenAck(
-		ch.PortID, ch.ID,
-		counterpartyCh.ID, counterpartyCh.Version, // testing doesn't use flexible selection
-		proof, height,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ChanOpenConfirm will construct and execute a MsgChannelOpenConfirm.
-func (chain *TestChain) ChanOpenConfirm(
-	counterparty *TestChain,
-	ch, counterpartyCh TestChannel,
-) error {
-	proof, height := counterparty.QueryProof(host.ChannelKey(counterpartyCh.PortID, counterpartyCh.ID))
-
-	msg := channeltypes.NewMsgChannelOpenConfirm(
-		ch.PortID, ch.ID,
-		proof, height,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// ChanCloseInit will construct and execute a MsgChannelCloseInit.
-//
-// NOTE: does not work with ibc-transfer module
-func (chain *TestChain) ChanCloseInit(
-	counterparty *TestChain,
-	channel TestChannel,
-) error {
-	msg := channeltypes.NewMsgChannelCloseInit(
-		channel.PortID, channel.ID,
-		chain.SenderAccount.GetAddress(),
-	)
-	return chain.sendMsgs(msg)
-}
-
-// GetPacketData returns a ibc-transfer marshalled packet to be used for
-// callback testing.
-func (chain *TestChain) GetPacketData(counterparty *TestChain) []byte {
-	packet := ibctransfertypes.FungibleTokenPacketData{
-		Denom:    TestCoin.Denom,
-		Amount:   TestCoin.Amount.Uint64(),
-		Sender:   chain.SenderAccount.GetAddress().String(),
-		Receiver: counterparty.SenderAccount.GetAddress().String(),
-	}
-
-	return packet.GetBytes()
-}
-
-// SendPacket simulates sending a packet through the channel keeper. No message needs to be
-// passed since this call is made from a module.
-func (chain *TestChain) SendPacket(
-	packet exported.PacketI,
-) error {
-	channelCap := chain.GetChannelCapability(packet.GetSourcePort(), packet.GetSourceChannel())
-
-	// no need to send message, acting as a module
-	err := chain.App.IBCKeeper.ChannelKeeper.SendPacket(chain.GetContext(), channelCap, packet)
-	if err != nil {
-		return err
-	}
-
-	// commit changes
-	chain.App.Commit()
-	chain.NextBlock()
-
-	return nil
-}
-
-// WriteAcknowledgement simulates writing an acknowledgement to the chain.
-func (chain *TestChain) WriteAcknowledgement(
-	packet exported.PacketI,
-) error {
-	channelCap := chain.GetChannelCapability(packet.GetDestPort(), packet.GetDestChannel())
-
-	// no need to send message, acting as a handler
-	err := chain.App.IBCKeeper.ChannelKeeper.WriteAcknowledgement(chain.GetContext(), channelCap, packet, TestHash)
-	if err != nil {
-		return err
-	}
-
-	// commit changes
-	chain.App.Commit()
-	chain.NextBlock()
-
-	return nil
-}
diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go
index 0d48777dc248..46635cacb944 100644
--- a/x/staking/keeper/delegation_test.go
+++ b/x/staking/keeper/delegation_test.go
@@ -345,11 +345,7 @@ func TestUndelegateSelfDelegationBelowMinSelfDelegation(t *testing.T) {
 	app.StakingKeeper.SetDelegation(ctx, delegation)
 
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-<<<<<<< HEAD
-	_, err = app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], app.StakingKeeper.TokensFromConsensusPower(ctx, 6).ToDec())
-=======
-	_, err := app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.TokensFromConsensusPower(6).ToDec())
->>>>>>> upstream/master
+	_, err := app.StakingKeeper.Undelegate(ctx, val0AccAddr, addrVals[0], app.StakingKeeper.TokensFromConsensusPower(ctx, 6).ToDec())
 	require.NoError(t, err)
 
 	// end block
diff --git a/x/staking/legacy/v040/commission.go b/x/staking/legacy/v040/commission.go
deleted file mode 100644
index c7d4044a213d..000000000000
--- a/x/staking/legacy/v040/commission.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package v040
-
-import (
-	yaml "gopkg.in/yaml.v2"
-)
-
-// String implements the Stringer interface for a Commission object.
-func (c Commission) String() string {
-	out, _ := yaml.Marshal(c)
-	return string(out)
-}
-
-// String implements the Stringer interface for a CommissionRates object.
-func (cr CommissionRates) String() string {
-	out, _ := yaml.Marshal(cr)
-	return string(out)
-}
diff --git a/x/staking/legacy/v040/delegation.go b/x/staking/legacy/v040/delegation.go
deleted file mode 100644
index 8c3f99874cee..000000000000
--- a/x/staking/legacy/v040/delegation.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package v040
-
-import (
-	"fmt"
-	"strings"
-
-	yaml "gopkg.in/yaml.v2"
-)
-
-// String returns a human readable string representation of a Delegation.
-func (d Delegation) String() string {
-	out, _ := yaml.Marshal(d)
-	return string(out)
-}
-
-// Delegations is a collection of delegations
-type Delegations []Delegation
-
-func (d Delegations) String() (out string) {
-	for _, del := range d {
-		out += del.String() + "\n"
-	}
-
-	return strings.TrimSpace(out)
-}
-
-// String implements the stringer interface for a UnbondingDelegationEntry.
-func (e UnbondingDelegationEntry) String() string {
-	out, _ := yaml.Marshal(e)
-	return string(out)
-}
-
-// String returns a human readable string representation of an UnbondingDelegation.
-func (ubd UnbondingDelegation) String() string {
-	out := fmt.Sprintf(`Unbonding Delegations between:
-  Delegator:                 %s
-  Validator:                 %s
-	Entries:`, ubd.DelegatorAddress, ubd.ValidatorAddress)
-	for i, entry := range ubd.Entries {
-		out += fmt.Sprintf(`    Unbonding Delegation %d:
-      Creation Height:           %v
-      Min time to unbond (unix): %v
-      Expected balance:          %s`, i, entry.CreationHeight,
-			entry.CompletionTime, entry.Balance)
-	}
-
-	return out
-}
-
-// UnbondingDelegations is a collection of UnbondingDelegation
-type UnbondingDelegations []UnbondingDelegation
-
-func (ubds UnbondingDelegations) String() (out string) {
-	for _, u := range ubds {
-		out += u.String() + "\n"
-	}
-
-	return strings.TrimSpace(out)
-}
-
-// String implements the Stringer interface for a RedelegationEntry object.
-func (e RedelegationEntry) String() string {
-	out, _ := yaml.Marshal(e)
-	return string(out)
-}
-
-// String returns a human readable string representation of a Redelegation.
-func (red Redelegation) String() string {
-	out := fmt.Sprintf(`Redelegations between:
-  Delegator:                 %s
-  Source Validator:          %s
-  Destination Validator:     %s
-  Entries:
-`,
-		red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress,
-	)
-
-	for i, entry := range red.Entries {
-		out += fmt.Sprintf(`    Redelegation Entry #%d:
-      Creation height:           %v
-      Min time to unbond (unix): %v
-      Dest Shares:               %s
-`,
-			i, entry.CreationHeight, entry.CompletionTime, entry.SharesDst,
-		)
-	}
-
-	return strings.TrimRight(out, "\n")
-}
-
-// Redelegations are a collection of Redelegation
-type Redelegations []Redelegation
-
-func (d Redelegations) String() (out string) {
-	for _, red := range d {
-		out += red.String() + "\n"
-	}
-
-	return strings.TrimSpace(out)
-}
diff --git a/x/staking/legacy/v040/genesis.pb.go b/x/staking/legacy/v040/genesis.pb.go
deleted file mode 100644
index 2e21644f1747..000000000000
--- a/x/staking/legacy/v040/genesis.pb.go
+++ /dev/null
@@ -1,774 +0,0 @@
-package v040
-
-import (
-	fmt "fmt"
-	io "io"
-	math_bits "math/bits"
-
-	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// GenesisState defines the staking module's genesis state.
-type GenesisState struct {
-	// params defines all the parameters of related to deposit.
-	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
-	// last_total_power tracks the total amounts of bonded tokens recorded during
-	// the previous end block.
-	LastTotalPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power" yaml:"last_total_power"`
-	// last_validator_powers is a special index that provides a historical list
-	// of the last-block's bonded validators.
-	LastValidatorPowers []LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers" yaml:"last_validator_powers"`
-	// delegations defines the validator set at genesis.
-	Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"`
-	// delegations defines the delegations active at genesis.
-	Delegations []Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"`
-	// unbonding_delegations defines the unbonding delegations active at genesis.
-	UnbondingDelegations []UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations" yaml:"unbonding_delegations"`
-	// redelegations defines the redelegations active at genesis.
-	Redelegations []Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"`
-	Exported      bool           `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"`
-}
-
-func (m *GenesisState) Reset()         { *m = GenesisState{} }
-func (m *GenesisState) String() string { return proto.CompactTextString(m) }
-func (*GenesisState) ProtoMessage()    {}
-
-// LastValidatorPower required for validator set update logic.
-type LastValidatorPower struct {
-	// address is the address of the validator.
-	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	// power defines the power of the validator.
-	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
-}
-
-func (m *LastValidatorPower) Reset()         { *m = LastValidatorPower{} }
-func (m *LastValidatorPower) String() string { return proto.CompactTextString(m) }
-func (*LastValidatorPower) ProtoMessage()    {}
-
-func (m *GenesisState) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Exported {
-		i--
-		if m.Exported {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x40
-	}
-	if len(m.Redelegations) > 0 {
-		for iNdEx := len(m.Redelegations) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Redelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x3a
-		}
-	}
-	if len(m.UnbondingDelegations) > 0 {
-		for iNdEx := len(m.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.UnbondingDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x32
-		}
-	}
-	if len(m.Delegations) > 0 {
-		for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x2a
-		}
-	}
-	if len(m.Validators) > 0 {
-		for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
-	}
-	if len(m.LastValidatorPowers) > 0 {
-		for iNdEx := len(m.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.LastValidatorPowers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	{
-		size := m.LastTotalPower.Size()
-		i -= size
-		if _, err := m.LastTotalPower.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintGenesis(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenesis(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *LastValidatorPower) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *LastValidatorPower) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *LastValidatorPower) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Power != 0 {
-		i = encodeVarintGenesis(dAtA, i, uint64(m.Power))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Address) > 0 {
-		i -= len(m.Address)
-		copy(dAtA[i:], m.Address)
-		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGenesis(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GenesisState) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Params.Size()
-	n += 1 + l + sovGenesis(uint64(l))
-	l = m.LastTotalPower.Size()
-	n += 1 + l + sovGenesis(uint64(l))
-	if len(m.LastValidatorPowers) > 0 {
-		for _, e := range m.LastValidatorPowers {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.Validators) > 0 {
-		for _, e := range m.Validators {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.Delegations) > 0 {
-		for _, e := range m.Delegations {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.UnbondingDelegations) > 0 {
-		for _, e := range m.UnbondingDelegations {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.Redelegations) > 0 {
-		for _, e := range m.Redelegations {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if m.Exported {
-		n += 2
-	}
-	return n
-}
-
-func (m *LastValidatorPower) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovGenesis(uint64(l))
-	}
-	if m.Power != 0 {
-		n += 1 + sovGenesis(uint64(m.Power))
-	}
-	return n
-}
-
-func sovGenesis(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-
-func (m *GenesisState) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenesis
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LastTotalPower", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.LastTotalPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.LastValidatorPowers = append(m.LastValidatorPowers, LastValidatorPower{})
-			if err := m.LastValidatorPowers[len(m.LastValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Validators = append(m.Validators, Validator{})
-			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Delegations = append(m.Delegations, Delegation{})
-			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.UnbondingDelegations = append(m.UnbondingDelegations, UnbondingDelegation{})
-			if err := m.UnbondingDelegations[len(m.UnbondingDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Redelegations", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Redelegations = append(m.Redelegations, Redelegation{})
-			if err := m.Redelegations[len(m.Redelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 8:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.Exported = bool(v != 0)
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenesis(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *LastValidatorPower) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenesis
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: LastValidatorPower: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: LastValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Address = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
-			}
-			m.Power = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Power |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenesis(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGenesis(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGenesis
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGenesis
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGenesis
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGenesis
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
-)
diff --git a/x/staking/legacy/v040/keys.go b/x/staking/legacy/v040/keys.go
index 6ad280e277e5..c01c41a417e3 100644
--- a/x/staking/legacy/v040/keys.go
+++ b/x/staking/legacy/v040/keys.go
@@ -1,5 +1,330 @@
+// Package v040 is copy-pasted from:
+// https://github.com/cosmos/cosmos-sdk/blob/v0.41.0/x/staking/types/keys.go
 package v040
 
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"strconv"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v040auth "github.com/cosmos/cosmos-sdk/x/auth/legacy/v040"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
 const (
+	// ModuleName is the name of the staking module
 	ModuleName = "staking"
+
+	// StoreKey is the string store representation
+	StoreKey = ModuleName
+
+	// QuerierRoute is the querier route for the staking module
+	QuerierRoute = ModuleName
+
+	// RouterKey is the msg router key for the staking module
+	RouterKey = ModuleName
+)
+
+var (
+	// Keys for store prefixes
+	// Last* values are constant during a block.
+	LastValidatorPowerKey = []byte{0x11} // prefix for each key to a validator index, for bonded validators
+	LastTotalPowerKey     = []byte{0x12} // prefix for the total power
+
+	ValidatorsKey             = []byte{0x21} // prefix for each key to a validator
+	ValidatorsByConsAddrKey   = []byte{0x22} // prefix for each key to a validator index, by pubkey
+	ValidatorsByPowerIndexKey = []byte{0x23} // prefix for each key to a validator index, sorted by power
+
+	DelegationKey                    = []byte{0x31} // key for a delegation
+	UnbondingDelegationKey           = []byte{0x32} // key for an unbonding-delegation
+	UnbondingDelegationByValIndexKey = []byte{0x33} // prefix for each key for an unbonding-delegation, by validator operator
+	RedelegationKey                  = []byte{0x34} // key for a redelegation
+	RedelegationByValSrcIndexKey     = []byte{0x35} // prefix for each key for an redelegation, by source validator operator
+	RedelegationByValDstIndexKey     = []byte{0x36} // prefix for each key for an redelegation, by destination validator operator
+
+	UnbondingQueueKey    = []byte{0x41} // prefix for the timestamps in unbonding queue
+	RedelegationQueueKey = []byte{0x42} // prefix for the timestamps in redelegations queue
+	ValidatorQueueKey    = []byte{0x43} // prefix for the timestamps in validator queue
+
+	HistoricalInfoKey = []byte{0x50} // prefix for the historical info
 )
+
+// gets the key for the validator with address
+// VALUE: staking/Validator
+func GetValidatorKey(operatorAddr sdk.ValAddress) []byte {
+	return append(ValidatorsKey, operatorAddr.Bytes()...)
+}
+
+// gets the key for the validator with pubkey
+// VALUE: validator operator address ([]byte)
+func GetValidatorByConsAddrKey(addr sdk.ConsAddress) []byte {
+	return append(ValidatorsByConsAddrKey, addr.Bytes()...)
+}
+
+// Get the validator operator address from LastValidatorPowerKey
+func AddressFromLastValidatorPowerKey(key []byte) []byte {
+	return key[1:] // remove prefix bytes
+}
+
+// get the validator by power index.
+// Power index is the key used in the power-store, and represents the relative
+// power ranking of the validator.
+// VALUE: validator operator address ([]byte)
+func GetValidatorsByPowerIndexKey(validator types.Validator) []byte {
+	// NOTE the address doesn't need to be stored because counter bytes must always be different
+	// NOTE the larger values are of higher value
+
+	consensusPower := sdk.TokensToConsensusPower(validator.Tokens, sdk.DefaultPowerReduction)
+	consensusPowerBytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(consensusPowerBytes, uint64(consensusPower))
+
+	powerBytes := consensusPowerBytes
+	powerBytesLen := len(powerBytes) // 8
+
+	// key is of format prefix || powerbytes || addrBytes
+	key := make([]byte, 1+powerBytesLen+v040auth.AddrLen)
+
+	key[0] = ValidatorsByPowerIndexKey[0]
+	copy(key[1:powerBytesLen+1], powerBytes)
+	addr, err := sdk.ValAddressFromBech32(validator.OperatorAddress)
+	if err != nil {
+		panic(err)
+	}
+	operAddrInvr := sdk.CopyBytes(addr)
+
+	for i, b := range operAddrInvr {
+		operAddrInvr[i] = ^b
+	}
+
+	copy(key[powerBytesLen+1:], operAddrInvr)
+
+	return key
+}
+
+// get the bonded validator index key for an operator address
+func GetLastValidatorPowerKey(operator sdk.ValAddress) []byte {
+	return append(LastValidatorPowerKey, operator...)
+}
+
+// parse the validators operator address from power rank key
+func ParseValidatorPowerRankKey(key []byte) (operAddr []byte) {
+	powerBytesLen := 8
+	if len(key) != 1+powerBytesLen+v040auth.AddrLen {
+		panic("Invalid validator power rank key length")
+	}
+
+	operAddr = sdk.CopyBytes(key[powerBytesLen+1:])
+
+	for i, b := range operAddr {
+		operAddr[i] = ^b
+	}
+
+	return operAddr
+}
+
+// GetValidatorQueueKey returns the prefix key used for getting a set of unbonding
+// validators whose unbonding completion occurs at the given time and height.
+func GetValidatorQueueKey(timestamp time.Time, height int64) []byte {
+	heightBz := sdk.Uint64ToBigEndian(uint64(height))
+	timeBz := sdk.FormatTimeBytes(timestamp)
+	timeBzL := len(timeBz)
+	prefixL := len(ValidatorQueueKey)
+
+	bz := make([]byte, prefixL+8+timeBzL+8)
+
+	// copy the prefix
+	copy(bz[:prefixL], ValidatorQueueKey)
+
+	// copy the encoded time bytes length
+	copy(bz[prefixL:prefixL+8], sdk.Uint64ToBigEndian(uint64(timeBzL)))
+
+	// copy the encoded time bytes
+	copy(bz[prefixL+8:prefixL+8+timeBzL], timeBz)
+
+	// copy the encoded height
+	copy(bz[prefixL+8+timeBzL:], heightBz)
+
+	return bz
+}
+
+// ParseValidatorQueueKey returns the encoded time and height from a key created
+// from GetValidatorQueueKey.
+func ParseValidatorQueueKey(bz []byte) (time.Time, int64, error) {
+	prefixL := len(ValidatorQueueKey)
+	if prefix := bz[:prefixL]; !bytes.Equal(prefix, ValidatorQueueKey) {
+		return time.Time{}, 0, fmt.Errorf("invalid prefix; expected: %X, got: %X", ValidatorQueueKey, prefix)
+	}
+
+	timeBzL := sdk.BigEndianToUint64(bz[prefixL : prefixL+8])
+	ts, err := sdk.ParseTimeBytes(bz[prefixL+8 : prefixL+8+int(timeBzL)])
+	if err != nil {
+		return time.Time{}, 0, err
+	}
+
+	height := sdk.BigEndianToUint64(bz[prefixL+8+int(timeBzL):])
+
+	return ts, int64(height), nil
+}
+
+// gets the key for delegator bond with validator
+// VALUE: staking/Delegation
+func GetDelegationKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
+	return append(GetDelegationsKey(delAddr), valAddr.Bytes()...)
+}
+
+// gets the prefix for a delegator for all validators
+func GetDelegationsKey(delAddr sdk.AccAddress) []byte {
+	return append(DelegationKey, delAddr.Bytes()...)
+}
+
+// gets the key for an unbonding delegation by delegator and validator addr
+// VALUE: staking/UnbondingDelegation
+func GetUBDKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
+	return append(
+		GetUBDsKey(delAddr.Bytes()),
+		valAddr.Bytes()...)
+}
+
+// gets the index-key for an unbonding delegation, stored by validator-index
+// VALUE: none (key rearrangement used)
+func GetUBDByValIndexKey(delAddr sdk.AccAddress, valAddr sdk.ValAddress) []byte {
+	return append(GetUBDsByValIndexKey(valAddr), delAddr.Bytes()...)
+}
+
+// rearranges the ValIndexKey to get the UBDKey
+func GetUBDKeyFromValIndexKey(indexKey []byte) []byte {
+	addrs := indexKey[1:] // remove prefix bytes
+	if len(addrs) != 2*v040auth.AddrLen {
+		panic("unexpected key length")
+	}
+
+	valAddr := addrs[:v040auth.AddrLen]
+	delAddr := addrs[v040auth.AddrLen:]
+
+	return GetUBDKey(delAddr, valAddr)
+}
+
+// gets the prefix for all unbonding delegations from a delegator
+func GetUBDsKey(delAddr sdk.AccAddress) []byte {
+	return append(UnbondingDelegationKey, delAddr.Bytes()...)
+}
+
+// gets the prefix keyspace for the indexes of unbonding delegations for a validator
+func GetUBDsByValIndexKey(valAddr sdk.ValAddress) []byte {
+	return append(UnbondingDelegationByValIndexKey, valAddr.Bytes()...)
+}
+
+// gets the prefix for all unbonding delegations from a delegator
+func GetUnbondingDelegationTimeKey(timestamp time.Time) []byte {
+	bz := sdk.FormatTimeBytes(timestamp)
+	return append(UnbondingQueueKey, bz...)
+}
+
+// GetREDKey returns a key prefix for indexing a redelegation from a delegator
+// and source validator to a destination validator.
+func GetREDKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
+	key := make([]byte, 1+v040auth.AddrLen*3)
+
+	copy(key[0:v040auth.AddrLen+1], GetREDsKey(delAddr.Bytes()))
+	copy(key[v040auth.AddrLen+1:2*v040auth.AddrLen+1], valSrcAddr.Bytes())
+	copy(key[2*v040auth.AddrLen+1:3*v040auth.AddrLen+1], valDstAddr.Bytes())
+
+	return key
+}
+
+// gets the index-key for a redelegation, stored by source-validator-index
+// VALUE: none (key rearrangement used)
+func GetREDByValSrcIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
+	REDSFromValsSrcKey := GetREDsFromValSrcIndexKey(valSrcAddr)
+	offset := len(REDSFromValsSrcKey)
+
+	// key is of the form REDSFromValsSrcKey || delAddr || valDstAddr
+	key := make([]byte, len(REDSFromValsSrcKey)+2*v040auth.AddrLen)
+	copy(key[0:offset], REDSFromValsSrcKey)
+	copy(key[offset:offset+v040auth.AddrLen], delAddr.Bytes())
+	copy(key[offset+v040auth.AddrLen:offset+2*v040auth.AddrLen], valDstAddr.Bytes())
+
+	return key
+}
+
+// gets the index-key for a redelegation, stored by destination-validator-index
+// VALUE: none (key rearrangement used)
+func GetREDByValDstIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) []byte {
+	REDSToValsDstKey := GetREDsToValDstIndexKey(valDstAddr)
+	offset := len(REDSToValsDstKey)
+
+	// key is of the form REDSToValsDstKey || delAddr || valSrcAddr
+	key := make([]byte, len(REDSToValsDstKey)+2*v040auth.AddrLen)
+	copy(key[0:offset], REDSToValsDstKey)
+	copy(key[offset:offset+v040auth.AddrLen], delAddr.Bytes())
+	copy(key[offset+v040auth.AddrLen:offset+2*v040auth.AddrLen], valSrcAddr.Bytes())
+
+	return key
+}
+
+// GetREDKeyFromValSrcIndexKey rearranges the ValSrcIndexKey to get the REDKey
+func GetREDKeyFromValSrcIndexKey(indexKey []byte) []byte {
+	// note that first byte is prefix byte
+	if len(indexKey) != 3*v040auth.AddrLen+1 {
+		panic("unexpected key length")
+	}
+
+	valSrcAddr := indexKey[1 : v040auth.AddrLen+1]
+	delAddr := indexKey[v040auth.AddrLen+1 : 2*v040auth.AddrLen+1]
+	valDstAddr := indexKey[2*v040auth.AddrLen+1 : 3*v040auth.AddrLen+1]
+
+	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
+}
+
+// GetREDKeyFromValDstIndexKey rearranges the ValDstIndexKey to get the REDKey
+func GetREDKeyFromValDstIndexKey(indexKey []byte) []byte {
+	// note that first byte is prefix byte
+	if len(indexKey) != 3*v040auth.AddrLen+1 {
+		panic("unexpected key length")
+	}
+
+	valDstAddr := indexKey[1 : v040auth.AddrLen+1]
+	delAddr := indexKey[v040auth.AddrLen+1 : 2*v040auth.AddrLen+1]
+	valSrcAddr := indexKey[2*v040auth.AddrLen+1 : 3*v040auth.AddrLen+1]
+
+	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
+}
+
+// GetRedelegationTimeKey returns a key prefix for indexing an unbonding
+// redelegation based on a completion time.
+func GetRedelegationTimeKey(timestamp time.Time) []byte {
+	bz := sdk.FormatTimeBytes(timestamp)
+	return append(RedelegationQueueKey, bz...)
+}
+
+// GetREDsKey returns a key prefix for indexing a redelegation from a delegator
+// address.
+func GetREDsKey(delAddr sdk.AccAddress) []byte {
+	return append(RedelegationKey, delAddr.Bytes()...)
+}
+
+// GetREDsFromValSrcIndexKey returns a key prefix for indexing a redelegation to
+// a source validator.
+func GetREDsFromValSrcIndexKey(valSrcAddr sdk.ValAddress) []byte {
+	return append(RedelegationByValSrcIndexKey, valSrcAddr.Bytes()...)
+}
+
+// GetREDsToValDstIndexKey returns a key prefix for indexing a redelegation to a
+// destination (target) validator.
+func GetREDsToValDstIndexKey(valDstAddr sdk.ValAddress) []byte {
+	return append(RedelegationByValDstIndexKey, valDstAddr.Bytes()...)
+}
+
+// GetREDsByDelToValDstIndexKey returns a key prefix for indexing a redelegation
+// from an address to a source validator.
+func GetREDsByDelToValDstIndexKey(delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) []byte {
+	return append(GetREDsToValDstIndexKey(valDstAddr), delAddr.Bytes()...)
+}
+
+// GetHistoricalInfoKey returns a key prefix for indexing HistoricalInfo objects.
+func GetHistoricalInfoKey(height int64) []byte {
+	return append(HistoricalInfoKey, []byte(strconv.FormatInt(height, 10))...)
+}
diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go
index a0d9b4c90378..b0746fa363a4 100644
--- a/x/staking/legacy/v040/migrate.go
+++ b/x/staking/legacy/v040/migrate.go
@@ -6,18 +6,19 @@ import (
 	codectypes "github.com/cosmos/cosmos-sdk/codec/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) BondStatus {
+func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus {
 	switch oldStatus {
 	case v034staking.Unbonded:
-		return Unbonded
+		return v040staking.Unbonded
 
 	case v034staking.Unbonding:
-		return Unbonding
+		return v040staking.Unbonding
 
 	case v034staking.Bonded:
-		return Bonded
+		return v040staking.Bonded
 
 	default:
 		panic(fmt.Errorf("invalid bond status %d", oldStatus))
@@ -30,29 +31,29 @@ func migrateBondStatus(oldStatus v034staking.BondStatus) BondStatus {
 // - Convert addresses from bytes to bech32 strings.
 // - Update BondStatus staking constants.
 // - Re-encode in v0.40 GenesisState.
-func Migrate(stakingState v038staking.GenesisState) *GenesisState {
-	newLastValidatorPowers := make([]LastValidatorPower, len(stakingState.LastValidatorPowers))
+func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
+	newLastValidatorPowers := make([]v040staking.LastValidatorPower, len(stakingState.LastValidatorPowers))
 	for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
-		newLastValidatorPowers[i] = LastValidatorPower{
+		newLastValidatorPowers[i] = v040staking.LastValidatorPower{
 			Address: oldLastValidatorPower.Address.String(),
 			Power:   oldLastValidatorPower.Power,
 		}
 	}
 
-	newValidators := make([]Validator, len(stakingState.Validators))
+	newValidators := make([]v040staking.Validator, len(stakingState.Validators))
 	for i, oldValidator := range stakingState.Validators {
 		pkAny, err := codectypes.NewAnyWithValue(oldValidator.ConsPubKey)
 		if err != nil {
 			panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
 		}
-		newValidators[i] = Validator{
+		newValidators[i] = v040staking.Validator{
 			OperatorAddress: oldValidator.OperatorAddress.String(),
 			ConsensusPubkey: pkAny,
 			Jailed:          oldValidator.Jailed,
 			Status:          migrateBondStatus(oldValidator.Status),
 			Tokens:          oldValidator.Tokens,
 			DelegatorShares: oldValidator.DelegatorShares,
-			Description: Description{
+			Description: v040staking.Description{
 				Moniker:         oldValidator.Description.Moniker,
 				Identity:        oldValidator.Description.Identity,
 				Website:         oldValidator.Description.Website,
@@ -61,8 +62,8 @@ func Migrate(stakingState v038staking.GenesisState) *GenesisState {
 			},
 			UnbondingHeight: oldValidator.UnbondingHeight,
 			UnbondingTime:   oldValidator.UnbondingCompletionTime,
-			Commission: Commission{
-				CommissionRates: CommissionRates{
+			Commission: v040staking.Commission{
+				CommissionRates: v040staking.CommissionRates{
 					Rate:          oldValidator.Commission.Rate,
 					MaxRate:       oldValidator.Commission.MaxRate,
 					MaxChangeRate: oldValidator.Commission.MaxChangeRate,
@@ -73,20 +74,20 @@ func Migrate(stakingState v038staking.GenesisState) *GenesisState {
 		}
 	}
 
-	newDelegations := make([]Delegation, len(stakingState.Delegations))
+	newDelegations := make([]v040staking.Delegation, len(stakingState.Delegations))
 	for i, oldDelegation := range stakingState.Delegations {
-		newDelegations[i] = Delegation{
+		newDelegations[i] = v040staking.Delegation{
 			DelegatorAddress: oldDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldDelegation.ValidatorAddress.String(),
 			Shares:           oldDelegation.Shares,
 		}
 	}
 
-	newUnbondingDelegations := make([]UnbondingDelegation, len(stakingState.UnbondingDelegations))
+	newUnbondingDelegations := make([]v040staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
 	for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
-		newEntries := make([]UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
+		newEntries := make([]v040staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
 		for j, oldEntry := range oldUnbondingDelegation.Entries {
-			newEntries[j] = UnbondingDelegationEntry{
+			newEntries[j] = v040staking.UnbondingDelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -94,18 +95,18 @@ func Migrate(stakingState v038staking.GenesisState) *GenesisState {
 			}
 		}
 
-		newUnbondingDelegations[i] = UnbondingDelegation{
+		newUnbondingDelegations[i] = v040staking.UnbondingDelegation{
 			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(),
 			Entries:          newEntries,
 		}
 	}
 
-	newRedelegations := make([]Redelegation, len(stakingState.Redelegations))
+	newRedelegations := make([]v040staking.Redelegation, len(stakingState.Redelegations))
 	for i, oldRedelegation := range stakingState.Redelegations {
-		newEntries := make([]RedelegationEntry, len(oldRedelegation.Entries))
+		newEntries := make([]v040staking.RedelegationEntry, len(oldRedelegation.Entries))
 		for j, oldEntry := range oldRedelegation.Entries {
-			newEntries[j] = RedelegationEntry{
+			newEntries[j] = v040staking.RedelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -113,7 +114,7 @@ func Migrate(stakingState v038staking.GenesisState) *GenesisState {
 			}
 		}
 
-		newRedelegations[i] = Redelegation{
+		newRedelegations[i] = v040staking.Redelegation{
 			DelegatorAddress:    oldRedelegation.DelegatorAddress.String(),
 			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(),
 			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(),
@@ -121,8 +122,8 @@ func Migrate(stakingState v038staking.GenesisState) *GenesisState {
 		}
 	}
 
-	return &GenesisState{
-		Params: Params{
+	return &v040staking.GenesisState{
+		Params: v040staking.Params{
 			UnbondingTime:     stakingState.Params.UnbondingTime,
 			MaxValidators:     uint32(stakingState.Params.MaxValidators),
 			MaxEntries:        uint32(stakingState.Params.MaxEntries),
diff --git a/x/staking/legacy/v040/params.go b/x/staking/legacy/v040/params.go
deleted file mode 100644
index 32ad0c72ebba..000000000000
--- a/x/staking/legacy/v040/params.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package v040
-
-import (
-	yaml "gopkg.in/yaml.v2"
-)
-
-// String returns a human readable string representation of the parameters.
-func (p Params) String() string {
-	out, _ := yaml.Marshal(p)
-	return string(out)
-}
diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
deleted file mode 100644
index 0146313d6d0c..000000000000
--- a/x/staking/legacy/v040/staking.pb.go
+++ /dev/null
@@ -1,3121 +0,0 @@
-package v040
-
-import (
-	fmt "fmt"
-	io "io"
-	math_bits "math/bits"
-	time "time"
-
-	types1 "github.com/cosmos/cosmos-sdk/codec/types"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	proto "github.com/gogo/protobuf/proto"
-	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-)
-
-// 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 BondStatusName = map[int32]string{
-	0: "BOND_STATUS_UNSPECIFIED",
-	1: "BOND_STATUS_UNBONDED",
-	2: "BOND_STATUS_UNBONDING",
-	3: "BOND_STATUS_BONDED",
-}
-
-func (x BondStatus) String() string {
-	return proto.EnumName(BondStatusName, int32(x))
-}
-
-// CommissionRates defines the initial commission rates to be used for creating
-// a validator.
-type CommissionRates struct {
-	Rate          sdk.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
-	MaxRate       sdk.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
-	MaxChangeRate sdk.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
-}
-
-func (m *CommissionRates) Reset()      { *m = CommissionRates{} }
-func (*CommissionRates) ProtoMessage() {}
-
-// Commission defines commission parameters for a given validator.
-type Commission struct {
-	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
-	UpdateTime      time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
-}
-
-func (m *Commission) Reset()      { *m = Commission{} }
-func (*Commission) ProtoMessage() {}
-
-// Description defines a validator description.
-type Description struct {
-	Moniker         string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
-	Identity        string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
-	Website         string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
-	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty" yaml:"security_contact"`
-	Details         string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
-}
-
-func (m *Description) Reset()      { *m = Description{} }
-func (*Description) ProtoMessage() {}
-
-// Validator defines a validator, together with the total amount of the
-// Validator's bond shares and their exchange rate to coins. Slashing results in
-// a decrease in the exchange rate, allowing correct calculation of future
-// undelegations without iterating over delegators. When coins are delegated to
-// this validator, the validator is credited with a delegation whose number of
-// bond shares is based on the amount of coins delegated divided by the current
-// 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   *types1.Any `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            sdk.Int     `protobuf:"bytes,5,opt,name=tokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tokens"`
-	DelegatorShares   sdk.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 sdk.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{} }
-func (*Validator) ProtoMessage() {}
-
-// Delegation represents the bond with tokens held by an account. It is
-// owned by one delegator, and is associated with the voting power of one
-// validator.
-type Delegation struct {
-	DelegatorAddress string  `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorAddress string  `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
-	Shares           sdk.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
-}
-
-func (m *Delegation) Reset()      { *m = Delegation{} }
-func (*Delegation) ProtoMessage() {}
-
-// UnbondingDelegation stores all of a single delegator's unbonding bonds
-// for a single validator in an time-ordered list.
-type UnbondingDelegation struct {
-	DelegatorAddress string                     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorAddress string                     `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
-	Entries          []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"`
-}
-
-func (m *UnbondingDelegation) Reset()      { *m = UnbondingDelegation{} }
-func (*UnbondingDelegation) ProtoMessage() {}
-
-// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
-type UnbondingDelegationEntry struct {
-	CreationHeight int64     `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
-	InitialBalance sdk.Int   `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	Balance        sdk.Int   `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
-}
-
-func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
-func (*UnbondingDelegationEntry) ProtoMessage() {}
-
-// RedelegationEntry defines a redelegation object with relevant metadata.
-type RedelegationEntry struct {
-	CreationHeight int64     `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
-	CompletionTime time.Time `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
-	InitialBalance sdk.Int   `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
-	SharesDst      sdk.Dec   `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
-}
-
-func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
-func (*RedelegationEntry) ProtoMessage() {}
-
-// Redelegation contains the list of a particular delegator's redelegating bonds
-// from a particular source validator to a particular destination validator.
-type Redelegation struct {
-	DelegatorAddress    string              `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
-	ValidatorSrcAddress string              `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
-	ValidatorDstAddress string              `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
-	Entries             []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"`
-}
-
-func (m *Redelegation) Reset()      { *m = Redelegation{} }
-func (*Redelegation) ProtoMessage() {}
-
-// Params defines the parameters for the staking module.
-type Params struct {
-	UnbondingTime     time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
-	MaxValidators     uint32        `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
-	MaxEntries        uint32        `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
-	HistoricalEntries uint32        `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
-	BondDenom         string        `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
-}
-
-func (m *Params) Reset()      { *m = Params{} }
-func (*Params) ProtoMessage() {}
-
-// DelegationResponse is equivalent to Delegation except that it contains a
-// balance in addition to shares which is more suitable for client responses.
-type DelegationResponse struct {
-	Delegation Delegation `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
-	Balance    sdk.Coin   `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
-}
-
-// Pool is used for tracking bonded and not-bonded token supply of the bond
-// denomination.
-type Pool struct {
-	NotBondedTokens sdk.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
-	BondedTokens    sdk.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"`
-}
-
-func (m *Pool) Reset()         { *m = Pool{} }
-func (m *Pool) String() string { return proto.CompactTextString(m) }
-func (*Pool) ProtoMessage()    {}
-
-func (m *CommissionRates) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *CommissionRates) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CommissionRates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.MaxChangeRate.Size()
-		i -= size
-		if _, err := m.MaxChangeRate.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	{
-		size := m.MaxRate.Size()
-		i -= size
-		if _, err := m.MaxRate.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size := m.Rate.Size()
-		i -= size
-		if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Commission) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Commission) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):])
-	if err2 != nil {
-		return 0, err2
-	}
-	i -= n2
-	i = encodeVarintStaking(dAtA, i, uint64(n2))
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.CommissionRates.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Description) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Description) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Description) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Details) > 0 {
-		i -= len(m.Details)
-		copy(dAtA[i:], m.Details)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.Details)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if len(m.SecurityContact) > 0 {
-		i -= len(m.SecurityContact)
-		copy(dAtA[i:], m.SecurityContact)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.SecurityContact)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.Website) > 0 {
-		i -= len(m.Website)
-		copy(dAtA[i:], m.Website)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.Website)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.Identity) > 0 {
-		i -= len(m.Identity)
-		copy(dAtA[i:], m.Identity)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.Identity)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Moniker) > 0 {
-		i -= len(m.Moniker)
-		copy(dAtA[i:], m.Moniker)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.Moniker)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Validator) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.MinSelfDelegation.Size()
-		i -= size
-		if _, err := m.MinSelfDelegation.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x5a
-	{
-		size, err := m.Commission.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x52
-	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):])
-	if err5 != nil {
-		return 0, err5
-	}
-	i -= n5
-	i = encodeVarintStaking(dAtA, i, uint64(n5))
-	i--
-	dAtA[i] = 0x4a
-	if m.UnbondingHeight != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.UnbondingHeight))
-		i--
-		dAtA[i] = 0x40
-	}
-	{
-		size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x3a
-	{
-		size := m.DelegatorShares.Size()
-		i -= size
-		if _, err := m.DelegatorShares.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x32
-	{
-		size := m.Tokens.Size()
-		i -= size
-		if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x2a
-	if m.Status != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.Status))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.Jailed {
-		i--
-		if m.Jailed {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.ConsensusPubkey != nil {
-		{
-			size, err := m.ConsensusPubkey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStaking(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.OperatorAddress) > 0 {
-		i -= len(m.OperatorAddress)
-		copy(dAtA[i:], m.OperatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.OperatorAddress)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Delegation) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Delegation) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Delegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.Shares.Size()
-		i -= size
-		if _, err := m.Shares.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	if len(m.ValidatorAddress) > 0 {
-		i -= len(m.ValidatorAddress)
-		copy(dAtA[i:], m.ValidatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.DelegatorAddress) > 0 {
-		i -= len(m.DelegatorAddress)
-		copy(dAtA[i:], m.DelegatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *UnbondingDelegation) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *UnbondingDelegation) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *UnbondingDelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Entries) > 0 {
-		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintStaking(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	if len(m.ValidatorAddress) > 0 {
-		i -= len(m.ValidatorAddress)
-		copy(dAtA[i:], m.ValidatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.DelegatorAddress) > 0 {
-		i -= len(m.DelegatorAddress)
-		copy(dAtA[i:], m.DelegatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *UnbondingDelegationEntry) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *UnbondingDelegationEntry) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.Balance.Size()
-		i -= size
-		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x22
-	{
-		size := m.InitialBalance.Size()
-		i -= size
-		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
-	if err8 != nil {
-		return 0, err8
-	}
-	i -= n8
-	i = encodeVarintStaking(dAtA, i, uint64(n8))
-	i--
-	dAtA[i] = 0x12
-	if m.CreationHeight != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *RedelegationEntry) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *RedelegationEntry) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.SharesDst.Size()
-		i -= size
-		if _, err := m.SharesDst.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x22
-	{
-		size := m.InitialBalance.Size()
-		i -= size
-		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
-	if err9 != nil {
-		return 0, err9
-	}
-	i -= n9
-	i = encodeVarintStaking(dAtA, i, uint64(n9))
-	i--
-	dAtA[i] = 0x12
-	if m.CreationHeight != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Redelegation) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Redelegation) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Redelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Entries) > 0 {
-		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintStaking(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
-	}
-	if len(m.ValidatorDstAddress) > 0 {
-		i -= len(m.ValidatorDstAddress)
-		copy(dAtA[i:], m.ValidatorDstAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.ValidatorSrcAddress) > 0 {
-		i -= len(m.ValidatorSrcAddress)
-		copy(dAtA[i:], m.ValidatorSrcAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.DelegatorAddress) > 0 {
-		i -= len(m.DelegatorAddress)
-		copy(dAtA[i:], m.DelegatorAddress)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Params) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Params) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i--
-	dAtA[i] = 0x32
-	if len(m.BondDenom) > 0 {
-		i -= len(m.BondDenom)
-		copy(dAtA[i:], m.BondDenom)
-		i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.HistoricalEntries != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.HistoricalEntries))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.MaxEntries != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.MaxEntries))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.MaxValidators != 0 {
-		i = encodeVarintStaking(dAtA, i, uint64(m.MaxValidators))
-		i--
-		dAtA[i] = 0x10
-	}
-	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):])
-	if err10 != nil {
-		return 0, err10
-	}
-	i -= n10
-	i = encodeVarintStaking(dAtA, i, uint64(n10))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Pool) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Pool) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.BondedTokens.Size()
-		i -= size
-		if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size := m.NotBondedTokens.Size()
-		i -= size
-		if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintStaking(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintStaking(dAtA []byte, offset int, v uint64) int {
-	offset -= sovStaking(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-
-func (m *CommissionRates) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Rate.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.MaxRate.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.MaxChangeRate.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *Commission) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.CommissionRates.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime)
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *Description) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Moniker)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.Identity)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.Website)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.SecurityContact)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.Details)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	return n
-}
-
-func (m *Validator) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.OperatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	if m.ConsensusPubkey != nil {
-		l = m.ConsensusPubkey.Size()
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	if m.Jailed {
-		n += 2
-	}
-	if m.Status != 0 {
-		n += 1 + sovStaking(uint64(m.Status))
-	}
-	l = m.Tokens.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.DelegatorShares.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.Description.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	if m.UnbondingHeight != 0 {
-		n += 1 + sovStaking(uint64(m.UnbondingHeight))
-	}
-	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime)
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.Commission.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.MinSelfDelegation.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *Delegation) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.DelegatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.ValidatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = m.Shares.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *UnbondingDelegation) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.DelegatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.ValidatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	if len(m.Entries) > 0 {
-		for _, e := range m.Entries {
-			l = e.Size()
-			n += 1 + l + sovStaking(uint64(l))
-		}
-	}
-	return n
-}
-
-func (m *UnbondingDelegationEntry) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.CreationHeight != 0 {
-		n += 1 + sovStaking(uint64(m.CreationHeight))
-	}
-	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.InitialBalance.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.Balance.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *RedelegationEntry) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.CreationHeight != 0 {
-		n += 1 + sovStaking(uint64(m.CreationHeight))
-	}
-	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.InitialBalance.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.SharesDst.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *Redelegation) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.DelegatorAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.ValidatorSrcAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	l = len(m.ValidatorDstAddress)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	if len(m.Entries) > 0 {
-		for _, e := range m.Entries {
-			l = e.Size()
-			n += 1 + l + sovStaking(uint64(l))
-		}
-	}
-	return n
-}
-
-func (m *Params) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime)
-	n += 1 + l + sovStaking(uint64(l))
-	if m.MaxValidators != 0 {
-		n += 1 + sovStaking(uint64(m.MaxValidators))
-	}
-	if m.MaxEntries != 0 {
-		n += 1 + sovStaking(uint64(m.MaxEntries))
-	}
-	if m.HistoricalEntries != 0 {
-		n += 1 + sovStaking(uint64(m.HistoricalEntries))
-	}
-	l = len(m.BondDenom)
-	if l > 0 {
-		n += 1 + l + sovStaking(uint64(l))
-	}
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func (m *Pool) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.NotBondedTokens.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	l = m.BondedTokens.Size()
-	n += 1 + l + sovStaking(uint64(l))
-	return n
-}
-
-func sovStaking(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-
-func (m *CommissionRates) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: CommissionRates: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxRate", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MaxRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MaxChangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Commission) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Commission: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.CommissionRates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Description) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Description: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Moniker = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Identity = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Website = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.SecurityContact = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Details = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Validator) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.ConsensusPubkey == nil {
-				m.ConsensusPubkey = &types1.Any{}
-			}
-			if err := m.ConsensusPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.Jailed = bool(v != 0)
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
-			}
-			m.Status = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Status |= BondStatus(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Tokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.DelegatorShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 8:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType)
-			}
-			m.UnbondingHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.UnbondingHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 9:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 10:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Commission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 11:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MinSelfDelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-
-func (m *Delegation) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Delegation: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Shares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *UnbondingDelegation) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: UnbondingDelegation: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Entries = append(m.Entries, UnbondingDelegationEntry{})
-			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: UnbondingDelegationEntry: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
-			}
-			m.CreationHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CreationHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *RedelegationEntry) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RedelegationEntry: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
-			}
-			m.CreationHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CreationHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SharesDst", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.SharesDst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Redelegation) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Redelegation: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Entries = append(m.Entries, RedelegationEntry{})
-			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Params) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Params: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
-			}
-			m.MaxValidators = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MaxValidators |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType)
-			}
-			m.MaxEntries = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MaxEntries |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
-			}
-			m.HistoricalEntries = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.HistoricalEntries |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.BondDenom = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Pool) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Pool: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStaking
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStaking(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStaking
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipStaking(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowStaking
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowStaking
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthStaking
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupStaking
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthStaking
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthStaking        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowStaking          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupStaking = fmt.Errorf("proto: unexpected end of group")
-)
diff --git a/x/staking/legacy/v040/validator.go b/x/staking/legacy/v040/validator.go
deleted file mode 100644
index 9b4d569e850f..000000000000
--- a/x/staking/legacy/v040/validator.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package v040
-
-import (
-	"strings"
-
-	"gopkg.in/yaml.v2"
-)
-
-var (
-	BondStatusUnspecified = BondStatusName[int32(Unspecified)]
-	BondStatusUnbonded    = BondStatusName[int32(Unbonded)]
-	BondStatusUnbonding   = BondStatusName[int32(Unbonding)]
-	BondStatusBonded      = BondStatusName[int32(Bonded)]
-)
-
-// String implements the Stringer interface for a Validator object.
-func (v Validator) String() string {
-	out, _ := yaml.Marshal(v)
-	return string(out)
-}
-
-// Validators is a collection of Validator
-type Validators []Validator
-
-func (v Validators) String() (out string) {
-	for _, val := range v {
-		out += val.String() + "\n"
-	}
-
-	return strings.TrimSpace(out)
-}
-
-// ValidatorsByVotingPower implements sort.Interface for []Validator based on
-// the VotingPower and Address fields.
-// The validators are sorted first by their voting power (descending). Secondary index - Address (ascending).
-// Copied from tendermint/types/validator_set.go
-type ValidatorsByVotingPower []Validator
-
-// String implements the Stringer interface for a Description object.
-func (d Description) String() string {
-	out, _ := yaml.Marshal(d)
-	return string(out)
-}
diff --git a/x/staking/legacy/v042/migrate.go b/x/staking/legacy/v042/migrate.go
deleted file mode 100644
index 8e3a0eacc1cb..000000000000
--- a/x/staking/legacy/v042/migrate.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package v042
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
-	v042staking "github.com/cosmos/cosmos-sdk/x/staking/types"
-)
-
-// Migrate accepts exported v0.40 x/staking genesis state and migrates it to
-// v0.42 x/staking genesis state. The migration includes:
-//
-// - Adding power reduction on-chain param
-func Migrate(stakingState v040staking.GenesisState) *v042staking.GenesisState {
-	newLastValidatorPowers := make([]v042staking.LastValidatorPower, len(stakingState.LastValidatorPowers))
-	for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
-		newLastValidatorPowers[i] = v042staking.LastValidatorPower{
-			Address: oldLastValidatorPower.Address,
-			Power:   oldLastValidatorPower.Power,
-		}
-	}
-
-	newValidators := make([]v042staking.Validator, len(stakingState.Validators))
-	for i, oldValidator := range stakingState.Validators {
-		newValidators[i] = v042staking.Validator{
-			OperatorAddress: oldValidator.OperatorAddress,
-			ConsensusPubkey: oldValidator.ConsensusPubkey,
-			Jailed:          oldValidator.Jailed,
-			Status:          v042staking.BondStatus(oldValidator.Status),
-			Tokens:          oldValidator.Tokens,
-			DelegatorShares: oldValidator.DelegatorShares,
-			Description: v042staking.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.UnbondingTime,
-			Commission: v042staking.Commission{
-				CommissionRates: v042staking.CommissionRates{
-					Rate:          oldValidator.Commission.Rate,
-					MaxRate:       oldValidator.Commission.MaxRate,
-					MaxChangeRate: oldValidator.Commission.MaxChangeRate,
-				},
-				UpdateTime: oldValidator.Commission.UpdateTime,
-			},
-			MinSelfDelegation: oldValidator.MinSelfDelegation,
-		}
-	}
-
-	newDelegations := make([]v042staking.Delegation, len(stakingState.Delegations))
-	for i, oldDelegation := range stakingState.Delegations {
-		newDelegations[i] = v042staking.Delegation{
-			DelegatorAddress: oldDelegation.DelegatorAddress,
-			ValidatorAddress: oldDelegation.ValidatorAddress,
-			Shares:           oldDelegation.Shares,
-		}
-	}
-
-	newUnbondingDelegations := make([]v042staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
-	for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
-		newEntries := make([]v042staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
-		for j, oldEntry := range oldUnbondingDelegation.Entries {
-			newEntries[j] = v042staking.UnbondingDelegationEntry{
-				CreationHeight: oldEntry.CreationHeight,
-				CompletionTime: oldEntry.CompletionTime,
-				InitialBalance: oldEntry.InitialBalance,
-				Balance:        oldEntry.Balance,
-			}
-		}
-
-		newUnbondingDelegations[i] = v042staking.UnbondingDelegation{
-			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress,
-			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress,
-			Entries:          newEntries,
-		}
-	}
-
-	newRedelegations := make([]v042staking.Redelegation, len(stakingState.Redelegations))
-	for i, oldRedelegation := range stakingState.Redelegations {
-		newEntries := make([]v042staking.RedelegationEntry, len(oldRedelegation.Entries))
-		for j, oldEntry := range oldRedelegation.Entries {
-			newEntries[j] = v042staking.RedelegationEntry{
-				CreationHeight: oldEntry.CreationHeight,
-				CompletionTime: oldEntry.CompletionTime,
-				InitialBalance: oldEntry.InitialBalance,
-				SharesDst:      oldEntry.SharesDst,
-			}
-		}
-
-		newRedelegations[i] = v042staking.Redelegation{
-			DelegatorAddress:    oldRedelegation.DelegatorAddress,
-			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress,
-			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress,
-			Entries:             newEntries,
-		}
-	}
-
-	return &v042staking.GenesisState{
-		Params: v042staking.Params{
-			UnbondingTime:     stakingState.Params.UnbondingTime,
-			MaxValidators:     stakingState.Params.MaxValidators,
-			MaxEntries:        stakingState.Params.MaxEntries,
-			HistoricalEntries: stakingState.Params.HistoricalEntries,
-			BondDenom:         stakingState.Params.BondDenom,
-			PowerReduction:    sdk.DefaultPowerReduction,
-		},
-		LastTotalPower:       stakingState.LastTotalPower,
-		LastValidatorPowers:  newLastValidatorPowers,
-		Validators:           newValidators,
-		Delegations:          newDelegations,
-		UnbondingDelegations: newUnbondingDelegations,
-		Redelegations:        newRedelegations,
-		Exported:             stakingState.Exported,
-	}
-}
diff --git a/x/staking/legacy/v042/migrate_test.go b/x/staking/legacy/v042/migrate_test.go
deleted file mode 100644
index 8bd00fd4db07..000000000000
--- a/x/staking/legacy/v042/migrate_test.go
+++ /dev/null
@@ -1,101 +0,0 @@
-package v042_test
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
-	"github.com/cosmos/cosmos-sdk/simapp"
-	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
-	v042staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v042"
-)
-
-func TestMigrate(t *testing.T) {
-	encodingConfig := simapp.MakeTestEncodingConfig()
-	clientCtx := client.Context{}.
-		WithInterfaceRegistry(encodingConfig.InterfaceRegistry).
-		WithTxConfig(encodingConfig.TxConfig).
-		WithLegacyAmino(encodingConfig.Amino).
-		WithJSONMarshaler(encodingConfig.Marshaler)
-
-	consPubKey := ed25519.GenPrivKeyFromSecret([]byte("val0")).PubKey()
-	pkAny, err := codectypes.NewAnyWithValue(consPubKey)
-	if err != nil {
-		panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
-	}
-	stakingGenState := v040staking.GenesisState{
-		Validators: v040staking.Validators{v040staking.Validator{
-			ConsensusPubkey: pkAny,
-			Status:          v040staking.Unbonded,
-		}},
-	}
-
-	migrated := v042staking.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 an any
-	// - 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,
-    "power_reduction": "1000000",
-    "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": {
-        "@type": "/cosmos.crypto.ed25519.PubKey",
-        "key": "KTeVrjP7NJIufvgMJsQRxZjfFyD+Exda6O7x+oxIvmA="
-      },
-      "delegator_shares": "0",
-      "description": {
-        "details": "",
-        "identity": "",
-        "moniker": "",
-        "security_contact": "",
-        "website": ""
-      },
-      "jailed": false,
-      "min_self_delegation": "0",
-      "operator_address": "",
-      "status": "BOND_STATUS_UNBONDED",
-      "tokens": "0",
-      "unbonding_height": "0",
-      "unbonding_time": "0001-01-01T00:00:00Z"
-    }
-  ]
-}`
-
-	require.Equal(t, expected, string(indentedBz))
-}
diff --git a/x/staking/legacy/v042/types.go b/x/staking/legacy/v042/types.go
deleted file mode 100644
index 0a7df2a327d0..000000000000
--- a/x/staking/legacy/v042/types.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package v042
-
-const (
-	ModuleName = "staking"
-)
diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go
index 387dadf2e8f6..f8d7bf9dab22 100644
--- a/x/staking/types/staking.pb.go
+++ b/x/staking/types/staking.pb.go
@@ -1263,1226 +1263,623 @@ 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{
-<<<<<<< HEAD
-		// 9630 bytes of a gzipped FileDescriptorSet
-		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x5c, 0xd7,
-		0x75, 0x18, 0xdf, 0xee, 0x02, 0xd8, 0x3d, 0x58, 0x00, 0x8b, 0x0b, 0x90, 0x5c, 0xae, 0x28, 0x00,
-		0x7a, 0xfa, 0xa2, 0x28, 0x09, 0x94, 0x28, 0x91, 0x92, 0x96, 0xb6, 0x64, 0x2c, 0xb0, 0x04, 0x21,
-		0xe2, 0x4b, 0x0f, 0x00, 0x25, 0x7f, 0xa4, 0x3b, 0x0f, 0x6f, 0x2f, 0x16, 0x4f, 0xd8, 0x7d, 0xef,
-		0xe9, 0xbd, 0xb7, 0x24, 0x21, 0xdb, 0x33, 0x8a, 0xed, 0xba, 0x36, 0xd3, 0xd4, 0x76, 0x9d, 0x49,
-		0x6d, 0xc5, 0x74, 0xed, 0x38, 0xad, 0x53, 0xc7, 0x6d, 0x3e, 0xec, 0xba, 0x4d, 0xdb, 0x99, 0xda,
-		0x6d, 0xd3, 0xd8, 0xee, 0x34, 0x63, 0x4f, 0x33, 0x6d, 0x9a, 0x69, 0x99, 0x54, 0xf6, 0xb8, 0x8a,
-		0xeb, 0x36, 0x0e, 0xeb, 0x4c, 0xd3, 0xf1, 0x74, 0xda, 0xb9, 0x5f, 0xef, 0x6b, 0x3f, 0xde, 0x2e,
-		0x4c, 0x5a, 0x4e, 0x93, 0x5f, 0xd8, 0x7b, 0xee, 0x39, 0xe7, 0x9e, 0x7b, 0xee, 0xb9, 0xe7, 0x9c,
-		0xfb, 0xf5, 0x00, 0xff, 0xf2, 0x1c, 0xcc, 0xd4, 0x4c, 0xb3, 0x56, 0xc7, 0xa7, 0x2c, 0xdb, 0x74,
-		0xcd, 0xed, 0xe6, 0xce, 0xa9, 0x2a, 0x76, 0x34, 0x5b, 0xb7, 0x5c, 0xd3, 0x9e, 0xa5, 0x30, 0x34,
-		0xc6, 0x30, 0x66, 0x05, 0x86, 0xbc, 0x02, 0xe3, 0xe7, 0xf5, 0x3a, 0x5e, 0xf0, 0x10, 0x37, 0xb0,
-		0x8b, 0x9e, 0x84, 0xd4, 0x8e, 0x5e, 0xc7, 0x79, 0x69, 0x26, 0x79, 0x62, 0xf8, 0xf4, 0x3d, 0xb3,
-		0x11, 0xa2, 0xd9, 0x30, 0xc5, 0x3a, 0x01, 0x2b, 0x94, 0x42, 0xfe, 0x76, 0x0a, 0x26, 0xda, 0xd4,
-		0x22, 0x04, 0x29, 0x43, 0x6d, 0x10, 0x8e, 0xd2, 0x89, 0x8c, 0x42, 0x7f, 0xa3, 0x3c, 0x0c, 0x59,
-		0xaa, 0xb6, 0xa7, 0xd6, 0x70, 0x3e, 0x41, 0xc1, 0xa2, 0x88, 0xa6, 0x00, 0xaa, 0xd8, 0xc2, 0x46,
-		0x15, 0x1b, 0xda, 0x7e, 0x3e, 0x39, 0x93, 0x3c, 0x91, 0x51, 0x02, 0x10, 0xf4, 0x20, 0x8c, 0x5b,
-		0xcd, 0xed, 0xba, 0xae, 0x55, 0x02, 0x68, 0x30, 0x93, 0x3c, 0x31, 0xa0, 0xe4, 0x58, 0xc5, 0x82,
-		0x8f, 0x7c, 0x3f, 0x8c, 0x5d, 0xc1, 0xea, 0x5e, 0x10, 0x75, 0x98, 0xa2, 0x8e, 0x12, 0x70, 0x00,
-		0x71, 0x1e, 0xb2, 0x0d, 0xec, 0x38, 0x6a, 0x0d, 0x57, 0xdc, 0x7d, 0x0b, 0xe7, 0x53, 0xb4, 0xf7,
-		0x33, 0x2d, 0xbd, 0x8f, 0xf6, 0x7c, 0x98, 0x53, 0x6d, 0xee, 0x5b, 0x18, 0xcd, 0x41, 0x06, 0x1b,
-		0xcd, 0x06, 0xe3, 0x30, 0xd0, 0x41, 0x7f, 0x65, 0xa3, 0xd9, 0x88, 0x72, 0x49, 0x13, 0x32, 0xce,
-		0x62, 0xc8, 0xc1, 0xf6, 0x65, 0x5d, 0xc3, 0xf9, 0x41, 0xca, 0xe0, 0xfe, 0x16, 0x06, 0x1b, 0xac,
-		0x3e, 0xca, 0x43, 0xd0, 0xa1, 0x79, 0xc8, 0xe0, 0xab, 0x2e, 0x36, 0x1c, 0xdd, 0x34, 0xf2, 0x43,
-		0x94, 0xc9, 0xbd, 0x6d, 0x46, 0x11, 0xd7, 0xab, 0x51, 0x16, 0x3e, 0x1d, 0x3a, 0x0b, 0x43, 0xa6,
-		0xe5, 0xea, 0xa6, 0xe1, 0xe4, 0xd3, 0x33, 0xd2, 0x89, 0xe1, 0xd3, 0xc7, 0xdb, 0x1a, 0xc2, 0x1a,
-		0xc3, 0x51, 0x04, 0x32, 0x5a, 0x82, 0x9c, 0x63, 0x36, 0x6d, 0x0d, 0x57, 0x34, 0xb3, 0x8a, 0x2b,
-		0xba, 0xb1, 0x63, 0xe6, 0x33, 0x94, 0xc1, 0x74, 0x6b, 0x47, 0x28, 0xe2, 0xbc, 0x59, 0xc5, 0x4b,
-		0xc6, 0x8e, 0xa9, 0x8c, 0x3a, 0xa1, 0x32, 0x3a, 0x02, 0x83, 0xce, 0xbe, 0xe1, 0xaa, 0x57, 0xf3,
-		0x59, 0x6a, 0x21, 0xbc, 0x24, 0xff, 0xe6, 0x20, 0x8c, 0xf5, 0x62, 0x62, 0xe7, 0x60, 0x60, 0x87,
-		0xf4, 0x32, 0x9f, 0xe8, 0x47, 0x07, 0x8c, 0x26, 0xac, 0xc4, 0xc1, 0x03, 0x2a, 0x71, 0x0e, 0x86,
-		0x0d, 0xec, 0xb8, 0xb8, 0xca, 0x2c, 0x22, 0xd9, 0xa3, 0x4d, 0x01, 0x23, 0x6a, 0x35, 0xa9, 0xd4,
-		0x81, 0x4c, 0xea, 0x05, 0x18, 0xf3, 0x44, 0xaa, 0xd8, 0xaa, 0x51, 0x13, 0xb6, 0x79, 0x2a, 0x4e,
-		0x92, 0xd9, 0xb2, 0xa0, 0x53, 0x08, 0x99, 0x32, 0x8a, 0x43, 0x65, 0xb4, 0x00, 0x60, 0x1a, 0xd8,
-		0xdc, 0xa9, 0x54, 0xb1, 0x56, 0xcf, 0xa7, 0x3b, 0x68, 0x69, 0x8d, 0xa0, 0xb4, 0x68, 0xc9, 0x64,
-		0x50, 0xad, 0x8e, 0x9e, 0xf2, 0x4d, 0x6d, 0xa8, 0x83, 0xa5, 0xac, 0xb0, 0x49, 0xd6, 0x62, 0x6d,
-		0x5b, 0x30, 0x6a, 0x63, 0x62, 0xf7, 0xb8, 0xca, 0x7b, 0x96, 0xa1, 0x42, 0xcc, 0xc6, 0xf6, 0x4c,
-		0xe1, 0x64, 0xac, 0x63, 0x23, 0x76, 0xb0, 0x88, 0xee, 0x06, 0x0f, 0x50, 0xa1, 0x66, 0x05, 0xd4,
-		0x0b, 0x65, 0x05, 0x70, 0x55, 0x6d, 0xe0, 0xc2, 0xcb, 0x30, 0x1a, 0x56, 0x0f, 0x9a, 0x84, 0x01,
-		0xc7, 0x55, 0x6d, 0x97, 0x5a, 0xe1, 0x80, 0xc2, 0x0a, 0x28, 0x07, 0x49, 0x6c, 0x54, 0xa9, 0x97,
-		0x1b, 0x50, 0xc8, 0x4f, 0xf4, 0x16, 0xbf, 0xc3, 0x49, 0xda, 0xe1, 0xfb, 0x5a, 0x47, 0x34, 0xc4,
-		0x39, 0xda, 0xef, 0xc2, 0x13, 0x30, 0x12, 0xea, 0x40, 0xaf, 0x4d, 0xcb, 0xef, 0x82, 0xc3, 0x6d,
-		0x59, 0xa3, 0x17, 0x60, 0xb2, 0x69, 0xe8, 0x86, 0x8b, 0x6d, 0xcb, 0xc6, 0xc4, 0x62, 0x59, 0x53,
-		0xf9, 0xff, 0x3a, 0xd4, 0xc1, 0xe6, 0xb6, 0x82, 0xd8, 0x8c, 0x8b, 0x32, 0xd1, 0x6c, 0x05, 0x9e,
-		0xcc, 0xa4, 0x5f, 0x1f, 0xca, 0xbd, 0xf2, 0xca, 0x2b, 0xaf, 0x24, 0xe4, 0xaf, 0x0c, 0xc2, 0x64,
-		0xbb, 0x39, 0xd3, 0x76, 0xfa, 0x1e, 0x81, 0x41, 0xa3, 0xd9, 0xd8, 0xc6, 0x36, 0x55, 0xd2, 0x80,
-		0xc2, 0x4b, 0x68, 0x0e, 0x06, 0xea, 0xea, 0x36, 0xae, 0xe7, 0x53, 0x33, 0xd2, 0x89, 0xd1, 0xd3,
-		0x0f, 0xf6, 0x34, 0x2b, 0x67, 0x97, 0x09, 0x89, 0xc2, 0x28, 0xd1, 0xd3, 0x90, 0xe2, 0x2e, 0x9a,
-		0x70, 0x38, 0xd9, 0x1b, 0x07, 0x32, 0x97, 0x14, 0x4a, 0x87, 0xee, 0x80, 0x0c, 0xf9, 0xcb, 0x6c,
-		0x63, 0x90, 0xca, 0x9c, 0x26, 0x00, 0x62, 0x17, 0xa8, 0x00, 0x69, 0x3a, 0x4d, 0xaa, 0x58, 0x84,
-		0x36, 0xaf, 0x4c, 0x0c, 0xab, 0x8a, 0x77, 0xd4, 0x66, 0xdd, 0xad, 0x5c, 0x56, 0xeb, 0x4d, 0x4c,
-		0x0d, 0x3e, 0xa3, 0x64, 0x39, 0xf0, 0x12, 0x81, 0xa1, 0x69, 0x18, 0x66, 0xb3, 0x4a, 0x37, 0xaa,
-		0xf8, 0x2a, 0xf5, 0x9e, 0x03, 0x0a, 0x9b, 0x68, 0x4b, 0x04, 0x42, 0x9a, 0x7f, 0xd1, 0x31, 0x0d,
-		0x61, 0x9a, 0xb4, 0x09, 0x02, 0xa0, 0xcd, 0x3f, 0x11, 0x75, 0xdc, 0x77, 0xb6, 0xef, 0x5e, 0xcb,
-		0x5c, 0xba, 0x1f, 0xc6, 0x28, 0xc6, 0x63, 0x7c, 0xe8, 0xd5, 0x7a, 0x7e, 0x7c, 0x46, 0x3a, 0x91,
-		0x56, 0x46, 0x19, 0x78, 0x8d, 0x43, 0xe5, 0x2f, 0x25, 0x20, 0x45, 0x1d, 0xcb, 0x18, 0x0c, 0x6f,
-		0xbe, 0x75, 0xbd, 0x5c, 0x59, 0x58, 0xdb, 0x2a, 0x2d, 0x97, 0x73, 0x12, 0x1a, 0x05, 0xa0, 0x80,
-		0xf3, 0xcb, 0x6b, 0x73, 0x9b, 0xb9, 0x84, 0x57, 0x5e, 0x5a, 0xdd, 0x3c, 0xfb, 0x78, 0x2e, 0xe9,
-		0x11, 0x6c, 0x31, 0x40, 0x2a, 0x88, 0xf0, 0xd8, 0xe9, 0xdc, 0x00, 0xca, 0x41, 0x96, 0x31, 0x58,
-		0x7a, 0xa1, 0xbc, 0x70, 0xf6, 0xf1, 0xdc, 0x60, 0x18, 0xf2, 0xd8, 0xe9, 0xdc, 0x10, 0x1a, 0x81,
-		0x0c, 0x85, 0x94, 0xd6, 0xd6, 0x96, 0x73, 0x69, 0x8f, 0xe7, 0xc6, 0xa6, 0xb2, 0xb4, 0xba, 0x98,
-		0xcb, 0x78, 0x3c, 0x17, 0x95, 0xb5, 0xad, 0xf5, 0x1c, 0x78, 0x1c, 0x56, 0xca, 0x1b, 0x1b, 0x73,
-		0x8b, 0xe5, 0xdc, 0xb0, 0x87, 0x51, 0x7a, 0xeb, 0x66, 0x79, 0x23, 0x97, 0x0d, 0x89, 0xf5, 0xd8,
-		0xe9, 0xdc, 0x88, 0xd7, 0x44, 0x79, 0x75, 0x6b, 0x25, 0x37, 0x8a, 0xc6, 0x61, 0x84, 0x35, 0x21,
-		0x84, 0x18, 0x8b, 0x80, 0xce, 0x3e, 0x9e, 0xcb, 0xf9, 0x82, 0x30, 0x2e, 0xe3, 0x21, 0xc0, 0xd9,
-		0xc7, 0x73, 0x48, 0x9e, 0x87, 0x01, 0x6a, 0x86, 0x08, 0xc1, 0xe8, 0xf2, 0x5c, 0xa9, 0xbc, 0x5c,
-		0x59, 0x5b, 0xdf, 0x5c, 0x5a, 0x5b, 0x9d, 0x5b, 0xce, 0x49, 0x3e, 0x4c, 0x29, 0x3f, 0xb7, 0xb5,
-		0xa4, 0x94, 0x17, 0x72, 0x89, 0x20, 0x6c, 0xbd, 0x3c, 0xb7, 0x59, 0x5e, 0xc8, 0x25, 0x65, 0x0d,
-		0x26, 0xdb, 0x39, 0xd4, 0xb6, 0x53, 0x28, 0x60, 0x0b, 0x89, 0x0e, 0xb6, 0x40, 0x79, 0x45, 0x6d,
-		0x41, 0xfe, 0x56, 0x02, 0x26, 0xda, 0x04, 0x95, 0xb6, 0x8d, 0x3c, 0x03, 0x03, 0xcc, 0x96, 0x59,
-		0x98, 0x7d, 0xa0, 0x6d, 0x74, 0xa2, 0x96, 0xdd, 0x12, 0x6a, 0x29, 0x5d, 0x30, 0xd5, 0x48, 0x76,
-		0x48, 0x35, 0x08, 0x8b, 0x16, 0x83, 0xfd, 0xa9, 0x16, 0xe7, 0xcf, 0xe2, 0xe3, 0xd9, 0x5e, 0xe2,
-		0x23, 0x85, 0xf5, 0x17, 0x04, 0x06, 0xda, 0x04, 0x81, 0x73, 0x30, 0xde, 0xc2, 0xa8, 0x67, 0x67,
-		0xfc, 0x5e, 0x09, 0xf2, 0x9d, 0x94, 0x13, 0xe3, 0x12, 0x13, 0x21, 0x97, 0x78, 0x2e, 0xaa, 0xc1,
-		0xbb, 0x3a, 0x0f, 0x42, 0xcb, 0x58, 0x7f, 0x56, 0x82, 0x23, 0xed, 0x53, 0xca, 0xb6, 0x32, 0x3c,
-		0x0d, 0x83, 0x0d, 0xec, 0xee, 0x9a, 0x22, 0xad, 0xba, 0xaf, 0x4d, 0xb0, 0x26, 0xd5, 0xd1, 0xc1,
-		0xe6, 0x54, 0xc1, 0x68, 0x9f, 0xec, 0x94, 0x17, 0x32, 0x69, 0x5a, 0x24, 0xfd, 0x60, 0x02, 0x0e,
-		0xb7, 0x65, 0xde, 0x56, 0xd0, 0x3b, 0x01, 0x74, 0xc3, 0x6a, 0xba, 0x2c, 0x75, 0x62, 0x9e, 0x38,
-		0x43, 0x21, 0xd4, 0x79, 0x11, 0x2f, 0xdb, 0x74, 0xbd, 0xfa, 0x24, 0xad, 0x07, 0x06, 0xa2, 0x08,
-		0x4f, 0xfa, 0x82, 0xa6, 0xa8, 0xa0, 0x53, 0x1d, 0x7a, 0xda, 0x62, 0x98, 0x8f, 0x40, 0x4e, 0xab,
-		0xeb, 0xd8, 0x70, 0x2b, 0x8e, 0x6b, 0x63, 0xb5, 0xa1, 0x1b, 0x35, 0x1a, 0x6a, 0xd2, 0xc5, 0x81,
-		0x1d, 0xb5, 0xee, 0x60, 0x65, 0x8c, 0x55, 0x6f, 0x88, 0x5a, 0x42, 0x41, 0x0d, 0xc8, 0x0e, 0x50,
-		0x0c, 0x86, 0x28, 0x58, 0xb5, 0x47, 0x21, 0x7f, 0x24, 0x03, 0xc3, 0x81, 0x04, 0x1c, 0xdd, 0x05,
-		0xd9, 0x17, 0xd5, 0xcb, 0x6a, 0x45, 0x2c, 0xaa, 0x98, 0x26, 0x86, 0x09, 0x6c, 0x9d, 0x2f, 0xac,
-		0x1e, 0x81, 0x49, 0x8a, 0x62, 0x36, 0x5d, 0x6c, 0x57, 0xb4, 0xba, 0xea, 0x38, 0x54, 0x69, 0x69,
-		0x8a, 0x8a, 0x48, 0xdd, 0x1a, 0xa9, 0x9a, 0x17, 0x35, 0xe8, 0x0c, 0x4c, 0x50, 0x8a, 0x46, 0xb3,
-		0xee, 0xea, 0x56, 0x1d, 0x57, 0xc8, 0x32, 0xcf, 0xa1, 0x21, 0xc7, 0x93, 0x6c, 0x9c, 0x60, 0xac,
-		0x70, 0x04, 0x22, 0x91, 0x83, 0x16, 0xe0, 0x4e, 0x4a, 0x56, 0xc3, 0x06, 0xb6, 0x55, 0x17, 0x57,
-		0xf0, 0x4b, 0x4d, 0xb5, 0xee, 0x54, 0x54, 0xa3, 0x5a, 0xd9, 0x55, 0x9d, 0xdd, 0xfc, 0x24, 0x61,
-		0x50, 0x4a, 0xe4, 0x25, 0xe5, 0x18, 0x41, 0x5c, 0xe4, 0x78, 0x65, 0x8a, 0x36, 0x67, 0x54, 0x2f,
-		0xa8, 0xce, 0x2e, 0x2a, 0xc2, 0x11, 0xca, 0xc5, 0x71, 0x6d, 0xdd, 0xa8, 0x55, 0xb4, 0x5d, 0xac,
-		0xed, 0x55, 0x9a, 0xee, 0xce, 0x93, 0xf9, 0x3b, 0x82, 0xed, 0x53, 0x09, 0x37, 0x28, 0xce, 0x3c,
-		0x41, 0xd9, 0x72, 0x77, 0x9e, 0x44, 0x1b, 0x90, 0x25, 0x83, 0xd1, 0xd0, 0x5f, 0xc6, 0x95, 0x1d,
-		0xd3, 0xa6, 0x31, 0x74, 0xb4, 0x8d, 0x6b, 0x0a, 0x68, 0x70, 0x76, 0x8d, 0x13, 0xac, 0x98, 0x55,
-		0x5c, 0x1c, 0xd8, 0x58, 0x2f, 0x97, 0x17, 0x94, 0x61, 0xc1, 0xe5, 0xbc, 0x69, 0x13, 0x83, 0xaa,
-		0x99, 0x9e, 0x82, 0x87, 0x99, 0x41, 0xd5, 0x4c, 0xa1, 0xde, 0x33, 0x30, 0xa1, 0x69, 0xac, 0xcf,
-		0xba, 0x56, 0xe1, 0x8b, 0x31, 0x27, 0x9f, 0x0b, 0x29, 0x4b, 0xd3, 0x16, 0x19, 0x02, 0xb7, 0x71,
-		0x07, 0x3d, 0x05, 0x87, 0x7d, 0x65, 0x05, 0x09, 0xc7, 0x5b, 0x7a, 0x19, 0x25, 0x3d, 0x03, 0x13,
-		0xd6, 0x7e, 0x2b, 0x21, 0x0a, 0xb5, 0x68, 0xed, 0x47, 0xc9, 0x9e, 0x80, 0x49, 0x6b, 0xd7, 0x6a,
-		0xa5, 0x3b, 0x19, 0xa4, 0x43, 0xd6, 0xae, 0x15, 0x25, 0xbc, 0x97, 0xae, 0xcc, 0x6d, 0xac, 0xa9,
-		0x2e, 0xae, 0xe6, 0x8f, 0x06, 0xd1, 0x03, 0x15, 0x68, 0x16, 0x72, 0x9a, 0x56, 0xc1, 0x86, 0xba,
-		0x5d, 0xc7, 0x15, 0xd5, 0xc6, 0x86, 0xea, 0xe4, 0xa7, 0x29, 0x72, 0xca, 0xb5, 0x9b, 0x58, 0x19,
-		0xd5, 0xb4, 0x32, 0xad, 0x9c, 0xa3, 0x75, 0xe8, 0x24, 0x8c, 0x9b, 0xdb, 0x2f, 0x6a, 0xcc, 0x22,
-		0x2b, 0x96, 0x8d, 0x77, 0xf4, 0xab, 0xf9, 0x7b, 0xa8, 0x7a, 0xc7, 0x48, 0x05, 0xb5, 0xc7, 0x75,
-		0x0a, 0x46, 0x0f, 0x40, 0x4e, 0x73, 0x76, 0x55, 0xdb, 0xa2, 0x2e, 0xd9, 0xb1, 0x54, 0x0d, 0xe7,
-		0xef, 0x65, 0xa8, 0x0c, 0xbe, 0x2a, 0xc0, 0x64, 0x46, 0x38, 0x57, 0xf4, 0x1d, 0x57, 0x70, 0xbc,
-		0x9f, 0xcd, 0x08, 0x0a, 0xe3, 0xdc, 0x4e, 0x40, 0x8e, 0x68, 0x22, 0xd4, 0xf0, 0x09, 0x8a, 0x36,
-		0x6a, 0xed, 0x5a, 0xc1, 0x76, 0xef, 0x86, 0x11, 0x82, 0xe9, 0x37, 0xfa, 0x00, 0x4b, 0xdc, 0xac,
-		0xdd, 0x40, 0x8b, 0x8f, 0xc3, 0x11, 0x82, 0xd4, 0xc0, 0xae, 0x5a, 0x55, 0x5d, 0x35, 0x80, 0xfd,
-		0x10, 0xc5, 0x26, 0x6a, 0x5f, 0xe1, 0x95, 0x21, 0x39, 0xed, 0xe6, 0xf6, 0xbe, 0x67, 0x58, 0x0f,
-		0x33, 0x39, 0x09, 0x4c, 0x98, 0xd6, 0x6d, 0x4b, 0xce, 0xe5, 0x22, 0x64, 0x83, 0x76, 0x8f, 0x32,
-		0xc0, 0x2c, 0x3f, 0x27, 0x91, 0x24, 0x68, 0x7e, 0x6d, 0x81, 0xa4, 0x2f, 0x6f, 0x2b, 0xe7, 0x12,
-		0x24, 0x8d, 0x5a, 0x5e, 0xda, 0x2c, 0x57, 0x94, 0xad, 0xd5, 0xcd, 0xa5, 0x95, 0x72, 0x2e, 0x19,
-		0x48, 0xec, 0x9f, 0x4d, 0xa5, 0xef, 0xcb, 0xdd, 0x2f, 0x7f, 0x33, 0x01, 0xa3, 0xe1, 0x95, 0x1a,
-		0x7a, 0x13, 0x1c, 0x15, 0xdb, 0x2a, 0x0e, 0x76, 0x2b, 0x57, 0x74, 0x9b, 0x4e, 0xc8, 0x86, 0xca,
-		0x82, 0xa3, 0x67, 0x3f, 0x93, 0x1c, 0x6b, 0x03, 0xbb, 0xcf, 0xeb, 0x36, 0x99, 0x6e, 0x0d, 0xd5,
-		0x45, 0xcb, 0x30, 0x6d, 0x98, 0x15, 0xc7, 0x55, 0x8d, 0xaa, 0x6a, 0x57, 0x2b, 0xfe, 0x86, 0x56,
-		0x45, 0xd5, 0x34, 0xec, 0x38, 0x26, 0x0b, 0x84, 0x1e, 0x97, 0xe3, 0x86, 0xb9, 0xc1, 0x91, 0xfd,
-		0x08, 0x31, 0xc7, 0x51, 0x23, 0xe6, 0x9b, 0xec, 0x64, 0xbe, 0x77, 0x40, 0xa6, 0xa1, 0x5a, 0x15,
-		0x6c, 0xb8, 0xf6, 0x3e, 0xcd, 0xcf, 0xd3, 0x4a, 0xba, 0xa1, 0x5a, 0x65, 0x52, 0xfe, 0xb1, 0x2c,
-		0x93, 0x9e, 0x4d, 0xa5, 0xd3, 0xb9, 0xcc, 0xb3, 0xa9, 0x74, 0x26, 0x07, 0xf2, 0x6b, 0x49, 0xc8,
-		0x06, 0xf3, 0x75, 0xb2, 0xfc, 0xd1, 0x68, 0xc4, 0x92, 0xa8, 0x4f, 0xbb, 0xbb, 0x6b, 0x76, 0x3f,
-		0x3b, 0x4f, 0x42, 0x59, 0x71, 0x90, 0x25, 0xc7, 0x0a, 0xa3, 0x24, 0x69, 0x04, 0x31, 0x36, 0xcc,
-		0x92, 0x91, 0xb4, 0xc2, 0x4b, 0x68, 0x11, 0x06, 0x5f, 0x74, 0x28, 0xef, 0x41, 0xca, 0xfb, 0x9e,
-		0xee, 0xbc, 0x9f, 0xdd, 0xa0, 0xcc, 0x33, 0xcf, 0x6e, 0x54, 0x56, 0xd7, 0x94, 0x95, 0xb9, 0x65,
-		0x85, 0x93, 0xa3, 0x63, 0x90, 0xaa, 0xab, 0x2f, 0xef, 0x87, 0x83, 0x1e, 0x05, 0xf5, 0x3a, 0x08,
-		0xc7, 0x20, 0x75, 0x05, 0xab, 0x7b, 0xe1, 0x50, 0x43, 0x41, 0xb7, 0x71, 0x32, 0x9c, 0x82, 0x01,
-		0xaa, 0x2f, 0x04, 0xc0, 0x35, 0x96, 0x3b, 0x84, 0xd2, 0x90, 0x9a, 0x5f, 0x53, 0xc8, 0x84, 0xc8,
-		0x41, 0x96, 0x41, 0x2b, 0xeb, 0x4b, 0xe5, 0xf9, 0x72, 0x2e, 0x21, 0x9f, 0x81, 0x41, 0xa6, 0x04,
-		0x32, 0x59, 0x3c, 0x35, 0xe4, 0x0e, 0xf1, 0x22, 0xe7, 0x21, 0x89, 0xda, 0xad, 0x95, 0x52, 0x59,
-		0xc9, 0x25, 0xc2, 0x43, 0x9d, 0xca, 0x0d, 0xc8, 0x0e, 0x64, 0x83, 0x79, 0xf8, 0x8f, 0x67, 0x31,
-		0xfe, 0x65, 0x09, 0x86, 0x03, 0x79, 0x35, 0x49, 0x88, 0xd4, 0x7a, 0xdd, 0xbc, 0x52, 0x51, 0xeb,
-		0xba, 0xea, 0x70, 0xd3, 0x00, 0x0a, 0x9a, 0x23, 0x90, 0x5e, 0x87, 0xee, 0xc7, 0x34, 0x45, 0x06,
-		0x72, 0x83, 0xf2, 0x27, 0x25, 0xc8, 0x45, 0x13, 0xdb, 0x88, 0x98, 0xd2, 0x1b, 0x29, 0xa6, 0xfc,
-		0x09, 0x09, 0x46, 0xc3, 0xd9, 0x6c, 0x44, 0xbc, 0xbb, 0xde, 0x50, 0xf1, 0xfe, 0x30, 0x01, 0x23,
-		0xa1, 0x1c, 0xb6, 0x57, 0xe9, 0x5e, 0x82, 0x71, 0xbd, 0x8a, 0x1b, 0x96, 0xe9, 0x62, 0x43, 0xdb,
-		0xaf, 0xd4, 0xf1, 0x65, 0x5c, 0xcf, 0xcb, 0xd4, 0x69, 0x9c, 0xea, 0x9e, 0x25, 0xcf, 0x2e, 0xf9,
-		0x74, 0xcb, 0x84, 0xac, 0x38, 0xb1, 0xb4, 0x50, 0x5e, 0x59, 0x5f, 0xdb, 0x2c, 0xaf, 0xce, 0xbf,
-		0xb5, 0xb2, 0xb5, 0x7a, 0x71, 0x75, 0xed, 0xf9, 0x55, 0x25, 0xa7, 0x47, 0xd0, 0x6e, 0xe3, 0xb4,
-		0x5f, 0x87, 0x5c, 0x54, 0x28, 0x74, 0x14, 0xda, 0x89, 0x95, 0x3b, 0x84, 0x26, 0x60, 0x6c, 0x75,
-		0xad, 0xb2, 0xb1, 0xb4, 0x50, 0xae, 0x94, 0xcf, 0x9f, 0x2f, 0xcf, 0x6f, 0x6e, 0xb0, 0x7d, 0x0f,
-		0x0f, 0x7b, 0x33, 0x34, 0xc1, 0xe5, 0x57, 0x93, 0x30, 0xd1, 0x46, 0x12, 0x34, 0xc7, 0x57, 0x2c,
-		0x6c, 0x11, 0xf5, 0x70, 0x2f, 0xd2, 0xcf, 0x92, 0x9c, 0x61, 0x5d, 0xb5, 0x5d, 0xbe, 0xc0, 0x79,
-		0x00, 0x88, 0x96, 0x0c, 0x57, 0xdf, 0xd1, 0xb1, 0xcd, 0xf7, 0x93, 0xd8, 0x32, 0x66, 0xcc, 0x87,
-		0xb3, 0x2d, 0xa5, 0x87, 0x00, 0x59, 0xa6, 0xa3, 0xbb, 0xfa, 0x65, 0x5c, 0xd1, 0x0d, 0xb1, 0xf9,
-		0x44, 0x96, 0x35, 0x29, 0x25, 0x27, 0x6a, 0x96, 0x0c, 0xd7, 0xc3, 0x36, 0x70, 0x4d, 0x8d, 0x60,
-		0x13, 0x67, 0x9e, 0x54, 0x72, 0xa2, 0xc6, 0xc3, 0xbe, 0x0b, 0xb2, 0x55, 0xb3, 0x49, 0x72, 0x3d,
-		0x86, 0x47, 0x62, 0x87, 0xa4, 0x0c, 0x33, 0x98, 0x87, 0xc2, 0xb3, 0x78, 0x7f, 0xd7, 0x2b, 0xab,
-		0x0c, 0x33, 0x18, 0x43, 0xb9, 0x1f, 0xc6, 0xd4, 0x5a, 0xcd, 0x26, 0xcc, 0x05, 0x23, 0xb6, 0x2e,
-		0x19, 0xf5, 0xc0, 0x14, 0xb1, 0xf0, 0x2c, 0xa4, 0x85, 0x1e, 0x48, 0xa8, 0x26, 0x9a, 0xa8, 0x58,
-		0x6c, 0xb1, 0x9d, 0x38, 0x91, 0x51, 0xd2, 0x86, 0xa8, 0xbc, 0x0b, 0xb2, 0xba, 0x53, 0xf1, 0x37,
-		0xf1, 0x13, 0x33, 0x89, 0x13, 0x69, 0x65, 0x58, 0x77, 0xbc, 0x0d, 0x50, 0xf9, 0xb3, 0x09, 0x18,
-		0x0d, 0x1f, 0x42, 0xa0, 0x05, 0x48, 0xd7, 0x4d, 0x4d, 0xa5, 0xa6, 0xc5, 0x4e, 0xc0, 0x4e, 0xc4,
-		0x9c, 0x5b, 0xcc, 0x2e, 0x73, 0x7c, 0xc5, 0xa3, 0x2c, 0xfc, 0x8e, 0x04, 0x69, 0x01, 0x46, 0x47,
-		0x20, 0x65, 0xa9, 0xee, 0x2e, 0x65, 0x37, 0x50, 0x4a, 0xe4, 0x24, 0x85, 0x96, 0x09, 0xdc, 0xb1,
-		0x54, 0x83, 0x9a, 0x00, 0x87, 0x93, 0x32, 0x19, 0xd7, 0x3a, 0x56, 0xab, 0x74, 0xd1, 0x63, 0x36,
-		0x1a, 0xd8, 0x70, 0x1d, 0x31, 0xae, 0x1c, 0x3e, 0xcf, 0xc1, 0xe8, 0x41, 0x18, 0x77, 0x6d, 0x55,
-		0xaf, 0x87, 0x70, 0x53, 0x14, 0x37, 0x27, 0x2a, 0x3c, 0xe4, 0x22, 0x1c, 0x13, 0x7c, 0xab, 0xd8,
-		0x55, 0xb5, 0x5d, 0x5c, 0xf5, 0x89, 0x06, 0xe9, 0xe6, 0xc6, 0x51, 0x8e, 0xb0, 0xc0, 0xeb, 0x05,
-		0xad, 0xfc, 0x4d, 0x09, 0xc6, 0xc5, 0x32, 0xad, 0xea, 0x29, 0x6b, 0x05, 0x40, 0x35, 0x0c, 0xd3,
-		0x0d, 0xaa, 0xab, 0xd5, 0x94, 0x5b, 0xe8, 0x66, 0xe7, 0x3c, 0x22, 0x25, 0xc0, 0xa0, 0xd0, 0x00,
-		0xf0, 0x6b, 0x3a, 0xaa, 0x6d, 0x1a, 0x86, 0xf9, 0x09, 0x13, 0x3d, 0xa6, 0x64, 0x0b, 0x7b, 0x60,
-		0x20, 0xb2, 0x9e, 0x43, 0x93, 0x30, 0xb0, 0x8d, 0x6b, 0xba, 0xc1, 0xf7, 0x8d, 0x59, 0x41, 0x6c,
-		0xbf, 0xa4, 0xbc, 0xed, 0x97, 0xd2, 0x87, 0x24, 0x98, 0xd0, 0xcc, 0x46, 0x54, 0xde, 0x52, 0x2e,
-		0xb2, 0xbb, 0xe0, 0x5c, 0x90, 0xde, 0xf6, 0x74, 0x4d, 0x77, 0x77, 0x9b, 0xdb, 0xb3, 0x9a, 0xd9,
-		0x38, 0x55, 0x33, 0xeb, 0xaa, 0x51, 0xf3, 0xcf, 0x59, 0xe9, 0x0f, 0xed, 0xe1, 0x1a, 0x36, 0x1e,
-		0xae, 0x99, 0x81, 0x53, 0xd7, 0x73, 0xfe, 0xcf, 0x3f, 0x93, 0xa4, 0x5f, 0x4c, 0x24, 0x17, 0xd7,
-		0x4b, 0x9f, 0x4b, 0x14, 0x16, 0x59, 0x73, 0xeb, 0x42, 0x3d, 0x0a, 0xde, 0xa9, 0x63, 0x8d, 0x74,
-		0x19, 0xbe, 0xfb, 0x20, 0x4c, 0xd6, 0xcc, 0x9a, 0x49, 0x39, 0x9e, 0x22, 0xbf, 0xf8, 0xc9, 0x6d,
-		0xc6, 0x83, 0x16, 0x62, 0x8f, 0x79, 0x8b, 0xab, 0x30, 0xc1, 0x91, 0x2b, 0xf4, 0xe8, 0x88, 0x2d,
-		0x6c, 0x50, 0xd7, 0x5d, 0xb5, 0xfc, 0xaf, 0x7f, 0x9b, 0x06, 0x74, 0x65, 0x9c, 0x93, 0x92, 0x3a,
-		0xb6, 0xf6, 0x29, 0x2a, 0x70, 0x38, 0xc4, 0x8f, 0x4d, 0x5b, 0x6c, 0xc7, 0x70, 0xfc, 0x2d, 0xce,
-		0x71, 0x22, 0xc0, 0x71, 0x83, 0x93, 0x16, 0xe7, 0x61, 0xa4, 0x1f, 0x5e, 0xff, 0x9a, 0xf3, 0xca,
-		0xe2, 0x20, 0x93, 0x45, 0x18, 0xa3, 0x4c, 0xb4, 0xa6, 0xe3, 0x9a, 0x0d, 0xea, 0x13, 0xbb, 0xb3,
-		0xf9, 0xed, 0x6f, 0xb3, 0x79, 0x34, 0x4a, 0xc8, 0xe6, 0x3d, 0xaa, 0x62, 0x11, 0xe8, 0x69, 0x59,
-		0x15, 0x6b, 0xf5, 0x18, 0x0e, 0x5f, 0xe5, 0x82, 0x78, 0xf8, 0xc5, 0x4b, 0x30, 0x49, 0x7e, 0x53,
-		0x97, 0x15, 0x94, 0x24, 0x7e, 0x0b, 0x2e, 0xff, 0xcd, 0xf7, 0xb2, 0xa9, 0x3a, 0xe1, 0x31, 0x08,
-		0xc8, 0x14, 0x18, 0xc5, 0x1a, 0x76, 0x5d, 0x6c, 0x3b, 0x15, 0xb5, 0xde, 0x4e, 0xbc, 0xc0, 0x1e,
-		0x46, 0xfe, 0xe3, 0xdf, 0x0b, 0x8f, 0xe2, 0x22, 0xa3, 0x9c, 0xab, 0xd7, 0x8b, 0x5b, 0x70, 0xb4,
-		0x8d, 0x55, 0xf4, 0xc0, 0xf3, 0x55, 0xce, 0x73, 0xb2, 0xc5, 0x32, 0x08, 0xdb, 0x75, 0x10, 0x70,
-		0x6f, 0x2c, 0x7b, 0xe0, 0xf9, 0x0b, 0x9c, 0x27, 0xe2, 0xb4, 0x62, 0x48, 0x09, 0xc7, 0x67, 0x61,
-		0xfc, 0x32, 0xb6, 0xb7, 0x4d, 0x87, 0xef, 0x1b, 0xf5, 0xc0, 0xee, 0x13, 0x9c, 0xdd, 0x18, 0x27,
-		0xa4, 0x1b, 0x49, 0x84, 0xd7, 0x53, 0x90, 0xde, 0x51, 0x35, 0xdc, 0x03, 0x8b, 0xeb, 0x9c, 0xc5,
-		0x10, 0xc1, 0x27, 0xa4, 0x73, 0x90, 0xad, 0x99, 0x3c, 0x6a, 0xc5, 0x93, 0x7f, 0x92, 0x93, 0x0f,
-		0x0b, 0x1a, 0xce, 0xc2, 0x32, 0xad, 0x66, 0x9d, 0x84, 0xb4, 0x78, 0x16, 0x7f, 0x5b, 0xb0, 0x10,
-		0x34, 0x9c, 0x45, 0x1f, 0x6a, 0xfd, 0x94, 0x60, 0xe1, 0x04, 0xf4, 0xf9, 0x0c, 0x0c, 0x9b, 0x46,
-		0x7d, 0xdf, 0x34, 0x7a, 0x11, 0xe2, 0xd3, 0x9c, 0x03, 0x70, 0x12, 0xc2, 0xe0, 0x1c, 0x64, 0x7a,
-		0x1d, 0x88, 0xbf, 0xf3, 0x3d, 0x31, 0x3d, 0xc4, 0x08, 0x2c, 0xc2, 0x98, 0x70, 0x50, 0xba, 0x69,
-		0xf4, 0xc0, 0xe2, 0xef, 0x72, 0x16, 0xa3, 0x01, 0x32, 0xde, 0x0d, 0x17, 0x3b, 0x6e, 0x0d, 0xf7,
-		0xc2, 0xe4, 0xb3, 0xa2, 0x1b, 0x9c, 0x84, 0xab, 0x72, 0x1b, 0x1b, 0xda, 0x6e, 0x6f, 0x1c, 0x7e,
-		0x59, 0xa8, 0x52, 0xd0, 0x10, 0x16, 0xf3, 0x30, 0xd2, 0x50, 0x6d, 0x67, 0x57, 0xad, 0xf7, 0x34,
-		0x1c, 0x7f, 0x8f, 0xf3, 0xc8, 0x7a, 0x44, 0x5c, 0x23, 0x4d, 0xa3, 0x1f, 0x36, 0x9f, 0x13, 0x1a,
-		0x09, 0x90, 0xf1, 0xa9, 0xe7, 0xb8, 0x74, 0x93, 0xad, 0x1f, 0x6e, 0xbf, 0x22, 0xa6, 0x1e, 0xa3,
-		0x5d, 0x09, 0x72, 0x3c, 0x07, 0x19, 0x47, 0x7f, 0xb9, 0x27, 0x36, 0x9f, 0x17, 0x23, 0x4d, 0x09,
-		0x08, 0xf1, 0x5b, 0xe1, 0x58, 0xdb, 0x30, 0xd1, 0x03, 0xb3, 0xbf, 0xcf, 0x99, 0x1d, 0x69, 0x13,
-		0x2a, 0xb8, 0x4b, 0xe8, 0x97, 0xe5, 0x3f, 0x10, 0x2e, 0x01, 0x47, 0x78, 0xad, 0x93, 0x75, 0x84,
-		0xa3, 0xee, 0xf4, 0xa7, 0xb5, 0x5f, 0x15, 0x5a, 0x63, 0xb4, 0x21, 0xad, 0x6d, 0xc2, 0x11, 0xce,
-		0xb1, 0xbf, 0x71, 0xfd, 0x35, 0xe1, 0x58, 0x19, 0xf5, 0x56, 0x78, 0x74, 0xdf, 0x0e, 0x05, 0x4f,
-		0x9d, 0x22, 0x61, 0x75, 0x2a, 0x0d, 0xd5, 0xea, 0x81, 0xf3, 0xaf, 0x73, 0xce, 0xc2, 0xe3, 0x7b,
-		0x19, 0xaf, 0xb3, 0xa2, 0x5a, 0x84, 0xf9, 0x0b, 0x90, 0x17, 0xcc, 0x9b, 0x86, 0x8d, 0x35, 0xb3,
-		0x66, 0xe8, 0x2f, 0xe3, 0x6a, 0x0f, 0xac, 0x7f, 0x23, 0x32, 0x54, 0x5b, 0x01, 0x72, 0xc2, 0x79,
-		0x09, 0x72, 0x5e, 0xae, 0x52, 0xd1, 0x1b, 0x96, 0x69, 0xbb, 0x31, 0x1c, 0xbf, 0x20, 0x46, 0xca,
-		0xa3, 0x5b, 0xa2, 0x64, 0xc5, 0x32, 0xb0, 0x93, 0xe7, 0x5e, 0x4d, 0xf2, 0x8b, 0x9c, 0xd1, 0x88,
-		0x4f, 0xc5, 0x1d, 0x87, 0x66, 0x36, 0x2c, 0xd5, 0xee, 0xc5, 0xff, 0xfd, 0x43, 0xe1, 0x38, 0x38,
-		0x09, 0x77, 0x1c, 0xee, 0xbe, 0x85, 0x49, 0xb4, 0xef, 0x81, 0xc3, 0x97, 0x84, 0xe3, 0x10, 0x34,
-		0x9c, 0x85, 0x48, 0x18, 0x7a, 0x60, 0xf1, 0x8f, 0x04, 0x0b, 0x41, 0x43, 0x58, 0x3c, 0xe7, 0x07,
-		0x5a, 0x1b, 0xd7, 0x74, 0xc7, 0xb5, 0x59, 0x9a, 0xdc, 0x9d, 0xd5, 0x3f, 0xfe, 0x5e, 0x38, 0x09,
-		0x53, 0x02, 0xa4, 0xc4, 0x13, 0xf1, 0x6d, 0x57, 0xba, 0x8a, 0x8a, 0x17, 0xec, 0x37, 0x85, 0x27,
-		0x0a, 0x90, 0x11, 0xd9, 0x02, 0x19, 0x22, 0x51, 0xbb, 0x46, 0xd6, 0x0e, 0x3d, 0xb0, 0xfb, 0x27,
-		0x11, 0xe1, 0x36, 0x04, 0x2d, 0xe1, 0x19, 0xc8, 0x7f, 0x9a, 0xc6, 0x1e, 0xde, 0xef, 0xc9, 0x3a,
-		0xff, 0x69, 0x24, 0xff, 0xd9, 0x62, 0x94, 0xcc, 0x87, 0x8c, 0x45, 0xf2, 0x29, 0x14, 0x77, 0xcf,
-		0x28, 0xff, 0xd3, 0x3f, 0xe0, 0xfd, 0x0d, 0xa7, 0x53, 0xc5, 0x65, 0x62, 0xe4, 0xe1, 0xa4, 0x27,
-		0x9e, 0xd9, 0x7b, 0x7f, 0xe0, 0xd9, 0x79, 0x28, 0xe7, 0x29, 0x9e, 0x87, 0x91, 0x50, 0xc2, 0x13,
-		0xcf, 0xea, 0x7d, 0x9c, 0x55, 0x36, 0x98, 0xef, 0x14, 0xcf, 0x40, 0x8a, 0x24, 0x2f, 0xf1, 0xe4,
-		0x7f, 0x95, 0x93, 0x53, 0xf4, 0xe2, 0x9b, 0x21, 0x2d, 0x92, 0x96, 0x78, 0xd2, 0xf7, 0x73, 0x52,
-		0x8f, 0x84, 0x90, 0x8b, 0x84, 0x25, 0x9e, 0xfc, 0xaf, 0x09, 0x72, 0x41, 0x42, 0xc8, 0x7b, 0x57,
-		0xe1, 0x97, 0x7f, 0x26, 0xc5, 0x83, 0x8e, 0xd0, 0xdd, 0x39, 0x18, 0xe2, 0x99, 0x4a, 0x3c, 0xf5,
-		0x07, 0x79, 0xe3, 0x82, 0xa2, 0xf8, 0x04, 0x0c, 0xf4, 0xa8, 0xf0, 0x9f, 0xe5, 0xa4, 0x0c, 0xbf,
-		0x38, 0x0f, 0xc3, 0x81, 0xec, 0x24, 0x9e, 0xfc, 0x6f, 0x70, 0xf2, 0x20, 0x15, 0x11, 0x9d, 0x67,
-		0x27, 0xf1, 0x0c, 0x3e, 0x24, 0x44, 0xe7, 0x14, 0x44, 0x6d, 0x22, 0x31, 0x89, 0xa7, 0xfe, 0xb0,
-		0xd0, 0xba, 0x20, 0x29, 0x3e, 0x03, 0x19, 0x2f, 0xd8, 0xc4, 0xd3, 0x7f, 0x84, 0xd3, 0xfb, 0x34,
-		0x44, 0x03, 0x81, 0x60, 0x17, 0xcf, 0xe2, 0x6f, 0x0a, 0x0d, 0x04, 0xa8, 0xc8, 0x34, 0x8a, 0x26,
-		0x30, 0xf1, 0x9c, 0x3e, 0x2a, 0xa6, 0x51, 0x24, 0x7f, 0x21, 0xa3, 0x49, 0x7d, 0x7e, 0x3c, 0x8b,
-		0x9f, 0x13, 0xa3, 0x49, 0xf1, 0x89, 0x18, 0xd1, 0x8c, 0x20, 0x9e, 0xc7, 0xdf, 0x12, 0x62, 0x44,
-		0x12, 0x82, 0xe2, 0x3a, 0xa0, 0xd6, 0x6c, 0x20, 0x9e, 0xdf, 0xc7, 0x38, 0xbf, 0xf1, 0x96, 0x64,
-		0xa0, 0xf8, 0x3c, 0x1c, 0x69, 0x9f, 0x09, 0xc4, 0x73, 0xfd, 0xf8, 0x0f, 0x22, 0x6b, 0xb7, 0x60,
-		0x22, 0x50, 0xdc, 0xf4, 0x43, 0x4a, 0x30, 0x0b, 0x88, 0x67, 0xfb, 0xea, 0x0f, 0xc2, 0x8e, 0x3b,
-		0x98, 0x04, 0x14, 0xe7, 0x00, 0xfc, 0x00, 0x1c, 0xcf, 0xeb, 0x13, 0x9c, 0x57, 0x80, 0x88, 0x4c,
-		0x0d, 0x1e, 0x7f, 0xe3, 0xe9, 0xaf, 0x8b, 0xa9, 0xc1, 0x29, 0xc8, 0xd4, 0x10, 0xa1, 0x37, 0x9e,
-		0xfa, 0x93, 0x62, 0x6a, 0x08, 0x12, 0x62, 0xd9, 0x81, 0xe8, 0x16, 0xcf, 0xe1, 0xd3, 0xc2, 0xb2,
-		0x03, 0x54, 0xc5, 0x55, 0x18, 0x6f, 0x09, 0x88, 0xf1, 0xac, 0x7e, 0x91, 0xb3, 0xca, 0x45, 0xe3,
-		0x61, 0x30, 0x78, 0xf1, 0x60, 0x18, 0xcf, 0xed, 0x33, 0x91, 0xe0, 0xc5, 0x63, 0x61, 0xf1, 0x1c,
-		0xa4, 0x8d, 0x66, 0xbd, 0x4e, 0x26, 0x0f, 0xea, 0x7e, 0x37, 0x30, 0xff, 0x47, 0x3f, 0xe4, 0xda,
-		0x11, 0x04, 0xc5, 0x33, 0x30, 0x80, 0x1b, 0xdb, 0xb8, 0x1a, 0x47, 0xf9, 0xdd, 0x1f, 0x0a, 0x87,
-		0x49, 0xb0, 0x8b, 0xcf, 0x00, 0xb0, 0xad, 0x11, 0x7a, 0x3c, 0x18, 0x43, 0xfb, 0xdf, 0x7e, 0xc8,
-		0x2f, 0xe3, 0xf8, 0x24, 0x3e, 0x03, 0x76, 0xb5, 0xa7, 0x3b, 0x83, 0xef, 0x85, 0x19, 0xd0, 0x11,
-		0x79, 0x0a, 0x86, 0x5e, 0x74, 0x4c, 0xc3, 0x55, 0x6b, 0x71, 0xd4, 0xff, 0x9d, 0x53, 0x0b, 0x7c,
-		0xa2, 0xb0, 0x86, 0x69, 0x63, 0x57, 0xad, 0x39, 0x71, 0xb4, 0xff, 0x83, 0xd3, 0x7a, 0x04, 0x84,
-		0x58, 0x53, 0x1d, 0xb7, 0x97, 0x7e, 0xff, 0xb1, 0x20, 0x16, 0x04, 0x44, 0x68, 0xf2, 0x7b, 0x0f,
-		0xef, 0xc7, 0xd1, 0x7e, 0x5f, 0x08, 0xcd, 0xf1, 0x8b, 0x6f, 0x86, 0x0c, 0xf9, 0xc9, 0x6e, 0xd8,
-		0xc5, 0x10, 0xff, 0x09, 0x27, 0xf6, 0x29, 0x48, 0xcb, 0x8e, 0x5b, 0x75, 0xf5, 0x78, 0x65, 0xdf,
-		0xe4, 0x23, 0x2d, 0xf0, 0x8b, 0x73, 0x30, 0xec, 0xb8, 0xd5, 0x6a, 0x93, 0xe7, 0xa7, 0x31, 0xe4,
-		0xff, 0xf3, 0x87, 0xde, 0x96, 0x85, 0x47, 0x43, 0x46, 0xfb, 0xca, 0x9e, 0x6b, 0x99, 0xf4, 0x08,
-		0x24, 0x8e, 0xc3, 0x0f, 0x38, 0x87, 0x00, 0x49, 0x71, 0x1e, 0xb2, 0xa4, 0x2f, 0x36, 0xb6, 0x30,
-		0x3d, 0xaf, 0x8a, 0x61, 0xf1, 0xa7, 0x5c, 0x01, 0x21, 0xa2, 0xd2, 0x4f, 0x7d, 0xf5, 0xb5, 0x29,
-		0xe9, 0x1b, 0xaf, 0x4d, 0x49, 0x7f, 0xf8, 0xda, 0x94, 0xf4, 0xe1, 0x6f, 0x4d, 0x1d, 0xfa, 0xc6,
-		0xb7, 0xa6, 0x0e, 0xfd, 0xde, 0xb7, 0xa6, 0x0e, 0xb5, 0xdf, 0x36, 0x86, 0x45, 0x73, 0xd1, 0x64,
-		0x1b, 0xc6, 0x6f, 0x93, 0x43, 0xdb, 0xc5, 0x35, 0xd3, 0xdf, 0xad, 0xf5, 0x16, 0x39, 0xf0, 0xa7,
-		0x12, 0x59, 0x30, 0x87, 0xf7, 0x72, 0x55, 0x63, 0xbf, 0xc3, 0x5b, 0x9d, 0x42, 0xdb, 0x8d, 0x61,
-		0xf9, 0x4d, 0x90, 0x9c, 0x33, 0xf6, 0xd1, 0x31, 0xe6, 0xf3, 0x2a, 0x4d, 0xbb, 0xce, 0x6f, 0x7e,
-		0x0d, 0x91, 0xf2, 0x96, 0x5d, 0x47, 0x93, 0xfe, 0xf5, 0x4c, 0xe9, 0x44, 0x96, 0xdf, 0xb9, 0x2c,
-		0xa6, 0xbe, 0xff, 0xe9, 0xe9, 0x43, 0xa5, 0xbd, 0x68, 0x0f, 0xbf, 0x1c, 0xdb, 0xcb, 0xf4, 0x9c,
-		0xb1, 0x4f, 0x3b, 0xb9, 0x2e, 0xbd, 0x6d, 0x80, 0xb4, 0xe1, 0x88, 0x8d, 0xed, 0xa9, 0xe8, 0xc6,
-		0xf6, 0xf3, 0xb8, 0x5e, 0xbf, 0x68, 0x98, 0x57, 0x8c, 0x4d, 0x82, 0xb6, 0x3d, 0xc8, 0xae, 0x11,
-		0xc3, 0x5f, 0x4f, 0xc0, 0x54, 0xcb, 0x1e, 0x36, 0x1f, 0xf9, 0x4e, 0x0f, 0x95, 0x8a, 0x90, 0x5e,
-		0x10, 0x06, 0x95, 0x87, 0x21, 0x07, 0x6b, 0xa6, 0x51, 0x75, 0x68, 0x57, 0x93, 0x8a, 0x28, 0x92,
-		0xae, 0x1a, 0xaa, 0x61, 0x3a, 0xfc, 0x76, 0x24, 0x2b, 0x94, 0x7e, 0x4e, 0xea, 0x6f, 0x1c, 0x47,
-		0x44, 0x4b, 0xa2, 0x9b, 0x27, 0xbb, 0xed, 0xfd, 0x53, 0x15, 0x78, 0xf2, 0x07, 0xf6, 0xf9, 0x7b,
-		0x55, 0xc7, 0x87, 0x13, 0x30, 0x1d, 0x55, 0x07, 0x99, 0x47, 0x8e, 0xab, 0x36, 0xac, 0x4e, 0xfa,
-		0x38, 0x07, 0x99, 0x4d, 0x81, 0xd3, 0xb7, 0x42, 0x7e, 0xbe, 0x4f, 0x85, 0x8c, 0x7a, 0x4d, 0x09,
-		0x8d, 0x3c, 0x18, 0xaf, 0x11, 0xaf, 0x0b, 0x07, 0x50, 0xc9, 0x7b, 0x92, 0x70, 0x4c, 0x33, 0x9d,
-		0x86, 0xe9, 0x54, 0x98, 0xc1, 0xb3, 0x02, 0x57, 0x46, 0x36, 0x58, 0xd5, 0xc3, 0x71, 0xc8, 0x05,
-		0x18, 0xa5, 0x4e, 0x81, 0x6e, 0x04, 0x53, 0x3f, 0x1c, 0x1b, 0x3a, 0xbf, 0xf6, 0xef, 0x07, 0xe8,
-		0x24, 0x1a, 0xf1, 0x08, 0xe9, 0x4d, 0x97, 0x4d, 0x98, 0xd4, 0x1b, 0x56, 0x1d, 0xd3, 0x23, 0xb1,
-		0x8a, 0x57, 0x17, 0xcf, 0xef, 0xeb, 0x9c, 0xdf, 0x84, 0x4f, 0xbe, 0x24, 0xa8, 0x8b, 0xcb, 0x30,
-		0xae, 0x6a, 0x1a, 0xb6, 0x42, 0x2c, 0x63, 0x1c, 0x96, 0x10, 0x30, 0xc7, 0x29, 0x3d, 0x6e, 0xa5,
-		0x67, 0x3a, 0x8d, 0xed, 0xdb, 0xee, 0x0d, 0x0c, 0x9a, 0x8d, 0x6b, 0xd8, 0x78, 0xd8, 0xc0, 0xee,
-		0x15, 0xd3, 0xde, 0xe3, 0xea, 0x7d, 0x98, 0x35, 0x25, 0x06, 0xe1, 0x7d, 0x49, 0x98, 0x62, 0x15,
-		0xa7, 0xb6, 0x55, 0x07, 0x9f, 0xba, 0xfc, 0xe8, 0x36, 0x76, 0xd5, 0x47, 0x4f, 0x69, 0xa6, 0x2e,
-		0xa6, 0xe9, 0x04, 0x1f, 0x17, 0x52, 0x3f, 0xcb, 0xeb, 0x3b, 0xf8, 0xa9, 0x45, 0x48, 0xcd, 0x9b,
-		0xba, 0x41, 0x2c, 0xb2, 0x8a, 0x0d, 0xb3, 0xc1, 0xbd, 0x14, 0x2b, 0xa0, 0xbb, 0x61, 0x50, 0x6d,
-		0x98, 0x4d, 0xc3, 0x65, 0xa7, 0x79, 0xa5, 0xe1, 0xaf, 0xde, 0x98, 0x3e, 0xf4, 0xfb, 0x37, 0xa6,
-		0x93, 0x4b, 0x86, 0xab, 0xf0, 0xaa, 0x62, 0xea, 0xf5, 0x4f, 0x4d, 0x4b, 0xf2, 0xb3, 0x30, 0xb4,
-		0x80, 0xb5, 0x83, 0xf0, 0x5a, 0xc0, 0x5a, 0x84, 0xd7, 0x03, 0x90, 0x5e, 0x32, 0x5c, 0x76, 0x83,
-		0xf8, 0x4e, 0x48, 0xea, 0x06, 0xbb, 0x94, 0x16, 0x69, 0x9f, 0xc0, 0x09, 0xea, 0x02, 0xd6, 0x3c,
-		0xd4, 0x2a, 0xd6, 0xa2, 0xa8, 0x84, 0x3d, 0x81, 0x97, 0x16, 0x7e, 0xef, 0xbf, 0x4c, 0x1d, 0x7a,
-		0xe5, 0xb5, 0xa9, 0x43, 0x1d, 0x47, 0x22, 0x18, 0x1d, 0xb8, 0x8a, 0xf9, 0x10, 0x38, 0xd5, 0xbd,
-		0x53, 0x6e, 0x68, 0x2e, 0x7c, 0x2e, 0x05, 0x77, 0xd2, 0xc7, 0x23, 0x76, 0x43, 0x37, 0xdc, 0x53,
-		0x9a, 0xbd, 0x6f, 0xb9, 0x34, 0x9c, 0x98, 0x3b, 0x7c, 0x14, 0xc6, 0xfd, 0xea, 0x59, 0x56, 0xdd,
-		0x61, 0x0c, 0x76, 0x60, 0x60, 0x9d, 0xd0, 0x11, 0xc5, 0xb9, 0xa6, 0xab, 0xd6, 0xb9, 0xbb, 0x60,
-		0x05, 0x02, 0x65, 0x0f, 0x4e, 0x12, 0x0c, 0xaa, 0x8b, 0xb7, 0x26, 0x75, 0xac, 0xee, 0xb0, 0x7b,
-		0xbb, 0x49, 0x1a, 0x42, 0xd2, 0x04, 0x40, 0xaf, 0xe8, 0x4e, 0xc2, 0x80, 0xda, 0x64, 0x47, 0xce,
-		0x49, 0x12, 0x5b, 0x68, 0x41, 0xbe, 0x08, 0x43, 0xfc, 0x98, 0x0b, 0xe5, 0x20, 0xb9, 0x87, 0xf7,
-		0x69, 0x3b, 0x59, 0x85, 0xfc, 0x44, 0xb3, 0x30, 0x40, 0x85, 0xe7, 0x0f, 0x12, 0xf2, 0xb3, 0x2d,
-		0xd2, 0xcf, 0x52, 0x21, 0x15, 0x86, 0x26, 0x3f, 0x0b, 0xe9, 0x05, 0xb3, 0xa1, 0x1b, 0x66, 0x98,
-		0x5b, 0x86, 0x71, 0xa3, 0x32, 0x5b, 0x4d, 0x3e, 0xd6, 0x0a, 0x2b, 0xa0, 0x23, 0x30, 0xc8, 0xee,
-		0x71, 0xf3, 0x63, 0x73, 0x5e, 0x92, 0xe7, 0x61, 0x88, 0xf2, 0x5e, 0xb3, 0x10, 0xe2, 0x2f, 0x80,
-		0xf8, 0x85, 0x71, 0xea, 0x16, 0x38, 0xfb, 0x84, 0x2f, 0x2c, 0x82, 0x54, 0x55, 0x75, 0x55, 0xde,
-		0x6f, 0xfa, 0x5b, 0x7e, 0x1a, 0xd2, 0x9c, 0x89, 0x83, 0x4e, 0x43, 0xd2, 0xb4, 0x1c, 0x7e, 0xf0,
-		0x5d, 0xe8, 0xd4, 0x95, 0x35, 0xab, 0x94, 0x22, 0x56, 0xa2, 0x10, 0xe4, 0x92, 0xd2, 0xd1, 0x2c,
-		0x9e, 0x0c, 0x98, 0x45, 0x60, 0xc8, 0x03, 0x3f, 0xd9, 0x90, 0xb6, 0x98, 0x83, 0x67, 0x2c, 0x9f,
-		0x4e, 0xc0, 0x54, 0xa0, 0xf6, 0x32, 0xb6, 0xc9, 0x5a, 0x8f, 0x59, 0x14, 0xb7, 0x16, 0x14, 0x10,
-		0x92, 0xd7, 0x77, 0x30, 0x97, 0x37, 0x43, 0x72, 0xce, 0xb2, 0x50, 0x01, 0xd2, 0xec, 0x80, 0xdb,
-		0x64, 0xf6, 0x92, 0x52, 0xbc, 0x32, 0xa9, 0x73, 0xcc, 0x1d, 0xf7, 0x8a, 0x6a, 0x7b, 0x4f, 0x9d,
-		0x44, 0x59, 0x7e, 0x0a, 0x32, 0xf3, 0xa6, 0xe1, 0x60, 0xc3, 0x69, 0xd2, 0x40, 0xb4, 0x5d, 0x37,
-		0xb5, 0x3d, 0xce, 0x81, 0x15, 0x88, 0xc2, 0x55, 0xcb, 0xa2, 0x94, 0x29, 0x85, 0xfc, 0x64, 0xf3,
-		0xb2, 0xb4, 0xd1, 0x51, 0x45, 0x4f, 0xf5, 0xaf, 0x22, 0xde, 0x49, 0x4f, 0x47, 0xff, 0x47, 0x82,
-		0xe3, 0xad, 0x13, 0x6a, 0x0f, 0xef, 0x3b, 0xfd, 0xce, 0xa7, 0x17, 0x20, 0xb3, 0x4e, 0xdf, 0x1b,
-		0x5f, 0xc4, 0xfb, 0xa8, 0x00, 0x43, 0xb8, 0x7a, 0xfa, 0xcc, 0x99, 0x47, 0x9f, 0x62, 0xd6, 0x7e,
-		0xe1, 0x90, 0x22, 0x00, 0x68, 0x0a, 0x32, 0x0e, 0xd6, 0xac, 0xd3, 0x67, 0xce, 0xee, 0x3d, 0xca,
-		0xcc, 0xeb, 0xc2, 0x21, 0xc5, 0x07, 0x15, 0xd3, 0xa4, 0xd7, 0xaf, 0x7f, 0x7a, 0x5a, 0x2a, 0x0d,
-		0x40, 0xd2, 0x69, 0x36, 0x6e, 0xab, 0x8d, 0xbc, 0x3a, 0x00, 0x33, 0x41, 0x4a, 0x1a, 0xad, 0x2f,
-		0xab, 0x75, 0xbd, 0xaa, 0xfa, 0x2f, 0xc5, 0x73, 0x01, 0x1d, 0x50, 0x8c, 0xf6, 0x2a, 0x28, 0x74,
-		0xd5, 0xa4, 0xfc, 0x1b, 0x12, 0x64, 0x2f, 0x09, 0xce, 0x1b, 0xd8, 0x45, 0xe7, 0x00, 0xbc, 0x96,
-		0xc4, 0xb4, 0xb9, 0x63, 0x36, 0xda, 0xd6, 0xac, 0x47, 0xa3, 0x04, 0xd0, 0xd1, 0x13, 0xd4, 0x10,
-		0x2d, 0xd3, 0xe1, 0xcf, 0x5f, 0x62, 0x48, 0x3d, 0x64, 0xf4, 0x10, 0x20, 0xea, 0xe1, 0x2a, 0x97,
-		0x4d, 0x57, 0x37, 0x6a, 0x15, 0xcb, 0xbc, 0xc2, 0x1f, 0x15, 0x26, 0x95, 0x1c, 0xad, 0xb9, 0x44,
-		0x2b, 0xd6, 0x09, 0x9c, 0x08, 0x9d, 0xf1, 0xb8, 0x90, 0xdc, 0x4a, 0xad, 0x56, 0x6d, 0xec, 0x38,
-		0xdc, 0x89, 0x89, 0x22, 0x3a, 0x07, 0x43, 0x56, 0x73, 0xbb, 0x22, 0x3c, 0xc6, 0xf0, 0xe9, 0xe3,
-		0xed, 0xe6, 0xbf, 0xb0, 0x0f, 0xee, 0x01, 0x06, 0xad, 0xe6, 0x36, 0xb1, 0x96, 0xbb, 0x20, 0xdb,
-		0x46, 0x98, 0xe1, 0xcb, 0xbe, 0x1c, 0xf4, 0x99, 0x3b, 0xef, 0x41, 0xc5, 0xb2, 0x75, 0xd3, 0xd6,
-		0xdd, 0x7d, 0x7a, 0x7b, 0x25, 0xa9, 0xe4, 0x44, 0xc5, 0x3a, 0x87, 0xcb, 0x7b, 0x30, 0xb6, 0x41,
-		0x73, 0x0b, 0x5f, 0xf2, 0x33, 0xbe, 0x7c, 0x52, 0xbc, 0x7c, 0x1d, 0x25, 0x4b, 0xb4, 0x48, 0x56,
-		0x7a, 0xae, 0xa3, 0x75, 0x3e, 0xd1, 0xbf, 0x75, 0x86, 0xa3, 0xdd, 0x1f, 0x1f, 0x0b, 0x4d, 0x4e,
-		0x9e, 0x4a, 0x06, 0xdc, 0x57, 0xaf, 0x86, 0x19, 0x97, 0x52, 0x17, 0xba, 0x07, 0xd5, 0x42, 0x8c,
-		0x1b, 0x2d, 0xc4, 0x4e, 0x21, 0xf9, 0x29, 0x18, 0x59, 0x57, 0x6d, 0x77, 0x03, 0xbb, 0x17, 0xb0,
-		0x5a, 0xc5, 0x76, 0x38, 0xea, 0x8e, 0x88, 0xa8, 0x8b, 0x20, 0x45, 0x43, 0x2b, 0x8b, 0x3a, 0xf4,
-		0xb7, 0xbc, 0x0b, 0x29, 0x7a, 0x83, 0xcd, 0x8b, 0xc8, 0x9c, 0x82, 0x45, 0x64, 0xe2, 0x4b, 0xf7,
-		0x5d, 0xec, 0x88, 0x05, 0x1d, 0x2d, 0xa0, 0xc7, 0x45, 0x5c, 0x4d, 0x76, 0x8f, 0xab, 0xdc, 0x10,
-		0x79, 0x74, 0xad, 0xc3, 0x50, 0x89, 0xb8, 0xe2, 0xa5, 0x05, 0x4f, 0x10, 0xc9, 0x17, 0x04, 0xad,
-		0xc0, 0x98, 0xa5, 0xda, 0x2e, 0xbd, 0xba, 0xbf, 0x4b, 0x7b, 0xc1, 0x6d, 0x7d, 0xba, 0x75, 0xe6,
-		0x85, 0x3a, 0xcb, 0x5b, 0x19, 0xb1, 0x82, 0x40, 0xf9, 0x3b, 0x29, 0x18, 0xe4, 0xca, 0x78, 0x33,
-		0x0c, 0x71, 0xb5, 0x72, 0xeb, 0xbc, 0x73, 0xb6, 0x35, 0x30, 0xcd, 0x7a, 0x01, 0x84, 0xf3, 0x13,
-		0x34, 0xe8, 0x3e, 0x48, 0x6b, 0xbb, 0xaa, 0x6e, 0x54, 0xf4, 0xaa, 0x48, 0xf3, 0x5e, 0xbb, 0x31,
-		0x3d, 0x34, 0x4f, 0x60, 0x4b, 0x0b, 0xca, 0x10, 0xad, 0x5c, 0xaa, 0x92, 0x4c, 0x60, 0x17, 0xeb,
-		0xb5, 0x5d, 0x97, 0xcf, 0x30, 0x5e, 0x42, 0x4f, 0x42, 0x8a, 0x18, 0x04, 0x7f, 0xd8, 0x55, 0x68,
-		0x49, 0xb6, 0xbd, 0x15, 0x4f, 0x29, 0x4d, 0x1a, 0xfe, 0xf0, 0x1f, 0x4c, 0x4b, 0x0a, 0xa5, 0x40,
-		0xf3, 0x30, 0x52, 0x57, 0x1d, 0xb7, 0x42, 0x23, 0x18, 0x69, 0x7e, 0x80, 0xb2, 0x38, 0xd6, 0xaa,
-		0x10, 0xae, 0x58, 0x2e, 0xfa, 0x30, 0xa1, 0x62, 0xa0, 0x2a, 0x3a, 0x01, 0x39, 0xca, 0x44, 0x33,
-		0x1b, 0x0d, 0xdd, 0x65, 0xb9, 0xd5, 0x20, 0xd5, 0xfb, 0x28, 0x81, 0xcf, 0x53, 0x30, 0xcd, 0xb0,
-		0xee, 0x80, 0x0c, 0x7d, 0x4a, 0x42, 0x51, 0xd8, 0xb5, 0xc9, 0x34, 0x01, 0xd0, 0xca, 0xfb, 0x61,
-		0xcc, 0xf7, 0x8f, 0x0c, 0x25, 0xcd, 0xb8, 0xf8, 0x60, 0x8a, 0xf8, 0x08, 0x4c, 0x1a, 0xf8, 0x2a,
-		0xbd, 0xc8, 0x19, 0xc2, 0xce, 0x50, 0x6c, 0x44, 0xea, 0x2e, 0x85, 0x29, 0xee, 0x85, 0x51, 0x4d,
-		0x28, 0x9f, 0xe1, 0x02, 0xc5, 0x1d, 0xf1, 0xa0, 0x14, 0xed, 0x18, 0xa4, 0x55, 0xcb, 0x62, 0x08,
-		0xc3, 0xdc, 0x3f, 0x5a, 0x16, 0xad, 0x3a, 0x09, 0xe3, 0xb4, 0x8f, 0x36, 0x76, 0x9a, 0x75, 0x97,
-		0x33, 0xc9, 0x52, 0x9c, 0x31, 0x52, 0xa1, 0x30, 0x38, 0xc5, 0xbd, 0x1b, 0x46, 0xf0, 0x65, 0xbd,
-		0x8a, 0x0d, 0x0d, 0x33, 0xbc, 0x11, 0x8a, 0x97, 0x15, 0x40, 0x8a, 0xf4, 0x00, 0x78, 0x7e, 0xaf,
-		0x22, 0x7c, 0xf2, 0x28, 0xe3, 0x27, 0xe0, 0x73, 0x0c, 0x2c, 0xe7, 0x21, 0xb5, 0xa0, 0xba, 0x2a,
-		0x49, 0x30, 0xdc, 0xab, 0x2c, 0xd0, 0x64, 0x15, 0xf2, 0x53, 0x7e, 0x3d, 0x01, 0xa9, 0x4b, 0xa6,
-		0x8b, 0xd1, 0x63, 0x81, 0x04, 0x70, 0xb4, 0x9d, 0x3d, 0x6f, 0xe8, 0x35, 0x03, 0x57, 0x57, 0x9c,
-		0x5a, 0xe0, 0xdd, 0xb7, 0x6f, 0x4e, 0x89, 0x90, 0x39, 0x4d, 0xc2, 0x80, 0x6d, 0x36, 0x8d, 0xaa,
-		0xb8, 0x71, 0x48, 0x0b, 0xa8, 0x0c, 0x69, 0xcf, 0x4a, 0x52, 0x71, 0x56, 0x32, 0x46, 0xac, 0x84,
-		0xd8, 0x30, 0x07, 0x28, 0x43, 0xdb, 0xdc, 0x58, 0x4a, 0x90, 0xf1, 0x9c, 0x17, 0xb7, 0xb6, 0xde,
-		0x0c, 0xd6, 0x27, 0x23, 0xc1, 0xc4, 0x1b, 0x7b, 0x4f, 0x79, 0xcc, 0xe2, 0x72, 0x5e, 0x05, 0xd7,
-		0x5e, 0xc8, 0xac, 0xf8, 0x1b, 0xf4, 0x21, 0xda, 0x2f, 0xdf, 0xac, 0xd8, 0x3b, 0xf4, 0xe3, 0x90,
-		0x71, 0xf4, 0x9a, 0xa1, 0xba, 0x4d, 0x1b, 0x73, 0xcb, 0xf3, 0x01, 0xf2, 0x97, 0x25, 0x18, 0x64,
-		0x96, 0x1c, 0xd0, 0x9b, 0xd4, 0x5e, 0x6f, 0x89, 0x4e, 0x7a, 0x4b, 0x1e, 0x5c, 0x6f, 0x73, 0x00,
-		0x9e, 0x30, 0x0e, 0x7f, 0x1a, 0xdc, 0x26, 0x63, 0x60, 0x22, 0x6e, 0xe8, 0x35, 0x3e, 0x51, 0x03,
-		0x44, 0xf2, 0x7f, 0x96, 0x48, 0x12, 0xcb, 0xeb, 0xd1, 0x1c, 0x8c, 0x08, 0xb9, 0x2a, 0x3b, 0x75,
-		0xb5, 0xc6, 0x6d, 0xe7, 0xce, 0x8e, 0xc2, 0x9d, 0xaf, 0xab, 0x35, 0x65, 0x98, 0xcb, 0x43, 0x0a,
-		0xed, 0xc7, 0x21, 0xd1, 0x61, 0x1c, 0x42, 0x03, 0x9f, 0x3c, 0xd8, 0xc0, 0x87, 0x86, 0x28, 0x15,
-		0x1d, 0xa2, 0x2f, 0x24, 0xe8, 0x62, 0xc6, 0x32, 0x1d, 0xb5, 0xfe, 0xe3, 0x98, 0x11, 0x77, 0x40,
-		0xc6, 0x32, 0xeb, 0x15, 0x56, 0xc3, 0x6e, 0xe2, 0xa6, 0x2d, 0xb3, 0xae, 0xb4, 0x0c, 0xfb, 0xc0,
-		0x2d, 0x9a, 0x2e, 0x83, 0xb7, 0x40, 0x6b, 0x43, 0x51, 0xad, 0xd9, 0x90, 0x65, 0xaa, 0xe0, 0xb1,
-		0xec, 0x11, 0xa2, 0x03, 0x1a, 0x1c, 0xa5, 0xd6, 0xd8, 0xcb, 0xc4, 0x66, 0x98, 0x0a, 0xc7, 0x23,
-		0x14, 0xcc, 0xf5, 0xb7, 0x5b, 0x05, 0x07, 0xcd, 0x52, 0xe1, 0x78, 0xf2, 0xcf, 0x4b, 0x00, 0xcb,
-		0x44, 0xb3, 0xb4, 0xbf, 0x24, 0x0a, 0x39, 0x54, 0x84, 0x4a, 0xa8, 0xe5, 0xa9, 0x4e, 0x83, 0xc6,
-		0xdb, 0xcf, 0x3a, 0x41, 0xb9, 0xe7, 0x61, 0xc4, 0x37, 0x46, 0x07, 0x0b, 0x61, 0xa6, 0xba, 0x64,
-		0xd5, 0x1b, 0xd8, 0x55, 0xb2, 0x97, 0x03, 0x25, 0xf9, 0x5f, 0x48, 0x90, 0xa1, 0x32, 0xad, 0x60,
-		0x57, 0x0d, 0x8d, 0xa1, 0x74, 0xf0, 0x31, 0xbc, 0x13, 0x80, 0xb1, 0x71, 0xf4, 0x97, 0x31, 0xb7,
-		0xac, 0x0c, 0x85, 0x6c, 0xe8, 0x2f, 0x63, 0x74, 0xd6, 0x53, 0x78, 0xb2, 0xbb, 0xc2, 0x45, 0xd6,
-		0xcd, 0xd5, 0x7e, 0x14, 0x86, 0xe8, 0xa7, 0x74, 0xae, 0x3a, 0x3c, 0x91, 0x1e, 0x34, 0x9a, 0x8d,
-		0xcd, 0xab, 0x8e, 0xfc, 0x22, 0x0c, 0x6d, 0x5e, 0x65, 0x7b, 0x23, 0x77, 0x40, 0xc6, 0x36, 0x4d,
-		0x1e, 0x93, 0x59, 0x2e, 0x94, 0x26, 0x00, 0x1a, 0x82, 0xc4, 0x7e, 0x40, 0xc2, 0xdf, 0x0f, 0xf0,
-		0x37, 0x34, 0x92, 0x3d, 0x6d, 0x68, 0x9c, 0xfc, 0x0f, 0x12, 0x0c, 0x07, 0xfc, 0x03, 0x7a, 0x14,
-		0x0e, 0x97, 0x96, 0xd7, 0xe6, 0x2f, 0x56, 0x96, 0x16, 0x2a, 0xe7, 0x97, 0xe7, 0x16, 0xfd, 0xb7,
-		0x26, 0x85, 0x23, 0xd7, 0xae, 0xcf, 0xa0, 0x00, 0xee, 0x96, 0xb1, 0x67, 0x98, 0x57, 0x0c, 0x74,
-		0x0a, 0x26, 0xc3, 0x24, 0x73, 0xa5, 0x8d, 0xf2, 0xea, 0x66, 0x4e, 0x2a, 0x1c, 0xbe, 0x76, 0x7d,
-		0x66, 0x3c, 0x40, 0x31, 0xb7, 0xed, 0x60, 0xc3, 0x6d, 0x25, 0x98, 0x5f, 0x5b, 0x59, 0x59, 0xda,
-		0xcc, 0x25, 0x5a, 0x08, 0xb8, 0xc3, 0x7e, 0x00, 0xc6, 0xc3, 0x04, 0xab, 0x4b, 0xcb, 0xb9, 0x64,
-		0x01, 0x5d, 0xbb, 0x3e, 0x33, 0x1a, 0xc0, 0x5e, 0xd5, 0xeb, 0x85, 0xf4, 0x07, 0x3e, 0x33, 0x75,
-		0xe8, 0x97, 0x7f, 0x69, 0x4a, 0x22, 0x3d, 0x1b, 0x09, 0xf9, 0x08, 0xf4, 0x10, 0x1c, 0xdd, 0x58,
-		0x5a, 0x5c, 0x2d, 0x2f, 0x54, 0x56, 0x36, 0x16, 0x2b, 0xec, 0x1b, 0x1b, 0x5e, 0xef, 0xc6, 0xae,
-		0x5d, 0x9f, 0x19, 0xe6, 0x5d, 0xea, 0x84, 0xbd, 0xae, 0x94, 0x2f, 0xad, 0x6d, 0x96, 0x73, 0x12,
-		0xc3, 0x5e, 0xb7, 0xf1, 0x65, 0xd3, 0x65, 0xdf, 0xda, 0x7a, 0x04, 0x8e, 0xb5, 0xc1, 0xf6, 0x3a,
-		0x36, 0x7e, 0xed, 0xfa, 0xcc, 0xc8, 0xba, 0x8d, 0xd9, 0xfc, 0xa1, 0x14, 0xb3, 0x90, 0x6f, 0xa5,
-		0x58, 0x5b, 0x5f, 0xdb, 0x98, 0x5b, 0xce, 0xcd, 0x14, 0x72, 0xd7, 0xae, 0xcf, 0x64, 0x85, 0x33,
-		0x24, 0xf8, 0x7e, 0xcf, 0x6e, 0xe7, 0x8a, 0xe7, 0x3b, 0xb3, 0x70, 0x0f, 0xdf, 0x03, 0x74, 0x5c,
-		0x75, 0x4f, 0x37, 0x6a, 0xde, 0x4e, 0x2b, 0x2f, 0xf3, 0x95, 0xcf, 0x11, 0xbe, 0xd9, 0x2a, 0xa0,
-		0x5d, 0xf7, 0x5b, 0x0b, 0x9d, 0x4f, 0x96, 0x0a, 0x31, 0x87, 0x2f, 0xf1, 0x4b, 0xa7, 0xce, 0x7b,
-		0xf3, 0x85, 0x98, 0x1d, 0xe3, 0x42, 0xd7, 0xc5, 0x9d, 0xfc, 0x41, 0x09, 0x46, 0x2f, 0xe8, 0x8e,
-		0x6b, 0xda, 0xba, 0xa6, 0xd6, 0xe9, 0x0b, 0x93, 0xb3, 0xbd, 0xfa, 0xd6, 0xc8, 0x54, 0x7f, 0x06,
-		0x06, 0x2f, 0xab, 0x75, 0xe6, 0xd4, 0x92, 0xf4, 0x83, 0x18, 0xed, 0xd5, 0xe7, 0xbb, 0x36, 0xc1,
-		0x80, 0x91, 0xc9, 0xbf, 0x9a, 0x80, 0x31, 0x3a, 0x19, 0x1c, 0xf6, 0xa9, 0x24, 0xb2, 0xc6, 0x2a,
-		0x41, 0xca, 0x56, 0x5d, 0xbe, 0x69, 0x58, 0x9a, 0xe5, 0x3b, 0xbf, 0xf7, 0xc5, 0xef, 0xe6, 0xce,
-		0x2e, 0x60, 0x4d, 0xa1, 0xb4, 0xe8, 0x1d, 0x90, 0x6e, 0xa8, 0x57, 0x2b, 0x94, 0x0f, 0x5b, 0xb9,
-		0xcc, 0xf5, 0xc7, 0xe7, 0xe6, 0x8d, 0xe9, 0xb1, 0x7d, 0xb5, 0x51, 0x2f, 0xca, 0x82, 0x8f, 0xac,
-		0x0c, 0x35, 0xd4, 0xab, 0x44, 0x44, 0x64, 0xc1, 0x18, 0x81, 0x6a, 0xbb, 0xaa, 0x51, 0xc3, 0xac,
-		0x11, 0xba, 0x05, 0x5a, 0xba, 0xd0, 0x77, 0x23, 0x47, 0xfc, 0x46, 0x02, 0xec, 0x64, 0x65, 0xa4,
-		0xa1, 0x5e, 0x9d, 0xa7, 0x00, 0xd2, 0x62, 0x31, 0xfd, 0xb1, 0x4f, 0x4d, 0x1f, 0xa2, 0xbb, 0xe9,
-		0xdf, 0x94, 0x00, 0x7c, 0x8d, 0xa1, 0x77, 0x40, 0x4e, 0xf3, 0x4a, 0x94, 0xd6, 0xe1, 0x63, 0x78,
-		0x7f, 0xa7, 0xb1, 0x88, 0xe8, 0x9b, 0xc5, 0xe6, 0x6f, 0xdc, 0x98, 0x96, 0x94, 0x31, 0x2d, 0x32,
-		0x14, 0x6f, 0x87, 0xe1, 0xa6, 0x55, 0x55, 0x5d, 0x5c, 0xa1, 0xeb, 0xb8, 0x44, 0x6c, 0x9c, 0x9f,
-		0x22, 0xbc, 0x6e, 0xde, 0x98, 0x46, 0xac, 0x5b, 0x01, 0x62, 0x99, 0x46, 0x7f, 0x60, 0x10, 0x42,
-		0x10, 0xe8, 0xd3, 0xd7, 0x24, 0x18, 0x5e, 0x08, 0xdc, 0xf4, 0xca, 0xc3, 0x50, 0xc3, 0x34, 0xf4,
-		0x3d, 0x6e, 0x8f, 0x19, 0x45, 0x14, 0x51, 0x01, 0xd2, 0xec, 0xd1, 0x9d, 0xbb, 0x2f, 0xb6, 0x42,
-		0x45, 0x99, 0x50, 0x5d, 0xc1, 0xdb, 0x8e, 0x2e, 0x46, 0x43, 0x11, 0x45, 0x74, 0x1e, 0x72, 0x0e,
-		0xd6, 0x9a, 0xb6, 0xee, 0xee, 0x57, 0x34, 0xd3, 0x70, 0x55, 0xcd, 0x65, 0xcf, 0xb7, 0x4a, 0x77,
-		0xdc, 0xbc, 0x31, 0x7d, 0x94, 0xc9, 0x1a, 0xc5, 0x90, 0x95, 0x31, 0x01, 0x9a, 0x67, 0x10, 0xd2,
-		0x42, 0x15, 0xbb, 0xaa, 0x5e, 0x77, 0xf2, 0xec, 0x60, 0x48, 0x14, 0x03, 0x7d, 0xf9, 0xfc, 0x50,
-		0x70, 0x63, 0xeb, 0x3c, 0xe4, 0x4c, 0x0b, 0xdb, 0xa1, 0x44, 0x54, 0x8a, 0xb6, 0x1c, 0xc5, 0x90,
-		0x95, 0x31, 0x01, 0x12, 0x49, 0xaa, 0x4b, 0x86, 0x59, 0x2c, 0x14, 0xad, 0xe6, 0xb6, 0xbf, 0x1f,
-		0x36, 0xd9, 0x32, 0x1a, 0x73, 0xc6, 0x7e, 0xe9, 0x31, 0x9f, 0x7b, 0x94, 0x4e, 0xfe, 0xfa, 0x17,
-		0x1f, 0x9e, 0xe4, 0xa6, 0xe1, 0xef, 0x4f, 0x5d, 0xc4, 0xfb, 0x64, 0xf8, 0x39, 0xea, 0x3a, 0xc5,
-		0x24, 0x69, 0xe7, 0x8b, 0xaa, 0x5e, 0x17, 0xcf, 0x90, 0x15, 0x5e, 0x42, 0x45, 0x18, 0x74, 0x5c,
-		0xd5, 0x6d, 0x3a, 0xfc, 0xe3, 0x60, 0x72, 0x27, 0x53, 0x2b, 0x99, 0x46, 0x75, 0x83, 0x62, 0x2a,
-		0x9c, 0x02, 0x9d, 0x87, 0x41, 0xd7, 0xdc, 0xc3, 0x06, 0x57, 0x61, 0x5f, 0xf3, 0x9b, 0x9e, 0x53,
-		0x31, 0x6a, 0xa2, 0x91, 0x2a, 0xae, 0xe3, 0x1a, 0x4b, 0xab, 0x76, 0x55, 0xb2, 0xfa, 0xa0, 0xdf,
-		0x08, 0x2b, 0x2d, 0xf5, 0x3d, 0x09, 0xb9, 0xa6, 0xa2, 0xfc, 0x64, 0x65, 0xcc, 0x03, 0x6d, 0x50,
-		0x08, 0xba, 0x18, 0xba, 0x92, 0xc8, 0x3f, 0xa4, 0x77, 0x77, 0xa7, 0xee, 0x07, 0x6c, 0x5a, 0xec,
-		0x4f, 0x04, 0x2f, 0x34, 0x9e, 0x87, 0x5c, 0xd3, 0xd8, 0x36, 0x0d, 0xfa, 0x56, 0x90, 0xe7, 0xf7,
-		0x64, 0x7d, 0x97, 0x0c, 0x1a, 0x47, 0x14, 0x43, 0x56, 0xc6, 0x3c, 0xd0, 0x05, 0xb6, 0x0a, 0xa8,
-		0xc2, 0xa8, 0x8f, 0x45, 0x27, 0x6a, 0x26, 0x76, 0xa2, 0xde, 0xc5, 0x27, 0xea, 0xe1, 0x68, 0x2b,
-		0xfe, 0x5c, 0x1d, 0xf1, 0x80, 0x84, 0x0c, 0x5d, 0x00, 0xf0, 0xdd, 0x03, 0xdd, 0xa7, 0x18, 0xee,
-		0x3c, 0xf0, 0xbe, 0x8f, 0x11, 0xeb, 0x3d, 0x9f, 0x16, 0xbd, 0x0b, 0x26, 0x1a, 0xba, 0x51, 0x71,
-		0x70, 0x7d, 0xa7, 0xc2, 0x15, 0x4c, 0x58, 0xd2, 0x4f, 0xbd, 0x94, 0x96, 0xfb, 0xb3, 0x87, 0x9b,
-		0x37, 0xa6, 0x0b, 0xdc, 0x85, 0xb6, 0xb2, 0x94, 0x95, 0xf1, 0x86, 0x6e, 0x6c, 0xe0, 0xfa, 0xce,
-		0x82, 0x07, 0x2b, 0x66, 0x3f, 0xf0, 0xa9, 0xe9, 0x43, 0x7c, 0xba, 0x1e, 0x92, 0xcf, 0xd2, 0xbd,
-		0x73, 0x3e, 0xcd, 0xb0, 0x43, 0xd6, 0x24, 0xaa, 0x28, 0xd0, 0x1d, 0x8d, 0x8c, 0xe2, 0x03, 0xd8,
-		0x34, 0x7f, 0xe5, 0x3f, 0xcd, 0x48, 0xf2, 0xe7, 0x25, 0x18, 0x5c, 0xb8, 0xb4, 0xae, 0xea, 0x36,
-		0x5a, 0x82, 0x71, 0xdf, 0x72, 0xc2, 0x93, 0xfc, 0xf8, 0xcd, 0x1b, 0xd3, 0xf9, 0xa8, 0x71, 0x79,
-		0xb3, 0xdc, 0x37, 0x60, 0x31, 0xcd, 0x97, 0x3a, 0x2d, 0x5c, 0x43, 0xac, 0x5a, 0x50, 0xe4, 0xd6,
-		0x65, 0x6d, 0xa4, 0x9b, 0x65, 0x18, 0x62, 0xd2, 0x3a, 0xa8, 0x08, 0x03, 0x16, 0xf9, 0xc1, 0x0f,
-		0x06, 0xa6, 0x3a, 0x1a, 0x2f, 0xc5, 0xf7, 0x36, 0x32, 0x09, 0x89, 0xfc, 0x91, 0x04, 0xc0, 0xc2,
-		0xa5, 0x4b, 0x9b, 0xb6, 0x6e, 0xd5, 0xb1, 0x7b, 0x2b, 0x7b, 0xbe, 0x09, 0x87, 0x03, 0xab, 0x24,
-		0x5b, 0x8b, 0xf4, 0x7e, 0xe6, 0xe6, 0x8d, 0xe9, 0xe3, 0xd1, 0xde, 0x07, 0xd0, 0x64, 0x65, 0xc2,
-		0x5f, 0x2f, 0xd9, 0x5a, 0x5b, 0xae, 0x55, 0xc7, 0xf5, 0xb8, 0x26, 0x3b, 0x73, 0x0d, 0xa0, 0x05,
-		0xb9, 0x2e, 0x38, 0x6e, 0x7b, 0xd5, 0x6e, 0xc0, 0xb0, 0xaf, 0x12, 0x07, 0x2d, 0x40, 0xda, 0xe5,
-		0xbf, 0xb9, 0x86, 0xe5, 0xce, 0x1a, 0x16, 0x64, 0x5c, 0xcb, 0x1e, 0xa5, 0xfc, 0x67, 0x12, 0x80,
-		0x6f, 0xb3, 0x3f, 0x99, 0x26, 0x46, 0x5c, 0x39, 0x77, 0xbc, 0xc9, 0x03, 0xa5, 0x6a, 0x9c, 0x3a,
-		0xa2, 0xcf, 0x9f, 0x49, 0xc0, 0xc4, 0x96, 0xf0, 0x3c, 0x3f, 0xf1, 0x3a, 0x58, 0x87, 0x21, 0x6c,
-		0xb8, 0xb6, 0x4e, 0x95, 0x40, 0x46, 0xfb, 0x91, 0x4e, 0xa3, 0xdd, 0xa6, 0x4f, 0xf4, 0x63, 0x37,
-		0x62, 0xd3, 0x9d, 0xb3, 0x89, 0x68, 0xe3, 0x43, 0x49, 0xc8, 0x77, 0xa2, 0x44, 0xf3, 0x30, 0xa6,
-		0xd9, 0x98, 0x02, 0x2a, 0xc1, 0x9d, 0xbf, 0x52, 0xc1, 0xcf, 0x2c, 0x23, 0x08, 0xb2, 0x32, 0x2a,
-		0x20, 0x3c, 0x7a, 0xd4, 0x80, 0xa4, 0x7d, 0xc4, 0xec, 0x08, 0x56, 0x8f, 0x79, 0x9e, 0xcc, 0xc3,
-		0x87, 0x68, 0x24, 0xcc, 0x80, 0xc5, 0x8f, 0x51, 0x1f, 0x4a, 0x03, 0xc8, 0x4b, 0x30, 0xa6, 0x1b,
-		0xba, 0xab, 0xab, 0xf5, 0xca, 0xb6, 0x5a, 0x57, 0x0d, 0xed, 0x20, 0x59, 0x33, 0x73, 0xf9, 0xbc,
-		0xd9, 0x08, 0x3b, 0x59, 0x19, 0xe5, 0x90, 0x12, 0x03, 0xa0, 0x0b, 0x30, 0x24, 0x9a, 0x4a, 0x1d,
-		0x28, 0xdb, 0x10, 0xe4, 0x81, 0x04, 0xef, 0x67, 0x93, 0x30, 0xae, 0xe0, 0xea, 0x5f, 0x0e, 0x45,
-		0x7f, 0x43, 0xb1, 0x02, 0xc0, 0xa6, 0x3b, 0x71, 0xb0, 0x07, 0x18, 0x0d, 0xe2, 0x30, 0x32, 0x8c,
-		0xc3, 0x82, 0xe3, 0x06, 0xc6, 0xe3, 0x46, 0x02, 0xb2, 0xc1, 0xf1, 0xf8, 0x0b, 0x1a, 0x95, 0xd0,
-		0x92, 0xef, 0x89, 0x52, 0xfc, 0x13, 0xa1, 0x1d, 0x3c, 0x51, 0x8b, 0xf5, 0x76, 0x77, 0x41, 0x7f,
-		0x94, 0x84, 0xc1, 0x75, 0xd5, 0x56, 0x1b, 0x0e, 0xd2, 0x5a, 0x32, 0x4d, 0xb1, 0xfd, 0xd8, 0xf2,
-		0x21, 0x68, 0xbe, 0xdb, 0x11, 0x93, 0x68, 0x7e, 0xac, 0x4d, 0xa2, 0xf9, 0x16, 0x18, 0x25, 0xcb,
-		0xe1, 0xc0, 0x15, 0x06, 0xa2, 0xed, 0x91, 0xd2, 0x31, 0x9f, 0x4b, 0xb8, 0x9e, 0xad, 0x96, 0x2f,
-		0x05, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0xdf, 0x31, 0x13, 0xf2, 0x23, 0xfe, 0xb2, 0x34, 0x50, 0x29,
-		0x2b, 0xd0, 0x50, 0xaf, 0x96, 0x59, 0x01, 0x2d, 0x03, 0xda, 0xf5, 0x76, 0x46, 0x2a, 0xbe, 0x3a,
-		0x09, 0xfd, 0x9d, 0x37, 0x6f, 0x4c, 0x1f, 0x63, 0xf4, 0xad, 0x38, 0xb2, 0x32, 0xee, 0x03, 0x05,
-		0xb7, 0xc7, 0x01, 0x48, 0xbf, 0x2a, 0xec, 0xfa, 0x1c, 0x5b, 0xee, 0x1c, 0xbe, 0x79, 0x63, 0x7a,
-		0x9c, 0x71, 0xf1, 0xeb, 0x64, 0x25, 0x43, 0x0a, 0x0b, 0xf4, 0x66, 0xdd, 0x4b, 0x30, 0x46, 0xef,
-		0x04, 0x54, 0x6c, 0x5c, 0x6d, 0xd2, 0x0f, 0x56, 0xf0, 0x75, 0xcd, 0x81, 0xe7, 0x66, 0x84, 0x9d,
-		0xac, 0x8c, 0x52, 0x88, 0x22, 0x00, 0x81, 0xc9, 0xf4, 0x19, 0x09, 0x90, 0x1f, 0x65, 0x14, 0xec,
-		0x58, 0x64, 0x49, 0x48, 0x72, 0xff, 0x40, 0xa2, 0x2e, 0x75, 0xcf, 0xfd, 0x7d, 0x7a, 0x91, 0xfb,
-		0x07, 0x26, 0xe7, 0x53, 0xbe, 0x47, 0x4e, 0x70, 0xd3, 0x69, 0x73, 0xbd, 0x71, 0x76, 0xde, 0xd4,
-		0x05, 0x75, 0x8b, 0x0b, 0x3e, 0x24, 0xff, 0x1b, 0x09, 0x8e, 0xb5, 0x18, 0xb1, 0x27, 0xec, 0x5f,
-		0x01, 0x64, 0x07, 0x2a, 0xf9, 0x27, 0xe6, 0x98, 0xd0, 0x7d, 0xcf, 0x89, 0x71, 0xbb, 0xc5, 0xd5,
-		0xdf, 0xba, 0xa0, 0xc2, 0xee, 0x47, 0xfe, 0x73, 0x09, 0x26, 0x83, 0xcd, 0x7b, 0x1d, 0x59, 0x85,
-		0x6c, 0xb0, 0x75, 0xde, 0x85, 0x7b, 0x7a, 0xe9, 0x02, 0x97, 0x3e, 0x44, 0x8f, 0x9e, 0xf3, 0x3d,
-		0x04, 0xdb, 0xae, 0x7b, 0xb4, 0x67, 0x6d, 0x08, 0x99, 0xa2, 0x9e, 0x22, 0x45, 0xc7, 0xe3, 0xff,
-		0x4a, 0x90, 0x5a, 0x37, 0xcd, 0x3a, 0x32, 0x61, 0xdc, 0x30, 0xdd, 0x0a, 0x31, 0x66, 0x5c, 0xad,
-		0xf0, 0x75, 0x3e, 0x73, 0xbd, 0xf3, 0xfd, 0x29, 0xe9, 0xbb, 0x37, 0xa6, 0x5b, 0x59, 0x29, 0x63,
-		0x86, 0xe9, 0x96, 0x28, 0x64, 0x93, 0xed, 0x02, 0xbc, 0x0b, 0x46, 0xc2, 0x8d, 0x31, 0xc7, 0xfc,
-		0x7c, 0xdf, 0x8d, 0x85, 0xd9, 0xdc, 0xbc, 0x31, 0x3d, 0xe9, 0x4f, 0x52, 0x0f, 0x2c, 0x2b, 0xd9,
-		0xed, 0x40, 0xeb, 0xec, 0x46, 0xd9, 0xf7, 0x3f, 0x35, 0x2d, 0x9d, 0xfc, 0x92, 0x04, 0xe0, 0x6f,
-		0x76, 0xa0, 0x87, 0xe0, 0x68, 0x69, 0x6d, 0x75, 0xa1, 0xb2, 0xb1, 0x39, 0xb7, 0xb9, 0xb5, 0x51,
-		0xd9, 0x5a, 0xdd, 0x58, 0x2f, 0xcf, 0x2f, 0x9d, 0x5f, 0x2a, 0x2f, 0xf8, 0x3b, 0xf2, 0x8e, 0x85,
-		0x35, 0x7d, 0x47, 0xc7, 0x55, 0x74, 0x1f, 0x4c, 0x86, 0xb1, 0x49, 0xa9, 0xbc, 0x90, 0x93, 0x0a,
-		0xd9, 0x6b, 0xd7, 0x67, 0xd2, 0x2c, 0xfd, 0xc3, 0x55, 0x74, 0x02, 0x0e, 0xb7, 0xe2, 0x2d, 0xad,
-		0x2e, 0xe6, 0x12, 0x85, 0x91, 0x6b, 0xd7, 0x67, 0x32, 0x5e, 0x9e, 0x88, 0x64, 0x40, 0x41, 0x4c,
-		0xce, 0x2f, 0x59, 0x80, 0x6b, 0xd7, 0x67, 0x06, 0x99, 0x02, 0x0b, 0xa9, 0x0f, 0x7c, 0x66, 0xea,
-		0x50, 0xe9, 0x7c, 0xc7, 0x3d, 0xf7, 0x87, 0xba, 0xea, 0xee, 0xaa, 0xb7, 0x8f, 0x1e, 0xde, 0x68,
-		0xff, 0x93, 0xa1, 0x8e, 0x1b, 0xed, 0x35, 0x6c, 0x60, 0x47, 0x77, 0x0e, 0xb4, 0xd1, 0xde, 0xd3,
-		0xe6, 0xbd, 0xfc, 0xbb, 0x03, 0x90, 0x5d, 0x64, 0xad, 0x90, 0x81, 0xc0, 0xe8, 0x4d, 0x30, 0x68,
-		0xd1, 0xc8, 0xe5, 0x9d, 0xdc, 0x75, 0x30, 0x78, 0x16, 0xdf, 0xbc, 0xeb, 0x63, 0x2c, 0xda, 0x39,
-		0xfc, 0xfe, 0x08, 0xbb, 0xd6, 0xe6, 0x5f, 0xd4, 0xca, 0xf6, 0xb5, 0xc5, 0xc4, 0x5c, 0x31, 0xdf,
-		0xcd, 0x89, 0xf2, 0x93, 0xd9, 0x55, 0x94, 0x4d, 0x02, 0x61, 0x17, 0xd2, 0xde, 0x27, 0xc1, 0x61,
-		0x8a, 0xe5, 0xc7, 0x7e, 0x8a, 0x29, 0xd6, 0x17, 0x27, 0x3b, 0x75, 0x61, 0x59, 0x75, 0xfc, 0xeb,
-		0x25, 0xec, 0x0a, 0xd9, 0x3d, 0x3c, 0xf6, 0x1e, 0x0f, 0x34, 0x1e, 0x65, 0x2b, 0x2b, 0x13, 0xf5,
-		0x16, 0x4a, 0x07, 0x2d, 0x86, 0xee, 0x10, 0xa6, 0xfa, 0xdb, 0xdd, 0x0f, 0xde, 0x27, 0x7c, 0x16,
-		0x86, 0x7d, 0x5f, 0xe2, 0xf0, 0x7f, 0x89, 0xd1, 0x7b, 0xec, 0x08, 0x12, 0xa3, 0xf7, 0x4b, 0x70,
-		0xd8, 0x4f, 0x20, 0x82, 0x6c, 0xd9, 0xbf, 0x0e, 0x79, 0xb0, 0x8f, 0xb5, 0x57, 0x54, 0x39, 0x6d,
-		0xf9, 0xca, 0xca, 0x64, 0xb3, 0x95, 0x94, 0xac, 0xfa, 0x46, 0x82, 0x9e, 0xd5, 0xc9, 0x8b, 0xaf,
-		0xe3, 0xf5, 0xee, 0x9a, 0xc3, 0x0c, 0xd8, 0xbf, 0x33, 0xb0, 0x4c, 0xdb, 0xc5, 0x55, 0xba, 0x07,
-		0x98, 0x56, 0xbc, 0xb2, 0xbc, 0x0a, 0xa8, 0x75, 0x70, 0xa3, 0x77, 0x26, 0x33, 0xfe, 0x9d, 0xc9,
-		0x49, 0x18, 0x08, 0xde, 0x2a, 0x64, 0x85, 0x62, 0xfa, 0x03, 0x3c, 0x7c, 0xde, 0xf2, 0x39, 0xff,
-		0xaf, 0x12, 0x70, 0x32, 0x78, 0x22, 0xf5, 0x52, 0x13, 0xdb, 0xfb, 0xde, 0x14, 0xb5, 0xd4, 0x9a,
-		0x6e, 0x04, 0x9f, 0x1d, 0x1d, 0x0b, 0x06, 0x7c, 0x8a, 0x2b, 0xf4, 0x24, 0x1b, 0x30, 0xbc, 0xae,
-		0xd6, 0xb0, 0x82, 0x5f, 0x6a, 0x62, 0xc7, 0x6d, 0x73, 0xaf, 0xfd, 0x08, 0x0c, 0x9a, 0x3b, 0x3b,
-		0xe2, 0x14, 0x3d, 0xa5, 0xf0, 0x12, 0xe9, 0x72, 0x5d, 0x6f, 0xe8, 0xec, 0x02, 0x5a, 0x4a, 0x61,
-		0x05, 0x34, 0x0d, 0xc3, 0x9a, 0xd9, 0x34, 0xf8, 0x8c, 0xcb, 0xa7, 0xc4, 0x37, 0x27, 0x9a, 0x06,
-		0x9b, 0x71, 0xf2, 0x33, 0x90, 0x65, 0xed, 0xf1, 0x88, 0x7b, 0x0c, 0xd2, 0xf4, 0x06, 0x97, 0xdf,
-		0xea, 0x10, 0x29, 0x5f, 0x64, 0x77, 0xe0, 0x19, 0x17, 0xd6, 0x30, 0x2b, 0x94, 0x4a, 0x1d, 0x55,
-		0x79, 0x22, 0xde, 0x35, 0x30, 0x45, 0x79, 0x6a, 0xfc, 0xad, 0x01, 0x38, 0xcc, 0x0f, 0x05, 0x55,
-		0x4b, 0x3f, 0xb5, 0xeb, 0xba, 0xe2, 0x61, 0x12, 0xf0, 0xec, 0x5a, 0xb5, 0x74, 0x79, 0x1f, 0x52,
-		0x17, 0x5c, 0xd7, 0x42, 0x27, 0x61, 0xc0, 0x6e, 0xd6, 0xb1, 0xd8, 0x64, 0xf2, 0x8e, 0x01, 0x54,
-		0x4b, 0x9f, 0x25, 0x08, 0x4a, 0xb3, 0x8e, 0x15, 0x86, 0x82, 0xca, 0x30, 0xbd, 0xd3, 0xac, 0xd7,
-		0xf7, 0x2b, 0x55, 0x4c, 0xff, 0x5d, 0x90, 0xf7, 0xc1, 0x7d, 0x7c, 0xd5, 0x52, 0xc5, 0x67, 0xfb,
-		0x88, 0x6e, 0x8e, 0x53, 0xb4, 0x05, 0x8a, 0x25, 0x3e, 0xb6, 0x5f, 0x16, 0x38, 0xf2, 0xef, 0x27,
-		0x20, 0x2d, 0x58, 0xd3, 0x4b, 0xe9, 0xb8, 0x8e, 0x35, 0xd7, 0x14, 0x87, 0x34, 0x5e, 0x19, 0x21,
-		0x48, 0xd6, 0xf8, 0x10, 0x65, 0x2e, 0x1c, 0x52, 0x48, 0x81, 0xc0, 0xbc, 0xa7, 0x02, 0x04, 0x66,
-		0x35, 0xc9, 0xa8, 0xa5, 0x2c, 0x53, 0xac, 0x06, 0x2f, 0x1c, 0x52, 0x68, 0x09, 0xe5, 0x61, 0x90,
-		0xcc, 0x0c, 0x97, 0x7d, 0x0b, 0x91, 0xc0, 0x79, 0x19, 0x1d, 0x81, 0x01, 0x4b, 0x75, 0x35, 0x76,
-		0x8b, 0x8f, 0x54, 0xb0, 0x22, 0x7a, 0x02, 0x06, 0xd9, 0x1b, 0xd4, 0xe8, 0xff, 0xe2, 0x20, 0xca,
-		0x60, 0x1f, 0xfb, 0x22, 0x72, 0xaf, 0xab, 0xae, 0x8b, 0x6d, 0x83, 0x30, 0x64, 0xe8, 0x08, 0x41,
-		0x6a, 0xdb, 0xac, 0xee, 0xf3, 0xff, 0x0f, 0x42, 0x7f, 0xf3, 0x7f, 0x48, 0x40, 0xed, 0xa1, 0x42,
-		0x2b, 0xd9, 0xbf, 0x45, 0xca, 0x0a, 0x60, 0x89, 0x20, 0x95, 0x61, 0x42, 0xad, 0x56, 0x75, 0xf6,
-		0xaf, 0x3a, 0x2a, 0xdb, 0x3a, 0xf5, 0x10, 0x0e, 0xfd, 0xa7, 0x57, 0x9d, 0xc6, 0x02, 0xf9, 0x04,
-		0x25, 0x8e, 0x5f, 0xca, 0xc0, 0x90, 0xc5, 0x84, 0x92, 0xcf, 0xc1, 0x78, 0x8b, 0xa4, 0x44, 0xbe,
-		0x3d, 0xdd, 0xa8, 0x8a, 0xf7, 0x13, 0xe4, 0x37, 0x81, 0xd1, 0x0f, 0xf6, 0xb1, 0xe3, 0x2f, 0xfa,
-		0xbb, 0xf4, 0x9e, 0xce, 0x6f, 0xcd, 0x46, 0x03, 0x6f, 0xcd, 0x54, 0x4b, 0x2f, 0x65, 0x28, 0x7f,
-		0xfe, 0xc2, 0x6c, 0x8e, 0x57, 0xb0, 0xd7, 0x65, 0xb3, 0xa6, 0x5d, 0x23, 0x51, 0x5a, 0x44, 0x5f,
-		0x52, 0xa5, 0x5a, 0xba, 0x43, 0xcd, 0xd1, 0xff, 0x80, 0xa0, 0x73, 0x2e, 0xf0, 0x9b, 0xbe, 0x3b,
-		0x4b, 0x2d, 0xce, 0xad, 0x2f, 0x79, 0x76, 0xfc, 0x95, 0x04, 0x1c, 0x0f, 0xd8, 0x71, 0x00, 0xb9,
-		0xd5, 0x9c, 0x0b, 0xed, 0x2d, 0xbe, 0x87, 0xf7, 0x66, 0x17, 0x21, 0x45, 0xf0, 0x51, 0xcc, 0xbf,
-		0x0b, 0xc8, 0xff, 0xda, 0xd7, 0xff, 0x99, 0x1c, 0x3e, 0x28, 0x0b, 0x8d, 0x0a, 0x65, 0x52, 0x7a,
-		0x7f, 0xef, 0xfa, 0xcb, 0xf9, 0xdf, 0x4e, 0x74, 0x6e, 0x9d, 0x1a, 0xa3, 0x3a, 0xfc, 0xf6, 0x19,
-		0x90, 0x3b, 0xa4, 0x3c, 0xcc, 0x63, 0x76, 0x4f, 0xa2, 0xfa, 0x70, 0xc7, 0x9d, 0x9e, 0x1c, 0x74,
-		0x1b, 0xc1, 0x1e, 0xd3, 0xb1, 0xab, 0x70, 0xe4, 0x39, 0xd2, 0xb6, 0xbf, 0x32, 0x17, 0x8e, 0xfd,
-		0x88, 0x77, 0x80, 0x28, 0xf1, 0xff, 0x39, 0x26, 0x0e, 0x07, 0xc1, 0x97, 0x8f, 0x2f, 0x10, 0xef,
-		0x9b, 0xed, 0x18, 0x2f, 0x66, 0x03, 0xc1, 0x42, 0x09, 0x50, 0xca, 0xbf, 0x22, 0xc1, 0xd1, 0x96,
-		0xa6, 0xb9, 0x8f, 0x5f, 0x6c, 0xf3, 0x3a, 0xe2, 0x40, 0x99, 0xcd, 0x62, 0x1b, 0x61, 0xef, 0x8f,
-		0x15, 0x96, 0x49, 0x11, 0x92, 0xf6, 0x69, 0x38, 0x1c, 0x16, 0x56, 0xa8, 0xe9, 0x5e, 0x18, 0x0d,
-		0x6f, 0x42, 0x73, 0x75, 0x8d, 0x84, 0xb6, 0xa1, 0xe5, 0x4a, 0x54, 0xcf, 0x5e, 0x5f, 0xcb, 0x90,
-		0xf1, 0x50, 0x79, 0x0a, 0xdc, 0x73, 0x57, 0x7d, 0x4a, 0xf9, 0x23, 0x12, 0xcc, 0x84, 0x5b, 0x08,
-		0x24, 0x43, 0xfd, 0x09, 0x7b, 0xcb, 0x86, 0xf8, 0x75, 0x09, 0xee, 0xea, 0x22, 0x13, 0x57, 0xc0,
-		0xcb, 0x30, 0x19, 0xd8, 0x09, 0x10, 0x2e, 0x5c, 0x0c, 0xfb, 0xc9, 0xf8, 0x34, 0xd4, 0x5b, 0xf8,
-		0xde, 0x41, 0x94, 0xf2, 0xb9, 0x3f, 0x98, 0x9e, 0x68, 0xad, 0x73, 0x94, 0x89, 0xd6, 0xd5, 0xfb,
-		0x2d, 0xb4, 0x8f, 0x57, 0x25, 0x78, 0x20, 0xdc, 0xd5, 0x36, 0xf9, 0xec, 0x1b, 0x35, 0x0e, 0xff,
-		0x51, 0x82, 0x93, 0xbd, 0x08, 0xc7, 0x07, 0x64, 0x1b, 0x26, 0xfc, 0x4c, 0x3b, 0x3a, 0x1e, 0x7d,
-		0xe5, 0xef, 0xcc, 0x4a, 0x91, 0xc7, 0xed, 0x36, 0x28, 0xde, 0xe2, 0x13, 0x2b, 0x38, 0xe4, 0x9e,
-		0x92, 0xc3, 0x1b, 0xc8, 0x42, 0xc9, 0xa1, 0x2d, 0xe4, 0x36, 0x63, 0x91, 0x68, 0x33, 0x16, 0x7e,
-		0x6a, 0x2e, 0x5f, 0xe6, 0x7e, 0xab, 0xcd, 0x1e, 0xdc, 0xdb, 0x61, 0xa2, 0x8d, 0x29, 0xf3, 0x59,
-		0xdd, 0x87, 0x25, 0x2b, 0xa8, 0xd5, 0x58, 0xe5, 0x7d, 0x98, 0xa6, 0xed, 0xb6, 0x51, 0xf4, 0xed,
-		0xee, 0x72, 0x83, 0xfb, 0x96, 0xb6, 0x4d, 0xf3, 0xbe, 0x2f, 0xc1, 0x20, 0x1b, 0x67, 0xde, 0xdd,
-		0x03, 0x18, 0x0a, 0x67, 0x20, 0xff, 0x82, 0xf0, 0x65, 0x0b, 0x42, 0xec, 0xf6, 0x73, 0xa8, 0x97,
-		0xbe, 0xde, 0xa2, 0x39, 0x14, 0x50, 0xc6, 0x37, 0x85, 0x57, 0x6b, 0x2f, 0x1d, 0x57, 0x87, 0x76,
-		0xcb, 0xbc, 0x1a, 0xd3, 0xcd, 0xed, 0x75, 0x5f, 0xbf, 0x24, 0xdc, 0x97, 0xd7, 0xa7, 0x18, 0xf7,
-		0xf5, 0xc6, 0xa8, 0xde, 0x73, 0x64, 0x31, 0x62, 0xfe, 0x79, 0x74, 0x64, 0xdf, 0x97, 0xe0, 0x18,
-		0xed, 0x5b, 0x70, 0x23, 0xa2, 0x5f, 0x95, 0x3f, 0x04, 0xc8, 0xb1, 0xb5, 0x4a, 0xdb, 0xd9, 0x9d,
-		0x73, 0x6c, 0xed, 0x52, 0x28, 0xbe, 0x3c, 0x04, 0xa8, 0x1a, 0xda, 0x6e, 0xa2, 0xd8, 0xec, 0x62,
-		0x5e, 0xae, 0x1a, 0xd8, 0xcd, 0x68, 0x33, 0x9c, 0xa9, 0x5b, 0x30, 0x9c, 0xdf, 0x90, 0xa0, 0xd0,
-		0xae, 0xcb, 0x7c, 0xf8, 0x74, 0x38, 0x12, 0x3a, 0x24, 0x88, 0x8e, 0xe0, 0x43, 0xbd, 0x6c, 0xe5,
-		0x44, 0xa6, 0xd1, 0x61, 0x1b, 0xdf, 0xee, 0x3c, 0x60, 0x3a, 0x6c, 0xa1, 0xad, 0x99, 0xf5, 0x1b,
-		0x36, 0x7d, 0xbe, 0xd8, 0xe2, 0x57, 0xff, 0x5c, 0xe4, 0xde, 0x57, 0x61, 0xaa, 0x83, 0xd4, 0xb7,
-		0x3b, 0xee, 0xed, 0x76, 0x1c, 0xcc, 0x5b, 0x9d, 0xbe, 0x3f, 0xce, 0x67, 0x42, 0xf8, 0xd2, 0x77,
-		0x60, 0x2d, 0xd6, 0xee, 0xd5, 0x98, 0xfc, 0x56, 0xb8, 0xa3, 0x2d, 0x15, 0x97, 0xad, 0x08, 0xa9,
-		0x5d, 0xdd, 0x71, 0xb9, 0x58, 0xf7, 0x75, 0x12, 0x2b, 0x42, 0x4d, 0x69, 0x64, 0x04, 0x39, 0xca,
-		0x7a, 0xdd, 0x34, 0xeb, 0x5c, 0x0c, 0xf9, 0x22, 0x8c, 0x07, 0x60, 0xbc, 0x91, 0xb3, 0x90, 0xb2,
-		0x4c, 0xfe, 0x45, 0x84, 0xe1, 0xd3, 0xc7, 0x3b, 0xee, 0xde, 0x9b, 0x66, 0x9d, 0x77, 0x9b, 0xe2,
-		0xcb, 0x93, 0x80, 0x18, 0x33, 0xba, 0x91, 0x2f, 0x9a, 0xd8, 0x80, 0x89, 0x10, 0x94, 0x37, 0xf2,
-		0x23, 0x1d, 0x12, 0x9c, 0xfe, 0xee, 0x61, 0x18, 0xa0, 0x5c, 0xd1, 0xc7, 0x25, 0x80, 0xc0, 0x21,
-		0xf4, 0x6c, 0x27, 0x36, 0xed, 0xd7, 0xc4, 0x85, 0x53, 0x3d, 0xe3, 0xf3, 0x9c, 0xed, 0xe4, 0x7b,
-		0xfe, 0xdd, 0xb7, 0x3f, 0x9a, 0xb8, 0x07, 0xc9, 0xa7, 0x3a, 0xac, 0xc6, 0x03, 0xf3, 0xe5, 0xb3,
-		0xa1, 0xe7, 0xf6, 0x0f, 0xf7, 0xd6, 0x94, 0x90, 0x6c, 0xb6, 0x57, 0x74, 0x2e, 0xd8, 0x39, 0x2a,
-		0xd8, 0x19, 0xf4, 0x58, 0xbc, 0x60, 0xa7, 0xde, 0x19, 0x9e, 0x34, 0xef, 0x46, 0xbf, 0x2b, 0xc1,
-		0x64, 0xbb, 0x25, 0x1d, 0x7a, 0xb2, 0x37, 0x29, 0x5a, 0x53, 0x8a, 0xc2, 0x53, 0x07, 0xa0, 0xe4,
-		0x5d, 0x59, 0xa4, 0x5d, 0x99, 0x43, 0xcf, 0x1c, 0xa0, 0x2b, 0xa7, 0x82, 0xfb, 0xfb, 0xff, 0x5b,
-		0x82, 0x3b, 0xbb, 0xae, 0x90, 0xd0, 0x5c, 0x6f, 0x52, 0x76, 0xc9, 0x9d, 0x0a, 0xa5, 0x1f, 0x85,
-		0x05, 0xef, 0xf1, 0x73, 0xb4, 0xc7, 0x17, 0xd1, 0xd2, 0x41, 0x7a, 0xdc, 0xf6, 0x10, 0x05, 0xfd,
-		0x76, 0xf8, 0x32, 0x63, 0x77, 0x73, 0x6a, 0x59, 0x78, 0xc4, 0x4c, 0x8c, 0xd6, 0xa4, 0x56, 0x7e,
-		0x81, 0x76, 0x41, 0x41, 0xeb, 0x3f, 0xe2, 0xa0, 0x9d, 0x7a, 0x67, 0xd8, 0xf1, 0xbf, 0x1b, 0xfd,
-		0x2f, 0xa9, 0xfd, 0xdd, 0xc4, 0x27, 0xba, 0x8a, 0xd8, 0x79, 0x51, 0x55, 0x78, 0xb2, 0x7f, 0x42,
-		0xde, 0xc9, 0x06, 0xed, 0x64, 0x0d, 0xe1, 0x5b, 0xdd, 0xc9, 0xb6, 0x83, 0x88, 0xbe, 0x26, 0xc1,
-		0x64, 0xbb, 0x35, 0x49, 0xcc, 0xb4, 0xec, 0xb2, 0xc8, 0x8a, 0x99, 0x96, 0xdd, 0x16, 0x40, 0xf2,
-		0x9b, 0x68, 0xe7, 0xcf, 0xa2, 0xc7, 0x3b, 0x75, 0xbe, 0xeb, 0x28, 0x92, 0xb9, 0xd8, 0x35, 0xc9,
-		0x8f, 0x99, 0x8b, 0xbd, 0xac, 0x63, 0x62, 0xe6, 0x62, 0x4f, 0x6b, 0x8c, 0xf8, 0xb9, 0xe8, 0xf5,
-		0xac, 0xc7, 0x61, 0x74, 0xd0, 0x57, 0x24, 0x18, 0x09, 0x65, 0xc4, 0xe8, 0xd1, 0xae, 0x82, 0xb6,
-		0x5b, 0x30, 0x14, 0x4e, 0xf7, 0x43, 0xc2, 0xfb, 0xb2, 0x44, 0xfb, 0x32, 0x8f, 0xe6, 0x0e, 0xd2,
-		0x97, 0xf0, 0x59, 0xe9, 0x37, 0x24, 0x98, 0x68, 0x93, 0x65, 0xc6, 0xcc, 0xc2, 0xce, 0x49, 0x73,
-		0xe1, 0xc9, 0xfe, 0x09, 0x79, 0xaf, 0xce, 0xd3, 0x5e, 0xbd, 0x05, 0x3d, 0x7d, 0x90, 0x5e, 0x05,
-		0xe2, 0xf3, 0x0d, 0xff, 0xde, 0x55, 0xa0, 0x1d, 0x74, 0xb6, 0x4f, 0xc1, 0x44, 0x87, 0x9e, 0xe8,
-		0x9b, 0x8e, 0xf7, 0xe7, 0x79, 0xda, 0x9f, 0xe7, 0xd0, 0xda, 0x8f, 0xd6, 0x9f, 0xd6, 0xb0, 0xfe,
-		0x85, 0xd6, 0x47, 0x87, 0xdd, 0xad, 0xa8, 0x6d, 0xb2, 0x5a, 0x78, 0xac, 0x2f, 0x1a, 0xde, 0xa9,
-		0x27, 0x69, 0xa7, 0x4e, 0xa3, 0x47, 0x3a, 0x75, 0x2a, 0x70, 0x9f, 0x4f, 0x37, 0x76, 0xcc, 0x53,
-		0xef, 0x64, 0x29, 0xf0, 0xbb, 0xd1, 0x4f, 0x8b, 0x8b, 0x4d, 0x27, 0xba, 0xb6, 0x1b, 0xc8, 0x63,
-		0x0b, 0x0f, 0xf4, 0x80, 0xc9, 0xe5, 0xba, 0x87, 0xca, 0x35, 0x85, 0x8e, 0x77, 0x92, 0x8b, 0xe4,
-		0xb2, 0xe8, 0x83, 0x92, 0x77, 0xfd, 0xf2, 0x64, 0x77, 0xde, 0xc1, 0x64, 0xb7, 0xf0, 0x60, 0x4f,
-		0xb8, 0x5c, 0x92, 0xfb, 0xa8, 0x24, 0x33, 0x68, 0xaa, 0xa3, 0x24, 0x2c, 0xf5, 0xbd, 0xd5, 0x37,
-		0x07, 0xae, 0x1d, 0x85, 0xe9, 0x0e, 0x2d, 0xba, 0x57, 0x63, 0xce, 0xb8, 0xba, 0xbc, 0xbd, 0x8d,
-		0x7d, 0x5b, 0xdb, 0xe1, 0x35, 0xef, 0xc1, 0x5f, 0xdc, 0xf6, 0x76, 0x20, 0xf6, 0x6f, 0x53, 0x80,
-		0x56, 0x9c, 0xda, 0xbc, 0x8d, 0xd9, 0xff, 0xd9, 0xe3, 0xb3, 0x3c, 0xf2, 0xa8, 0x4c, 0xfa, 0x91,
-		0x1e, 0x95, 0xad, 0x84, 0x9e, 0x69, 0x25, 0xfa, 0x7b, 0x0a, 0xda, 0xf3, 0x5b, 0xad, 0xe4, 0x8f,
-		0xe5, 0xad, 0x56, 0xfb, 0xab, 0xdc, 0xa9, 0x5b, 0xf7, 0xe6, 0x63, 0xe0, 0xa0, 0xef, 0x5e, 0xf8,
-		0x13, 0xcc, 0xc1, 0x2e, 0x4f, 0x30, 0xf3, 0x1d, 0xdf, 0x59, 0x72, 0x6a, 0x74, 0x46, 0x7c, 0x33,
-		0x78, 0xa8, 0xb7, 0x9b, 0xb0, 0xfc, 0xa3, 0xc2, 0xfe, 0x16, 0xc2, 0x71, 0x28, 0xb4, 0x9a, 0x93,
-		0x37, 0xa9, 0x3f, 0x9a, 0x84, 0xdc, 0x8a, 0x53, 0x2b, 0x57, 0x75, 0xf7, 0x36, 0xd9, 0xda, 0x33,
-		0x9d, 0xdf, 0xd1, 0xa0, 0x9b, 0x37, 0xa6, 0x47, 0x99, 0x4e, 0xbb, 0x68, 0xb2, 0x01, 0x63, 0x91,
-		0xd7, 0xcb, 0xdc, 0xb2, 0x16, 0x0e, 0xf2, 0x88, 0x3a, 0xc2, 0x4a, 0xa6, 0xcf, 0x1e, 0x02, 0xf6,
-		0x8d, 0xae, 0xb6, 0x37, 0x66, 0x66, 0x50, 0x17, 0x6e, 0xe7, 0xa3, 0x43, 0x7f, 0xcc, 0x0a, 0x90,
-		0x8f, 0x0e, 0x8a, 0x37, 0x62, 0xdf, 0x91, 0x60, 0x78, 0xc5, 0x11, 0xa9, 0x20, 0xfe, 0x09, 0x7d,
-		0xf2, 0xf4, 0x84, 0xf7, 0xe9, 0xd7, 0x64, 0x6f, 0x76, 0x2b, 0x3e, 0x07, 0xeb, 0x2b, 0xe1, 0x30,
-		0x4c, 0x04, 0xfa, 0xe9, 0xf5, 0xff, 0x77, 0x12, 0xd4, 0x3f, 0x96, 0x70, 0x4d, 0x37, 0xbc, 0x2c,
-		0x12, 0xff, 0x45, 0x7d, 0xd0, 0xe1, 0xeb, 0x39, 0x75, 0x50, 0x3d, 0xef, 0x51, 0x07, 0x11, 0xd1,
-		0xa7, 0xb7, 0xf1, 0xb5, 0xd2, 0xfa, 0xdc, 0x48, 0xea, 0xe3, 0x4b, 0x3e, 0x91, 0x47, 0x45, 0xf2,
-		0xeb, 0x12, 0x8c, 0xac, 0x38, 0xb5, 0x2d, 0xa3, 0xfa, 0xff, 0xbd, 0xfd, 0xee, 0xc0, 0xe1, 0x50,
-		0x4f, 0x6f, 0x93, 0x4a, 0x4f, 0xbf, 0x9a, 0x82, 0xe4, 0x8a, 0x53, 0x43, 0x2f, 0xc1, 0x58, 0x34,
-		0x69, 0xe8, 0x98, 0x0b, 0xb6, 0x46, 0x84, 0xce, 0xeb, 0xb5, 0xce, 0xd1, 0x03, 0xed, 0xc1, 0x48,
-		0x38, 0x72, 0x9c, 0xe8, 0xc2, 0x24, 0x84, 0x59, 0x78, 0xa4, 0x57, 0x4c, 0xaf, 0xb1, 0x77, 0x40,
-		0xda, 0x73, 0x7a, 0x77, 0x77, 0xa1, 0x16, 0x48, 0x9d, 0xb3, 0xdb, 0x36, 0x6e, 0x85, 0x68, 0x2f,
-		0xea, 0x52, 0xba, 0x69, 0x2f, 0x82, 0xdb, 0x55, 0x7b, 0x9d, 0xa6, 0xd6, 0x36, 0x40, 0x60, 0x1e,
-		0xdc, 0xdb, 0x85, 0x83, 0x8f, 0x56, 0x78, 0xb8, 0x27, 0x34, 0xef, 0xd0, 0xe9, 0x16, 0x27, 0xe3,
-		0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x2a, 0x2c, 0x38, 0xdd, 0x94, 0x00, 0x00,
-=======
-		// 9808 bytes of a gzipped FileDescriptorSet
+		// 9849 bytes of a gzipped FileDescriptorSet
 		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x5c, 0xd7,
 		0x75, 0x18, 0xde, 0x7e, 0x00, 0xbb, 0x07, 0x0b, 0x60, 0x71, 0x01, 0x92, 0xcb, 0x25, 0x09, 0x40,
 		0x4f, 0x5f, 0x14, 0x25, 0x81, 0x12, 0x25, 0x52, 0xd2, 0xd2, 0xb6, 0xbc, 0x8b, 0x5d, 0x82, 0x10,
 		0xf1, 0xa5, 0x07, 0x80, 0x92, 0x65, 0xa7, 0x3b, 0x0f, 0xbb, 0x17, 0x8b, 0x27, 0xec, 0xbe, 0xf7,
-		0xf4, 0xde, 0x5b, 0x12, 0xa0, 0xed, 0x8e, 0x62, 0xbb, 0xae, 0xcd, 0x4c, 0x1a, 0xbb, 0xee, 0x34,
-		0xb6, 0x6c, 0xba, 0x76, 0x9c, 0xd6, 0xa9, 0xe3, 0x36, 0x71, 0xec, 0xba, 0x4d, 0xdb, 0x99, 0xda,
-		0x9d, 0xa6, 0xb1, 0xdd, 0x26, 0x63, 0xb7, 0x99, 0x36, 0xcd, 0xb4, 0x74, 0x2a, 0x7b, 0x52, 0xd5,
-		0x75, 0x1b, 0x87, 0x71, 0xda, 0x74, 0x3c, 0x9d, 0x76, 0xee, 0xd7, 0xfb, 0xda, 0x4f, 0x40, 0xa4,
-		0xe5, 0x34, 0xf9, 0x85, 0xbd, 0xe7, 0x9e, 0x73, 0xee, 0x39, 0xe7, 0x9e, 0x7b, 0xee, 0xb9, 0x5f,
-		0x0f, 0xf0, 0x85, 0xf3, 0x30, 0x53, 0x33, 0x8c, 0x5a, 0x1d, 0x9f, 0x36, 0x2d, 0xc3, 0x31, 0x36,
+		0xf4, 0xde, 0x5b, 0x12, 0x90, 0xed, 0x8e, 0xfc, 0x51, 0xd7, 0x66, 0x26, 0x8d, 0x5d, 0x77, 0x1a,
+		0x5b, 0x36, 0x5d, 0x39, 0x4e, 0xeb, 0xd4, 0x71, 0x1b, 0x3b, 0x76, 0xdd, 0xa6, 0xed, 0x4c, 0xed,
+		0x4e, 0xd3, 0xd8, 0x6e, 0x93, 0xb1, 0xdb, 0x4c, 0x9b, 0x66, 0x52, 0x3a, 0x95, 0x3d, 0xae, 0xe2,
+		0xba, 0x8d, 0xc3, 0xba, 0xd3, 0x74, 0x3c, 0x9d, 0x76, 0xee, 0xd7, 0xfb, 0xda, 0x4f, 0x40, 0xa4,
+		0xe5, 0x34, 0xfd, 0x85, 0xbd, 0xe7, 0x9e, 0x73, 0xee, 0xb9, 0xe7, 0x9e, 0x73, 0xee, 0xb9, 0x5f,
+		0x0f, 0xf0, 0xc5, 0xf3, 0x30, 0x53, 0x33, 0x8c, 0x5a, 0x1d, 0x9f, 0x36, 0x2d, 0xc3, 0x31, 0x36,
 		0x9b, 0x5b, 0xa7, 0xab, 0xd8, 0xae, 0x58, 0x9a, 0xe9, 0x18, 0xd6, 0x2c, 0x85, 0xa1, 0x31, 0x86,
 		0x31, 0x2b, 0x30, 0xe4, 0x25, 0x18, 0xbf, 0xa0, 0xd5, 0x71, 0xd1, 0x45, 0x5c, 0xc3, 0x0e, 0x7a,
-		0x12, 0x62, 0x5b, 0x5a, 0x1d, 0x67, 0xa4, 0x99, 0xe8, 0xc9, 0xe1, 0x33, 0xf7, 0xcc, 0x86, 0x88,
-		0x66, 0x83, 0x14, 0xab, 0x04, 0xac, 0x50, 0x0a, 0xf9, 0xbb, 0x31, 0x98, 0x68, 0x53, 0x8b, 0x10,
+		0x1c, 0x62, 0x5b, 0x5a, 0x1d, 0x67, 0xa4, 0x99, 0xe8, 0xc9, 0xe1, 0x33, 0x77, 0xcd, 0x86, 0x88,
+		0x66, 0x83, 0x14, 0xab, 0x04, 0xac, 0x50, 0x0a, 0xf9, 0x7b, 0x31, 0x98, 0x68, 0x53, 0x8b, 0x10,
 		0xc4, 0x74, 0xb5, 0x41, 0x38, 0x4a, 0x27, 0x93, 0x0a, 0xfd, 0x8d, 0x32, 0x30, 0x64, 0xaa, 0x95,
 		0x1d, 0xb5, 0x86, 0x33, 0x11, 0x0a, 0x16, 0x45, 0x34, 0x05, 0x50, 0xc5, 0x26, 0xd6, 0xab, 0x58,
-		0xaf, 0xec, 0x65, 0xa2, 0x33, 0xd1, 0x93, 0x49, 0xc5, 0x07, 0x41, 0x0f, 0xc2, 0xb8, 0xd9, 0xdc,
+		0xaf, 0xec, 0x65, 0xa2, 0x33, 0xd1, 0x93, 0x49, 0xc5, 0x07, 0x41, 0xf7, 0xc3, 0xb8, 0xd9, 0xdc,
 		0xac, 0x6b, 0x95, 0xb2, 0x0f, 0x0d, 0x66, 0xa2, 0x27, 0xe3, 0x4a, 0x9a, 0x55, 0x14, 0x3d, 0xe4,
-		0xfb, 0x61, 0xec, 0x2a, 0x56, 0x77, 0xfc, 0xa8, 0xc3, 0x14, 0x75, 0x94, 0x80, 0x7d, 0x88, 0x73,
-		0x90, 0x6a, 0x60, 0xdb, 0x56, 0x6b, 0xb8, 0xec, 0xec, 0x99, 0x38, 0x13, 0xa3, 0xda, 0xcf, 0xb4,
-		0x68, 0x1f, 0xd6, 0x7c, 0x98, 0x53, 0xad, 0xef, 0x99, 0x18, 0xe5, 0x21, 0x89, 0xf5, 0x66, 0x83,
-		0x71, 0x88, 0x77, 0xb0, 0x5f, 0x49, 0x6f, 0x36, 0xc2, 0x5c, 0x12, 0x84, 0x8c, 0xb3, 0x18, 0xb2,
-		0xb1, 0x75, 0x45, 0xab, 0xe0, 0xcc, 0x20, 0x65, 0x70, 0x7f, 0x0b, 0x83, 0x35, 0x56, 0x1f, 0xe6,
-		0x21, 0xe8, 0xd0, 0x1c, 0x24, 0xf1, 0xae, 0x83, 0x75, 0x5b, 0x33, 0xf4, 0xcc, 0x10, 0x65, 0x72,
-		0x6f, 0x9b, 0x5e, 0xc4, 0xf5, 0x6a, 0x98, 0x85, 0x47, 0x87, 0xce, 0xc1, 0x90, 0x61, 0x3a, 0x9a,
-		0xa1, 0xdb, 0x99, 0xc4, 0x8c, 0x74, 0x72, 0xf8, 0xcc, 0xf1, 0xb6, 0x8e, 0xb0, 0xc2, 0x70, 0x14,
-		0x81, 0x8c, 0x16, 0x20, 0x6d, 0x1b, 0x4d, 0xab, 0x82, 0xcb, 0x15, 0xa3, 0x8a, 0xcb, 0x9a, 0xbe,
-		0x65, 0x64, 0x92, 0x94, 0xc1, 0x74, 0xab, 0x22, 0x14, 0x71, 0xce, 0xa8, 0xe2, 0x05, 0x7d, 0xcb,
-		0x50, 0x46, 0xed, 0x40, 0x19, 0x1d, 0x86, 0x41, 0x7b, 0x4f, 0x77, 0xd4, 0xdd, 0x4c, 0x8a, 0x7a,
-		0x08, 0x2f, 0xc9, 0xbf, 0x3e, 0x08, 0x63, 0xfd, 0xb8, 0xd8, 0x79, 0x88, 0x6f, 0x11, 0x2d, 0x33,
-		0x91, 0xfd, 0xd8, 0x80, 0xd1, 0x04, 0x8d, 0x38, 0x78, 0x40, 0x23, 0xe6, 0x61, 0x58, 0xc7, 0xb6,
-		0x83, 0xab, 0xcc, 0x23, 0xa2, 0x7d, 0xfa, 0x14, 0x30, 0xa2, 0x56, 0x97, 0x8a, 0x1d, 0xc8, 0xa5,
-		0x9e, 0x87, 0x31, 0x57, 0xa4, 0xb2, 0xa5, 0xea, 0x35, 0xe1, 0x9b, 0xa7, 0x7b, 0x49, 0x32, 0x5b,
-		0x12, 0x74, 0x0a, 0x21, 0x53, 0x46, 0x71, 0xa0, 0x8c, 0x8a, 0x00, 0x86, 0x8e, 0x8d, 0xad, 0x72,
-		0x15, 0x57, 0xea, 0x99, 0x44, 0x07, 0x2b, 0xad, 0x10, 0x94, 0x16, 0x2b, 0x19, 0x0c, 0x5a, 0xa9,
-		0xa3, 0xa7, 0x3c, 0x57, 0x1b, 0xea, 0xe0, 0x29, 0x4b, 0x6c, 0x90, 0xb5, 0x78, 0xdb, 0x06, 0x8c,
-		0x5a, 0x98, 0xf8, 0x3d, 0xae, 0x72, 0xcd, 0x92, 0x54, 0x88, 0xd9, 0x9e, 0x9a, 0x29, 0x9c, 0x8c,
-		0x29, 0x36, 0x62, 0xf9, 0x8b, 0xe8, 0x6e, 0x70, 0x01, 0x65, 0xea, 0x56, 0x40, 0xa3, 0x50, 0x4a,
-		0x00, 0x97, 0xd5, 0x06, 0xce, 0x5e, 0x83, 0xd1, 0xa0, 0x79, 0xd0, 0x24, 0xc4, 0x6d, 0x47, 0xb5,
-		0x1c, 0xea, 0x85, 0x71, 0x85, 0x15, 0x50, 0x1a, 0xa2, 0x58, 0xaf, 0xd2, 0x28, 0x17, 0x57, 0xc8,
-		0x4f, 0xf4, 0x56, 0x4f, 0xe1, 0x28, 0x55, 0xf8, 0xbe, 0xd6, 0x1e, 0x0d, 0x70, 0x0e, 0xeb, 0x9d,
-		0x7d, 0x02, 0x46, 0x02, 0x0a, 0xf4, 0xdb, 0xb4, 0xfc, 0x2e, 0x38, 0xd4, 0x96, 0x35, 0x7a, 0x1e,
-		0x26, 0x9b, 0xba, 0xa6, 0x3b, 0xd8, 0x32, 0x2d, 0x4c, 0x3c, 0x96, 0x35, 0x95, 0xf9, 0x2f, 0x43,
-		0x1d, 0x7c, 0x6e, 0xc3, 0x8f, 0xcd, 0xb8, 0x28, 0x13, 0xcd, 0x56, 0xe0, 0xa9, 0x64, 0xe2, 0xb5,
-		0xa1, 0xf4, 0xcb, 0x2f, 0xbf, 0xfc, 0x72, 0x44, 0xfe, 0xea, 0x20, 0x4c, 0xb6, 0x1b, 0x33, 0x6d,
-		0x87, 0xef, 0x61, 0x18, 0xd4, 0x9b, 0x8d, 0x4d, 0x6c, 0x51, 0x23, 0xc5, 0x15, 0x5e, 0x42, 0x79,
-		0x88, 0xd7, 0xd5, 0x4d, 0x5c, 0xcf, 0xc4, 0x66, 0xa4, 0x93, 0xa3, 0x67, 0x1e, 0xec, 0x6b, 0x54,
-		0xce, 0x2e, 0x12, 0x12, 0x85, 0x51, 0xa2, 0xb7, 0x40, 0x8c, 0x87, 0x68, 0xc2, 0xe1, 0x54, 0x7f,
-		0x1c, 0xc8, 0x58, 0x52, 0x28, 0x1d, 0x3a, 0x06, 0x49, 0xf2, 0x97, 0xf9, 0xc6, 0x20, 0x95, 0x39,
-		0x41, 0x00, 0xc4, 0x2f, 0x50, 0x16, 0x12, 0x74, 0x98, 0x54, 0xb1, 0x98, 0xda, 0xdc, 0x32, 0x71,
-		0xac, 0x2a, 0xde, 0x52, 0x9b, 0x75, 0xa7, 0x7c, 0x45, 0xad, 0x37, 0x31, 0x75, 0xf8, 0xa4, 0x92,
-		0xe2, 0xc0, 0xcb, 0x04, 0x86, 0xa6, 0x61, 0x98, 0x8d, 0x2a, 0x4d, 0xaf, 0xe2, 0x5d, 0x1a, 0x3d,
-		0xe3, 0x0a, 0x1b, 0x68, 0x0b, 0x04, 0x42, 0x9a, 0x7f, 0xd1, 0x36, 0x74, 0xe1, 0x9a, 0xb4, 0x09,
-		0x02, 0xa0, 0xcd, 0x3f, 0x11, 0x0e, 0xdc, 0x27, 0xda, 0xab, 0xd7, 0x32, 0x96, 0xee, 0x87, 0x31,
-		0x8a, 0xf1, 0x18, 0xef, 0x7a, 0xb5, 0x9e, 0x19, 0x9f, 0x91, 0x4e, 0x26, 0x94, 0x51, 0x06, 0x5e,
-		0xe1, 0x50, 0xf9, 0xcb, 0x11, 0x88, 0xd1, 0xc0, 0x32, 0x06, 0xc3, 0xeb, 0x6f, 0x5b, 0x2d, 0x95,
-		0x8b, 0x2b, 0x1b, 0x85, 0xc5, 0x52, 0x5a, 0x42, 0xa3, 0x00, 0x14, 0x70, 0x61, 0x71, 0x25, 0xbf,
-		0x9e, 0x8e, 0xb8, 0xe5, 0x85, 0xe5, 0xf5, 0x73, 0x8f, 0xa7, 0xa3, 0x2e, 0xc1, 0x06, 0x03, 0xc4,
-		0xfc, 0x08, 0x8f, 0x9d, 0x49, 0xc7, 0x51, 0x1a, 0x52, 0x8c, 0xc1, 0xc2, 0xf3, 0xa5, 0xe2, 0xb9,
-		0xc7, 0xd3, 0x83, 0x41, 0xc8, 0x63, 0x67, 0xd2, 0x43, 0x68, 0x04, 0x92, 0x14, 0x52, 0x58, 0x59,
-		0x59, 0x4c, 0x27, 0x5c, 0x9e, 0x6b, 0xeb, 0xca, 0xc2, 0xf2, 0x7c, 0x3a, 0xe9, 0xf2, 0x9c, 0x57,
-		0x56, 0x36, 0x56, 0xd3, 0xe0, 0x72, 0x58, 0x2a, 0xad, 0xad, 0xe5, 0xe7, 0x4b, 0xe9, 0x61, 0x17,
-		0xa3, 0xf0, 0xb6, 0xf5, 0xd2, 0x5a, 0x3a, 0x15, 0x10, 0xeb, 0xb1, 0x33, 0xe9, 0x11, 0xb7, 0x89,
-		0xd2, 0xf2, 0xc6, 0x52, 0x7a, 0x14, 0x8d, 0xc3, 0x08, 0x6b, 0x42, 0x08, 0x31, 0x16, 0x02, 0x9d,
-		0x7b, 0x3c, 0x9d, 0xf6, 0x04, 0x61, 0x5c, 0xc6, 0x03, 0x80, 0x73, 0x8f, 0xa7, 0x91, 0x3c, 0x07,
-		0x71, 0xea, 0x86, 0x08, 0xc1, 0xe8, 0x62, 0xbe, 0x50, 0x5a, 0x2c, 0xaf, 0xac, 0xae, 0x2f, 0xac,
-		0x2c, 0xe7, 0x17, 0xd3, 0x92, 0x07, 0x53, 0x4a, 0xcf, 0x6e, 0x2c, 0x28, 0xa5, 0x62, 0x3a, 0xe2,
-		0x87, 0xad, 0x96, 0xf2, 0xeb, 0xa5, 0x62, 0x3a, 0x2a, 0x57, 0x60, 0xb2, 0x5d, 0x40, 0x6d, 0x3b,
-		0x84, 0x7c, 0xbe, 0x10, 0xe9, 0xe0, 0x0b, 0x94, 0x57, 0xd8, 0x17, 0xe4, 0xef, 0x44, 0x60, 0xa2,
-		0xcd, 0xa4, 0xd2, 0xb6, 0x91, 0xa7, 0x21, 0xce, 0x7c, 0x99, 0x4d, 0xb3, 0x0f, 0xb4, 0x9d, 0x9d,
-		0xa8, 0x67, 0xb7, 0x4c, 0xb5, 0x94, 0xce, 0x9f, 0x6a, 0x44, 0x3b, 0xa4, 0x1a, 0x84, 0x45, 0x8b,
-		0xc3, 0xfe, 0x54, 0x4b, 0xf0, 0x67, 0xf3, 0xe3, 0xb9, 0x7e, 0xe6, 0x47, 0x0a, 0xdb, 0xdf, 0x24,
-		0x10, 0x6f, 0x33, 0x09, 0x9c, 0x87, 0xf1, 0x16, 0x46, 0x7d, 0x07, 0xe3, 0xf7, 0x4a, 0x90, 0xe9,
-		0x64, 0x9c, 0x1e, 0x21, 0x31, 0x12, 0x08, 0x89, 0xe7, 0xc3, 0x16, 0xbc, 0xab, 0x73, 0x27, 0xb4,
-		0xf4, 0xf5, 0x67, 0x25, 0x38, 0xdc, 0x3e, 0xa5, 0x6c, 0x2b, 0xc3, 0x5b, 0x60, 0xb0, 0x81, 0x9d,
-		0x6d, 0x43, 0xa4, 0x55, 0xf7, 0xb5, 0x99, 0xac, 0x49, 0x75, 0xb8, 0xb3, 0x39, 0x95, 0x7f, 0xb6,
-		0x8f, 0x76, 0xca, 0x0b, 0x99, 0x34, 0x2d, 0x92, 0x7e, 0x30, 0x02, 0x87, 0xda, 0x32, 0x6f, 0x2b,
-		0xe8, 0x09, 0x00, 0x4d, 0x37, 0x9b, 0x0e, 0x4b, 0x9d, 0x58, 0x24, 0x4e, 0x52, 0x08, 0x0d, 0x5e,
-		0x24, 0xca, 0x36, 0x1d, 0xb7, 0x3e, 0x4a, 0xeb, 0x81, 0x81, 0x28, 0xc2, 0x93, 0x9e, 0xa0, 0x31,
-		0x2a, 0xe8, 0x54, 0x07, 0x4d, 0x5b, 0x1c, 0xf3, 0x11, 0x48, 0x57, 0xea, 0x1a, 0xd6, 0x9d, 0xb2,
-		0xed, 0x58, 0x58, 0x6d, 0x68, 0x7a, 0x8d, 0x4e, 0x35, 0x89, 0x5c, 0x7c, 0x4b, 0xad, 0xdb, 0x58,
-		0x19, 0x63, 0xd5, 0x6b, 0xa2, 0x96, 0x50, 0x50, 0x07, 0xb2, 0x7c, 0x14, 0x83, 0x01, 0x0a, 0x56,
-		0xed, 0x52, 0xc8, 0x1f, 0x4e, 0xc2, 0xb0, 0x2f, 0x01, 0x47, 0x77, 0x41, 0xea, 0x45, 0xf5, 0x8a,
-		0x5a, 0x16, 0x8b, 0x2a, 0x66, 0x89, 0x61, 0x02, 0x5b, 0xe5, 0x0b, 0xab, 0x47, 0x60, 0x92, 0xa2,
-		0x18, 0x4d, 0x07, 0x5b, 0xe5, 0x4a, 0x5d, 0xb5, 0x6d, 0x6a, 0xb4, 0x04, 0x45, 0x45, 0xa4, 0x6e,
-		0x85, 0x54, 0xcd, 0x89, 0x1a, 0x74, 0x16, 0x26, 0x28, 0x45, 0xa3, 0x59, 0x77, 0x34, 0xb3, 0x8e,
-		0xcb, 0x64, 0x99, 0x67, 0xd3, 0x29, 0xc7, 0x95, 0x6c, 0x9c, 0x60, 0x2c, 0x71, 0x04, 0x22, 0x91,
-		0x8d, 0x8a, 0x70, 0x82, 0x92, 0xd5, 0xb0, 0x8e, 0x2d, 0xd5, 0xc1, 0x65, 0xfc, 0x52, 0x53, 0xad,
-		0xdb, 0x65, 0x55, 0xaf, 0x96, 0xb7, 0x55, 0x7b, 0x3b, 0x33, 0x49, 0x18, 0x14, 0x22, 0x19, 0x49,
-		0x39, 0x4a, 0x10, 0xe7, 0x39, 0x5e, 0x89, 0xa2, 0xe5, 0xf5, 0xea, 0x45, 0xd5, 0xde, 0x46, 0x39,
-		0x38, 0x4c, 0xb9, 0xd8, 0x8e, 0xa5, 0xe9, 0xb5, 0x72, 0x65, 0x1b, 0x57, 0x76, 0xca, 0x4d, 0x67,
-		0xeb, 0xc9, 0xcc, 0x31, 0x7f, 0xfb, 0x54, 0xc2, 0x35, 0x8a, 0x33, 0x47, 0x50, 0x36, 0x9c, 0xad,
-		0x27, 0xd1, 0x1a, 0xa4, 0x48, 0x67, 0x34, 0xb4, 0x6b, 0xb8, 0xbc, 0x65, 0x58, 0x74, 0x0e, 0x1d,
-		0x6d, 0x13, 0x9a, 0x7c, 0x16, 0x9c, 0x5d, 0xe1, 0x04, 0x4b, 0x46, 0x15, 0xe7, 0xe2, 0x6b, 0xab,
-		0xa5, 0x52, 0x51, 0x19, 0x16, 0x5c, 0x2e, 0x18, 0x16, 0x71, 0xa8, 0x9a, 0xe1, 0x1a, 0x78, 0x98,
-		0x39, 0x54, 0xcd, 0x10, 0xe6, 0x3d, 0x0b, 0x13, 0x95, 0x0a, 0xd3, 0x59, 0xab, 0x94, 0xf9, 0x62,
-		0xcc, 0xce, 0xa4, 0x03, 0xc6, 0xaa, 0x54, 0xe6, 0x19, 0x02, 0xf7, 0x71, 0x1b, 0x3d, 0x05, 0x87,
-		0x3c, 0x63, 0xf9, 0x09, 0xc7, 0x5b, 0xb4, 0x0c, 0x93, 0x9e, 0x85, 0x09, 0x73, 0xaf, 0x95, 0x10,
-		0x05, 0x5a, 0x34, 0xf7, 0xc2, 0x64, 0x4f, 0xc0, 0xa4, 0xb9, 0x6d, 0xb6, 0xd2, 0x9d, 0xf2, 0xd3,
-		0x21, 0x73, 0xdb, 0x0c, 0x13, 0xde, 0x4b, 0x57, 0xe6, 0x16, 0xae, 0xa8, 0x0e, 0xae, 0x66, 0x8e,
-		0xf8, 0xd1, 0x7d, 0x15, 0x68, 0x16, 0xd2, 0x95, 0x4a, 0x19, 0xeb, 0xea, 0x66, 0x1d, 0x97, 0x55,
-		0x0b, 0xeb, 0xaa, 0x9d, 0x99, 0xa6, 0xc8, 0x31, 0xc7, 0x6a, 0x62, 0x65, 0xb4, 0x52, 0x29, 0xd1,
-		0xca, 0x3c, 0xad, 0x43, 0xa7, 0x60, 0xdc, 0xd8, 0x7c, 0xb1, 0xc2, 0x3c, 0xb2, 0x6c, 0x5a, 0x78,
-		0x4b, 0xdb, 0xcd, 0xdc, 0x43, 0xcd, 0x3b, 0x46, 0x2a, 0xa8, 0x3f, 0xae, 0x52, 0x30, 0x7a, 0x00,
-		0xd2, 0x15, 0x7b, 0x5b, 0xb5, 0x4c, 0x1a, 0x92, 0x6d, 0x53, 0xad, 0xe0, 0xcc, 0xbd, 0x0c, 0x95,
-		0xc1, 0x97, 0x05, 0x98, 0x8c, 0x08, 0xfb, 0xaa, 0xb6, 0xe5, 0x08, 0x8e, 0xf7, 0xb3, 0x11, 0x41,
-		0x61, 0x9c, 0xdb, 0x49, 0x48, 0x13, 0x4b, 0x04, 0x1a, 0x3e, 0x49, 0xd1, 0x46, 0xcd, 0x6d, 0xd3,
-		0xdf, 0xee, 0xdd, 0x30, 0x42, 0x30, 0xbd, 0x46, 0x1f, 0x60, 0x89, 0x9b, 0xb9, 0xed, 0x6b, 0xf1,
-		0x71, 0x38, 0x4c, 0x90, 0x1a, 0xd8, 0x51, 0xab, 0xaa, 0xa3, 0xfa, 0xb0, 0x1f, 0xa2, 0xd8, 0xc4,
-		0xec, 0x4b, 0xbc, 0x32, 0x20, 0xa7, 0xd5, 0xdc, 0xdc, 0x73, 0x1d, 0xeb, 0x61, 0x26, 0x27, 0x81,
-		0x09, 0xd7, 0xba, 0x63, 0xc9, 0xb9, 0x9c, 0x83, 0x94, 0xdf, 0xef, 0x51, 0x12, 0x98, 0xe7, 0xa7,
-		0x25, 0x92, 0x04, 0xcd, 0xad, 0x14, 0x49, 0xfa, 0xf2, 0x42, 0x29, 0x1d, 0x21, 0x69, 0xd4, 0xe2,
-		0xc2, 0x7a, 0xa9, 0xac, 0x6c, 0x2c, 0xaf, 0x2f, 0x2c, 0x95, 0xd2, 0x51, 0x5f, 0x62, 0xff, 0x4c,
-		0x2c, 0x71, 0x5f, 0xfa, 0x7e, 0xf9, 0x5b, 0x11, 0x18, 0x0d, 0xae, 0xd4, 0xd0, 0x9b, 0xe0, 0x88,
-		0xd8, 0x56, 0xb1, 0xb1, 0x53, 0xbe, 0xaa, 0x59, 0x74, 0x40, 0x36, 0x54, 0x36, 0x39, 0xba, 0xfe,
-		0x33, 0xc9, 0xb1, 0xd6, 0xb0, 0xf3, 0x9c, 0x66, 0x91, 0xe1, 0xd6, 0x50, 0x1d, 0xb4, 0x08, 0xd3,
-		0xba, 0x51, 0xb6, 0x1d, 0x55, 0xaf, 0xaa, 0x56, 0xb5, 0xec, 0x6d, 0x68, 0x95, 0xd5, 0x4a, 0x05,
-		0xdb, 0xb6, 0xc1, 0x26, 0x42, 0x97, 0xcb, 0x71, 0xdd, 0x58, 0xe3, 0xc8, 0xde, 0x0c, 0x91, 0xe7,
-		0xa8, 0x21, 0xf7, 0x8d, 0x76, 0x72, 0xdf, 0x63, 0x90, 0x6c, 0xa8, 0x66, 0x19, 0xeb, 0x8e, 0xb5,
-		0x47, 0xf3, 0xf3, 0x84, 0x92, 0x68, 0xa8, 0x66, 0x89, 0x94, 0x7f, 0x2c, 0xcb, 0xa4, 0x67, 0x62,
-		0x89, 0x44, 0x3a, 0xf9, 0x4c, 0x2c, 0x91, 0x4c, 0x83, 0xfc, 0x6a, 0x14, 0x52, 0xfe, 0x7c, 0x9d,
-		0x2c, 0x7f, 0x2a, 0x74, 0xc6, 0x92, 0x68, 0x4c, 0xbb, 0xbb, 0x6b, 0x76, 0x3f, 0x3b, 0x47, 0xa6,
-		0xb2, 0xdc, 0x20, 0x4b, 0x8e, 0x15, 0x46, 0x49, 0xd2, 0x08, 0xe2, 0x6c, 0x98, 0x25, 0x23, 0x09,
-		0x85, 0x97, 0xd0, 0x3c, 0x0c, 0xbe, 0x68, 0x53, 0xde, 0x83, 0x94, 0xf7, 0x3d, 0xdd, 0x79, 0x3f,
-		0xb3, 0x46, 0x99, 0x27, 0x9f, 0x59, 0x2b, 0x2f, 0xaf, 0x28, 0x4b, 0xf9, 0x45, 0x85, 0x93, 0xa3,
-		0xa3, 0x10, 0xab, 0xab, 0xd7, 0xf6, 0x82, 0x93, 0x1e, 0x05, 0xf5, 0xdb, 0x09, 0x47, 0x21, 0x76,
-		0x15, 0xab, 0x3b, 0xc1, 0xa9, 0x86, 0x82, 0xee, 0xe0, 0x60, 0x38, 0x0d, 0x71, 0x6a, 0x2f, 0x04,
-		0xc0, 0x2d, 0x96, 0x1e, 0x40, 0x09, 0x88, 0xcd, 0xad, 0x28, 0x64, 0x40, 0xa4, 0x21, 0xc5, 0xa0,
-		0xe5, 0xd5, 0x85, 0xd2, 0x5c, 0x29, 0x1d, 0x91, 0xcf, 0xc2, 0x20, 0x33, 0x02, 0x19, 0x2c, 0xae,
-		0x19, 0xd2, 0x03, 0xbc, 0xc8, 0x79, 0x48, 0xa2, 0x76, 0x63, 0xa9, 0x50, 0x52, 0xd2, 0x91, 0x60,
-		0x57, 0xc7, 0xd2, 0x71, 0xd9, 0x86, 0x94, 0x3f, 0x0f, 0xff, 0xf1, 0x2c, 0xc6, 0xbf, 0x22, 0xc1,
-		0xb0, 0x2f, 0xaf, 0x26, 0x09, 0x91, 0x5a, 0xaf, 0x1b, 0x57, 0xcb, 0x6a, 0x5d, 0x53, 0x6d, 0xee,
-		0x1a, 0x40, 0x41, 0x79, 0x02, 0xe9, 0xb7, 0xeb, 0x7e, 0x4c, 0x43, 0x24, 0x9e, 0x1e, 0x94, 0x3f,
-		0x29, 0x41, 0x3a, 0x9c, 0xd8, 0x86, 0xc4, 0x94, 0xde, 0x48, 0x31, 0xe5, 0x4f, 0x48, 0x30, 0x1a,
-		0xcc, 0x66, 0x43, 0xe2, 0xdd, 0xf5, 0x86, 0x8a, 0xf7, 0xfb, 0x11, 0x18, 0x09, 0xe4, 0xb0, 0xfd,
-		0x4a, 0xf7, 0x12, 0x8c, 0x6b, 0x55, 0xdc, 0x30, 0x0d, 0x07, 0xeb, 0x95, 0xbd, 0x72, 0x1d, 0x5f,
-		0xc1, 0xf5, 0x8c, 0x4c, 0x83, 0xc6, 0xe9, 0xee, 0x59, 0xf2, 0xec, 0x82, 0x47, 0xb7, 0x48, 0xc8,
-		0x72, 0x13, 0x0b, 0xc5, 0xd2, 0xd2, 0xea, 0xca, 0x7a, 0x69, 0x79, 0xee, 0x6d, 0xe5, 0x8d, 0xe5,
-		0x4b, 0xcb, 0x2b, 0xcf, 0x2d, 0x2b, 0x69, 0x2d, 0x84, 0x76, 0x07, 0x87, 0xfd, 0x2a, 0xa4, 0xc3,
+		0x7b, 0x61, 0xec, 0x2a, 0x56, 0x77, 0xfc, 0xa8, 0xc3, 0x14, 0x75, 0x94, 0x80, 0x7d, 0x88, 0x73,
+		0x90, 0x6a, 0x60, 0xdb, 0x56, 0x6b, 0xb8, 0xec, 0xec, 0x99, 0x38, 0x13, 0xa3, 0xbd, 0x9f, 0x69,
+		0xe9, 0x7d, 0xb8, 0xe7, 0xc3, 0x9c, 0x6a, 0x7d, 0xcf, 0xc4, 0x28, 0x0f, 0x49, 0xac, 0x37, 0x1b,
+		0x8c, 0x43, 0xbc, 0x83, 0xfe, 0x4a, 0x7a, 0xb3, 0x11, 0xe6, 0x92, 0x20, 0x64, 0x9c, 0xc5, 0x90,
+		0x8d, 0xad, 0x2b, 0x5a, 0x05, 0x67, 0x06, 0x29, 0x83, 0x7b, 0x5b, 0x18, 0xac, 0xb1, 0xfa, 0x30,
+		0x0f, 0x41, 0x87, 0xe6, 0x20, 0x89, 0x77, 0x1d, 0xac, 0xdb, 0x9a, 0xa1, 0x67, 0x86, 0x28, 0x93,
+		0xbb, 0xdb, 0x8c, 0x22, 0xae, 0x57, 0xc3, 0x2c, 0x3c, 0x3a, 0x74, 0x0e, 0x86, 0x0c, 0xd3, 0xd1,
+		0x0c, 0xdd, 0xce, 0x24, 0x66, 0xa4, 0x93, 0xc3, 0x67, 0x8e, 0xb7, 0x35, 0x84, 0x15, 0x86, 0xa3,
+		0x08, 0x64, 0xb4, 0x00, 0x69, 0xdb, 0x68, 0x5a, 0x15, 0x5c, 0xae, 0x18, 0x55, 0x5c, 0xd6, 0xf4,
+		0x2d, 0x23, 0x93, 0xa4, 0x0c, 0xa6, 0x5b, 0x3b, 0x42, 0x11, 0xe7, 0x8c, 0x2a, 0x5e, 0xd0, 0xb7,
+		0x0c, 0x65, 0xd4, 0x0e, 0x94, 0xd1, 0x61, 0x18, 0xb4, 0xf7, 0x74, 0x47, 0xdd, 0xcd, 0xa4, 0xa8,
+		0x85, 0xf0, 0x92, 0xfc, 0x9b, 0x83, 0x30, 0xd6, 0x8f, 0x89, 0x9d, 0x87, 0xf8, 0x16, 0xe9, 0x65,
+		0x26, 0xb2, 0x1f, 0x1d, 0x30, 0x9a, 0xa0, 0x12, 0x07, 0x0f, 0xa8, 0xc4, 0x3c, 0x0c, 0xeb, 0xd8,
+		0x76, 0x70, 0x95, 0x59, 0x44, 0xb4, 0x4f, 0x9b, 0x02, 0x46, 0xd4, 0x6a, 0x52, 0xb1, 0x03, 0x99,
+		0xd4, 0xb3, 0x30, 0xe6, 0x8a, 0x54, 0xb6, 0x54, 0xbd, 0x26, 0x6c, 0xf3, 0x74, 0x2f, 0x49, 0x66,
+		0x4b, 0x82, 0x4e, 0x21, 0x64, 0xca, 0x28, 0x0e, 0x94, 0x51, 0x11, 0xc0, 0xd0, 0xb1, 0xb1, 0x55,
+		0xae, 0xe2, 0x4a, 0x3d, 0x93, 0xe8, 0xa0, 0xa5, 0x15, 0x82, 0xd2, 0xa2, 0x25, 0x83, 0x41, 0x2b,
+		0x75, 0xf4, 0x84, 0x67, 0x6a, 0x43, 0x1d, 0x2c, 0x65, 0x89, 0x39, 0x59, 0x8b, 0xb5, 0x6d, 0xc0,
+		0xa8, 0x85, 0x89, 0xdd, 0xe3, 0x2a, 0xef, 0x59, 0x92, 0x0a, 0x31, 0xdb, 0xb3, 0x67, 0x0a, 0x27,
+		0x63, 0x1d, 0x1b, 0xb1, 0xfc, 0x45, 0x74, 0x27, 0xb8, 0x80, 0x32, 0x35, 0x2b, 0xa0, 0x51, 0x28,
+		0x25, 0x80, 0xcb, 0x6a, 0x03, 0x67, 0x5f, 0x84, 0xd1, 0xa0, 0x7a, 0xd0, 0x24, 0xc4, 0x6d, 0x47,
+		0xb5, 0x1c, 0x6a, 0x85, 0x71, 0x85, 0x15, 0x50, 0x1a, 0xa2, 0x58, 0xaf, 0xd2, 0x28, 0x17, 0x57,
+		0xc8, 0x4f, 0xf4, 0x56, 0xaf, 0xc3, 0x51, 0xda, 0xe1, 0x7b, 0x5a, 0x47, 0x34, 0xc0, 0x39, 0xdc,
+		0xef, 0xec, 0x63, 0x30, 0x12, 0xe8, 0x40, 0xbf, 0x4d, 0xcb, 0xef, 0x82, 0x43, 0x6d, 0x59, 0xa3,
+		0x67, 0x61, 0xb2, 0xa9, 0x6b, 0xba, 0x83, 0x2d, 0xd3, 0xc2, 0xc4, 0x62, 0x59, 0x53, 0x99, 0xff,
+		0x3c, 0xd4, 0xc1, 0xe6, 0x36, 0xfc, 0xd8, 0x8c, 0x8b, 0x32, 0xd1, 0x6c, 0x05, 0x9e, 0x4a, 0x26,
+		0x5e, 0x1b, 0x4a, 0xbf, 0xf4, 0xd2, 0x4b, 0x2f, 0x45, 0xe4, 0xaf, 0x0d, 0xc2, 0x64, 0x3b, 0x9f,
+		0x69, 0xeb, 0xbe, 0x87, 0x61, 0x50, 0x6f, 0x36, 0x36, 0xb1, 0x45, 0x95, 0x14, 0x57, 0x78, 0x09,
+		0xe5, 0x21, 0x5e, 0x57, 0x37, 0x71, 0x3d, 0x13, 0x9b, 0x91, 0x4e, 0x8e, 0x9e, 0xb9, 0xbf, 0x2f,
+		0xaf, 0x9c, 0x5d, 0x24, 0x24, 0x0a, 0xa3, 0x44, 0x6f, 0x81, 0x18, 0x0f, 0xd1, 0x84, 0xc3, 0xa9,
+		0xfe, 0x38, 0x10, 0x5f, 0x52, 0x28, 0x1d, 0x3a, 0x06, 0x49, 0xf2, 0x97, 0xd9, 0xc6, 0x20, 0x95,
+		0x39, 0x41, 0x00, 0xc4, 0x2e, 0x50, 0x16, 0x12, 0xd4, 0x4d, 0xaa, 0x58, 0x4c, 0x6d, 0x6e, 0x99,
+		0x18, 0x56, 0x15, 0x6f, 0xa9, 0xcd, 0xba, 0x53, 0xbe, 0xa2, 0xd6, 0x9b, 0x98, 0x1a, 0x7c, 0x52,
+		0x49, 0x71, 0xe0, 0x65, 0x02, 0x43, 0xd3, 0x30, 0xcc, 0xbc, 0x4a, 0xd3, 0xab, 0x78, 0x97, 0x46,
+		0xcf, 0xb8, 0xc2, 0x1c, 0x6d, 0x81, 0x40, 0x48, 0xf3, 0xcf, 0xdb, 0x86, 0x2e, 0x4c, 0x93, 0x36,
+		0x41, 0x00, 0xb4, 0xf9, 0xc7, 0xc2, 0x81, 0xfb, 0x44, 0xfb, 0xee, 0xb5, 0xf8, 0xd2, 0xbd, 0x30,
+		0x46, 0x31, 0x1e, 0xe1, 0x43, 0xaf, 0xd6, 0x33, 0xe3, 0x33, 0xd2, 0xc9, 0x84, 0x32, 0xca, 0xc0,
+		0x2b, 0x1c, 0x2a, 0x7f, 0x25, 0x02, 0x31, 0x1a, 0x58, 0xc6, 0x60, 0x78, 0xfd, 0x6d, 0xab, 0xa5,
+		0x72, 0x71, 0x65, 0xa3, 0xb0, 0x58, 0x4a, 0x4b, 0x68, 0x14, 0x80, 0x02, 0x2e, 0x2c, 0xae, 0xe4,
+		0xd7, 0xd3, 0x11, 0xb7, 0xbc, 0xb0, 0xbc, 0x7e, 0xee, 0xd1, 0x74, 0xd4, 0x25, 0xd8, 0x60, 0x80,
+		0x98, 0x1f, 0xe1, 0x91, 0x33, 0xe9, 0x38, 0x4a, 0x43, 0x8a, 0x31, 0x58, 0x78, 0xb6, 0x54, 0x3c,
+		0xf7, 0x68, 0x7a, 0x30, 0x08, 0x79, 0xe4, 0x4c, 0x7a, 0x08, 0x8d, 0x40, 0x92, 0x42, 0x0a, 0x2b,
+		0x2b, 0x8b, 0xe9, 0x84, 0xcb, 0x73, 0x6d, 0x5d, 0x59, 0x58, 0x9e, 0x4f, 0x27, 0x5d, 0x9e, 0xf3,
+		0xca, 0xca, 0xc6, 0x6a, 0x1a, 0x5c, 0x0e, 0x4b, 0xa5, 0xb5, 0xb5, 0xfc, 0x7c, 0x29, 0x3d, 0xec,
+		0x62, 0x14, 0xde, 0xb6, 0x5e, 0x5a, 0x4b, 0xa7, 0x02, 0x62, 0x3d, 0x72, 0x26, 0x3d, 0xe2, 0x36,
+		0x51, 0x5a, 0xde, 0x58, 0x4a, 0x8f, 0xa2, 0x71, 0x18, 0x61, 0x4d, 0x08, 0x21, 0xc6, 0x42, 0xa0,
+		0x73, 0x8f, 0xa6, 0xd3, 0x9e, 0x20, 0x8c, 0xcb, 0x78, 0x00, 0x70, 0xee, 0xd1, 0x34, 0x92, 0xe7,
+		0x20, 0x4e, 0xcd, 0x10, 0x21, 0x18, 0x5d, 0xcc, 0x17, 0x4a, 0x8b, 0xe5, 0x95, 0xd5, 0xf5, 0x85,
+		0x95, 0xe5, 0xfc, 0x62, 0x5a, 0xf2, 0x60, 0x4a, 0xe9, 0xe9, 0x8d, 0x05, 0xa5, 0x54, 0x4c, 0x47,
+		0xfc, 0xb0, 0xd5, 0x52, 0x7e, 0xbd, 0x54, 0x4c, 0x47, 0xe5, 0x0a, 0x4c, 0xb6, 0x0b, 0xa8, 0x6d,
+		0x5d, 0xc8, 0x67, 0x0b, 0x91, 0x0e, 0xb6, 0x40, 0x79, 0x85, 0x6d, 0x41, 0xfe, 0x6e, 0x04, 0x26,
+		0xda, 0x4c, 0x2a, 0x6d, 0x1b, 0x79, 0x12, 0xe2, 0xcc, 0x96, 0xd9, 0x34, 0x7b, 0x5f, 0xdb, 0xd9,
+		0x89, 0x5a, 0x76, 0xcb, 0x54, 0x4b, 0xe9, 0xfc, 0xa9, 0x46, 0xb4, 0x43, 0xaa, 0x41, 0x58, 0xb4,
+		0x18, 0xec, 0xcf, 0xb5, 0x04, 0x7f, 0x36, 0x3f, 0x9e, 0xeb, 0x67, 0x7e, 0xa4, 0xb0, 0xfd, 0x4d,
+		0x02, 0xf1, 0x36, 0x93, 0xc0, 0x79, 0x18, 0x6f, 0x61, 0xd4, 0x77, 0x30, 0x7e, 0x9f, 0x04, 0x99,
+		0x4e, 0xca, 0xe9, 0x11, 0x12, 0x23, 0x81, 0x90, 0x78, 0x3e, 0xac, 0xc1, 0x3b, 0x3a, 0x0f, 0x42,
+		0xcb, 0x58, 0x7f, 0x56, 0x82, 0xc3, 0xed, 0x53, 0xca, 0xb6, 0x32, 0xbc, 0x05, 0x06, 0x1b, 0xd8,
+		0xd9, 0x36, 0x44, 0x5a, 0x75, 0x4f, 0x9b, 0xc9, 0x9a, 0x54, 0x87, 0x07, 0x9b, 0x53, 0xf9, 0x67,
+		0xfb, 0x68, 0xa7, 0xbc, 0x90, 0x49, 0xd3, 0x22, 0xe9, 0x87, 0x22, 0x70, 0xa8, 0x2d, 0xf3, 0xb6,
+		0x82, 0x9e, 0x00, 0xd0, 0x74, 0xb3, 0xe9, 0xb0, 0xd4, 0x89, 0x45, 0xe2, 0x24, 0x85, 0xd0, 0xe0,
+		0x45, 0xa2, 0x6c, 0xd3, 0x71, 0xeb, 0xa3, 0xb4, 0x1e, 0x18, 0x88, 0x22, 0x3c, 0xee, 0x09, 0x1a,
+		0xa3, 0x82, 0x4e, 0x75, 0xe8, 0x69, 0x8b, 0x61, 0x3e, 0x04, 0xe9, 0x4a, 0x5d, 0xc3, 0xba, 0x53,
+		0xb6, 0x1d, 0x0b, 0xab, 0x0d, 0x4d, 0xaf, 0xd1, 0xa9, 0x26, 0x91, 0x8b, 0x6f, 0xa9, 0x75, 0x1b,
+		0x2b, 0x63, 0xac, 0x7a, 0x4d, 0xd4, 0x12, 0x0a, 0x6a, 0x40, 0x96, 0x8f, 0x62, 0x30, 0x40, 0xc1,
+		0xaa, 0x5d, 0x0a, 0xf9, 0x23, 0x49, 0x18, 0xf6, 0x25, 0xe0, 0xe8, 0x0e, 0x48, 0x3d, 0xaf, 0x5e,
+		0x51, 0xcb, 0x62, 0x51, 0xc5, 0x34, 0x31, 0x4c, 0x60, 0xab, 0x7c, 0x61, 0xf5, 0x10, 0x4c, 0x52,
+		0x14, 0xa3, 0xe9, 0x60, 0xab, 0x5c, 0xa9, 0xab, 0xb6, 0x4d, 0x95, 0x96, 0xa0, 0xa8, 0x88, 0xd4,
+		0xad, 0x90, 0xaa, 0x39, 0x51, 0x83, 0xce, 0xc2, 0x04, 0xa5, 0x68, 0x34, 0xeb, 0x8e, 0x66, 0xd6,
+		0x71, 0x99, 0x2c, 0xf3, 0x6c, 0x3a, 0xe5, 0xb8, 0x92, 0x8d, 0x13, 0x8c, 0x25, 0x8e, 0x40, 0x24,
+		0xb2, 0x51, 0x11, 0x4e, 0x50, 0xb2, 0x1a, 0xd6, 0xb1, 0xa5, 0x3a, 0xb8, 0x8c, 0x5f, 0x68, 0xaa,
+		0x75, 0xbb, 0xac, 0xea, 0xd5, 0xf2, 0xb6, 0x6a, 0x6f, 0x67, 0x26, 0x09, 0x83, 0x42, 0x24, 0x23,
+		0x29, 0x47, 0x09, 0xe2, 0x3c, 0xc7, 0x2b, 0x51, 0xb4, 0xbc, 0x5e, 0xbd, 0xa8, 0xda, 0xdb, 0x28,
+		0x07, 0x87, 0x29, 0x17, 0xdb, 0xb1, 0x34, 0xbd, 0x56, 0xae, 0x6c, 0xe3, 0xca, 0x4e, 0xb9, 0xe9,
+		0x6c, 0x3d, 0x9e, 0x39, 0xe6, 0x6f, 0x9f, 0x4a, 0xb8, 0x46, 0x71, 0xe6, 0x08, 0xca, 0x86, 0xb3,
+		0xf5, 0x38, 0x5a, 0x83, 0x14, 0x19, 0x8c, 0x86, 0xf6, 0x22, 0x2e, 0x6f, 0x19, 0x16, 0x9d, 0x43,
+		0x47, 0xdb, 0x84, 0x26, 0x9f, 0x06, 0x67, 0x57, 0x38, 0xc1, 0x92, 0x51, 0xc5, 0xb9, 0xf8, 0xda,
+		0x6a, 0xa9, 0x54, 0x54, 0x86, 0x05, 0x97, 0x0b, 0x86, 0x45, 0x0c, 0xaa, 0x66, 0xb8, 0x0a, 0x1e,
+		0x66, 0x06, 0x55, 0x33, 0x84, 0x7a, 0xcf, 0xc2, 0x44, 0xa5, 0xc2, 0xfa, 0xac, 0x55, 0xca, 0x7c,
+		0x31, 0x66, 0x67, 0xd2, 0x01, 0x65, 0x55, 0x2a, 0xf3, 0x0c, 0x81, 0xdb, 0xb8, 0x8d, 0x9e, 0x80,
+		0x43, 0x9e, 0xb2, 0xfc, 0x84, 0xe3, 0x2d, 0xbd, 0x0c, 0x93, 0x9e, 0x85, 0x09, 0x73, 0xaf, 0x95,
+		0x10, 0x05, 0x5a, 0x34, 0xf7, 0xc2, 0x64, 0x8f, 0xc1, 0xa4, 0xb9, 0x6d, 0xb6, 0xd2, 0x9d, 0xf2,
+		0xd3, 0x21, 0x73, 0xdb, 0x0c, 0x13, 0xde, 0x4d, 0x57, 0xe6, 0x16, 0xae, 0xa8, 0x0e, 0xae, 0x66,
+		0x8e, 0xf8, 0xd1, 0x7d, 0x15, 0x68, 0x16, 0xd2, 0x95, 0x4a, 0x19, 0xeb, 0xea, 0x66, 0x1d, 0x97,
+		0x55, 0x0b, 0xeb, 0xaa, 0x9d, 0x99, 0xa6, 0xc8, 0x31, 0xc7, 0x6a, 0x62, 0x65, 0xb4, 0x52, 0x29,
+		0xd1, 0xca, 0x3c, 0xad, 0x43, 0xa7, 0x60, 0xdc, 0xd8, 0x7c, 0xbe, 0xc2, 0x2c, 0xb2, 0x6c, 0x5a,
+		0x78, 0x4b, 0xdb, 0xcd, 0xdc, 0x45, 0xd5, 0x3b, 0x46, 0x2a, 0xa8, 0x3d, 0xae, 0x52, 0x30, 0xba,
+		0x0f, 0xd2, 0x15, 0x7b, 0x5b, 0xb5, 0x4c, 0x1a, 0x92, 0x6d, 0x53, 0xad, 0xe0, 0xcc, 0xdd, 0x0c,
+		0x95, 0xc1, 0x97, 0x05, 0x98, 0x78, 0x84, 0x7d, 0x55, 0xdb, 0x72, 0x04, 0xc7, 0x7b, 0x99, 0x47,
+		0x50, 0x18, 0xe7, 0x76, 0x12, 0xd2, 0x44, 0x13, 0x81, 0x86, 0x4f, 0x52, 0xb4, 0x51, 0x73, 0xdb,
+		0xf4, 0xb7, 0x7b, 0x27, 0x8c, 0x10, 0x4c, 0xaf, 0xd1, 0xfb, 0x58, 0xe2, 0x66, 0x6e, 0xfb, 0x5a,
+		0x7c, 0x14, 0x0e, 0x13, 0xa4, 0x06, 0x76, 0xd4, 0xaa, 0xea, 0xa8, 0x3e, 0xec, 0x07, 0x28, 0x36,
+		0x51, 0xfb, 0x12, 0xaf, 0x0c, 0xc8, 0x69, 0x35, 0x37, 0xf7, 0x5c, 0xc3, 0x7a, 0x90, 0xc9, 0x49,
+		0x60, 0xc2, 0xb4, 0x6e, 0x5b, 0x72, 0x2e, 0xe7, 0x20, 0xe5, 0xb7, 0x7b, 0x94, 0x04, 0x66, 0xf9,
+		0x69, 0x89, 0x24, 0x41, 0x73, 0x2b, 0x45, 0x92, 0xbe, 0x3c, 0x57, 0x4a, 0x47, 0x48, 0x1a, 0xb5,
+		0xb8, 0xb0, 0x5e, 0x2a, 0x2b, 0x1b, 0xcb, 0xeb, 0x0b, 0x4b, 0xa5, 0x74, 0xd4, 0x97, 0xd8, 0x3f,
+		0x15, 0x4b, 0xdc, 0x93, 0xbe, 0x57, 0xfe, 0x76, 0x04, 0x46, 0x83, 0x2b, 0x35, 0xf4, 0x26, 0x38,
+		0x22, 0xb6, 0x55, 0x6c, 0xec, 0x94, 0xaf, 0x6a, 0x16, 0x75, 0xc8, 0x86, 0xca, 0x26, 0x47, 0xd7,
+		0x7e, 0x26, 0x39, 0xd6, 0x1a, 0x76, 0x9e, 0xd1, 0x2c, 0xe2, 0x6e, 0x0d, 0xd5, 0x41, 0x8b, 0x30,
+		0xad, 0x1b, 0x65, 0xdb, 0x51, 0xf5, 0xaa, 0x6a, 0x55, 0xcb, 0xde, 0x86, 0x56, 0x59, 0xad, 0x54,
+		0xb0, 0x6d, 0x1b, 0x6c, 0x22, 0x74, 0xb9, 0x1c, 0xd7, 0x8d, 0x35, 0x8e, 0xec, 0xcd, 0x10, 0x79,
+		0x8e, 0x1a, 0x32, 0xdf, 0x68, 0x27, 0xf3, 0x3d, 0x06, 0xc9, 0x86, 0x6a, 0x96, 0xb1, 0xee, 0x58,
+		0x7b, 0x34, 0x3f, 0x4f, 0x28, 0x89, 0x86, 0x6a, 0x96, 0x48, 0xf9, 0xa7, 0xb2, 0x4c, 0x7a, 0x2a,
+		0x96, 0x48, 0xa4, 0x93, 0x4f, 0xc5, 0x12, 0xc9, 0x34, 0xc8, 0xaf, 0x46, 0x21, 0xe5, 0xcf, 0xd7,
+		0xc9, 0xf2, 0xa7, 0x42, 0x67, 0x2c, 0x89, 0xc6, 0xb4, 0x3b, 0xbb, 0x66, 0xf7, 0xb3, 0x73, 0x64,
+		0x2a, 0xcb, 0x0d, 0xb2, 0xe4, 0x58, 0x61, 0x94, 0x24, 0x8d, 0x20, 0xc6, 0x86, 0x59, 0x32, 0x92,
+		0x50, 0x78, 0x09, 0xcd, 0xc3, 0xe0, 0xf3, 0x36, 0xe5, 0x3d, 0x48, 0x79, 0xdf, 0xd5, 0x9d, 0xf7,
+		0x53, 0x6b, 0x94, 0x79, 0xf2, 0xa9, 0xb5, 0xf2, 0xf2, 0x8a, 0xb2, 0x94, 0x5f, 0x54, 0x38, 0x39,
+		0x3a, 0x0a, 0xb1, 0xba, 0xfa, 0xe2, 0x5e, 0x70, 0xd2, 0xa3, 0xa0, 0x7e, 0x07, 0xe1, 0x28, 0xc4,
+		0xae, 0x62, 0x75, 0x27, 0x38, 0xd5, 0x50, 0xd0, 0x6d, 0x74, 0x86, 0xd3, 0x10, 0xa7, 0xfa, 0x42,
+		0x00, 0x5c, 0x63, 0xe9, 0x01, 0x94, 0x80, 0xd8, 0xdc, 0x8a, 0x42, 0x1c, 0x22, 0x0d, 0x29, 0x06,
+		0x2d, 0xaf, 0x2e, 0x94, 0xe6, 0x4a, 0xe9, 0x88, 0x7c, 0x16, 0x06, 0x99, 0x12, 0x88, 0xb3, 0xb8,
+		0x6a, 0x48, 0x0f, 0xf0, 0x22, 0xe7, 0x21, 0x89, 0xda, 0x8d, 0xa5, 0x42, 0x49, 0x49, 0x47, 0x82,
+		0x43, 0x1d, 0x4b, 0xc7, 0x65, 0x1b, 0x52, 0xfe, 0x3c, 0xfc, 0xa7, 0xb3, 0x18, 0xff, 0xaa, 0x04,
+		0xc3, 0xbe, 0xbc, 0x9a, 0x24, 0x44, 0x6a, 0xbd, 0x6e, 0x5c, 0x2d, 0xab, 0x75, 0x4d, 0xb5, 0xb9,
+		0x69, 0x00, 0x05, 0xe5, 0x09, 0xa4, 0xdf, 0xa1, 0xfb, 0x29, 0xb9, 0x48, 0x3c, 0x3d, 0x28, 0x7f,
+		0x4a, 0x82, 0x74, 0x38, 0xb1, 0x0d, 0x89, 0x29, 0xbd, 0x91, 0x62, 0xca, 0x9f, 0x94, 0x60, 0x34,
+		0x98, 0xcd, 0x86, 0xc4, 0xbb, 0xe3, 0x0d, 0x15, 0xef, 0x8f, 0x22, 0x30, 0x12, 0xc8, 0x61, 0xfb,
+		0x95, 0xee, 0x05, 0x18, 0xd7, 0xaa, 0xb8, 0x61, 0x1a, 0x0e, 0xd6, 0x2b, 0x7b, 0xe5, 0x3a, 0xbe,
+		0x82, 0xeb, 0x19, 0x99, 0x06, 0x8d, 0xd3, 0xdd, 0xb3, 0xe4, 0xd9, 0x05, 0x8f, 0x6e, 0x91, 0x90,
+		0xe5, 0x26, 0x16, 0x8a, 0xa5, 0xa5, 0xd5, 0x95, 0xf5, 0xd2, 0xf2, 0xdc, 0xdb, 0xca, 0x1b, 0xcb,
+		0x97, 0x96, 0x57, 0x9e, 0x59, 0x56, 0xd2, 0x5a, 0x08, 0xed, 0x36, 0xba, 0xfd, 0x2a, 0xa4, 0xc3,
 		0x42, 0xa1, 0x23, 0xd0, 0x4e, 0xac, 0xf4, 0x00, 0x9a, 0x80, 0xb1, 0xe5, 0x95, 0xf2, 0xda, 0x42,
-		0xb1, 0x54, 0x2e, 0x5d, 0xb8, 0x50, 0x9a, 0x5b, 0x5f, 0x63, 0xfb, 0x1e, 0x2e, 0xf6, 0x7a, 0x60,
-		0x80, 0xcb, 0xaf, 0x44, 0x61, 0xa2, 0x8d, 0x24, 0x28, 0xcf, 0x57, 0x2c, 0x6c, 0x11, 0xf5, 0x70,
-		0x3f, 0xd2, 0xcf, 0x92, 0x9c, 0x61, 0x55, 0xb5, 0x1c, 0xbe, 0xc0, 0x79, 0x00, 0x88, 0x95, 0x74,
-		0x47, 0xdb, 0xd2, 0xb0, 0xc5, 0xf7, 0x93, 0xd8, 0x32, 0x66, 0xcc, 0x83, 0xb3, 0x2d, 0xa5, 0x87,
-		0x00, 0x99, 0x86, 0xad, 0x39, 0xda, 0x15, 0x5c, 0xd6, 0x74, 0xb1, 0xf9, 0x44, 0x96, 0x35, 0x31,
-		0x25, 0x2d, 0x6a, 0x16, 0x74, 0xc7, 0xc5, 0xd6, 0x71, 0x4d, 0x0d, 0x61, 0x93, 0x60, 0x1e, 0x55,
-		0xd2, 0xa2, 0xc6, 0xc5, 0xbe, 0x0b, 0x52, 0x55, 0xa3, 0x49, 0x72, 0x3d, 0x86, 0x47, 0xe6, 0x0e,
-		0x49, 0x19, 0x66, 0x30, 0x17, 0x85, 0x67, 0xf1, 0xde, 0xae, 0x57, 0x4a, 0x19, 0x66, 0x30, 0x86,
-		0x72, 0x3f, 0x8c, 0xa9, 0xb5, 0x9a, 0x45, 0x98, 0x0b, 0x46, 0x6c, 0x5d, 0x32, 0xea, 0x82, 0x29,
-		0x62, 0xf6, 0x19, 0x48, 0x08, 0x3b, 0x90, 0xa9, 0x9a, 0x58, 0xa2, 0x6c, 0xb2, 0xc5, 0x76, 0xe4,
-		0x64, 0x52, 0x49, 0xe8, 0xa2, 0xf2, 0x2e, 0x48, 0x69, 0x76, 0xd9, 0xdb, 0xc4, 0x8f, 0xcc, 0x44,
-		0x4e, 0x26, 0x94, 0x61, 0xcd, 0x76, 0x37, 0x40, 0xe5, 0xcf, 0x46, 0x60, 0x34, 0x78, 0x08, 0x81,
-		0x8a, 0x90, 0xa8, 0x1b, 0x15, 0x95, 0xba, 0x16, 0x3b, 0x01, 0x3b, 0xd9, 0xe3, 0xdc, 0x62, 0x76,
-		0x91, 0xe3, 0x2b, 0x2e, 0x65, 0xf6, 0xb7, 0x25, 0x48, 0x08, 0x30, 0x3a, 0x0c, 0x31, 0x53, 0x75,
-		0xb6, 0x29, 0xbb, 0x78, 0x21, 0x92, 0x96, 0x14, 0x5a, 0x26, 0x70, 0xdb, 0x54, 0x75, 0xea, 0x02,
-		0x1c, 0x4e, 0xca, 0xa4, 0x5f, 0xeb, 0x58, 0xad, 0xd2, 0x45, 0x8f, 0xd1, 0x68, 0x60, 0xdd, 0xb1,
-		0x45, 0xbf, 0x72, 0xf8, 0x1c, 0x07, 0xa3, 0x07, 0x61, 0xdc, 0xb1, 0x54, 0xad, 0x1e, 0xc0, 0x8d,
-		0x51, 0xdc, 0xb4, 0xa8, 0x70, 0x91, 0x73, 0x70, 0x54, 0xf0, 0xad, 0x62, 0x47, 0xad, 0x6c, 0xe3,
-		0xaa, 0x47, 0x34, 0x48, 0x37, 0x37, 0x8e, 0x70, 0x84, 0x22, 0xaf, 0x17, 0xb4, 0xf2, 0xb7, 0x24,
-		0x18, 0x17, 0xcb, 0xb4, 0xaa, 0x6b, 0xac, 0x25, 0x00, 0x55, 0xd7, 0x0d, 0xc7, 0x6f, 0xae, 0x56,
-		0x57, 0x6e, 0xa1, 0x9b, 0xcd, 0xbb, 0x44, 0x8a, 0x8f, 0x41, 0xb6, 0x01, 0xe0, 0xd5, 0x74, 0x34,
-		0xdb, 0x34, 0x0c, 0xf3, 0x13, 0x26, 0x7a, 0x4c, 0xc9, 0x16, 0xf6, 0xc0, 0x40, 0x64, 0x3d, 0x87,
-		0x26, 0x21, 0xbe, 0x89, 0x6b, 0x9a, 0xce, 0xf7, 0x8d, 0x59, 0x41, 0x6c, 0xbf, 0xc4, 0xdc, 0xed,
-		0x97, 0xc2, 0x5f, 0x86, 0x89, 0x8a, 0xd1, 0x08, 0x8b, 0x5b, 0x48, 0x87, 0x36, 0x17, 0xec, 0x8b,
-		0xd2, 0x0b, 0x0f, 0x73, 0xa4, 0x9a, 0x51, 0x57, 0xf5, 0xda, 0xac, 0x61, 0xd5, 0xbc, 0x63, 0x56,
-		0x92, 0xf1, 0xd8, 0xbe, 0xc3, 0x56, 0x73, 0xf3, 0x4f, 0x25, 0xe9, 0x17, 0x22, 0xd1, 0xf9, 0xd5,
-		0xc2, 0xe7, 0x22, 0xd9, 0x79, 0x46, 0xb8, 0x2a, 0x8c, 0xa1, 0xe0, 0xad, 0x3a, 0xae, 0x10, 0x05,
-		0xe1, 0x7b, 0x0f, 0xc2, 0x64, 0xcd, 0xa8, 0x19, 0x94, 0xd3, 0x69, 0xf2, 0x8b, 0x9f, 0xd3, 0x26,
+		0xb1, 0x54, 0x2e, 0x5d, 0xb8, 0x50, 0x9a, 0x5b, 0x5f, 0x63, 0xfb, 0x1e, 0x2e, 0xf6, 0x7a, 0xc0,
+		0xc1, 0xe5, 0x97, 0xa3, 0x30, 0xd1, 0x46, 0x12, 0x94, 0xe7, 0x2b, 0x16, 0xb6, 0x88, 0x7a, 0xb0,
+		0x1f, 0xe9, 0x67, 0x49, 0xce, 0xb0, 0xaa, 0x5a, 0x0e, 0x5f, 0xe0, 0xdc, 0x07, 0x44, 0x4b, 0xba,
+		0xa3, 0x6d, 0x69, 0xd8, 0xe2, 0xfb, 0x49, 0x6c, 0x19, 0x33, 0xe6, 0xc1, 0xd9, 0x96, 0xd2, 0x03,
+		0x80, 0x4c, 0xc3, 0xd6, 0x1c, 0xed, 0x0a, 0x2e, 0x6b, 0xba, 0xd8, 0x7c, 0x22, 0xcb, 0x9a, 0x98,
+		0x92, 0x16, 0x35, 0x0b, 0xba, 0xe3, 0x62, 0xeb, 0xb8, 0xa6, 0x86, 0xb0, 0x49, 0x30, 0x8f, 0x2a,
+		0x69, 0x51, 0xe3, 0x62, 0xdf, 0x01, 0xa9, 0xaa, 0xd1, 0x24, 0xb9, 0x1e, 0xc3, 0x23, 0x73, 0x87,
+		0xa4, 0x0c, 0x33, 0x98, 0x8b, 0xc2, 0xb3, 0x78, 0x6f, 0xd7, 0x2b, 0xa5, 0x0c, 0x33, 0x18, 0x43,
+		0xb9, 0x17, 0xc6, 0xd4, 0x5a, 0xcd, 0x22, 0xcc, 0x05, 0x23, 0xb6, 0x2e, 0x19, 0x75, 0xc1, 0x14,
+		0x31, 0xfb, 0x14, 0x24, 0x84, 0x1e, 0xc8, 0x54, 0x4d, 0x34, 0x51, 0x36, 0xd9, 0x62, 0x3b, 0x72,
+		0x32, 0xa9, 0x24, 0x74, 0x51, 0x79, 0x07, 0xa4, 0x34, 0xbb, 0xec, 0x6d, 0xe2, 0x47, 0x66, 0x22,
+		0x27, 0x13, 0xca, 0xb0, 0x66, 0xbb, 0x1b, 0xa0, 0xf2, 0x67, 0x23, 0x30, 0x1a, 0x3c, 0x84, 0x40,
+		0x45, 0x48, 0xd4, 0x8d, 0x8a, 0x4a, 0x4d, 0x8b, 0x9d, 0x80, 0x9d, 0xec, 0x71, 0x6e, 0x31, 0xbb,
+		0xc8, 0xf1, 0x15, 0x97, 0x32, 0xfb, 0xbb, 0x12, 0x24, 0x04, 0x18, 0x1d, 0x86, 0x98, 0xa9, 0x3a,
+		0xdb, 0x94, 0x5d, 0xbc, 0x10, 0x49, 0x4b, 0x0a, 0x2d, 0x13, 0xb8, 0x6d, 0xaa, 0x3a, 0x35, 0x01,
+		0x0e, 0x27, 0x65, 0x32, 0xae, 0x75, 0xac, 0x56, 0xe9, 0xa2, 0xc7, 0x68, 0x34, 0xb0, 0xee, 0xd8,
+		0x62, 0x5c, 0x39, 0x7c, 0x8e, 0x83, 0xd1, 0xfd, 0x30, 0xee, 0x58, 0xaa, 0x56, 0x0f, 0xe0, 0xc6,
+		0x28, 0x6e, 0x5a, 0x54, 0xb8, 0xc8, 0x39, 0x38, 0x2a, 0xf8, 0x56, 0xb1, 0xa3, 0x56, 0xb6, 0x71,
+		0xd5, 0x23, 0x1a, 0xa4, 0x9b, 0x1b, 0x47, 0x38, 0x42, 0x91, 0xd7, 0x0b, 0x5a, 0xf9, 0xdb, 0x12,
+		0x8c, 0x8b, 0x65, 0x5a, 0xd5, 0x55, 0xd6, 0x12, 0x80, 0xaa, 0xeb, 0x86, 0xe3, 0x57, 0x57, 0xab,
+		0x29, 0xb7, 0xd0, 0xcd, 0xe6, 0x5d, 0x22, 0xc5, 0xc7, 0x20, 0xdb, 0x00, 0xf0, 0x6a, 0x3a, 0xaa,
+		0x6d, 0x1a, 0x86, 0xf9, 0x09, 0x13, 0x3d, 0xa6, 0x64, 0x0b, 0x7b, 0x60, 0x20, 0xb2, 0x9e, 0x43,
+		0x93, 0x10, 0xdf, 0xc4, 0x35, 0x4d, 0xe7, 0xfb, 0xc6, 0xac, 0x20, 0xb6, 0x5f, 0x62, 0xee, 0xf6,
+		0x4b, 0xe1, 0x2f, 0xc3, 0x44, 0xc5, 0x68, 0x84, 0xc5, 0x2d, 0xa4, 0x43, 0x9b, 0x0b, 0xf6, 0x45,
+		0xe9, 0xb9, 0x07, 0x39, 0x52, 0xcd, 0xa8, 0xab, 0x7a, 0x6d, 0xd6, 0xb0, 0x6a, 0xde, 0x31, 0x2b,
+		0xc9, 0x78, 0x6c, 0xdf, 0x61, 0xab, 0xb9, 0xf9, 0x67, 0x92, 0xf4, 0xcb, 0x91, 0xe8, 0xfc, 0x6a,
+		0xe1, 0x73, 0x91, 0xec, 0x3c, 0x23, 0x5c, 0x15, 0xca, 0x50, 0xf0, 0x56, 0x1d, 0x57, 0x48, 0x07,
+		0xe1, 0x07, 0xf7, 0xc3, 0x64, 0xcd, 0xa8, 0x19, 0x94, 0xd3, 0x69, 0xf2, 0x8b, 0x9f, 0xd3, 0x26,
 		0x5d, 0x68, 0xb6, 0xe7, 0xa1, 0x6e, 0x6e, 0x19, 0x26, 0x38, 0x72, 0x99, 0x1e, 0x14, 0xb1, 0x65,
-		0x0c, 0xea, 0xba, 0x87, 0x96, 0xf9, 0xc2, 0x77, 0xe9, 0xf4, 0xad, 0x8c, 0x73, 0x52, 0x52, 0xc7,
-		0x56, 0x3a, 0x39, 0x05, 0x0e, 0x05, 0xf8, 0xb1, 0x41, 0x8a, 0xad, 0x1e, 0x1c, 0x7f, 0x83, 0x73,
-		0x9c, 0xf0, 0x71, 0x5c, 0xe3, 0xa4, 0xb9, 0x39, 0x18, 0xd9, 0x0f, 0xaf, 0x7f, 0xc9, 0x79, 0xa5,
-		0xb0, 0x9f, 0xc9, 0x3c, 0x8c, 0x51, 0x26, 0x95, 0xa6, 0xed, 0x18, 0x0d, 0x1a, 0x01, 0xbb, 0xb3,
-		0xf9, 0xcd, 0xef, 0xb2, 0x51, 0x33, 0x4a, 0xc8, 0xe6, 0x5c, 0xaa, 0x5c, 0x0e, 0xe8, 0xd9, 0x58,
-		0x15, 0x57, 0xea, 0x3d, 0x38, 0x7c, 0x8d, 0x0b, 0xe2, 0xe2, 0xe7, 0x2e, 0xc3, 0x24, 0xf9, 0x4d,
-		0x03, 0x94, 0x5f, 0x92, 0xde, 0x1b, 0x6e, 0x99, 0x6f, 0xbd, 0x97, 0x0d, 0xcc, 0x09, 0x97, 0x81,
-		0x4f, 0x26, 0x5f, 0x2f, 0xd6, 0xb0, 0xe3, 0x60, 0xcb, 0x2e, 0xab, 0xf5, 0x76, 0xe2, 0xf9, 0x76,
-		0x2c, 0x32, 0x1f, 0xfb, 0x7e, 0xb0, 0x17, 0xe7, 0x19, 0x65, 0xbe, 0x5e, 0xcf, 0x6d, 0xc0, 0x91,
-		0x36, 0x5e, 0xd1, 0x07, 0xcf, 0x57, 0x38, 0xcf, 0xc9, 0x16, 0xcf, 0x20, 0x6c, 0x57, 0x41, 0xc0,
-		0xdd, 0xbe, 0xec, 0x83, 0xe7, 0xc7, 0x39, 0x4f, 0xc4, 0x69, 0x45, 0x97, 0x12, 0x8e, 0xcf, 0xc0,
-		0xf8, 0x15, 0x6c, 0x6d, 0x1a, 0x36, 0xdf, 0x25, 0xea, 0x83, 0xdd, 0x27, 0x38, 0xbb, 0x31, 0x4e,
-		0x48, 0xb7, 0x8d, 0x08, 0xaf, 0xa7, 0x20, 0xb1, 0xa5, 0x56, 0x70, 0x1f, 0x2c, 0x6e, 0x70, 0x16,
-		0x43, 0x04, 0x9f, 0x90, 0xe6, 0x21, 0x55, 0x33, 0xf8, 0x1c, 0xd5, 0x9b, 0xfc, 0x93, 0x9c, 0x7c,
-		0x58, 0xd0, 0x70, 0x16, 0xa6, 0x61, 0x36, 0xeb, 0x64, 0x02, 0xeb, 0xcd, 0xe2, 0x6f, 0x09, 0x16,
-		0x82, 0x86, 0xb3, 0xd8, 0x87, 0x59, 0x3f, 0x25, 0x58, 0xd8, 0x3e, 0x7b, 0x3e, 0x0d, 0xc3, 0x86,
-		0x5e, 0xdf, 0x33, 0xf4, 0x7e, 0x84, 0xf8, 0x34, 0xe7, 0x00, 0x9c, 0x84, 0x30, 0x38, 0x0f, 0xc9,
-		0x7e, 0x3b, 0xe2, 0x6f, 0x7f, 0x5f, 0x0c, 0x0f, 0xd1, 0x03, 0xf3, 0x30, 0x26, 0x02, 0x94, 0x66,
-		0xe8, 0x7d, 0xb0, 0xf8, 0x3b, 0x9c, 0xc5, 0xa8, 0x8f, 0x8c, 0xab, 0xe1, 0x60, 0xdb, 0xa9, 0xe1,
-		0x7e, 0x98, 0x7c, 0x56, 0xa8, 0xc1, 0x49, 0xb8, 0x29, 0x37, 0xb1, 0x5e, 0xd9, 0xee, 0x8f, 0xc3,
-		0x2f, 0x09, 0x53, 0x0a, 0x1a, 0xc2, 0x62, 0x0e, 0x46, 0x1a, 0xaa, 0x65, 0x6f, 0xab, 0xf5, 0xbe,
-		0xba, 0xe3, 0xef, 0x72, 0x1e, 0x29, 0x97, 0x88, 0x5b, 0xa4, 0xa9, 0xef, 0x87, 0xcd, 0xe7, 0x84,
-		0x45, 0x7c, 0x64, 0x7c, 0xe8, 0xd9, 0x0e, 0xdd, 0x52, 0xdb, 0x0f, 0xb7, 0x5f, 0x16, 0x43, 0x8f,
-		0xd1, 0x2e, 0xf9, 0x39, 0x9e, 0x87, 0xa4, 0xad, 0x5d, 0xeb, 0x8b, 0xcd, 0xe7, 0x45, 0x4f, 0x53,
-		0x02, 0x42, 0xfc, 0x36, 0x38, 0xda, 0x76, 0x9a, 0xe8, 0x83, 0xd9, 0xdf, 0xe3, 0xcc, 0x0e, 0xb7,
-		0x99, 0x2a, 0x78, 0x48, 0xd8, 0x2f, 0xcb, 0xbf, 0x2f, 0x42, 0x02, 0x0e, 0xf1, 0x5a, 0x25, 0xab,
-		0x06, 0x5b, 0xdd, 0xda, 0x9f, 0xd5, 0x7e, 0x45, 0x58, 0x8d, 0xd1, 0x06, 0xac, 0xb6, 0x0e, 0x87,
-		0x39, 0xc7, 0xfd, 0xf5, 0xeb, 0xaf, 0x8a, 0xc0, 0xca, 0xa8, 0x37, 0x82, 0xbd, 0xfb, 0x76, 0xc8,
-		0xba, 0xe6, 0x14, 0xe9, 0xa9, 0x5d, 0x6e, 0xa8, 0x66, 0x1f, 0x9c, 0xbf, 0xc0, 0x39, 0x8b, 0x88,
-		0xef, 0xe6, 0xb7, 0xf6, 0x92, 0x6a, 0x12, 0xe6, 0xcf, 0x43, 0x46, 0x30, 0x6f, 0xea, 0x16, 0xae,
-		0x18, 0x35, 0x5d, 0xbb, 0x86, 0xab, 0x7d, 0xb0, 0xfe, 0xb5, 0x50, 0x57, 0x6d, 0xf8, 0xc8, 0x09,
-		0xe7, 0x05, 0x48, 0xbb, 0xb9, 0x4a, 0x59, 0x6b, 0x98, 0x86, 0xe5, 0xf4, 0xe0, 0xf8, 0x45, 0xd1,
-		0x53, 0x2e, 0xdd, 0x02, 0x25, 0xcb, 0x95, 0x80, 0x9d, 0x33, 0xf7, 0xeb, 0x92, 0x5f, 0xe2, 0x8c,
-		0x46, 0x3c, 0x2a, 0x1e, 0x38, 0x2a, 0x46, 0xc3, 0x54, 0xad, 0x7e, 0xe2, 0xdf, 0x3f, 0x10, 0x81,
-		0x83, 0x93, 0xf0, 0xc0, 0x41, 0x32, 0x3a, 0x32, 0xdb, 0xf7, 0xc1, 0xe1, 0xcb, 0x22, 0x70, 0x08,
-		0x1a, 0xce, 0x42, 0x24, 0x0c, 0x7d, 0xb0, 0xf8, 0x87, 0x82, 0x85, 0xa0, 0x21, 0x2c, 0x9e, 0xf5,
-		0x26, 0x5a, 0x0b, 0xd7, 0x34, 0xdb, 0xb1, 0x58, 0x52, 0xdc, 0x9d, 0xd5, 0x3f, 0xfa, 0x7e, 0x30,
-		0x09, 0x53, 0x7c, 0xa4, 0x24, 0x12, 0xf1, 0x4d, 0x56, 0xba, 0x66, 0xea, 0x2d, 0xd8, 0xaf, 0x8b,
-		0x48, 0xe4, 0x23, 0x23, 0xb2, 0xf9, 0x32, 0x44, 0x62, 0xf6, 0x0a, 0x59, 0x29, 0xf4, 0xc1, 0xee,
-		0x1f, 0x87, 0x84, 0x5b, 0x13, 0xb4, 0x84, 0xa7, 0x2f, 0xff, 0x69, 0xea, 0x3b, 0x78, 0xaf, 0x2f,
-		0xef, 0xfc, 0x27, 0xa1, 0xfc, 0x67, 0x83, 0x51, 0xb2, 0x18, 0x32, 0x16, 0xca, 0xa7, 0x50, 0xaf,
-		0x5b, 0x45, 0x99, 0x9f, 0xfe, 0x21, 0xd7, 0x37, 0x98, 0x4e, 0xe5, 0x16, 0x89, 0x93, 0x07, 0x93,
-		0x9e, 0xde, 0xcc, 0xde, 0xfb, 0x43, 0xd7, 0xcf, 0x03, 0x39, 0x4f, 0xee, 0x02, 0x8c, 0x04, 0x12,
-		0x9e, 0xde, 0xac, 0xde, 0xc7, 0x59, 0xa5, 0xfc, 0xf9, 0x4e, 0xee, 0x2c, 0xc4, 0x48, 0xf2, 0xd2,
-		0x9b, 0xfc, 0xaf, 0x70, 0x72, 0x8a, 0x9e, 0x7b, 0x33, 0x24, 0x44, 0xd2, 0xd2, 0x9b, 0xf4, 0xfd,
-		0x9c, 0xd4, 0x25, 0x21, 0xe4, 0x22, 0x61, 0xe9, 0x4d, 0xfe, 0x57, 0x05, 0xb9, 0x20, 0x21, 0xe4,
-		0xfd, 0x9b, 0xf0, 0x2b, 0x3f, 0x13, 0xe3, 0x93, 0x8e, 0xb0, 0xdd, 0x79, 0x18, 0xe2, 0x99, 0x4a,
-		0x6f, 0xea, 0x0f, 0xf2, 0xc6, 0x05, 0x45, 0xee, 0x09, 0x88, 0xf7, 0x69, 0xf0, 0x9f, 0xe5, 0xa4,
-		0x0c, 0x3f, 0x37, 0x07, 0xc3, 0xbe, 0xec, 0xa4, 0x37, 0xf9, 0x5f, 0xe3, 0xe4, 0x7e, 0x2a, 0x22,
-		0x3a, 0xcf, 0x4e, 0x7a, 0x33, 0xf8, 0x39, 0x21, 0x3a, 0xa7, 0x20, 0x66, 0x13, 0x89, 0x49, 0x6f,
-		0xea, 0x0f, 0x09, 0xab, 0x0b, 0x92, 0xdc, 0xd3, 0x90, 0x74, 0x27, 0x9b, 0xde, 0xf4, 0x1f, 0xe6,
-		0xf4, 0x1e, 0x0d, 0xb1, 0x80, 0x6f, 0xb2, 0xeb, 0xcd, 0xe2, 0xaf, 0x0b, 0x0b, 0xf8, 0xa8, 0xc8,
-		0x30, 0x0a, 0x27, 0x30, 0xbd, 0x39, 0x7d, 0x44, 0x0c, 0xa3, 0x50, 0xfe, 0x42, 0x7a, 0x93, 0xc6,
-		0xfc, 0xde, 0x2c, 0xfe, 0x86, 0xe8, 0x4d, 0x8a, 0x4f, 0xc4, 0x08, 0x67, 0x04, 0xbd, 0x79, 0xfc,
-		0xbc, 0x10, 0x23, 0x94, 0x10, 0xe4, 0x56, 0x01, 0xb5, 0x66, 0x03, 0xbd, 0xf9, 0x7d, 0x94, 0xf3,
-		0x1b, 0x6f, 0x49, 0x06, 0x72, 0xcf, 0xc1, 0xe1, 0xf6, 0x99, 0x40, 0x6f, 0xae, 0x1f, 0xfb, 0x61,
-		0x68, 0xed, 0xe6, 0x4f, 0x04, 0x72, 0xeb, 0xde, 0x94, 0xe2, 0xcf, 0x02, 0x7a, 0xb3, 0x7d, 0xe5,
-		0x87, 0xc1, 0xc0, 0xed, 0x4f, 0x02, 0x72, 0x79, 0x00, 0x6f, 0x02, 0xee, 0xcd, 0xeb, 0x13, 0x9c,
-		0x97, 0x8f, 0x88, 0x0c, 0x0d, 0x3e, 0xff, 0xf6, 0xa6, 0xbf, 0x21, 0x86, 0x06, 0xa7, 0x20, 0x43,
-		0x43, 0x4c, 0xbd, 0xbd, 0xa9, 0x3f, 0x29, 0x86, 0x86, 0x20, 0x21, 0x9e, 0xed, 0x9b, 0xdd, 0x7a,
-		0x73, 0xf8, 0xb4, 0xf0, 0x6c, 0x1f, 0x55, 0x6e, 0x19, 0xc6, 0x5b, 0x26, 0xc4, 0xde, 0xac, 0x7e,
-		0x81, 0xb3, 0x4a, 0x87, 0xe7, 0x43, 0xff, 0xe4, 0xc5, 0x27, 0xc3, 0xde, 0xdc, 0x3e, 0x13, 0x9a,
-		0xbc, 0xf8, 0x5c, 0x98, 0x3b, 0x0f, 0x09, 0xbd, 0x59, 0xaf, 0x93, 0xc1, 0x83, 0xba, 0xdf, 0x04,
-		0xcc, 0xfc, 0xd7, 0x1f, 0x71, 0xeb, 0x08, 0x82, 0xdc, 0x59, 0x88, 0xe3, 0xc6, 0x26, 0xae, 0xf6,
-		0xa2, 0xfc, 0xde, 0x8f, 0x44, 0xc0, 0x24, 0xd8, 0xb9, 0xa7, 0x01, 0xd8, 0xd6, 0x08, 0x3d, 0x0c,
-		0xec, 0x41, 0xfb, 0xdf, 0x7e, 0xc4, 0xaf, 0xde, 0x78, 0x24, 0x1e, 0x03, 0x76, 0x91, 0xa7, 0x3b,
-		0x83, 0xef, 0x07, 0x19, 0xd0, 0x1e, 0x79, 0x0a, 0x86, 0x5e, 0xb4, 0x0d, 0xdd, 0x51, 0x6b, 0xbd,
-		0xa8, 0xff, 0x3b, 0xa7, 0x16, 0xf8, 0xc4, 0x60, 0x0d, 0xc3, 0xc2, 0x8e, 0x5a, 0xb3, 0x7b, 0xd1,
-		0xfe, 0x0f, 0x4e, 0xeb, 0x12, 0x10, 0xe2, 0x8a, 0x6a, 0x3b, 0xfd, 0xe8, 0xfd, 0x87, 0x82, 0x58,
-		0x10, 0x10, 0xa1, 0xc9, 0xef, 0x1d, 0xbc, 0xd7, 0x8b, 0xf6, 0x07, 0x42, 0x68, 0x8e, 0x9f, 0x7b,
-		0x33, 0x24, 0xc9, 0x4f, 0x76, 0x9f, 0xae, 0x07, 0xf1, 0x1f, 0x71, 0x62, 0x8f, 0x82, 0xb4, 0x6c,
-		0x3b, 0x55, 0x47, 0xeb, 0x6d, 0xec, 0x5b, 0xbc, 0xa7, 0x05, 0x7e, 0x2e, 0x0f, 0xc3, 0xb6, 0x53,
-		0xad, 0x36, 0x79, 0x7e, 0xda, 0x83, 0xfc, 0x8f, 0x7f, 0xe4, 0x6e, 0x59, 0xb8, 0x34, 0xa4, 0xb7,
-		0xaf, 0xee, 0x38, 0xa6, 0x41, 0x0f, 0x3c, 0x7a, 0x71, 0xf8, 0x21, 0xe7, 0xe0, 0x23, 0xc9, 0xcd,
-		0x41, 0x8a, 0xe8, 0x62, 0x61, 0x13, 0xd3, 0xd3, 0xa9, 0x1e, 0x2c, 0xfe, 0x84, 0x1b, 0x20, 0x40,
-		0x54, 0xf8, 0xa9, 0xaf, 0xbd, 0x3a, 0x25, 0x7d, 0xf3, 0xd5, 0x29, 0xe9, 0xf7, 0x5f, 0x9d, 0x92,
-		0x3e, 0xf4, 0x9d, 0xa9, 0x81, 0x6f, 0x7e, 0x67, 0x6a, 0xe0, 0x77, 0xbf, 0x33, 0x35, 0xd0, 0x7e,
-		0x97, 0x18, 0xe6, 0x8d, 0x79, 0x83, 0xed, 0x0f, 0xbf, 0x20, 0xd7, 0x34, 0x67, 0xbb, 0xb9, 0x39,
-		0x5b, 0x31, 0x1a, 0x74, 0x1b, 0xd7, 0xdb, 0xad, 0x75, 0x17, 0x39, 0xf0, 0x9e, 0x28, 0x1c, 0xad,
-		0x18, 0x76, 0xc3, 0xb0, 0xcb, 0x6c, 0xbf, 0x97, 0x15, 0xf8, 0x8e, 0x6f, 0xca, 0x5f, 0xd5, 0xc7,
-		0xa6, 0xef, 0x45, 0x18, 0xa5, 0xaa, 0xd3, 0xed, 0x2e, 0xea, 0x6d, 0x3d, 0x03, 0xc4, 0xd7, 0xff,
-		0x5d, 0x9c, 0x6a, 0x3d, 0xe2, 0x12, 0xd2, 0xd3, 0xfb, 0x75, 0x98, 0xd4, 0x1a, 0x66, 0x1d, 0xd3,
-		0x6d, 0xfe, 0xb2, 0x5b, 0xd7, 0x9b, 0xdf, 0x37, 0x38, 0xbf, 0x09, 0x8f, 0x7c, 0x41, 0x50, 0xe7,
-		0x16, 0x61, 0x5c, 0xad, 0x54, 0xb0, 0x19, 0x60, 0xd9, 0xa3, 0x5b, 0x84, 0x80, 0x69, 0x4e, 0xe9,
-		0x72, 0x2b, 0x3c, 0xdd, 0xa9, 0x6b, 0x5e, 0xb8, 0xd7, 0x67, 0x79, 0x0b, 0xd7, 0xb0, 0xfe, 0xb0,
-		0x8e, 0x9d, 0xab, 0x86, 0xb5, 0xc3, 0xcd, 0xfb, 0x30, 0x6b, 0x6a, 0x90, 0xdd, 0x60, 0x86, 0xf7,
-		0x45, 0x61, 0x8a, 0x55, 0x9c, 0xde, 0x54, 0x6d, 0x7c, 0xfa, 0xca, 0xa3, 0x9b, 0xd8, 0x51, 0x1f,
-		0x3d, 0x5d, 0x31, 0x34, 0x9d, 0xf7, 0xc4, 0x04, 0xef, 0x17, 0x52, 0x3f, 0xcb, 0xeb, 0xb3, 0x6d,
-		0xb7, 0xe9, 0xe5, 0x79, 0x88, 0xcd, 0x19, 0x9a, 0x8e, 0x26, 0x21, 0x5e, 0xc5, 0xba, 0xd1, 0xe0,
-		0x77, 0xee, 0x58, 0x01, 0xdd, 0x0d, 0x83, 0x6a, 0xc3, 0x68, 0xea, 0x0e, 0x3b, 0xa1, 0x28, 0x0c,
-		0x7f, 0xed, 0xe6, 0xf4, 0xc0, 0xef, 0xdd, 0x9c, 0x8e, 0x2e, 0xe8, 0x8e, 0xc2, 0xab, 0x72, 0xb1,
-		0xd7, 0x3e, 0x35, 0x2d, 0xc9, 0xcf, 0xc0, 0x50, 0x11, 0x57, 0x0e, 0xc2, 0xab, 0x88, 0x2b, 0x21,
-		0x5e, 0x0f, 0x40, 0x62, 0x41, 0x77, 0xd8, 0xad, 0xc8, 0x13, 0x10, 0xd5, 0x74, 0x76, 0xd1, 0x26,
-		0xd4, 0x3e, 0x81, 0x13, 0xd4, 0x22, 0xae, 0xb8, 0xa8, 0x55, 0x5c, 0x09, 0xa3, 0x12, 0xf6, 0x04,
-		0x5e, 0x28, 0xfe, 0xee, 0x7f, 0x9e, 0x1a, 0x78, 0xf9, 0xd5, 0xa9, 0x81, 0x8e, 0x3d, 0xe1, 0x1f,
-		0x03, 0xdc, 0xc4, 0xbc, 0x0b, 0xec, 0xea, 0x0e, 0x3b, 0x23, 0x71, 0xbb, 0xe1, 0xb7, 0x06, 0x41,
-		0xe6, 0x38, 0xb6, 0xa3, 0xee, 0x68, 0x7a, 0xcd, 0xed, 0x09, 0xb5, 0xe9, 0x6c, 0x5f, 0xe3, 0x5d,
-		0x71, 0x98, 0x77, 0x05, 0xc7, 0xe9, 0xde, 0x1b, 0xd9, 0xce, 0xa3, 0x2b, 0xdb, 0xa3, 0xcf, 0xe5,
-		0x7f, 0x1d, 0x05, 0xb4, 0xe6, 0xa8, 0x3b, 0x38, 0xdf, 0x74, 0xb6, 0x0d, 0x4b, 0xbb, 0xc6, 0x62,
-		0x19, 0x06, 0x68, 0xa8, 0xbb, 0x65, 0xc7, 0xd8, 0xc1, 0xba, 0x4d, 0x4d, 0x33, 0x7c, 0xe6, 0xe8,
-		0x6c, 0x1b, 0xff, 0x98, 0x25, 0x5d, 0x57, 0x78, 0xf0, 0x73, 0xdf, 0x9e, 0xbe, 0xbf, 0xb7, 0x15,
-		0x28, 0x32, 0x49, 0xae, 0x77, 0xd7, 0x29, 0x63, 0x74, 0x19, 0xd8, 0x25, 0x8b, 0x72, 0x5d, 0xb3,
-		0x1d, 0x7e, 0x4f, 0xfb, 0xec, 0x6c, 0x7b, 0xdd, 0x67, 0x5b, 0xc5, 0x9c, 0xbd, 0xac, 0xd6, 0xb5,
-		0xaa, 0xea, 0x18, 0x96, 0x7d, 0x71, 0x40, 0x49, 0x52, 0x56, 0x8b, 0x9a, 0xed, 0xa0, 0x75, 0x48,
-		0x56, 0xb1, 0xbe, 0xc7, 0xd8, 0x46, 0x5f, 0x1f, 0xdb, 0x04, 0xe1, 0x44, 0xb9, 0x3e, 0x0f, 0x48,
-		0xf5, 0xe3, 0x89, 0x87, 0x49, 0xec, 0x7e, 0x65, 0x07, 0xf6, 0x01, 0xce, 0xf4, 0x1d, 0xc5, 0xb8,
-		0x1a, 0x06, 0x65, 0xef, 0x03, 0xf0, 0xda, 0x44, 0x19, 0x18, 0x52, 0xab, 0x55, 0x0b, 0xdb, 0x36,
-		0x3d, 0x00, 0x4c, 0x2a, 0xa2, 0x98, 0x1b, 0xff, 0x37, 0x5f, 0x7a, 0x78, 0x24, 0xc0, 0xb1, 0x90,
-		0x02, 0xb8, 0xe2, 0x92, 0x9e, 0xfa, 0xa4, 0x04, 0xe3, 0x2d, 0x2d, 0x22, 0x19, 0xa6, 0xf2, 0x1b,
-		0xeb, 0x17, 0x57, 0x94, 0x85, 0x17, 0xf2, 0xeb, 0x0b, 0x2b, 0xcb, 0x65, 0x76, 0xe5, 0x7f, 0x79,
-		0x6d, 0xb5, 0x34, 0xb7, 0x70, 0x61, 0xa1, 0x54, 0x4c, 0x0f, 0xa0, 0x69, 0x38, 0xd6, 0x06, 0xa7,
-		0x58, 0x5a, 0x2c, 0xcd, 0xe7, 0xd7, 0x4b, 0x69, 0x09, 0xdd, 0x05, 0x27, 0xda, 0x32, 0x71, 0x51,
-		0x22, 0x1d, 0x50, 0x94, 0x92, 0x8b, 0x12, 0x2d, 0x5c, 0xe8, 0x38, 0x8a, 0x1e, 0xea, 0xea, 0x3f,
-		0xbb, 0xee, 0x70, 0x09, 0x8e, 0xa7, 0x3f, 0x91, 0xe0, 0x68, 0x78, 0xca, 0x50, 0xf5, 0xbd, 0x0e,
-		0xaf, 0x3e, 0x3b, 0x44, 0xb3, 0x37, 0x41, 0x34, 0xaf, 0xef, 0xa1, 0xa3, 0x2c, 0x9f, 0x2e, 0x37,
-		0xad, 0x3a, 0x8f, 0x41, 0x43, 0xa4, 0xbc, 0x61, 0xd5, 0x49, 0x6c, 0x12, 0x17, 0xfd, 0xa5, 0x93,
-		0x29, 0x7e, 0x7b, 0x3f, 0x17, 0xfb, 0xc1, 0xa7, 0xa7, 0x07, 0x0a, 0x3b, 0x61, 0x95, 0xbe, 0xd2,
-		0x73, 0x06, 0x4d, 0xe4, 0xf5, 0x3d, 0x1a, 0x7c, 0x56, 0xa5, 0x17, 0xe2, 0x54, 0x21, 0x71, 0x68,
-		0x3a, 0x15, 0x3e, 0x34, 0x7d, 0x0e, 0xd7, 0xeb, 0x97, 0x74, 0xe3, 0x2a, 0xed, 0x49, 0x4f, 0xef,
-		0x8f, 0x44, 0x60, 0xaa, 0x65, 0xaa, 0xe4, 0x59, 0x45, 0xa7, 0x27, 0xaf, 0x39, 0x48, 0x14, 0x45,
-		0xb2, 0x92, 0x81, 0x21, 0x1b, 0x57, 0x0c, 0xbd, 0xca, 0x46, 0x77, 0x54, 0x11, 0x45, 0xa2, 0xaa,
-		0xae, 0xea, 0x86, 0xcd, 0xef, 0xd9, 0xb3, 0x42, 0xe1, 0xe3, 0xd2, 0xfe, 0x72, 0x84, 0x11, 0xd1,
-		0x92, 0x50, 0xf3, 0xd1, 0x9e, 0xc7, 0xc8, 0x3b, 0x44, 0x4b, 0x57, 0x89, 0xc0, 0x51, 0x72, 0xbf,
-		0x56, 0xf9, 0xf9, 0x08, 0x4c, 0x87, 0xad, 0x42, 0x52, 0x35, 0xdb, 0x51, 0x1b, 0x66, 0x27, 0xb3,
-		0x9c, 0x87, 0xe4, 0xba, 0xc0, 0xd9, 0xb7, 0x5d, 0x6e, 0xec, 0xd3, 0x2e, 0xa3, 0x6e, 0x53, 0xc2,
-		0x30, 0x67, 0xfa, 0x34, 0x8c, 0xab, 0xc7, 0x81, 0x2c, 0xf3, 0xb9, 0x18, 0x9c, 0xa0, 0x0f, 0xb1,
-		0xac, 0x86, 0xa6, 0x3b, 0xa7, 0x2b, 0xd6, 0x9e, 0xe9, 0xd0, 0x64, 0xcd, 0xd8, 0xe2, 0x76, 0x19,
-		0xf7, 0xaa, 0x67, 0x59, 0x75, 0x87, 0xd1, 0xb2, 0x05, 0xf1, 0x55, 0x42, 0x47, 0x2c, 0xe2, 0x18,
-		0x8e, 0x5a, 0xe7, 0x96, 0x62, 0x05, 0x02, 0x65, 0x8f, 0xb7, 0x22, 0x0c, 0xaa, 0x89, 0x77, 0x5b,
-		0x75, 0xac, 0x6e, 0xb1, 0x3b, 0xf0, 0x51, 0x3a, 0x88, 0x12, 0x04, 0x40, 0xaf, 0xbb, 0x4f, 0x42,
-		0x5c, 0x6d, 0xb2, 0xeb, 0x1b, 0x51, 0x32, 0xba, 0x68, 0x41, 0xbe, 0x04, 0x43, 0xfc, 0x10, 0x19,
-		0xa5, 0x21, 0xba, 0x83, 0xf7, 0x68, 0x3b, 0x29, 0x85, 0xfc, 0x44, 0xb3, 0x10, 0xa7, 0xc2, 0xf3,
-		0x49, 0x23, 0x33, 0xdb, 0x22, 0xfd, 0x2c, 0x15, 0x52, 0x61, 0x68, 0xf2, 0x33, 0x90, 0x28, 0x1a,
-		0x0d, 0x4d, 0x37, 0x82, 0xdc, 0x92, 0x8c, 0x1b, 0x95, 0xd9, 0x6c, 0xf2, 0x1c, 0x43, 0x61, 0x05,
-		0x74, 0x18, 0x06, 0xd9, 0x9b, 0x08, 0x7e, 0x05, 0x85, 0x97, 0xe4, 0x39, 0x18, 0xa2, 0xbc, 0x57,
-		0x4c, 0x84, 0xf8, 0x6b, 0x3a, 0xfe, 0xf8, 0x82, 0xa6, 0xa3, 0x9c, 0x7d, 0xc4, 0x13, 0x16, 0x41,
-		0xac, 0xaa, 0x3a, 0x2a, 0xd7, 0x9b, 0xfe, 0x96, 0xdf, 0x02, 0x09, 0xce, 0xc4, 0x46, 0x67, 0x20,
-		0x6a, 0x98, 0x36, 0xbf, 0x44, 0x92, 0xed, 0xa4, 0xca, 0x8a, 0x59, 0x88, 0x91, 0xec, 0x44, 0x21,
-		0xc8, 0x05, 0xa5, 0x63, 0x20, 0x7d, 0xd2, 0x17, 0x48, 0x7d, 0x5d, 0xee, 0xfb, 0xc9, 0xba, 0xb4,
-		0xc5, 0x1d, 0x5c, 0x67, 0xf9, 0x74, 0x04, 0xa6, 0x7c, 0xb5, 0x57, 0xb0, 0x65, 0x6b, 0x86, 0xce,
-		0xe7, 0x70, 0xe6, 0x2d, 0xc8, 0x27, 0x24, 0xaf, 0xef, 0xe0, 0x2e, 0x6f, 0x86, 0x68, 0xde, 0x34,
-		0x51, 0x16, 0x12, 0xb4, 0x5c, 0x31, 0x98, 0xbf, 0xc4, 0x14, 0xb7, 0x4c, 0xea, 0x6c, 0x63, 0xcb,
-		0xb9, 0xaa, 0x5a, 0xee, 0xb3, 0x41, 0x51, 0x96, 0x9f, 0x82, 0xe4, 0x9c, 0xa1, 0xdb, 0x58, 0xb7,
-		0x9b, 0x74, 0x0c, 0x6e, 0xd6, 0x8d, 0xca, 0x0e, 0xe7, 0xc0, 0x0a, 0xc4, 0xe0, 0xaa, 0x69, 0x52,
-		0xca, 0x98, 0x42, 0x7e, 0xb2, 0x7c, 0xb0, 0xb0, 0xd6, 0xd1, 0x44, 0x4f, 0xed, 0xdf, 0x44, 0x5c,
-		0x49, 0xd7, 0x46, 0xff, 0x47, 0x82, 0xe3, 0xad, 0x03, 0x6a, 0x07, 0xef, 0xd9, 0xfb, 0x1d, 0x4f,
-		0xcf, 0x43, 0x72, 0x95, 0xbe, 0xdd, 0xbf, 0x84, 0xf7, 0x50, 0x16, 0x86, 0x70, 0xf5, 0xcc, 0xd9,
-		0xb3, 0x8f, 0x3e, 0xc5, 0xbc, 0xfd, 0xe2, 0x80, 0x22, 0x00, 0x68, 0x0a, 0x92, 0x36, 0xae, 0x98,
-		0x67, 0xce, 0x9e, 0xdb, 0x79, 0x94, 0xb9, 0x17, 0xc9, 0x7a, 0x5c, 0x50, 0x2e, 0x41, 0xb4, 0x7e,
-		0xed, 0xd3, 0xd3, 0x52, 0x21, 0x0e, 0x51, 0xbb, 0xd9, 0xb8, 0xa3, 0x3e, 0xf2, 0x4a, 0x1c, 0x66,
-		0xfc, 0x94, 0x34, 0x52, 0xb9, 0x99, 0x08, 0xb7, 0x41, 0xda, 0x67, 0x03, 0x8a, 0xd1, 0x21, 0x81,
-		0xed, 0x6a, 0x49, 0xf9, 0xd7, 0x24, 0x48, 0xb9, 0xe9, 0xd1, 0x1a, 0x76, 0xd0, 0x79, 0x7f, 0xce,
-		0xc3, 0x87, 0xcd, 0xb1, 0xd9, 0x70, 0x5b, 0x5e, 0x1a, 0xa7, 0xf8, 0xd0, 0xd1, 0x13, 0xd4, 0x11,
-		0x4d, 0xc3, 0xe6, 0x4f, 0xc9, 0x7a, 0x90, 0xba, 0xc8, 0xe8, 0x21, 0x40, 0x34, 0xc2, 0x95, 0xaf,
-		0x18, 0x8e, 0xa6, 0xd7, 0xca, 0xa6, 0x71, 0x95, 0x3f, 0xd0, 0x8d, 0x2a, 0x69, 0x5a, 0x73, 0x99,
-		0x56, 0xac, 0x12, 0x38, 0x11, 0x3a, 0xe9, 0x72, 0x09, 0xa6, 0x74, 0x24, 0x08, 0x88, 0x22, 0x3a,
-		0x0f, 0x43, 0x66, 0x73, 0xb3, 0x2c, 0x22, 0xc6, 0xf0, 0x99, 0xe3, 0xed, 0xc6, 0xbf, 0xf0, 0x0f,
-		0x1e, 0x01, 0x06, 0xcd, 0xe6, 0x26, 0xf1, 0x96, 0xbb, 0x20, 0xd5, 0x46, 0x98, 0xe1, 0x2b, 0x9e,
-		0x1c, 0xf4, 0x93, 0x11, 0x5c, 0x83, 0xb2, 0x69, 0x69, 0x86, 0xa5, 0x39, 0x7b, 0x34, 0x67, 0x8d,
-		0x2a, 0x69, 0x51, 0xb1, 0xca, 0xe1, 0xf2, 0x0e, 0x8c, 0xad, 0xd1, 0x35, 0xad, 0x27, 0xf9, 0x59,
-		0x4f, 0x3e, 0xa9, 0xb7, 0x7c, 0x1d, 0x25, 0x8b, 0xb4, 0x48, 0x56, 0x78, 0xb6, 0xa3, 0x77, 0x3e,
-		0xb1, 0x7f, 0xef, 0x0c, 0x66, 0x85, 0x7f, 0x78, 0x34, 0x30, 0x38, 0x99, 0x73, 0xfa, 0xc3, 0x57,
-		0xbf, 0x8e, 0xd9, 0x2b, 0x9b, 0xc8, 0x76, 0x9f, 0x54, 0xb3, 0x3d, 0xc2, 0x68, 0xb6, 0xe7, 0x10,
-		0x92, 0x9f, 0x82, 0x91, 0x55, 0xd5, 0x72, 0xd6, 0xb0, 0x73, 0x11, 0xab, 0x55, 0x6c, 0x05, 0x67,
-		0xdd, 0x11, 0x31, 0xeb, 0x22, 0x88, 0xd1, 0xa9, 0x95, 0xcd, 0x3a, 0xf4, 0xb7, 0xbc, 0x0d, 0x31,
-		0x7a, 0x1b, 0xd4, 0x9d, 0x91, 0x39, 0x05, 0x9b, 0x91, 0x49, 0x2c, 0xdd, 0x73, 0xb0, 0x2d, 0x52,
-		0x5a, 0x5a, 0x40, 0x8f, 0x8b, 0x79, 0x35, 0xda, 0x7d, 0x5e, 0xe5, 0x8e, 0xc8, 0x67, 0xd7, 0x3a,
-		0x0c, 0x15, 0x48, 0x28, 0x5e, 0x28, 0xba, 0x82, 0x48, 0x9e, 0x20, 0x68, 0x09, 0xc6, 0x4c, 0xd5,
-		0x72, 0xe8, 0x33, 0x98, 0x6d, 0xaa, 0x05, 0xf7, 0xf5, 0xe9, 0xd6, 0x91, 0x17, 0x50, 0x96, 0xb7,
-		0x32, 0x62, 0xfa, 0x81, 0xf2, 0x1f, 0xc4, 0x60, 0x90, 0x1b, 0xe3, 0xcd, 0x30, 0xc4, 0xcd, 0xca,
-		0xbd, 0xf3, 0xc4, 0x6c, 0xeb, 0xc4, 0x34, 0xeb, 0x4e, 0x20, 0x9c, 0x9f, 0xa0, 0x41, 0xf7, 0x41,
-		0xa2, 0xb2, 0xad, 0x6a, 0x7a, 0x59, 0xab, 0x8a, 0xed, 0x85, 0x57, 0x6f, 0x4e, 0x0f, 0xcd, 0x11,
-		0xd8, 0x42, 0x51, 0x19, 0xa2, 0x95, 0x0b, 0x55, 0x92, 0x09, 0x6c, 0x63, 0xad, 0xb6, 0xed, 0xf0,
-		0x11, 0xc6, 0x4b, 0xe8, 0x49, 0x88, 0x11, 0x87, 0xe0, 0x8f, 0x24, 0xb3, 0x2d, 0x9b, 0x3c, 0x6e,
-		0xb2, 0x57, 0x48, 0x90, 0x86, 0x3f, 0xf4, 0xed, 0x69, 0x49, 0xa1, 0x14, 0x68, 0x0e, 0x46, 0xea,
-		0xaa, 0xed, 0x94, 0xe9, 0x0c, 0x46, 0x9a, 0x8f, 0xf3, 0x35, 0x76, 0x8b, 0x41, 0xb8, 0x61, 0xb9,
-		0xe8, 0xc3, 0x84, 0x8a, 0x81, 0xaa, 0xe8, 0x24, 0xa4, 0x29, 0x93, 0x8a, 0xd1, 0x68, 0x68, 0x0e,
-		0xcb, 0xad, 0x06, 0xa9, 0xdd, 0x47, 0x09, 0x7c, 0x8e, 0x82, 0x69, 0x86, 0x75, 0x0c, 0x92, 0xf4,
-		0x59, 0x16, 0x45, 0x61, 0x57, 0x90, 0x13, 0x04, 0x40, 0x2b, 0xef, 0x87, 0x31, 0x2f, 0x3e, 0x32,
-		0x94, 0x04, 0xe3, 0xe2, 0x81, 0x29, 0xe2, 0x23, 0x30, 0xa9, 0xe3, 0x5d, 0x7a, 0x29, 0x3a, 0x80,
-		0x9d, 0xa4, 0xd8, 0x88, 0xd4, 0x5d, 0x0e, 0x52, 0xdc, 0x0b, 0xa3, 0x15, 0x61, 0x7c, 0x86, 0x0b,
-		0x14, 0x77, 0xc4, 0x85, 0x52, 0xb4, 0xa3, 0x90, 0x50, 0x4d, 0x93, 0x21, 0x0c, 0xf3, 0xf8, 0x68,
-		0x9a, 0xb4, 0xea, 0x14, 0x8c, 0x53, 0x1d, 0x2d, 0x6c, 0x37, 0xeb, 0x0e, 0x67, 0x92, 0xa2, 0x38,
-		0x63, 0xa4, 0x42, 0x61, 0x70, 0x8a, 0x7b, 0x37, 0x8c, 0xe0, 0x2b, 0x5a, 0x15, 0xeb, 0x15, 0xcc,
-		0xf0, 0x46, 0x28, 0x5e, 0x4a, 0x00, 0x29, 0xd2, 0x03, 0xe0, 0xc6, 0xbd, 0xb2, 0x88, 0xc9, 0xa3,
-		0x8c, 0x9f, 0x80, 0xe7, 0x19, 0x58, 0xce, 0x40, 0xac, 0xa8, 0x3a, 0x2a, 0x49, 0x30, 0x9c, 0x5d,
-		0x36, 0xd1, 0xa4, 0x14, 0xf2, 0x53, 0x7e, 0x2d, 0x02, 0xb1, 0xcb, 0x86, 0x83, 0xd1, 0x63, 0xbe,
-		0x04, 0x70, 0xb4, 0x9d, 0x3f, 0xaf, 0x69, 0x35, 0x1d, 0x57, 0x97, 0xec, 0x9a, 0xef, 0x1b, 0x0a,
-		0x9e, 0x3b, 0x45, 0x02, 0xee, 0x34, 0x09, 0x71, 0xcb, 0x68, 0xea, 0x55, 0x71, 0x7b, 0x97, 0x16,
-		0x50, 0x09, 0x12, 0xae, 0x97, 0xc4, 0x7a, 0x79, 0xc9, 0x18, 0xf1, 0x12, 0xe2, 0xc3, 0x1c, 0xa0,
-		0x0c, 0x6d, 0x72, 0x67, 0x29, 0x40, 0xd2, 0x0d, 0x5e, 0xdc, 0xdb, 0xfa, 0x73, 0x58, 0x8f, 0x8c,
-		0x4c, 0x26, 0x6e, 0xdf, 0xbb, 0xc6, 0x63, 0x1e, 0x97, 0x76, 0x2b, 0xb8, 0xf5, 0x02, 0x6e, 0xc5,
-		0xbf, 0xe7, 0x30, 0x44, 0xf5, 0xf2, 0xdc, 0x8a, 0x7d, 0xd3, 0xe1, 0x38, 0x24, 0x6d, 0xad, 0xa6,
-		0xab, 0x4e, 0xd3, 0xc2, 0xdc, 0xf3, 0x3c, 0x80, 0xfc, 0x15, 0x09, 0x06, 0x99, 0x27, 0xfb, 0xec,
-		0x26, 0xb5, 0xb7, 0x5b, 0xa4, 0x93, 0xdd, 0xa2, 0x07, 0xb7, 0x5b, 0x1e, 0xc0, 0x15, 0xc6, 0xe6,
-		0xcf, 0xec, 0xdb, 0x64, 0x0c, 0x4c, 0xc4, 0x35, 0xad, 0xc6, 0x07, 0xaa, 0x8f, 0x48, 0xfe, 0x4f,
-		0x12, 0x49, 0x62, 0x79, 0x3d, 0xca, 0xc3, 0x88, 0x90, 0xab, 0xbc, 0x55, 0x57, 0x6b, 0xdc, 0x77,
-		0x4e, 0x74, 0x14, 0xee, 0x42, 0x5d, 0xad, 0x29, 0xc3, 0x5c, 0x1e, 0x52, 0x68, 0xdf, 0x0f, 0x91,
-		0x0e, 0xfd, 0x10, 0xe8, 0xf8, 0xe8, 0xc1, 0x3a, 0x3e, 0xd0, 0x45, 0xb1, 0x70, 0x17, 0x7d, 0x31,
-		0x42, 0x17, 0x33, 0xa6, 0x61, 0xab, 0xf5, 0x1f, 0xc7, 0x88, 0x38, 0x06, 0x49, 0xd3, 0xa8, 0x97,
-		0x59, 0x0d, 0xbb, 0xd5, 0x9e, 0x30, 0x8d, 0xba, 0xd2, 0xd2, 0xed, 0xf1, 0xdb, 0x34, 0x5c, 0x06,
-		0x6f, 0x83, 0xd5, 0x86, 0xc2, 0x56, 0xb3, 0x20, 0xc5, 0x4c, 0xc1, 0xe7, 0xb2, 0x47, 0x88, 0x0d,
-		0xe8, 0xe4, 0x28, 0xb5, 0xce, 0xbd, 0x4c, 0x6c, 0x86, 0xa9, 0x70, 0x3c, 0x42, 0xc1, 0x42, 0x7f,
-		0xbb, 0x55, 0xb0, 0xdf, 0x2d, 0x15, 0x8e, 0x27, 0xff, 0x4d, 0x09, 0x60, 0x91, 0x58, 0x96, 0xea,
-		0x4b, 0x66, 0x21, 0x9b, 0x8a, 0x50, 0x0e, 0xb4, 0x3c, 0xd5, 0xa9, 0xd3, 0x78, 0xfb, 0x29, 0xdb,
-		0x2f, 0xf7, 0x1c, 0x8c, 0x78, 0xce, 0x68, 0x63, 0x21, 0xcc, 0x54, 0x97, 0xac, 0x7a, 0x0d, 0x3b,
-		0x4a, 0xea, 0x8a, 0xaf, 0x24, 0xff, 0x73, 0x09, 0x92, 0x54, 0xa6, 0x25, 0xec, 0xa8, 0x81, 0x3e,
-		0x94, 0x0e, 0xde, 0x87, 0x27, 0x00, 0x18, 0x1b, 0x5b, 0xbb, 0x86, 0xb9, 0x67, 0x25, 0x29, 0x64,
-		0x4d, 0xbb, 0x86, 0xd1, 0x39, 0xd7, 0xe0, 0xd1, 0xee, 0x06, 0x17, 0x59, 0x37, 0x37, 0xfb, 0x11,
-		0x18, 0xa2, 0x9f, 0xa5, 0xda, 0xb5, 0x79, 0x22, 0x3d, 0xa8, 0x37, 0x1b, 0xeb, 0xbb, 0xb6, 0xfc,
-		0x22, 0x0c, 0xad, 0xef, 0xb2, 0xbd, 0x91, 0x63, 0x90, 0xb4, 0x0c, 0x83, 0xcf, 0xc9, 0x2c, 0x17,
-		0x4a, 0x10, 0x00, 0x9d, 0x82, 0xc4, 0x7e, 0x40, 0xc4, 0xdb, 0x0f, 0xf0, 0x36, 0x34, 0xa2, 0x7d,
-		0x6d, 0x68, 0x9c, 0xfa, 0xf7, 0x12, 0x0c, 0xfb, 0xe2, 0x03, 0x7a, 0x14, 0x0e, 0x15, 0x16, 0x57,
-		0xe6, 0x2e, 0x95, 0x17, 0x8a, 0xe5, 0x0b, 0x8b, 0xf9, 0x79, 0xef, 0xdd, 0x56, 0xf6, 0xf0, 0xf5,
-		0x1b, 0x33, 0xc8, 0x87, 0xbb, 0xa1, 0xd3, 0x1d, 0x25, 0x74, 0x1a, 0x26, 0x83, 0x24, 0xf9, 0xc2,
-		0x5a, 0x69, 0x79, 0x3d, 0x2d, 0x65, 0x0f, 0x5d, 0xbf, 0x31, 0x33, 0xee, 0xa3, 0xc8, 0x6f, 0xda,
-		0x58, 0x77, 0x5a, 0x09, 0xe6, 0x56, 0x96, 0x96, 0x16, 0xd6, 0xd3, 0x91, 0x16, 0x02, 0x1e, 0xb0,
-		0x1f, 0x80, 0xf1, 0x20, 0xc1, 0xf2, 0xc2, 0x62, 0x3a, 0x9a, 0x45, 0xd7, 0x6f, 0xcc, 0x8c, 0xfa,
-		0xb0, 0x97, 0xb5, 0x7a, 0x36, 0xf1, 0x81, 0xcf, 0x4c, 0x0d, 0xfc, 0xd2, 0x2f, 0x4e, 0x49, 0x44,
-		0xb3, 0x91, 0x40, 0x8c, 0x40, 0x0f, 0xc1, 0x91, 0xb5, 0x85, 0xf9, 0xe5, 0x52, 0xb1, 0xbc, 0xb4,
-		0x36, 0x2f, 0xf6, 0x9d, 0x85, 0x76, 0x63, 0xd7, 0x6f, 0xcc, 0x0c, 0x73, 0x95, 0x3a, 0x61, 0xaf,
-		0x2a, 0xa5, 0xcb, 0x2b, 0xeb, 0xa5, 0xb4, 0xc4, 0xb0, 0x57, 0x2d, 0x7c, 0xc5, 0x70, 0xd8, 0x77,
-		0xeb, 0x1e, 0x81, 0xa3, 0x6d, 0xb0, 0x5d, 0xc5, 0xc6, 0xaf, 0xdf, 0x98, 0x19, 0x59, 0xb5, 0x30,
-		0x1b, 0x3f, 0x94, 0x62, 0x16, 0x32, 0xad, 0x14, 0x2b, 0xab, 0x2b, 0x6b, 0xf9, 0xc5, 0xf4, 0x4c,
-		0x36, 0x7d, 0xfd, 0xc6, 0x4c, 0x4a, 0x04, 0x43, 0xba, 0xb9, 0xef, 0x6a, 0x76, 0x27, 0x57, 0x3c,
-		0x7f, 0xfc, 0x30, 0xdc, 0xd3, 0xe1, 0x5c, 0x49, 0x9c, 0x48, 0x1c, 0xe8, 0x64, 0xa9, 0xe3, 0xde,
-		0x7a, 0xb6, 0xc7, 0xf6, 0x73, 0xef, 0xa5, 0xd3, 0xc1, 0x4f, 0xad, 0xb2, 0x5d, 0x17, 0x77, 0xf2,
-		0x07, 0x25, 0x18, 0xbd, 0xa8, 0xd9, 0x8e, 0x61, 0x69, 0x15, 0xb5, 0x4e, 0x5f, 0x6b, 0x9d, 0xeb,
-		0x37, 0xb6, 0x86, 0x86, 0xfa, 0xd3, 0x30, 0x78, 0x45, 0xad, 0xb3, 0xa0, 0x16, 0xa5, 0x1f, 0x97,
-		0xe9, 0x70, 0xcc, 0xe3, 0x86, 0x36, 0xc1, 0x80, 0x91, 0xc9, 0xbf, 0x12, 0x81, 0x31, 0x3a, 0x18,
-		0x6c, 0xf6, 0xd9, 0x31, 0xb2, 0xc6, 0x2a, 0x40, 0xcc, 0x52, 0x1d, 0xbe, 0x69, 0x58, 0x98, 0xe5,
-		0x27, 0x8e, 0xf7, 0xf5, 0x71, 0x7e, 0x56, 0xc4, 0x15, 0x85, 0xd2, 0xa2, 0x77, 0x40, 0xa2, 0xa1,
-		0xee, 0x96, 0x29, 0x1f, 0xb6, 0x72, 0xc9, 0xef, 0x8f, 0xcf, 0xad, 0x9b, 0xd3, 0x63, 0x7b, 0x6a,
-		0xa3, 0x9e, 0x93, 0x05, 0x1f, 0x59, 0x19, 0x6a, 0xa8, 0xbb, 0x44, 0x44, 0x64, 0xc2, 0x18, 0x81,
-		0x56, 0xb6, 0x55, 0xbd, 0x86, 0x59, 0x23, 0x74, 0x0b, 0xb4, 0x70, 0x71, 0xdf, 0x8d, 0x1c, 0xf6,
-		0x1a, 0xf1, 0xb1, 0x93, 0x95, 0x91, 0x86, 0xba, 0x3b, 0x47, 0x01, 0xa4, 0xc5, 0x5c, 0xe2, 0xa3,
-		0x9f, 0x9a, 0x1e, 0xa0, 0xa7, 0xb8, 0xdf, 0x92, 0x00, 0x3c, 0x8b, 0xa1, 0x77, 0x40, 0xba, 0xe2,
-		0x96, 0x28, 0xad, 0x38, 0x8f, 0xbc, 0xbf, 0x53, 0x5f, 0x84, 0xec, 0xcd, 0xe6, 0xe6, 0x6f, 0xde,
-		0x9c, 0x96, 0x94, 0xb1, 0x4a, 0xa8, 0x2b, 0xde, 0x0e, 0xc3, 0x4d, 0xb3, 0xaa, 0x3a, 0xb8, 0x4c,
-		0xd7, 0x71, 0x91, 0x9e, 0xf3, 0xfc, 0x14, 0xe1, 0x75, 0xeb, 0xe6, 0x34, 0x62, 0x6a, 0xf9, 0x88,
-		0x65, 0x3a, 0xfb, 0x03, 0x83, 0x10, 0x02, 0x9f, 0x4e, 0x5f, 0x97, 0x60, 0xb8, 0xe8, 0xbb, 0x47,
-		0x99, 0x81, 0xa1, 0x86, 0xa1, 0x6b, 0x3b, 0xdc, 0x1f, 0x93, 0x8a, 0x28, 0xa2, 0x2c, 0x24, 0xd8,
-		0x03, 0x56, 0x67, 0x4f, 0x6c, 0x85, 0x8a, 0x32, 0xa1, 0xba, 0x8a, 0x37, 0x6d, 0x4d, 0xf4, 0x86,
-		0x22, 0x8a, 0xe8, 0x02, 0xa4, 0x6d, 0x5c, 0x69, 0x5a, 0x9a, 0xb3, 0x57, 0xae, 0x18, 0xba, 0xa3,
-		0x56, 0x1c, 0xf6, 0x14, 0xb2, 0x70, 0xec, 0xd6, 0xcd, 0xe9, 0x23, 0x4c, 0xd6, 0x30, 0x86, 0xac,
-		0x8c, 0x09, 0xd0, 0x1c, 0x83, 0x90, 0x16, 0xaa, 0xd8, 0x51, 0xb5, 0xba, 0x9d, 0x61, 0x17, 0x12,
-		0x44, 0xd1, 0xa7, 0xcb, 0xe7, 0x87, 0xfc, 0x1b, 0x5b, 0x17, 0x20, 0x6d, 0x98, 0xd8, 0x0a, 0x24,
-		0xa2, 0x52, 0xb8, 0xe5, 0x30, 0x86, 0xac, 0x8c, 0x09, 0x90, 0x48, 0x52, 0x1d, 0xd2, 0xcd, 0x62,
-		0xa1, 0x68, 0x36, 0x37, 0xbd, 0xfd, 0xb0, 0xc9, 0x96, 0xde, 0xc8, 0xeb, 0x7b, 0x85, 0xc7, 0x3c,
-		0xee, 0x61, 0x3a, 0xf9, 0x1b, 0x5f, 0x7a, 0x78, 0x92, 0xbb, 0x86, 0xb7, 0x3f, 0x75, 0x09, 0xef,
-		0x91, 0xee, 0xe7, 0xa8, 0xab, 0x14, 0x93, 0xa4, 0x9d, 0x2f, 0xaa, 0x5a, 0x5d, 0x3c, 0xe9, 0x57,
-		0x78, 0x09, 0xe5, 0x60, 0xd0, 0x76, 0x54, 0xa7, 0x69, 0xf3, 0xd3, 0x5d, 0xb9, 0x93, 0xab, 0x15,
-		0x0c, 0xbd, 0xba, 0x46, 0x31, 0x15, 0x4e, 0x81, 0x2e, 0xc0, 0x20, 0x3f, 0x36, 0x8f, 0xef, 0x7b,
-		0x7c, 0xd3, 0xfb, 0x11, 0x8c, 0x9a, 0x58, 0xa4, 0x8a, 0xeb, 0xb8, 0xc6, 0xd2, 0xaa, 0x6d, 0x95,
-		0xac, 0x3e, 0xe8, 0xf7, 0xf6, 0x0a, 0x0b, 0xfb, 0x1e, 0x84, 0xdc, 0x52, 0x61, 0x7e, 0xb2, 0x32,
-		0xe6, 0x82, 0xd6, 0x28, 0x04, 0x5d, 0x0a, 0x5c, 0xf8, 0xe5, 0x1f, 0xa5, 0xbc, 0xbb, 0x93, 0xfa,
-		0x3e, 0x9f, 0x16, 0xfb, 0x13, 0xfe, 0xeb, 0xc2, 0x17, 0x20, 0xdd, 0xd4, 0x37, 0x0d, 0x9d, 0xbe,
-		0xbb, 0xe5, 0xf9, 0x3d, 0x59, 0xdf, 0x45, 0xfd, 0xce, 0x11, 0xc6, 0x90, 0x95, 0x31, 0x17, 0x74,
-		0x91, 0xad, 0x02, 0xaa, 0x30, 0xea, 0x61, 0xd1, 0x81, 0x9a, 0xec, 0x39, 0x50, 0xef, 0xe2, 0x03,
-		0xf5, 0x50, 0xb8, 0x15, 0x6f, 0xac, 0x8e, 0xb8, 0x40, 0x42, 0x86, 0x2e, 0x02, 0x78, 0xe1, 0x81,
-		0xee, 0x53, 0x0c, 0x77, 0xee, 0x78, 0x2f, 0xc6, 0x88, 0xf5, 0x9e, 0x47, 0x8b, 0xde, 0x05, 0x13,
-		0x0d, 0x4d, 0x2f, 0xdb, 0xb8, 0xbe, 0x55, 0xe6, 0x06, 0x26, 0x2c, 0xe9, 0x67, 0x93, 0x0a, 0x8b,
-		0xfb, 0xf3, 0x87, 0x5b, 0x37, 0xa7, 0xb3, 0x3c, 0x84, 0xb6, 0xb2, 0x94, 0x95, 0xf1, 0x86, 0xa6,
-		0xaf, 0xe1, 0xfa, 0x56, 0xd1, 0x85, 0xe5, 0x52, 0x1f, 0xf8, 0xd4, 0xf4, 0x00, 0x1f, 0xae, 0x03,
-		0xf2, 0x39, 0xba, 0x77, 0xce, 0x87, 0x19, 0xb6, 0xc9, 0x9a, 0x44, 0x15, 0x05, 0x7e, 0xbd, 0xc0,
-		0x03, 0xb0, 0x61, 0xfe, 0xf2, 0x7f, 0x9c, 0x91, 0xe4, 0xcf, 0x4b, 0x30, 0x58, 0xbc, 0xbc, 0xaa,
-		0x6a, 0x16, 0x5a, 0x80, 0x71, 0xcf, 0x73, 0x82, 0x83, 0xfc, 0xf8, 0xad, 0x9b, 0xd3, 0x99, 0xb0,
-		0x73, 0xb9, 0xa3, 0xdc, 0x73, 0x60, 0x31, 0xcc, 0x17, 0x3a, 0x2d, 0x5c, 0x03, 0xac, 0x5a, 0x50,
-		0xe4, 0xd6, 0x65, 0x6d, 0x48, 0xcd, 0x12, 0x0c, 0x31, 0x69, 0x6d, 0x94, 0x83, 0xb8, 0x49, 0x7e,
-		0xf0, 0x83, 0x81, 0xa9, 0x8e, 0xce, 0x4b, 0xf1, 0xdd, 0x8d, 0x4c, 0x42, 0x22, 0x7f, 0x38, 0x02,
-		0x50, 0xbc, 0x7c, 0x79, 0xdd, 0xd2, 0xcc, 0x3a, 0x76, 0x6e, 0xa7, 0xe6, 0xeb, 0x70, 0xc8, 0xb7,
-		0x4a, 0xb2, 0x2a, 0x21, 0xed, 0x67, 0x6e, 0xdd, 0x9c, 0x3e, 0x1e, 0xd6, 0xde, 0x87, 0x26, 0x2b,
-		0x13, 0xde, 0x7a, 0xc9, 0xaa, 0xb4, 0xe5, 0x5a, 0xb5, 0x1d, 0x97, 0x6b, 0xb4, 0x33, 0x57, 0x1f,
-		0x9a, 0x9f, 0x6b, 0xd1, 0x76, 0xda, 0x9b, 0x76, 0x0d, 0x86, 0x3d, 0x93, 0xd8, 0xa8, 0x08, 0x09,
-		0x87, 0xff, 0xe6, 0x16, 0x96, 0x3b, 0x5b, 0x58, 0x90, 0x71, 0x2b, 0xbb, 0x94, 0xf2, 0x9f, 0x4a,
-		0x00, 0x9e, 0xcf, 0xfe, 0x64, 0xba, 0x18, 0x09, 0xe5, 0x3c, 0xf0, 0x46, 0x0f, 0x94, 0xaa, 0x71,
-		0xea, 0x90, 0x3d, 0x7f, 0x26, 0x02, 0x13, 0x1b, 0x22, 0xf2, 0xfc, 0xc4, 0xdb, 0x60, 0x15, 0x86,
-		0xb0, 0xee, 0x58, 0x1a, 0x35, 0x02, 0xe9, 0xed, 0x47, 0x3a, 0xf5, 0x76, 0x1b, 0x9d, 0xe8, 0x87,
-		0xa3, 0xc4, 0xa6, 0x3b, 0x67, 0x13, 0xb2, 0xc6, 0xcf, 0x45, 0x21, 0xd3, 0x89, 0x12, 0xcd, 0xc1,
-		0x58, 0xc5, 0xc2, 0xec, 0xb2, 0x95, 0x7f, 0xe7, 0xaf, 0x90, 0xf5, 0x32, 0xcb, 0x10, 0x82, 0xac,
-		0x8c, 0x0a, 0x08, 0x9f, 0x3d, 0x6a, 0x40, 0xd2, 0x3e, 0xe2, 0x76, 0xf4, 0xce, 0x56, 0x7f, 0x79,
-		0x9e, 0xcc, 0xa7, 0x0f, 0xd1, 0x48, 0x90, 0x01, 0x9b, 0x3f, 0x46, 0x3d, 0x28, 0x9d, 0x40, 0x5e,
-		0x82, 0x31, 0x4d, 0xd7, 0x1c, 0x4d, 0xad, 0x97, 0x37, 0xd5, 0xba, 0xaa, 0x57, 0x0e, 0x92, 0x35,
-		0xb3, 0x90, 0xcf, 0x9b, 0x0d, 0xb1, 0x93, 0x95, 0x51, 0x0e, 0x29, 0x30, 0x00, 0xba, 0x08, 0x43,
-		0xa2, 0xa9, 0xd8, 0x81, 0xb2, 0x0d, 0x41, 0xee, 0x4b, 0xf0, 0x7e, 0x36, 0x0a, 0xe3, 0x0a, 0xae,
-		0xfe, 0x45, 0x57, 0xec, 0xaf, 0x2b, 0x96, 0x00, 0xd8, 0x70, 0x27, 0x01, 0xf6, 0x00, 0xbd, 0x41,
-		0x02, 0x46, 0x92, 0x71, 0x28, 0xda, 0x8e, 0xaf, 0x3f, 0x6e, 0x46, 0x20, 0xe5, 0xef, 0x8f, 0x3f,
-		0xa7, 0xb3, 0x12, 0x5a, 0xf0, 0x22, 0x51, 0x8c, 0x7f, 0x6e, 0xb7, 0x43, 0x24, 0x6a, 0xf1, 0xde,
-		0xee, 0x21, 0xe8, 0x7f, 0x46, 0x60, 0x70, 0x55, 0xb5, 0xd4, 0x86, 0x8d, 0x2a, 0x2d, 0x99, 0xa6,
-		0xd8, 0x7e, 0x6c, 0xf9, 0xa8, 0x3a, 0xdf, 0xed, 0xe8, 0x91, 0x68, 0x7e, 0xb4, 0x4d, 0xa2, 0xf9,
-		0x56, 0x18, 0x25, 0xcb, 0x61, 0xdf, 0x15, 0x06, 0x62, 0xed, 0x91, 0xc2, 0x51, 0x8f, 0x4b, 0xb0,
-		0x9e, 0xad, 0x96, 0x2f, 0xfb, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0x2f, 0x30, 0x13, 0xf2, 0xc3, 0xde,
-		0xb2, 0xd4, 0x57, 0x29, 0x2b, 0xd0, 0x50, 0x77, 0x4b, 0xac, 0x80, 0x16, 0x01, 0x6d, 0xbb, 0x3b,
-		0x23, 0x65, 0xcf, 0x9c, 0x84, 0xfe, 0xc4, 0xad, 0x9b, 0xd3, 0x47, 0x19, 0x7d, 0x2b, 0x8e, 0xac,
-		0x8c, 0x7b, 0x40, 0xc1, 0xed, 0x71, 0x00, 0xa2, 0x57, 0x99, 0x5d, 0xdb, 0x66, 0xcb, 0x9d, 0x43,
-		0xb7, 0x6e, 0x4e, 0x8f, 0x33, 0x2e, 0x5e, 0x9d, 0xac, 0x24, 0x49, 0xa1, 0x48, 0x7e, 0xfb, 0x3c,
-		0xfb, 0x33, 0x12, 0x20, 0x2f, 0xe4, 0x2b, 0xd8, 0x36, 0xc9, 0xfa, 0x8c, 0x24, 0xe2, 0xbe, 0xac,
-		0x59, 0xea, 0x9e, 0x88, 0x7b, 0xf4, 0x22, 0x11, 0xf7, 0x8d, 0x94, 0xa7, 0xbc, 0xf0, 0x18, 0xe9,
-		0x75, 0x87, 0x99, 0xbb, 0x48, 0x38, 0x1e, 0x0e, 0xc8, 0xff, 0x4a, 0x82, 0xa3, 0x2d, 0x1e, 0xe5,
-		0x0a, 0xfb, 0x97, 0x00, 0x59, 0xbe, 0x4a, 0xfe, 0xed, 0x44, 0x26, 0xf4, 0xbe, 0x1d, 0x74, 0xdc,
-		0x6a, 0x89, 0xbb, 0xb7, 0x2f, 0xc2, 0xb3, 0x4b, 0xf2, 0xff, 0x4c, 0x82, 0x49, 0x7f, 0xf3, 0xae,
-		0x22, 0xcb, 0x90, 0xf2, 0xb7, 0xce, 0x55, 0xb8, 0xa7, 0x1f, 0x15, 0xb8, 0xf4, 0x01, 0x7a, 0xf4,
-		0xac, 0x37, 0x5c, 0xd9, 0xde, 0xd9, 0xa3, 0x7d, 0x5b, 0x43, 0xc8, 0x14, 0x1e, 0xb6, 0x31, 0xda,
-		0x1f, 0xff, 0x57, 0x82, 0xd8, 0xaa, 0x61, 0xd4, 0x91, 0x01, 0xe3, 0xba, 0xe1, 0x94, 0x89, 0x67,
-		0xe1, 0xaa, 0xff, 0xae, 0x7a, 0xb2, 0x30, 0xb7, 0x3f, 0x23, 0x7d, 0xef, 0xe6, 0x74, 0x2b, 0x2b,
-		0x65, 0x4c, 0x37, 0x9c, 0x02, 0x85, 0xf0, 0xeb, 0xea, 0xef, 0x82, 0x91, 0x60, 0x63, 0x2c, 0x4a,
-		0x3e, 0xb7, 0xef, 0xc6, 0x82, 0x6c, 0x6e, 0xdd, 0x9c, 0x9e, 0xf4, 0x46, 0x8c, 0x0b, 0x96, 0x95,
-		0xd4, 0xa6, 0xaf, 0x75, 0x76, 0xbd, 0xeb, 0x07, 0x9f, 0x9a, 0x96, 0x4e, 0x7d, 0x59, 0x02, 0xf0,
-		0x76, 0x1e, 0xd0, 0x43, 0x70, 0xa4, 0xb0, 0xb2, 0x5c, 0x2c, 0xaf, 0xad, 0xe7, 0xd7, 0x37, 0xd6,
-		0x82, 0xf7, 0xba, 0xc5, 0xf6, 0xb8, 0x6d, 0xe2, 0x8a, 0xb6, 0xa5, 0xe1, 0x2a, 0xba, 0x0f, 0x26,
-		0x83, 0xd8, 0xa4, 0x54, 0x2a, 0xa6, 0xa5, 0x6c, 0xea, 0xfa, 0x8d, 0x99, 0x04, 0xcb, 0xc5, 0x70,
-		0x15, 0x9d, 0x84, 0x43, 0xad, 0x78, 0x0b, 0xcb, 0xf3, 0xe9, 0x48, 0x76, 0xe4, 0xfa, 0x8d, 0x99,
-		0xa4, 0x9b, 0xb4, 0x21, 0x19, 0x90, 0x1f, 0x93, 0xf3, 0x8b, 0x66, 0xe1, 0xfa, 0x8d, 0x99, 0x41,
-		0x66, 0xc0, 0x6c, 0xec, 0x03, 0x9f, 0x99, 0x1a, 0xb8, 0xed, 0xb7, 0xbf, 0xff, 0x68, 0xa8, 0xe3,
-		0xae, 0x77, 0x0d, 0xeb, 0xd8, 0xd6, 0xec, 0x03, 0xed, 0x7a, 0xf7, 0xb5, 0x93, 0x2e, 0xff, 0x4e,
-		0x1c, 0x52, 0xf3, 0xac, 0x15, 0xd2, 0x11, 0x18, 0xbd, 0x09, 0x06, 0x4d, 0x3a, 0x8d, 0xb8, 0xc7,
-		0x68, 0x1d, 0x1c, 0x9e, 0x4d, 0x36, 0xee, 0x5d, 0x2e, 0x36, 0xf5, 0xd8, 0xfc, 0x32, 0x07, 0xbb,
-		0x63, 0xe6, 0xdd, 0x9a, 0x4a, 0xed, 0x6b, 0xbf, 0x87, 0xe5, 0x2c, 0x7c, 0x6b, 0x25, 0xcc, 0x4f,
-		0x66, 0xf7, 0x42, 0xd6, 0x09, 0x84, 0xdd, 0x0e, 0x7b, 0x9f, 0x04, 0x87, 0x28, 0x96, 0x37, 0x11,
-		0x53, 0x4c, 0x91, 0xec, 0x9f, 0xea, 0xa4, 0xc2, 0xa2, 0x6a, 0x7b, 0x77, 0x3d, 0xd8, 0x7d, 0xae,
-		0x7b, 0xf8, 0x44, 0x78, 0xdc, 0xd7, 0x78, 0x98, 0xad, 0xac, 0x4c, 0xd4, 0x5b, 0x28, 0x6d, 0x34,
-		0x1f, 0xb8, 0xd0, 0x17, 0xdb, 0xdf, 0x56, 0xbb, 0xff, 0x72, 0xdf, 0x33, 0x30, 0xec, 0xc5, 0x12,
-		0x9b, 0xff, 0xaf, 0x97, 0xfe, 0xe7, 0x0e, 0x3f, 0x31, 0x7a, 0xbf, 0x04, 0x87, 0xbc, 0xd9, 0xdc,
-		0xcf, 0x96, 0xfd, 0x4f, 0x9c, 0x07, 0xf7, 0xb1, 0x10, 0x0a, 0x1b, 0xa7, 0x2d, 0x5f, 0x59, 0x99,
-		0x6c, 0xb6, 0x92, 0x92, 0x25, 0xd8, 0x88, 0x3f, 0xb2, 0xda, 0x19, 0xf1, 0xd9, 0xc7, 0xfe, 0x43,
-		0x73, 0x90, 0x01, 0xfb, 0x3f, 0x1d, 0xa6, 0x61, 0x39, 0xb8, 0x4a, 0x37, 0xe4, 0x12, 0x8a, 0x5b,
-		0x96, 0x97, 0x01, 0xb5, 0x76, 0x6e, 0xf8, 0x02, 0xa3, 0xf7, 0x26, 0x05, 0x4d, 0x42, 0xdc, 0x7f,
-		0xc5, 0x8f, 0x15, 0x72, 0x89, 0x0f, 0xf0, 0xe9, 0xf3, 0xb6, 0x8f, 0xf9, 0x7f, 0x11, 0x81, 0x53,
-		0xfe, 0xe3, 0xa1, 0x97, 0x9a, 0xd8, 0xda, 0x73, 0x87, 0xa8, 0xa9, 0xd6, 0x34, 0xdd, 0xff, 0x0a,
-		0xe2, 0xa8, 0x7f, 0xc2, 0xa7, 0xb8, 0xc2, 0x4e, 0xb2, 0x0e, 0xc3, 0xab, 0x6a, 0x0d, 0x2b, 0xf8,
-		0xa5, 0x26, 0xb6, 0x9d, 0x36, 0x97, 0xcc, 0x0f, 0xc3, 0xa0, 0xb1, 0xb5, 0x25, 0x8e, 0xb4, 0x63,
-		0x0a, 0x2f, 0x11, 0x95, 0xeb, 0x5a, 0x43, 0x63, 0xb7, 0xc1, 0x62, 0x0a, 0x2b, 0xa0, 0x69, 0x18,
-		0xae, 0x18, 0x4d, 0x9d, 0x8f, 0xb8, 0x4c, 0x4c, 0x7c, 0x5e, 0xa5, 0xa9, 0xb3, 0x11, 0x27, 0x3f,
-		0x0d, 0x29, 0xd6, 0x1e, 0x9f, 0x71, 0x8f, 0x42, 0x82, 0x5e, 0xa7, 0xf2, 0x5a, 0x1d, 0x22, 0xe5,
-		0x4b, 0xec, 0x42, 0x3a, 0xe3, 0xc2, 0x1a, 0x66, 0x85, 0x42, 0xa1, 0xa3, 0x29, 0x4f, 0xf6, 0x0e,
-		0x0d, 0xcc, 0x50, 0xae, 0x19, 0x7f, 0x23, 0x0e, 0x87, 0xf8, 0x09, 0x9d, 0x6a, 0x6a, 0xa7, 0xb7,
-		0x1d, 0x47, 0x3c, 0x90, 0x00, 0x9e, 0xea, 0xaa, 0xa6, 0x26, 0xef, 0x41, 0xec, 0xa2, 0xe3, 0x98,
-		0xe8, 0x14, 0xc4, 0xad, 0x66, 0x1d, 0x8b, 0x1d, 0x1f, 0x77, 0x4f, 0x5e, 0x35, 0xb5, 0x59, 0x82,
-		0xa0, 0x34, 0xeb, 0x58, 0x61, 0x28, 0xa8, 0x04, 0xd3, 0x5b, 0xcd, 0x7a, 0x7d, 0xaf, 0x5c, 0xc5,
-		0xf4, 0xff, 0x60, 0xb9, 0xff, 0x49, 0x02, 0xef, 0x9a, 0xaa, 0xf8, 0x1e, 0x25, 0xb1, 0xcd, 0x71,
-		0x8a, 0x56, 0xa4, 0x58, 0xe2, 0xbf, 0x48, 0x94, 0x04, 0x8e, 0xfc, 0x7b, 0x11, 0x48, 0x08, 0xd6,
-		0xf4, 0x86, 0x38, 0xae, 0xe3, 0x8a, 0x63, 0x88, 0x13, 0x13, 0xb7, 0x8c, 0x10, 0x44, 0x6b, 0xbc,
-		0x8b, 0x92, 0x17, 0x07, 0x14, 0x52, 0x20, 0x30, 0xf7, 0xde, 0x3e, 0x81, 0x99, 0x4d, 0xd2, 0x6b,
-		0x31, 0xd3, 0x10, 0x4b, 0xb3, 0x8b, 0x03, 0x0a, 0x2d, 0xa1, 0x0c, 0x0c, 0x92, 0x91, 0xe1, 0xb0,
-		0x8f, 0x7c, 0x12, 0x38, 0x2f, 0xa3, 0xc3, 0x10, 0x37, 0x55, 0xa7, 0xc2, 0xae, 0xd4, 0x91, 0x0a,
-		0x56, 0x44, 0x4f, 0xc0, 0x20, 0x7b, 0x6e, 0x1d, 0xfe, 0x27, 0x33, 0xc4, 0x18, 0xec, 0xbb, 0x76,
-		0x44, 0xee, 0x55, 0xd5, 0x71, 0xb0, 0xa5, 0x13, 0x86, 0x0c, 0x1d, 0x21, 0x88, 0x6d, 0x1a, 0xd5,
-		0x3d, 0xfe, 0x8f, 0x6f, 0xe8, 0x6f, 0xfe, 0x9f, 0x36, 0xa8, 0x3f, 0x94, 0x69, 0x25, 0xfb, 0x7f,
-		0x5f, 0x29, 0x01, 0x2c, 0x10, 0xa4, 0x12, 0x4c, 0xa8, 0xd5, 0xaa, 0xc6, 0xfe, 0x07, 0x4d, 0x79,
-		0x53, 0xa3, 0x11, 0xc2, 0xa6, 0xff, 0xcd, 0xad, 0x53, 0x5f, 0x20, 0x8f, 0xa0, 0xc0, 0xf1, 0x0b,
-		0x49, 0x18, 0x32, 0x99, 0x50, 0xf2, 0x79, 0x18, 0x6f, 0x91, 0x94, 0xc8, 0xb7, 0xa3, 0xe9, 0x55,
-		0xf1, 0x98, 0x81, 0xfc, 0x26, 0x30, 0xfa, 0x25, 0x4a, 0x76, 0x16, 0x45, 0x7f, 0x17, 0xde, 0xd3,
-		0xf9, 0xcd, 0xcb, 0xa8, 0xef, 0xcd, 0x8b, 0x6a, 0x6a, 0x85, 0x24, 0xe5, 0xcf, 0x5f, 0xba, 0xe4,
-		0x5b, 0x5f, 0xba, 0xd4, 0xb0, 0x2e, 0x66, 0x5f, 0x52, 0xa5, 0x9a, 0x9a, 0x4d, 0xdd, 0xd1, 0xfb,
-		0x32, 0xa6, 0x7d, 0xde, 0xf7, 0x9b, 0x3e, 0x7c, 0x89, 0xcd, 0xe7, 0x57, 0x17, 0x5c, 0x3f, 0xfe,
-		0x6a, 0x04, 0x8e, 0xfb, 0xfc, 0xd8, 0x87, 0xdc, 0xea, 0xce, 0xd9, 0xf6, 0x1e, 0xdf, 0xc7, 0xa3,
-		0xe3, 0x4b, 0x10, 0x23, 0xf8, 0xa8, 0xc7, 0xff, 0xc1, 0xc8, 0xfc, 0xea, 0x37, 0xfe, 0xa9, 0x1c,
-		0x3c, 0xb5, 0x0a, 0xf4, 0x0a, 0x65, 0x52, 0x78, 0x7f, 0xff, 0xf6, 0x4b, 0x7b, 0x1f, 0x05, 0xb5,
-		0x6f, 0x9f, 0x19, 0xc3, 0x36, 0xfc, 0xee, 0xd9, 0x8e, 0x8f, 0x52, 0x59, 0xc4, 0xec, 0x9e, 0x44,
-		0xed, 0x23, 0x1c, 0x77, 0xba, 0xff, 0xdf, 0xad, 0x07, 0xfb, 0x4c, 0xc7, 0x76, 0xe1, 0xf0, 0xb3,
-		0xa4, 0x6d, 0x6f, 0x99, 0x2c, 0x02, 0xfb, 0x61, 0xf7, 0x34, 0x4f, 0xe2, 0xff, 0x4c, 0x4f, 0x9c,
-		0xd4, 0x81, 0x27, 0x1f, 0x5f, 0x20, 0xde, 0x37, 0xdb, 0x71, 0xbe, 0x98, 0xf5, 0x4d, 0x16, 0x8a,
-		0x8f, 0x52, 0xfe, 0x65, 0x09, 0x8e, 0xb4, 0x34, 0xcd, 0x63, 0xfc, 0x7c, 0x9b, 0xa7, 0x0a, 0x07,
-		0xca, 0x6c, 0xe6, 0xdb, 0x08, 0x7b, 0x7f, 0x4f, 0x61, 0x99, 0x14, 0x01, 0x69, 0xdf, 0x02, 0x87,
-		0x82, 0xc2, 0x0a, 0x33, 0xdd, 0x0b, 0xa3, 0xc1, 0x1d, 0x61, 0x6e, 0xae, 0x91, 0xc0, 0x9e, 0xb0,
-		0x5c, 0x0e, 0xdb, 0xd9, 0xd5, 0xb5, 0x04, 0x49, 0x17, 0x95, 0xa7, 0xc0, 0x7d, 0xab, 0xea, 0x51,
-		0xca, 0x1f, 0x96, 0x60, 0x26, 0xd8, 0x82, 0x2f, 0x19, 0xda, 0x9f, 0xb0, 0xb7, 0xad, 0x8b, 0x5f,
-		0x93, 0xe0, 0xae, 0x2e, 0x32, 0x71, 0x03, 0x5c, 0x83, 0x49, 0xdf, 0x4e, 0x80, 0x08, 0xe1, 0xa2,
-		0xdb, 0x4f, 0xf5, 0x4e, 0x43, 0xdd, 0x85, 0xef, 0x31, 0x62, 0x94, 0xcf, 0x7d, 0x7b, 0x7a, 0xa2,
-		0xb5, 0xce, 0x56, 0x26, 0x5a, 0x57, 0xef, 0xb7, 0xd1, 0x3f, 0x5e, 0x91, 0xe0, 0x81, 0xa0, 0xaa,
-		0x6d, 0xf2, 0xd9, 0x37, 0xaa, 0x1f, 0xfe, 0x83, 0x04, 0xa7, 0xfa, 0x11, 0x8e, 0x77, 0xc8, 0x26,
-		0x4c, 0x78, 0x99, 0x76, 0xb8, 0x3f, 0xf6, 0x95, 0xbf, 0x33, 0x2f, 0x45, 0x2e, 0xb7, 0x3b, 0x60,
-		0x78, 0x93, 0x0f, 0x2c, 0x7f, 0x97, 0xbb, 0x46, 0x0e, 0xee, 0xe6, 0x0a, 0x23, 0x07, 0xf6, 0x73,
-		0xdb, 0xf4, 0x45, 0xa4, 0x4d, 0x5f, 0x78, 0xa9, 0xb9, 0x7c, 0x85, 0xc7, 0xad, 0x36, 0x7b, 0x70,
-		0x6f, 0x87, 0x89, 0x36, 0xae, 0xcc, 0x47, 0xf5, 0x3e, 0x3c, 0x59, 0x41, 0xad, 0xce, 0x2a, 0xef,
-		0xc1, 0x34, 0x6d, 0xb7, 0x8d, 0xa1, 0xef, 0xb4, 0xca, 0x0d, 0x1e, 0x5b, 0xda, 0x36, 0xcd, 0x75,
-		0x5f, 0x80, 0x41, 0xd6, 0xcf, 0x5c, 0xdd, 0x03, 0x38, 0x0a, 0x67, 0x20, 0x7f, 0x5c, 0xc4, 0xb2,
-		0xa2, 0x10, 0xbb, 0xfd, 0x18, 0xea, 0x47, 0xd7, 0xdb, 0x34, 0x86, 0x7c, 0xc6, 0xf8, 0x96, 0x88,
-		0x6a, 0xed, 0xa5, 0xe3, 0xe6, 0xa8, 0xdc, 0xb6, 0xa8, 0xc6, 0x6c, 0x73, 0x67, 0xc3, 0xd7, 0x2f,
-		0x8a, 0xf0, 0xe5, 0xea, 0xd4, 0x23, 0x7c, 0xbd, 0x31, 0xa6, 0x77, 0x03, 0x59, 0x0f, 0x31, 0xff,
-		0x2c, 0x06, 0xb2, 0x1f, 0x48, 0x70, 0x94, 0xea, 0xe6, 0xdf, 0x88, 0xd8, 0xaf, 0xc9, 0x1f, 0x02,
-		0x64, 0x5b, 0x95, 0x72, 0xdb, 0xd1, 0x9d, 0xb6, 0xad, 0xca, 0xe5, 0xc0, 0xfc, 0xf2, 0x10, 0xa0,
-		0x6a, 0x60, 0xbb, 0x89, 0x62, 0xb3, 0x5b, 0x72, 0xe9, 0xaa, 0x6f, 0x37, 0xa3, 0x4d, 0x77, 0xc6,
-		0x6e, 0x43, 0x77, 0x7e, 0x53, 0x82, 0x6c, 0x3b, 0x95, 0x79, 0xf7, 0x69, 0x70, 0x38, 0x70, 0x48,
-		0x10, 0xee, 0xc1, 0x87, 0xfa, 0xd9, 0xca, 0x09, 0x0d, 0xa3, 0x43, 0x16, 0xbe, 0xd3, 0x79, 0xc0,
-		0x74, 0xd0, 0x43, 0x5b, 0x33, 0xeb, 0x37, 0x6c, 0xf8, 0x7c, 0xa9, 0x25, 0xae, 0xfe, 0x99, 0xc8,
-		0xbd, 0x77, 0x61, 0xaa, 0x83, 0xd4, 0x77, 0x7a, 0xde, 0xdb, 0xee, 0xd8, 0x99, 0xb7, 0x3b, 0x7d,
-		0x7f, 0x9c, 0x8f, 0x84, 0xe0, 0x0d, 0x6c, 0xdf, 0x5a, 0xac, 0xdd, 0x13, 0x2e, 0xf9, 0x6d, 0x70,
-		0xac, 0x2d, 0x15, 0x97, 0x2d, 0x07, 0xb1, 0x6d, 0xcd, 0x76, 0xb8, 0x58, 0xf7, 0x75, 0x12, 0x2b,
-		0x44, 0x4d, 0x69, 0x64, 0x04, 0x69, 0xca, 0x7a, 0xd5, 0x30, 0xea, 0x5c, 0x0c, 0xf9, 0x12, 0x8c,
-		0xfb, 0x60, 0xbc, 0x91, 0x73, 0x10, 0x33, 0x0d, 0xfe, 0x79, 0x82, 0xe1, 0x33, 0xc7, 0x3b, 0xee,
-		0xde, 0x1b, 0x46, 0x9d, 0xab, 0x4d, 0xf1, 0xe5, 0x49, 0x40, 0x8c, 0x19, 0xdd, 0xc8, 0x17, 0x4d,
-		0xac, 0xc1, 0x44, 0x00, 0xca, 0x1b, 0x79, 0x5d, 0x87, 0x04, 0x67, 0xbe, 0x77, 0x08, 0xe2, 0x94,
-		0x2b, 0xfa, 0x98, 0x14, 0xf8, 0x66, 0xd0, 0x6c, 0x27, 0x36, 0xed, 0xd7, 0xc4, 0xd9, 0xd3, 0x7d,
-		0xe3, 0xf3, 0x9c, 0xed, 0xd4, 0x7b, 0xfe, 0xed, 0x77, 0x3f, 0x12, 0xb9, 0x07, 0xc9, 0xa7, 0x3b,
-		0xac, 0xc6, 0x7d, 0xe3, 0xe5, 0xb3, 0x81, 0xb7, 0xef, 0x0f, 0xf7, 0xd7, 0x94, 0x90, 0x6c, 0xb6,
-		0x5f, 0x74, 0x2e, 0xd8, 0x79, 0x2a, 0xd8, 0x59, 0xf4, 0x58, 0x6f, 0xc1, 0x4e, 0xbf, 0x33, 0x38,
-		0x68, 0xde, 0x8d, 0x7e, 0x47, 0x82, 0xc9, 0x76, 0x4b, 0x3a, 0xf4, 0x64, 0x7f, 0x52, 0xb4, 0xa6,
-		0x14, 0xd9, 0xa7, 0x0e, 0x40, 0xc9, 0x55, 0x99, 0xa7, 0xaa, 0xe4, 0xd1, 0xd3, 0x07, 0x50, 0xe5,
-		0xb4, 0x7f, 0x7f, 0xff, 0x7f, 0x4b, 0x70, 0xa2, 0xeb, 0x0a, 0x09, 0xe5, 0xfb, 0x93, 0xb2, 0x4b,
-		0xee, 0x94, 0x2d, 0xbc, 0x1e, 0x16, 0x5c, 0xe3, 0x67, 0xa9, 0xc6, 0x97, 0xd0, 0xc2, 0x41, 0x34,
-		0x6e, 0x7b, 0x88, 0x82, 0x7e, 0x33, 0x78, 0xb3, 0xb0, 0xbb, 0x3b, 0xb5, 0x2c, 0x3c, 0x7a, 0x0c,
-		0x8c, 0xd6, 0xa4, 0x56, 0x7e, 0x9e, 0xaa, 0xa0, 0xa0, 0xd5, 0xd7, 0xd9, 0x69, 0xa7, 0xdf, 0x19,
-		0x0c, 0xfc, 0xef, 0x46, 0xff, 0x4b, 0x6a, 0x7f, 0x51, 0xf0, 0x89, 0xae, 0x22, 0x76, 0x5e, 0x54,
-		0x65, 0x9f, 0xdc, 0x3f, 0x21, 0x57, 0xb2, 0x41, 0x95, 0xac, 0x21, 0x7c, 0xbb, 0x95, 0x6c, 0xdb,
-		0x89, 0xe8, 0xeb, 0x12, 0x4c, 0xb6, 0x5b, 0x93, 0xf4, 0x18, 0x96, 0x5d, 0x16, 0x59, 0x3d, 0x86,
-		0x65, 0xb7, 0x05, 0x90, 0xfc, 0x26, 0xaa, 0xfc, 0x39, 0xf4, 0x78, 0x27, 0xe5, 0xbb, 0xf6, 0x22,
-		0x19, 0x8b, 0x5d, 0x93, 0xfc, 0x1e, 0x63, 0xb1, 0x9f, 0x75, 0x4c, 0x8f, 0xb1, 0xd8, 0xd7, 0x1a,
-		0xa3, 0xf7, 0x58, 0x74, 0x35, 0xeb, 0xb3, 0x1b, 0x6d, 0xf4, 0x55, 0x09, 0x46, 0x02, 0x19, 0x31,
-		0x7a, 0xb4, 0xab, 0xa0, 0xed, 0x16, 0x0c, 0xd9, 0x33, 0xfb, 0x21, 0xe1, 0xba, 0x2c, 0x50, 0x5d,
-		0xe6, 0x50, 0xfe, 0x20, 0xba, 0x04, 0xcf, 0x4a, 0xbf, 0x29, 0xc1, 0x44, 0x9b, 0x2c, 0xb3, 0xc7,
-		0x28, 0xec, 0x9c, 0x34, 0x67, 0x9f, 0xdc, 0x3f, 0x21, 0xd7, 0xea, 0x02, 0xd5, 0xea, 0xad, 0xe8,
-		0x2d, 0x07, 0xd1, 0xca, 0x37, 0x3f, 0xdf, 0xf4, 0xee, 0x5d, 0xf9, 0xda, 0x41, 0xe7, 0xf6, 0x29,
-		0x98, 0x50, 0xe8, 0x89, 0x7d, 0xd3, 0x71, 0x7d, 0x9e, 0xa3, 0xfa, 0x3c, 0x8b, 0x56, 0x5e, 0x9f,
-		0x3e, 0xad, 0xd3, 0xfa, 0x17, 0x5b, 0x5f, 0x00, 0x76, 0xf7, 0xa2, 0xb6, 0xc9, 0x6a, 0xf6, 0xb1,
-		0x7d, 0xd1, 0x70, 0xa5, 0x9e, 0xa4, 0x4a, 0x9d, 0x41, 0x8f, 0x74, 0x52, 0xca, 0x77, 0xb9, 0x4e,
-		0xd3, 0xb7, 0x8c, 0xd3, 0xef, 0x64, 0x29, 0xf0, 0xbb, 0xd1, 0x4f, 0x8b, 0x8b, 0x4d, 0x27, 0xbb,
-		0xb6, 0xeb, 0xcb, 0x63, 0xb3, 0x0f, 0xf4, 0x81, 0xc9, 0xe5, 0xba, 0x87, 0xca, 0x35, 0x85, 0x8e,
-		0x77, 0x92, 0x8b, 0xe4, 0xb2, 0xe8, 0x83, 0x92, 0x7b, 0x17, 0xf2, 0x54, 0x77, 0xde, 0xfe, 0x64,
-		0x37, 0xfb, 0x60, 0x5f, 0xb8, 0x5c, 0x92, 0xfb, 0xa8, 0x24, 0x33, 0x68, 0xaa, 0xa3, 0x24, 0x2c,
-		0xf5, 0xbd, 0xdd, 0x37, 0x07, 0xae, 0x1f, 0x81, 0xe9, 0x0e, 0x2d, 0x3a, 0xbb, 0x3d, 0xce, 0xb8,
-		0xba, 0x3c, 0x84, 0xed, 0xf9, 0xd0, 0xf5, 0x76, 0x7f, 0xb4, 0xb5, 0xcf, 0x03, 0xb1, 0xdf, 0x8a,
-		0x01, 0x5a, 0xb2, 0x6b, 0x73, 0x16, 0x66, 0xff, 0x40, 0x92, 0x8f, 0xf2, 0xd0, 0x0b, 0x2f, 0xe9,
-		0x75, 0xbd, 0xf0, 0x5a, 0x0a, 0xbc, 0x99, 0x8a, 0xec, 0xef, 0x5d, 0x66, 0xdf, 0x0f, 0xa7, 0xa2,
-		0x3f, 0x96, 0x87, 0x53, 0xed, 0xef, 0x55, 0xc7, 0x6e, 0xdf, 0x03, 0x8c, 0xf8, 0x41, 0x1f, 0xa1,
-		0xf0, 0xf7, 0x90, 0x83, 0x5d, 0xde, 0x43, 0x66, 0x3a, 0x3e, 0x7a, 0xe4, 0xd4, 0xe8, 0xac, 0xf8,
-		0x84, 0xe9, 0x50, 0x7f, 0x37, 0x61, 0xf9, 0x37, 0x4e, 0xbd, 0x2d, 0x84, 0xe3, 0x90, 0x6d, 0x75,
-		0x27, 0x77, 0x50, 0x7f, 0x24, 0x0a, 0xe9, 0x25, 0xbb, 0x56, 0xaa, 0x6a, 0xce, 0x1d, 0xf2, 0xb5,
-		0xa7, 0x3b, 0x3f, 0x6a, 0x41, 0xb7, 0x6e, 0x4e, 0x8f, 0x32, 0x9b, 0x76, 0xb1, 0x64, 0x03, 0xc6,
-		0x42, 0x4f, 0x89, 0xb9, 0x67, 0x15, 0x0f, 0xf2, 0xa2, 0x39, 0xc4, 0x4a, 0xa6, 0x6f, 0x10, 0x7c,
-		0xfe, 0x8d, 0x76, 0xdb, 0x3b, 0x33, 0x73, 0xa8, 0x8b, 0x77, 0xf2, 0x05, 0xa0, 0xd7, 0x67, 0x59,
-		0xc8, 0x84, 0x3b, 0xc5, 0xed, 0xb1, 0x3f, 0x90, 0x60, 0x78, 0xc9, 0x16, 0xa9, 0x20, 0xfe, 0x09,
-		0x7d, 0x7f, 0xf4, 0x84, 0xfb, 0xfd, 0xef, 0x68, 0x7f, 0x7e, 0x2b, 0xbe, 0x09, 0xee, 0x19, 0xe1,
-		0x10, 0x4c, 0xf8, 0xf4, 0x74, 0xf5, 0xff, 0xed, 0x08, 0x8d, 0x8f, 0x05, 0x5c, 0xd3, 0x74, 0x37,
-		0x8b, 0xc4, 0x7f, 0x5e, 0x5f, 0x57, 0x78, 0x76, 0x8e, 0x1d, 0xd4, 0xce, 0x3b, 0x34, 0x40, 0x84,
-		0xec, 0xe9, 0x6e, 0x7c, 0x2d, 0xb5, 0xbe, 0xfd, 0x91, 0xf6, 0xf1, 0x59, 0x9d, 0xd0, 0x0b, 0x1f,
-		0xf9, 0x35, 0x09, 0x46, 0x96, 0xec, 0xda, 0x86, 0x5e, 0xfd, 0xff, 0xde, 0x7f, 0xb7, 0xe0, 0x50,
-		0x40, 0xd3, 0x3b, 0x64, 0xd2, 0x33, 0xaf, 0xc4, 0x20, 0xba, 0x64, 0xd7, 0xd0, 0x4b, 0x30, 0x16,
-		0x4e, 0x1a, 0x3a, 0xe6, 0x82, 0xad, 0x33, 0x42, 0xe7, 0xf5, 0x5a, 0xe7, 0xd9, 0x03, 0xed, 0xc0,
-		0x48, 0x70, 0xe6, 0x38, 0xd9, 0x85, 0x49, 0x00, 0x33, 0xfb, 0x48, 0xbf, 0x98, 0x6e, 0x63, 0xef,
-		0x80, 0x84, 0x1b, 0xf4, 0xee, 0xee, 0x42, 0x2d, 0x90, 0x3a, 0x67, 0xb7, 0x6d, 0xc2, 0x0a, 0xb1,
-		0x5e, 0x38, 0xa4, 0x74, 0xb3, 0x5e, 0x08, 0xb7, 0xab, 0xf5, 0x3a, 0x0d, 0xad, 0x4d, 0x00, 0xdf,
-		0x38, 0xb8, 0xb7, 0x0b, 0x07, 0x0f, 0x2d, 0xfb, 0x70, 0x5f, 0x68, 0xee, 0xa1, 0xd3, 0x6d, 0x4e,
-		0xc6, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x8f, 0xbc, 0xb2, 0xb6, 0x97, 0x00, 0x00,
->>>>>>> upstream/master
+		0x0c, 0xea, 0xba, 0x87, 0x96, 0xf9, 0xe2, 0xf7, 0xe8, 0xf4, 0xad, 0x8c, 0x73, 0x52, 0x52, 0xc7,
+		0x56, 0x3a, 0x39, 0x05, 0x0e, 0x05, 0xf8, 0x31, 0x27, 0xc5, 0x56, 0x0f, 0x8e, 0xbf, 0xc5, 0x39,
+		0x4e, 0xf8, 0x38, 0xae, 0x71, 0xd2, 0xdc, 0x1c, 0x8c, 0xec, 0x87, 0xd7, 0xbf, 0xe4, 0xbc, 0x52,
+		0xd8, 0xcf, 0x64, 0x1e, 0xc6, 0x28, 0x93, 0x4a, 0xd3, 0x76, 0x8c, 0x06, 0x8d, 0x80, 0xdd, 0xd9,
+		0xfc, 0xf6, 0xf7, 0x98, 0xd7, 0x8c, 0x12, 0xb2, 0x39, 0x97, 0x2a, 0x97, 0x03, 0x7a, 0x36, 0x56,
+		0xc5, 0x95, 0x7a, 0x0f, 0x0e, 0x5f, 0xe7, 0x82, 0xb8, 0xf8, 0xb9, 0xcb, 0x30, 0x49, 0x7e, 0xd3,
+		0x00, 0xe5, 0x97, 0xa4, 0xf7, 0x86, 0x5b, 0xe6, 0xdb, 0xef, 0x63, 0x8e, 0x39, 0xe1, 0x32, 0xf0,
+		0xc9, 0xe4, 0x1b, 0xc5, 0x1a, 0x76, 0x1c, 0x6c, 0xd9, 0x65, 0xb5, 0xde, 0x4e, 0x3c, 0xdf, 0x8e,
+		0x45, 0xe6, 0xe3, 0x3f, 0x0c, 0x8e, 0xe2, 0x3c, 0xa3, 0xcc, 0xd7, 0xeb, 0xb9, 0x0d, 0x38, 0xd2,
+		0xc6, 0x2a, 0xfa, 0xe0, 0xf9, 0x32, 0xe7, 0x39, 0xd9, 0x62, 0x19, 0x84, 0xed, 0x2a, 0x08, 0xb8,
+		0x3b, 0x96, 0x7d, 0xf0, 0xfc, 0x04, 0xe7, 0x89, 0x38, 0xad, 0x18, 0x52, 0xc2, 0xf1, 0x29, 0x18,
+		0xbf, 0x82, 0xad, 0x4d, 0xc3, 0xe6, 0xbb, 0x44, 0x7d, 0xb0, 0xfb, 0x24, 0x67, 0x37, 0xc6, 0x09,
+		0xe9, 0xb6, 0x11, 0xe1, 0xf5, 0x04, 0x24, 0xb6, 0xd4, 0x0a, 0xee, 0x83, 0xc5, 0x75, 0xce, 0x62,
+		0x88, 0xe0, 0x13, 0xd2, 0x3c, 0xa4, 0x6a, 0x06, 0x9f, 0xa3, 0x7a, 0x93, 0x7f, 0x8a, 0x93, 0x0f,
+		0x0b, 0x1a, 0xce, 0xc2, 0x34, 0xcc, 0x66, 0x9d, 0x4c, 0x60, 0xbd, 0x59, 0xfc, 0x2d, 0xc1, 0x42,
+		0xd0, 0x70, 0x16, 0xfb, 0x50, 0xeb, 0x2b, 0x82, 0x85, 0xed, 0xd3, 0xe7, 0x93, 0x30, 0x6c, 0xe8,
+		0xf5, 0x3d, 0x43, 0xef, 0x47, 0x88, 0x4f, 0x73, 0x0e, 0xc0, 0x49, 0x08, 0x83, 0xf3, 0x90, 0xec,
+		0x77, 0x20, 0xfe, 0xf6, 0x0f, 0x85, 0x7b, 0x88, 0x11, 0x98, 0x87, 0x31, 0x11, 0xa0, 0x34, 0x43,
+		0xef, 0x83, 0xc5, 0xdf, 0xe1, 0x2c, 0x46, 0x7d, 0x64, 0xbc, 0x1b, 0x0e, 0xb6, 0x9d, 0x1a, 0xee,
+		0x87, 0xc9, 0x67, 0x45, 0x37, 0x38, 0x09, 0x57, 0xe5, 0x26, 0xd6, 0x2b, 0xdb, 0xfd, 0x71, 0xf8,
+		0x55, 0xa1, 0x4a, 0x41, 0x43, 0x58, 0xcc, 0xc1, 0x48, 0x43, 0xb5, 0xec, 0x6d, 0xb5, 0xde, 0xd7,
+		0x70, 0xfc, 0x5d, 0xce, 0x23, 0xe5, 0x12, 0x71, 0x8d, 0x34, 0xf5, 0xfd, 0xb0, 0xf9, 0x9c, 0xd0,
+		0x88, 0x8f, 0x8c, 0xbb, 0x9e, 0xed, 0xd0, 0x2d, 0xb5, 0xfd, 0x70, 0xfb, 0x35, 0xe1, 0x7a, 0x8c,
+		0x76, 0xc9, 0xcf, 0xf1, 0x3c, 0x24, 0x6d, 0xed, 0xc5, 0xbe, 0xd8, 0x7c, 0x5e, 0x8c, 0x34, 0x25,
+		0x20, 0xc4, 0x6f, 0x83, 0xa3, 0x6d, 0xa7, 0x89, 0x3e, 0x98, 0xfd, 0x3d, 0xce, 0xec, 0x70, 0x9b,
+		0xa9, 0x82, 0x87, 0x84, 0xfd, 0xb2, 0xfc, 0xfb, 0x22, 0x24, 0xe0, 0x10, 0xaf, 0x55, 0xb2, 0x6a,
+		0xb0, 0xd5, 0xad, 0xfd, 0x69, 0xed, 0xd7, 0x85, 0xd6, 0x18, 0x6d, 0x40, 0x6b, 0xeb, 0x70, 0x98,
+		0x73, 0xdc, 0xdf, 0xb8, 0x7e, 0x41, 0x04, 0x56, 0x46, 0xbd, 0x11, 0x1c, 0xdd, 0xb7, 0x43, 0xd6,
+		0x55, 0xa7, 0x48, 0x4f, 0xed, 0x72, 0x43, 0x35, 0xfb, 0xe0, 0xfc, 0x45, 0xce, 0x59, 0x44, 0x7c,
+		0x37, 0xbf, 0xb5, 0x97, 0x54, 0x93, 0x30, 0x7f, 0x16, 0x32, 0x82, 0x79, 0x53, 0xb7, 0x70, 0xc5,
+		0xa8, 0xe9, 0xda, 0x8b, 0xb8, 0xda, 0x07, 0xeb, 0xdf, 0x08, 0x0d, 0xd5, 0x86, 0x8f, 0x9c, 0x70,
+		0x5e, 0x80, 0xb4, 0x9b, 0xab, 0x94, 0xb5, 0x86, 0x69, 0x58, 0x4e, 0x0f, 0x8e, 0x5f, 0x12, 0x23,
+		0xe5, 0xd2, 0x2d, 0x50, 0xb2, 0x5c, 0x09, 0xd8, 0x39, 0x73, 0xbf, 0x26, 0xf9, 0x65, 0xce, 0x68,
+		0xc4, 0xa3, 0xe2, 0x81, 0xa3, 0x62, 0x34, 0x4c, 0xd5, 0xea, 0x27, 0xfe, 0xfd, 0x03, 0x11, 0x38,
+		0x38, 0x09, 0x0f, 0x1c, 0x24, 0xa3, 0x23, 0xb3, 0x7d, 0x1f, 0x1c, 0xbe, 0x22, 0x02, 0x87, 0xa0,
+		0xe1, 0x2c, 0x44, 0xc2, 0xd0, 0x07, 0x8b, 0x7f, 0x28, 0x58, 0x08, 0x1a, 0xc2, 0xe2, 0x69, 0x6f,
+		0xa2, 0xb5, 0x70, 0x4d, 0xb3, 0x1d, 0x8b, 0x25, 0xc5, 0xdd, 0x59, 0xfd, 0xa3, 0x1f, 0x06, 0x93,
+		0x30, 0xc5, 0x47, 0x4a, 0x22, 0x11, 0xdf, 0x64, 0xa5, 0x6b, 0xa6, 0xde, 0x82, 0xfd, 0xa6, 0x88,
+		0x44, 0x3e, 0x32, 0x22, 0x9b, 0x2f, 0x43, 0x24, 0x6a, 0xaf, 0x90, 0x95, 0x42, 0x1f, 0xec, 0xfe,
+		0x71, 0x48, 0xb8, 0x35, 0x41, 0x4b, 0x78, 0xfa, 0xf2, 0x9f, 0xa6, 0xbe, 0x83, 0xf7, 0xfa, 0xb2,
+		0xce, 0x7f, 0x12, 0xca, 0x7f, 0x36, 0x18, 0x25, 0x8b, 0x21, 0x63, 0xa1, 0x7c, 0x0a, 0xf5, 0xba,
+		0x55, 0x94, 0x79, 0xcf, 0x8f, 0x79, 0x7f, 0x83, 0xe9, 0x54, 0x6e, 0x91, 0x18, 0x79, 0x30, 0xe9,
+		0xe9, 0xcd, 0xec, 0x7d, 0x3f, 0x76, 0xed, 0x3c, 0x90, 0xf3, 0xe4, 0x2e, 0xc0, 0x48, 0x20, 0xe1,
+		0xe9, 0xcd, 0xea, 0xfd, 0x9c, 0x55, 0xca, 0x9f, 0xef, 0xe4, 0xce, 0x42, 0x8c, 0x24, 0x2f, 0xbd,
+		0xc9, 0xff, 0x0a, 0x27, 0xa7, 0xe8, 0xb9, 0x37, 0x43, 0x42, 0x24, 0x2d, 0xbd, 0x49, 0x3f, 0xc0,
+		0x49, 0x5d, 0x12, 0x42, 0x2e, 0x12, 0x96, 0xde, 0xe4, 0x7f, 0x55, 0x90, 0x0b, 0x12, 0x42, 0xde,
+		0xbf, 0x0a, 0xbf, 0xfa, 0xf3, 0x31, 0x3e, 0xe9, 0x08, 0xdd, 0x9d, 0x87, 0x21, 0x9e, 0xa9, 0xf4,
+		0xa6, 0xfe, 0x10, 0x6f, 0x5c, 0x50, 0xe4, 0x1e, 0x83, 0x78, 0x9f, 0x0a, 0xff, 0x05, 0x4e, 0xca,
+		0xf0, 0x73, 0x73, 0x30, 0xec, 0xcb, 0x4e, 0x7a, 0x93, 0xff, 0x35, 0x4e, 0xee, 0xa7, 0x22, 0xa2,
+		0xf3, 0xec, 0xa4, 0x37, 0x83, 0x5f, 0x14, 0xa2, 0x73, 0x0a, 0xa2, 0x36, 0x91, 0x98, 0xf4, 0xa6,
+		0xfe, 0xb0, 0xd0, 0xba, 0x20, 0xc9, 0x3d, 0x09, 0x49, 0x77, 0xb2, 0xe9, 0x4d, 0xff, 0x11, 0x4e,
+		0xef, 0xd1, 0x10, 0x0d, 0xf8, 0x26, 0xbb, 0xde, 0x2c, 0xfe, 0xba, 0xd0, 0x80, 0x8f, 0x8a, 0xb8,
+		0x51, 0x38, 0x81, 0xe9, 0xcd, 0xe9, 0xa3, 0xc2, 0x8d, 0x42, 0xf9, 0x0b, 0x19, 0x4d, 0x1a, 0xf3,
+		0x7b, 0xb3, 0xf8, 0x1b, 0x62, 0x34, 0x29, 0x3e, 0x11, 0x23, 0x9c, 0x11, 0xf4, 0xe6, 0xf1, 0x4b,
+		0x42, 0x8c, 0x50, 0x42, 0x90, 0x5b, 0x05, 0xd4, 0x9a, 0x0d, 0xf4, 0xe6, 0xf7, 0x31, 0xce, 0x6f,
+		0xbc, 0x25, 0x19, 0xc8, 0x3d, 0x03, 0x87, 0xdb, 0x67, 0x02, 0xbd, 0xb9, 0x7e, 0xfc, 0xc7, 0xa1,
+		0xb5, 0x9b, 0x3f, 0x11, 0xc8, 0xad, 0x7b, 0x53, 0x8a, 0x3f, 0x0b, 0xe8, 0xcd, 0xf6, 0xe5, 0x1f,
+		0x07, 0x03, 0xb7, 0x3f, 0x09, 0xc8, 0xe5, 0x01, 0xbc, 0x09, 0xb8, 0x37, 0xaf, 0x4f, 0x72, 0x5e,
+		0x3e, 0x22, 0xe2, 0x1a, 0x7c, 0xfe, 0xed, 0x4d, 0x7f, 0x5d, 0xb8, 0x06, 0xa7, 0x20, 0xae, 0x21,
+		0xa6, 0xde, 0xde, 0xd4, 0x9f, 0x12, 0xae, 0x21, 0x48, 0x88, 0x65, 0xfb, 0x66, 0xb7, 0xde, 0x1c,
+		0x3e, 0x2d, 0x2c, 0xdb, 0x47, 0x95, 0x5b, 0x86, 0xf1, 0x96, 0x09, 0xb1, 0x37, 0xab, 0x5f, 0xe6,
+		0xac, 0xd2, 0xe1, 0xf9, 0xd0, 0x3f, 0x79, 0xf1, 0xc9, 0xb0, 0x37, 0xb7, 0xcf, 0x84, 0x26, 0x2f,
+		0x3e, 0x17, 0xe6, 0xce, 0x43, 0x42, 0x6f, 0xd6, 0xeb, 0xc4, 0x79, 0x50, 0xf7, 0x9b, 0x80, 0x99,
+		0x3f, 0xfe, 0x09, 0xd7, 0x8e, 0x20, 0xc8, 0x9d, 0x85, 0x38, 0x6e, 0x6c, 0xe2, 0x6a, 0x2f, 0xca,
+		0x1f, 0xfc, 0x44, 0x04, 0x4c, 0x82, 0x9d, 0x7b, 0x12, 0x80, 0x6d, 0x8d, 0xd0, 0xc3, 0xc0, 0x1e,
+		0xb4, 0xff, 0xe5, 0x27, 0xfc, 0xea, 0x8d, 0x47, 0xe2, 0x31, 0x60, 0x17, 0x79, 0xba, 0x33, 0xf8,
+		0x61, 0x90, 0x01, 0x1d, 0x91, 0x27, 0x60, 0xe8, 0x79, 0xdb, 0xd0, 0x1d, 0xb5, 0xd6, 0x8b, 0xfa,
+		0xbf, 0x72, 0x6a, 0x81, 0x4f, 0x14, 0xd6, 0x30, 0x2c, 0xec, 0xa8, 0x35, 0xbb, 0x17, 0xed, 0x7f,
+		0xe3, 0xb4, 0x2e, 0x01, 0x21, 0xae, 0xa8, 0xb6, 0xd3, 0x4f, 0xbf, 0xff, 0x44, 0x10, 0x0b, 0x02,
+		0x22, 0x34, 0xf9, 0xbd, 0x83, 0xf7, 0x7a, 0xd1, 0xfe, 0x48, 0x08, 0xcd, 0xf1, 0x73, 0x6f, 0x86,
+		0x24, 0xf9, 0xc9, 0xee, 0xd3, 0xf5, 0x20, 0xfe, 0x53, 0x4e, 0xec, 0x51, 0x90, 0x96, 0x6d, 0xa7,
+		0xea, 0x68, 0xbd, 0x95, 0x7d, 0x93, 0x8f, 0xb4, 0xc0, 0xcf, 0xe5, 0x61, 0xd8, 0x76, 0xaa, 0xd5,
+		0x26, 0xcf, 0x4f, 0x7b, 0x90, 0xff, 0xf7, 0x9f, 0xb8, 0x5b, 0x16, 0x2e, 0x0d, 0x19, 0xed, 0xab,
+		0x3b, 0x8e, 0x69, 0xd0, 0x03, 0x8f, 0x5e, 0x1c, 0x7e, 0xcc, 0x39, 0xf8, 0x48, 0x72, 0x73, 0x90,
+		0x22, 0x7d, 0xb1, 0xb0, 0x89, 0xe9, 0xe9, 0x54, 0x0f, 0x16, 0xff, 0x83, 0x2b, 0x20, 0x40, 0x54,
+		0xf8, 0xb9, 0xaf, 0xbf, 0x3a, 0x25, 0x7d, 0xeb, 0xd5, 0x29, 0xe9, 0x8f, 0x5e, 0x9d, 0x92, 0x3e,
+		0xfc, 0xdd, 0xa9, 0x81, 0x6f, 0x7d, 0x77, 0x6a, 0xe0, 0xf7, 0xbf, 0x3b, 0x35, 0xd0, 0x7e, 0x97,
+		0x18, 0xe6, 0x8d, 0x79, 0x83, 0xed, 0x0f, 0x3f, 0x27, 0xd7, 0x34, 0x67, 0xbb, 0xb9, 0x39, 0x5b,
+		0x31, 0x1a, 0x74, 0x1b, 0xd7, 0xdb, 0xad, 0x75, 0x17, 0x39, 0xf0, 0xde, 0x28, 0x1c, 0xad, 0x18,
+		0x76, 0xc3, 0xb0, 0xcb, 0x6c, 0xbf, 0x97, 0x15, 0xf8, 0x8e, 0x6f, 0xca, 0x5f, 0xd5, 0xc7, 0xa6,
+		0xef, 0x45, 0x18, 0xa5, 0x5d, 0xa7, 0xdb, 0x5d, 0xd4, 0xda, 0x7a, 0x06, 0x88, 0x6f, 0xfc, 0xbb,
+		0x38, 0xed, 0xf5, 0x88, 0x4b, 0x48, 0x4f, 0xef, 0xd7, 0x61, 0x52, 0x6b, 0x98, 0x75, 0x4c, 0xb7,
+		0xf9, 0xcb, 0x6e, 0x5d, 0x6f, 0x7e, 0xdf, 0xe4, 0xfc, 0x26, 0x3c, 0xf2, 0x05, 0x41, 0x9d, 0x5b,
+		0x84, 0x71, 0xb5, 0x52, 0xc1, 0x66, 0x80, 0x65, 0x8f, 0x61, 0x11, 0x02, 0xa6, 0x39, 0xa5, 0xcb,
+		0xad, 0xf0, 0x64, 0xa7, 0xa1, 0x79, 0xee, 0x6e, 0x9f, 0xe6, 0x2d, 0x5c, 0xc3, 0xfa, 0x83, 0x3a,
+		0x76, 0xae, 0x1a, 0xd6, 0x0e, 0x57, 0xef, 0x83, 0xac, 0xa9, 0x41, 0x76, 0x83, 0x19, 0xde, 0x1f,
+		0x85, 0x29, 0x56, 0x71, 0x7a, 0x53, 0xb5, 0xf1, 0xe9, 0x2b, 0x0f, 0x6f, 0x62, 0x47, 0x7d, 0xf8,
+		0x74, 0xc5, 0xd0, 0x74, 0x3e, 0x12, 0x13, 0x7c, 0x5c, 0x48, 0xfd, 0x2c, 0xaf, 0xcf, 0xb6, 0xdd,
+		0xa6, 0x97, 0xe7, 0x21, 0x36, 0x67, 0x68, 0x3a, 0x9a, 0x84, 0x78, 0x15, 0xeb, 0x46, 0x83, 0xdf,
+		0xb9, 0x63, 0x05, 0x74, 0x27, 0x0c, 0xaa, 0x0d, 0xa3, 0xa9, 0x3b, 0xec, 0x84, 0xa2, 0x30, 0xfc,
+		0xf5, 0x1b, 0xd3, 0x03, 0x7f, 0x70, 0x63, 0x3a, 0xba, 0xa0, 0x3b, 0x0a, 0xaf, 0xca, 0xc5, 0x5e,
+		0x7b, 0x65, 0x5a, 0x92, 0x9f, 0x82, 0xa1, 0x22, 0xae, 0x1c, 0x84, 0x57, 0x11, 0x57, 0x42, 0xbc,
+		0xee, 0x83, 0xc4, 0x82, 0xee, 0xb0, 0x5b, 0x91, 0x27, 0x20, 0xaa, 0xe9, 0xec, 0xa2, 0x4d, 0xa8,
+		0x7d, 0x02, 0x27, 0xa8, 0x45, 0x5c, 0x71, 0x51, 0xab, 0xb8, 0x12, 0x46, 0x25, 0xec, 0x09, 0xbc,
+		0x50, 0xfc, 0xfd, 0xff, 0x34, 0x35, 0xf0, 0xd2, 0xab, 0x53, 0x03, 0x1d, 0x47, 0xc2, 0xef, 0x03,
+		0x5c, 0xc5, 0x7c, 0x08, 0xec, 0xea, 0x0e, 0x3b, 0x23, 0x71, 0x87, 0xe1, 0x77, 0x06, 0x41, 0xe6,
+		0x38, 0xb6, 0xa3, 0xee, 0x68, 0x7a, 0xcd, 0x1d, 0x09, 0xb5, 0xe9, 0x6c, 0xbf, 0xc8, 0x87, 0xe2,
+		0x30, 0x1f, 0x0a, 0x8e, 0xd3, 0x7d, 0x34, 0xb2, 0x9d, 0xbd, 0x2b, 0xdb, 0x63, 0xcc, 0xe5, 0x7f,
+		0x1d, 0x05, 0xb4, 0xe6, 0xa8, 0x3b, 0x38, 0xdf, 0x74, 0xb6, 0x0d, 0x4b, 0x7b, 0x91, 0xc5, 0x32,
+		0x0c, 0xd0, 0x50, 0x77, 0xcb, 0x8e, 0xb1, 0x83, 0x75, 0x9b, 0xaa, 0x66, 0xf8, 0xcc, 0xd1, 0xd9,
+		0x36, 0xf6, 0x31, 0x4b, 0x86, 0xae, 0x70, 0xff, 0xe7, 0xbe, 0x33, 0x7d, 0x6f, 0x6f, 0x2d, 0x50,
+		0x64, 0x92, 0x5c, 0xef, 0xae, 0x53, 0xc6, 0xe8, 0x32, 0xb0, 0x4b, 0x16, 0xe5, 0xba, 0x66, 0x3b,
+		0xfc, 0x9e, 0xf6, 0xd9, 0xd9, 0xf6, 0x7d, 0x9f, 0x6d, 0x15, 0x73, 0xf6, 0xb2, 0x5a, 0xd7, 0xaa,
+		0xaa, 0x63, 0x58, 0xf6, 0xc5, 0x01, 0x25, 0x49, 0x59, 0x2d, 0x6a, 0xb6, 0x83, 0xd6, 0x21, 0x59,
+		0xc5, 0xfa, 0x1e, 0x63, 0x1b, 0x7d, 0x7d, 0x6c, 0x13, 0x84, 0x13, 0xe5, 0xfa, 0x2c, 0x20, 0xd5,
+		0x8f, 0x27, 0x1e, 0x26, 0xb1, 0xfb, 0x95, 0x1d, 0xd8, 0x07, 0x38, 0xd3, 0x77, 0x14, 0xe3, 0x6a,
+		0x18, 0x94, 0xbd, 0x07, 0xc0, 0x6b, 0x13, 0x65, 0x60, 0x48, 0xad, 0x56, 0x2d, 0x6c, 0xdb, 0xf4,
+		0x00, 0x30, 0xa9, 0x88, 0x62, 0x6e, 0xfc, 0xdf, 0x7c, 0xf9, 0xc1, 0x91, 0x00, 0xc7, 0x42, 0x0a,
+		0xe0, 0x8a, 0x4b, 0x7a, 0xea, 0x53, 0x12, 0x8c, 0xb7, 0xb4, 0x88, 0x64, 0x98, 0xca, 0x6f, 0xac,
+		0x5f, 0x5c, 0x51, 0x16, 0x9e, 0xcb, 0xaf, 0x2f, 0xac, 0x2c, 0x97, 0xd9, 0x95, 0xff, 0xe5, 0xb5,
+		0xd5, 0xd2, 0xdc, 0xc2, 0x85, 0x85, 0x52, 0x31, 0x3d, 0x80, 0xa6, 0xe1, 0x58, 0x1b, 0x9c, 0x62,
+		0x69, 0xb1, 0x34, 0x9f, 0x5f, 0x2f, 0xa5, 0x25, 0x74, 0x07, 0x9c, 0x68, 0xcb, 0xc4, 0x45, 0x89,
+		0x74, 0x40, 0x51, 0x4a, 0x2e, 0x4a, 0xb4, 0x70, 0xa1, 0xa3, 0x17, 0x3d, 0xd0, 0xd5, 0x7e, 0x76,
+		0x5d, 0x77, 0x09, 0xfa, 0xd3, 0x7b, 0x22, 0x70, 0x34, 0x3c, 0x65, 0xa8, 0xfa, 0x5e, 0x87, 0x57,
+		0x9f, 0x1d, 0xa2, 0xd9, 0x45, 0x88, 0xe6, 0xf5, 0x3d, 0x74, 0x94, 0xe5, 0xd3, 0xe5, 0xa6, 0x55,
+		0xe7, 0x31, 0x68, 0x88, 0x94, 0x37, 0xac, 0x3a, 0x89, 0x4d, 0xe2, 0xa2, 0xbf, 0x74, 0x32, 0xc5,
+		0x6f, 0xef, 0xe7, 0xd2, 0x1f, 0x7b, 0x65, 0x7a, 0xe0, 0x0b, 0xaf, 0x4c, 0x0f, 0xfc, 0xe8, 0xd3,
+		0xd3, 0x03, 0x2f, 0xfd, 0xe1, 0xcc, 0x40, 0x61, 0x27, 0xdc, 0xbd, 0xaf, 0xf6, 0x9c, 0x4d, 0x13,
+		0x79, 0x7d, 0x8f, 0x06, 0xa2, 0x55, 0xe9, 0xb9, 0x38, 0xed, 0x9c, 0x38, 0x40, 0x9d, 0x0a, 0x1f,
+		0xa0, 0x3e, 0x83, 0xeb, 0xf5, 0x4b, 0xba, 0x71, 0x95, 0x8e, 0xaa, 0xa7, 0x83, 0x8f, 0x46, 0x60,
+		0xaa, 0x65, 0xda, 0xe4, 0x19, 0x46, 0xa7, 0xe7, 0xaf, 0x39, 0x48, 0x14, 0x45, 0xe2, 0x92, 0x81,
+		0x21, 0x1b, 0x57, 0x0c, 0xbd, 0xca, 0x3c, 0x3d, 0xaa, 0x88, 0x22, 0xe9, 0xb6, 0xae, 0xea, 0x86,
+		0xcd, 0xef, 0xdc, 0xb3, 0x42, 0xe1, 0x13, 0xd2, 0xfe, 0xf2, 0x85, 0x11, 0xd1, 0x92, 0xe8, 0xe6,
+		0xc3, 0x3d, 0x8f, 0x94, 0x77, 0x48, 0x2f, 0xdd, 0x4e, 0x04, 0x8e, 0x95, 0xfb, 0xd5, 0xca, 0x2f,
+		0x45, 0x60, 0x3a, 0xac, 0x15, 0x92, 0xb6, 0xd9, 0x8e, 0xda, 0x30, 0x3b, 0xa9, 0xe5, 0x3c, 0x24,
+		0xd7, 0x05, 0xce, 0xbe, 0xf5, 0x72, 0x7d, 0x9f, 0x7a, 0x19, 0x75, 0x9b, 0x12, 0x8a, 0x39, 0xd3,
+		0xa7, 0x62, 0xdc, 0x7e, 0x1c, 0x48, 0x33, 0x9f, 0x8b, 0xc1, 0x09, 0xfa, 0x28, 0xcb, 0x6a, 0x68,
+		0xba, 0x73, 0xba, 0x62, 0xed, 0x99, 0x0e, 0x4d, 0xdc, 0x8c, 0x2d, 0xae, 0x97, 0x71, 0xaf, 0x7a,
+		0x96, 0x55, 0x77, 0xf0, 0x9c, 0x2d, 0x88, 0xaf, 0x12, 0x3a, 0xa2, 0x11, 0xc7, 0x70, 0xd4, 0x3a,
+		0xd7, 0x14, 0x2b, 0x10, 0x28, 0x7b, 0xc8, 0x15, 0x61, 0x50, 0x4d, 0xbc, 0xe1, 0xaa, 0x63, 0x75,
+		0x8b, 0xdd, 0x87, 0x8f, 0x52, 0x87, 0x4a, 0x10, 0x00, 0xbd, 0xfa, 0x3e, 0x09, 0x71, 0xb5, 0xc9,
+		0xae, 0x72, 0x44, 0x89, 0xa7, 0xd1, 0x82, 0x7c, 0x09, 0x86, 0xf8, 0x81, 0x32, 0x4a, 0x43, 0x74,
+		0x07, 0xef, 0xd1, 0x76, 0x52, 0x0a, 0xf9, 0x89, 0x66, 0x21, 0x4e, 0x85, 0xe7, 0x13, 0x48, 0x66,
+		0xb6, 0x45, 0xfa, 0x59, 0x2a, 0xa4, 0xc2, 0xd0, 0xe4, 0xa7, 0x20, 0x51, 0x34, 0x1a, 0x9a, 0x6e,
+		0x04, 0xb9, 0x25, 0x19, 0x37, 0x2a, 0xb3, 0xd9, 0xe4, 0xf9, 0x86, 0xc2, 0x0a, 0xe8, 0x30, 0x0c,
+		0xb2, 0xf7, 0x11, 0xfc, 0x3a, 0x0a, 0x2f, 0xc9, 0x73, 0x30, 0x44, 0x79, 0xaf, 0x98, 0x08, 0xf1,
+		0x97, 0x75, 0xfc, 0x21, 0x06, 0x4d, 0x4d, 0x39, 0xfb, 0x88, 0x27, 0x2c, 0x82, 0x58, 0x55, 0x75,
+		0x54, 0xde, 0x6f, 0xfa, 0x5b, 0x7e, 0x0b, 0x24, 0x38, 0x13, 0x1b, 0x9d, 0x81, 0xa8, 0x61, 0xda,
+		0xfc, 0x42, 0x49, 0xb6, 0x53, 0x57, 0x56, 0xcc, 0x42, 0x8c, 0x64, 0x2a, 0x0a, 0x41, 0x2e, 0x28,
+		0x1d, 0x83, 0xea, 0xe3, 0xbe, 0xa0, 0xea, 0x1b, 0x72, 0xdf, 0x4f, 0x36, 0xa4, 0x2d, 0xe6, 0xe0,
+		0x1a, 0xcb, 0xa7, 0x23, 0x30, 0xe5, 0xab, 0xbd, 0x82, 0x2d, 0x5b, 0x33, 0x74, 0x3e, 0x9f, 0x33,
+		0x6b, 0x41, 0x3e, 0x21, 0x79, 0x7d, 0x07, 0x73, 0x79, 0x33, 0x44, 0xf3, 0xa6, 0x89, 0xb2, 0x90,
+		0xa0, 0xe5, 0x8a, 0xc1, 0xec, 0x25, 0xa6, 0xb8, 0x65, 0x52, 0x67, 0x1b, 0x5b, 0xce, 0x55, 0xd5,
+		0x72, 0x9f, 0x10, 0x8a, 0xb2, 0xfc, 0x04, 0x24, 0xe7, 0x0c, 0xdd, 0xc6, 0xba, 0xdd, 0xa4, 0x3e,
+		0xb8, 0x59, 0x37, 0x2a, 0x3b, 0x9c, 0x03, 0x2b, 0x10, 0x85, 0xab, 0xa6, 0x49, 0x29, 0x63, 0x0a,
+		0xf9, 0xc9, 0x72, 0xc3, 0xc2, 0x5a, 0x47, 0x15, 0x3d, 0xb1, 0x7f, 0x15, 0xf1, 0x4e, 0xba, 0x3a,
+		0xfa, 0xdf, 0x12, 0x1c, 0x6f, 0x75, 0xa8, 0x1d, 0xbc, 0x67, 0xef, 0xd7, 0x9f, 0x9e, 0x85, 0xe4,
+		0x2a, 0x7d, 0xc7, 0x7f, 0x09, 0xef, 0xa1, 0x2c, 0x0c, 0xe1, 0xea, 0x99, 0xb3, 0x67, 0x1f, 0x7e,
+		0x82, 0x59, 0xfb, 0xc5, 0x01, 0x45, 0x00, 0xd0, 0x14, 0x24, 0x6d, 0x5c, 0x31, 0xcf, 0x9c, 0x3d,
+		0xb7, 0xf3, 0x30, 0x33, 0x2f, 0x92, 0x01, 0xb9, 0xa0, 0x5c, 0x82, 0xf4, 0xfa, 0xb5, 0x4f, 0x4f,
+		0x4b, 0x85, 0x38, 0x44, 0xed, 0x66, 0xe3, 0xb6, 0xda, 0xc8, 0xcb, 0x71, 0x98, 0xf1, 0x53, 0xd2,
+		0x48, 0xe5, 0x66, 0x25, 0x5c, 0x07, 0x69, 0x9f, 0x0e, 0x28, 0x46, 0x87, 0x64, 0xb6, 0xab, 0x26,
+		0xe5, 0xdf, 0x90, 0x20, 0xe5, 0xa6, 0x4a, 0x6b, 0xd8, 0x41, 0xe7, 0xfd, 0xf9, 0x0f, 0x77, 0x9b,
+		0x63, 0xb3, 0xe1, 0xb6, 0xbc, 0x94, 0x4e, 0xf1, 0xa1, 0xa3, 0xc7, 0xa8, 0x21, 0x9a, 0x86, 0xcd,
+		0x9f, 0x95, 0xf5, 0x20, 0x75, 0x91, 0xd1, 0x03, 0x80, 0x68, 0x84, 0x2b, 0x5f, 0x31, 0x1c, 0x4d,
+		0xaf, 0x95, 0x4d, 0xe3, 0x2a, 0x7f, 0xac, 0x1b, 0x55, 0xd2, 0xb4, 0xe6, 0x32, 0xad, 0x58, 0x25,
+		0x70, 0x22, 0x74, 0xd2, 0xe5, 0x12, 0x4c, 0xef, 0x48, 0x10, 0x10, 0x45, 0x74, 0x1e, 0x86, 0xcc,
+		0xe6, 0x66, 0x59, 0x44, 0x8c, 0xe1, 0x33, 0xc7, 0xdb, 0xf9, 0xbf, 0xb0, 0x0f, 0x1e, 0x01, 0x06,
+		0xcd, 0xe6, 0x26, 0xb1, 0x96, 0x3b, 0x20, 0xd5, 0x46, 0x98, 0xe1, 0x2b, 0x9e, 0x1c, 0xf4, 0xf3,
+		0x11, 0xbc, 0x07, 0x65, 0xd3, 0xd2, 0x0c, 0x4b, 0x73, 0xf6, 0x68, 0xfe, 0x1a, 0x55, 0xd2, 0xa2,
+		0x62, 0x95, 0xc3, 0xe5, 0x1d, 0x18, 0x5b, 0xa3, 0xeb, 0x5b, 0x4f, 0xf2, 0xb3, 0x9e, 0x7c, 0x52,
+		0x6f, 0xf9, 0x3a, 0x4a, 0x16, 0x69, 0x91, 0xac, 0xf0, 0x74, 0x47, 0xeb, 0x7c, 0x6c, 0xff, 0xd6,
+		0x19, 0xcc, 0x10, 0xff, 0xe4, 0x68, 0xc0, 0x39, 0x99, 0x71, 0xfa, 0xc3, 0x57, 0xbf, 0x86, 0xd9,
+		0x2b, 0x9b, 0xc8, 0x76, 0x9f, 0x54, 0xb3, 0x3d, 0xc2, 0x68, 0xb6, 0xa7, 0x0b, 0xc9, 0x4f, 0xc0,
+		0xc8, 0xaa, 0x6a, 0x39, 0x6b, 0xd8, 0xb9, 0x88, 0xd5, 0x2a, 0xb6, 0x82, 0xb3, 0xee, 0x88, 0x98,
+		0x75, 0x11, 0xc4, 0xe8, 0xd4, 0xca, 0x66, 0x1d, 0xfa, 0x5b, 0xde, 0x86, 0x18, 0xbd, 0x19, 0xea,
+		0xce, 0xc8, 0x9c, 0x82, 0xcd, 0xc8, 0x24, 0x96, 0xee, 0x39, 0xd8, 0x16, 0xe9, 0x2d, 0x2d, 0xa0,
+		0x47, 0xc5, 0xbc, 0x1a, 0xed, 0x3e, 0xaf, 0x72, 0x43, 0xe4, 0xb3, 0x6b, 0x1d, 0x86, 0x0a, 0x24,
+		0x14, 0x2f, 0x14, 0x5d, 0x41, 0x24, 0x4f, 0x10, 0xb4, 0x04, 0x63, 0xa6, 0x6a, 0x39, 0xf4, 0x49,
+		0xcc, 0x36, 0xed, 0x05, 0xb7, 0xf5, 0xe9, 0x56, 0xcf, 0x0b, 0x74, 0x96, 0xb7, 0x32, 0x62, 0xfa,
+		0x81, 0xf2, 0xf7, 0x63, 0x30, 0xc8, 0x95, 0xf1, 0x66, 0x18, 0xe2, 0x6a, 0xe5, 0xd6, 0x79, 0x62,
+		0xb6, 0x75, 0x62, 0x9a, 0x75, 0x27, 0x10, 0xce, 0x4f, 0xd0, 0xa0, 0x7b, 0x20, 0x51, 0xd9, 0x56,
+		0x35, 0xbd, 0xac, 0x55, 0xc5, 0x56, 0xc3, 0xab, 0x37, 0xa6, 0x87, 0xe6, 0x08, 0x6c, 0xa1, 0xa8,
+		0x0c, 0xd1, 0xca, 0x85, 0x2a, 0xc9, 0x04, 0xb6, 0xb1, 0x56, 0xdb, 0x76, 0xb8, 0x87, 0xf1, 0x12,
+		0x7a, 0x1c, 0x62, 0xc4, 0x20, 0xf8, 0x83, 0xc9, 0x6c, 0xcb, 0x86, 0x8f, 0x9b, 0xec, 0x15, 0x12,
+		0xa4, 0xe1, 0x0f, 0x7f, 0x67, 0x5a, 0x52, 0x28, 0x05, 0x9a, 0x83, 0x91, 0xba, 0x6a, 0x3b, 0x65,
+		0x3a, 0x83, 0x91, 0xe6, 0xe3, 0x7c, 0xbd, 0xdd, 0xa2, 0x10, 0xae, 0x58, 0x2e, 0xfa, 0x30, 0xa1,
+		0x62, 0xa0, 0x2a, 0x3a, 0x09, 0x69, 0xca, 0xa4, 0x62, 0x34, 0x1a, 0x9a, 0xc3, 0x72, 0xab, 0x41,
+		0xaa, 0xf7, 0x51, 0x02, 0x9f, 0xa3, 0x60, 0x9a, 0x61, 0x1d, 0x83, 0x24, 0x7d, 0xa2, 0x45, 0x51,
+		0xd8, 0x75, 0xe4, 0x04, 0x01, 0xd0, 0xca, 0x7b, 0x61, 0xcc, 0x8b, 0x8f, 0x0c, 0x25, 0xc1, 0xb8,
+		0x78, 0x60, 0x8a, 0xf8, 0x10, 0x4c, 0xea, 0x78, 0x97, 0x5e, 0x90, 0x0e, 0x60, 0x27, 0x29, 0x36,
+		0x22, 0x75, 0x97, 0x83, 0x14, 0x77, 0xc3, 0x68, 0x45, 0x28, 0x9f, 0xe1, 0x02, 0xc5, 0x1d, 0x71,
+		0xa1, 0x14, 0xed, 0x28, 0x24, 0x54, 0xd3, 0x64, 0x08, 0xc3, 0x3c, 0x3e, 0x9a, 0x26, 0xad, 0x3a,
+		0x05, 0xe3, 0xb4, 0x8f, 0x16, 0xb6, 0x9b, 0x75, 0x87, 0x33, 0x49, 0x51, 0x9c, 0x31, 0x52, 0xa1,
+		0x30, 0x38, 0xc5, 0xbd, 0x13, 0x46, 0xf0, 0x15, 0xad, 0x8a, 0xf5, 0x0a, 0x66, 0x78, 0x23, 0x14,
+		0x2f, 0x25, 0x80, 0x14, 0xe9, 0x3e, 0x70, 0xe3, 0x5e, 0x59, 0xc4, 0xe4, 0x51, 0xc6, 0x4f, 0xc0,
+		0xf3, 0x0c, 0x2c, 0x67, 0x20, 0x56, 0x54, 0x1d, 0x95, 0x24, 0x18, 0xce, 0x2e, 0x9b, 0x68, 0x52,
+		0x0a, 0xf9, 0x29, 0xbf, 0x16, 0x81, 0xd8, 0x65, 0xc3, 0xc1, 0xe8, 0x11, 0x5f, 0x02, 0x38, 0xda,
+		0xce, 0x9e, 0xd7, 0xb4, 0x9a, 0x8e, 0xab, 0x4b, 0x76, 0xcd, 0xf7, 0x3d, 0x05, 0xcf, 0x9c, 0x22,
+		0x01, 0x73, 0x9a, 0x84, 0xb8, 0x65, 0x34, 0xf5, 0xaa, 0xb8, 0xc9, 0x4b, 0x0b, 0xa8, 0x04, 0x09,
+		0xd7, 0x4a, 0x62, 0xbd, 0xac, 0x64, 0x8c, 0x58, 0x09, 0xb1, 0x61, 0x0e, 0x50, 0x86, 0x36, 0xb9,
+		0xb1, 0x14, 0x20, 0xe9, 0x06, 0x2f, 0x6e, 0x6d, 0xfd, 0x19, 0xac, 0x47, 0x46, 0x26, 0x13, 0x77,
+		0xec, 0x5d, 0xe5, 0x31, 0x8b, 0x4b, 0xbb, 0x15, 0x5c, 0x7b, 0x01, 0xb3, 0xe2, 0xdf, 0x76, 0x18,
+		0xa2, 0xfd, 0xf2, 0xcc, 0x8a, 0x7d, 0xdf, 0xe1, 0x38, 0x24, 0x6d, 0xad, 0xa6, 0xab, 0x4e, 0xd3,
+		0xc2, 0xdc, 0xf2, 0x3c, 0x80, 0xfc, 0x55, 0x09, 0x06, 0x99, 0x25, 0xfb, 0xf4, 0x26, 0xb5, 0xd7,
+		0x5b, 0xa4, 0x93, 0xde, 0xa2, 0x07, 0xd7, 0x5b, 0x1e, 0xc0, 0x15, 0xc6, 0xe6, 0x4f, 0xee, 0xdb,
+		0x64, 0x0c, 0x4c, 0xc4, 0x35, 0xad, 0xc6, 0x1d, 0xd5, 0x47, 0x24, 0xff, 0x47, 0x89, 0x24, 0xb1,
+		0xbc, 0x1e, 0xe5, 0x61, 0x44, 0xc8, 0x55, 0xde, 0xaa, 0xab, 0x35, 0x6e, 0x3b, 0x27, 0x3a, 0x0a,
+		0x77, 0xa1, 0xae, 0xd6, 0x94, 0x61, 0x2e, 0x0f, 0x29, 0xb4, 0x1f, 0x87, 0x48, 0x87, 0x71, 0x08,
+		0x0c, 0x7c, 0xf4, 0x60, 0x03, 0x1f, 0x18, 0xa2, 0x58, 0x78, 0x88, 0xbe, 0x14, 0xa1, 0x8b, 0x19,
+		0xd3, 0xb0, 0xd5, 0xfa, 0x4f, 0xc3, 0x23, 0x8e, 0x41, 0xd2, 0x34, 0xea, 0x65, 0x56, 0xc3, 0x6e,
+		0xb8, 0x27, 0x4c, 0xa3, 0xae, 0xb4, 0x0c, 0x7b, 0xfc, 0x16, 0xb9, 0xcb, 0xe0, 0x2d, 0xd0, 0xda,
+		0x50, 0x58, 0x6b, 0x16, 0xa4, 0x98, 0x2a, 0xf8, 0x5c, 0xf6, 0x10, 0xd1, 0x01, 0x9d, 0x1c, 0xa5,
+		0xd6, 0xb9, 0x97, 0x89, 0xcd, 0x30, 0x15, 0x8e, 0x47, 0x28, 0x58, 0xe8, 0x6f, 0xb7, 0x0a, 0xf6,
+		0x9b, 0xa5, 0xc2, 0xf1, 0xe4, 0xbf, 0x29, 0x01, 0x2c, 0x12, 0xcd, 0xd2, 0xfe, 0x92, 0x59, 0xc8,
+		0xa6, 0x22, 0x94, 0x03, 0x2d, 0x4f, 0x75, 0x1a, 0x34, 0xde, 0x7e, 0xca, 0xf6, 0xcb, 0x3d, 0x07,
+		0x23, 0x9e, 0x31, 0xda, 0x58, 0x08, 0x33, 0xd5, 0x25, 0xab, 0x5e, 0xc3, 0x8e, 0x92, 0xba, 0xe2,
+		0x2b, 0xc9, 0xff, 0x5c, 0x82, 0x24, 0x95, 0x69, 0x09, 0x3b, 0x6a, 0x60, 0x0c, 0xa5, 0x83, 0x8f,
+		0xe1, 0x09, 0x00, 0xc6, 0xc6, 0xd6, 0x5e, 0xc4, 0xdc, 0xb2, 0x92, 0x14, 0xb2, 0xa6, 0xbd, 0x88,
+		0xd1, 0x39, 0x57, 0xe1, 0xd1, 0xee, 0x0a, 0x17, 0x59, 0x37, 0x57, 0xfb, 0x11, 0x18, 0xa2, 0x9f,
+		0xa8, 0xda, 0xb5, 0x79, 0x22, 0x3d, 0xa8, 0x37, 0x1b, 0xeb, 0xbb, 0xb6, 0xfc, 0x3c, 0x0c, 0xad,
+		0xef, 0xb2, 0xbd, 0x91, 0x63, 0x90, 0xb4, 0x0c, 0x83, 0xcf, 0xc9, 0x2c, 0x17, 0x4a, 0x10, 0x00,
+		0x9d, 0x82, 0xc4, 0x7e, 0x40, 0xc4, 0xdb, 0x0f, 0xf0, 0x36, 0x34, 0xa2, 0x7d, 0x6d, 0x68, 0x9c,
+		0xfa, 0xf7, 0x12, 0x0c, 0xfb, 0xe2, 0x03, 0x7a, 0x18, 0x0e, 0x15, 0x16, 0x57, 0xe6, 0x2e, 0x95,
+		0x17, 0x8a, 0xe5, 0x0b, 0x8b, 0xf9, 0x79, 0xef, 0x0d, 0x57, 0xf6, 0xf0, 0xb5, 0xeb, 0x33, 0xc8,
+		0x87, 0xbb, 0xa1, 0xd3, 0x1d, 0x25, 0x74, 0x1a, 0x26, 0x83, 0x24, 0xf9, 0xc2, 0x5a, 0x69, 0x79,
+		0x3d, 0x2d, 0x65, 0x0f, 0x5d, 0xbb, 0x3e, 0x33, 0xee, 0xa3, 0xc8, 0x6f, 0xda, 0x58, 0x77, 0x5a,
+		0x09, 0xe6, 0x56, 0x96, 0x96, 0x16, 0xd6, 0xd3, 0x91, 0x16, 0x02, 0x1e, 0xb0, 0xef, 0x83, 0xf1,
+		0x20, 0xc1, 0xf2, 0xc2, 0x62, 0x3a, 0x9a, 0x45, 0xd7, 0xae, 0xcf, 0x8c, 0xfa, 0xb0, 0x97, 0xb5,
+		0x7a, 0x36, 0xf1, 0xc1, 0xcf, 0x4c, 0x0d, 0xfc, 0xea, 0xaf, 0x4c, 0x49, 0xa4, 0x67, 0x23, 0x81,
+		0x18, 0x81, 0x1e, 0x80, 0x23, 0x6b, 0x0b, 0xf3, 0xcb, 0xa5, 0x62, 0x79, 0x69, 0x6d, 0x5e, 0xec,
+		0x41, 0x8b, 0xde, 0x8d, 0x5d, 0xbb, 0x3e, 0x33, 0xcc, 0xbb, 0xd4, 0x09, 0x7b, 0x55, 0x29, 0x5d,
+		0x5e, 0x59, 0x2f, 0xa5, 0x25, 0x86, 0xbd, 0x6a, 0xe1, 0x2b, 0x86, 0xc3, 0xbe, 0x61, 0xf7, 0x10,
+		0x1c, 0x6d, 0x83, 0xed, 0x76, 0x6c, 0xfc, 0xda, 0xf5, 0x99, 0x91, 0x55, 0x0b, 0x33, 0xff, 0xa1,
+		0x14, 0xb3, 0x90, 0x69, 0xa5, 0x58, 0x59, 0x5d, 0x59, 0xcb, 0x2f, 0xa6, 0x67, 0xb2, 0xe9, 0x6b,
+		0xd7, 0x67, 0x52, 0x22, 0x18, 0xd2, 0x8d, 0x7e, 0xb7, 0x67, 0xb7, 0x73, 0xc5, 0xf3, 0xfd, 0x59,
+		0xb8, 0xab, 0xc3, 0x19, 0x93, 0x38, 0x9d, 0x38, 0xd0, 0x29, 0x53, 0xc7, 0x7d, 0xf6, 0x6c, 0x8f,
+		0xed, 0xe7, 0xde, 0x4b, 0xa7, 0x83, 0x9f, 0x60, 0x65, 0xbb, 0x2e, 0xee, 0xe4, 0x0f, 0x49, 0x30,
+		0x7a, 0x51, 0xb3, 0x1d, 0xc3, 0xd2, 0x2a, 0x6a, 0x9d, 0xbe, 0xdc, 0x3a, 0xd7, 0x6f, 0x6c, 0x0d,
+		0xb9, 0xfa, 0x93, 0x30, 0x78, 0x45, 0xad, 0xb3, 0xa0, 0x16, 0xa5, 0x1f, 0x9a, 0xe9, 0x70, 0xe4,
+		0xe3, 0x86, 0x36, 0xc1, 0x80, 0x91, 0xc9, 0xbf, 0x1e, 0x81, 0x31, 0xea, 0x0c, 0x36, 0xfb, 0x04,
+		0x19, 0x59, 0x63, 0x15, 0x20, 0x66, 0xa9, 0x0e, 0xdf, 0x34, 0x2c, 0xcc, 0xf2, 0xd3, 0xc7, 0x7b,
+		0xfa, 0x38, 0x4b, 0x2b, 0xe2, 0x8a, 0x42, 0x69, 0xd1, 0x3b, 0x20, 0xd1, 0x50, 0x77, 0xcb, 0x94,
+		0x0f, 0x5b, 0xb9, 0xe4, 0xf7, 0xc7, 0xe7, 0xe6, 0x8d, 0xe9, 0xb1, 0x3d, 0xb5, 0x51, 0xcf, 0xc9,
+		0x82, 0x8f, 0xac, 0x0c, 0x35, 0xd4, 0x5d, 0x22, 0x22, 0x32, 0x61, 0x8c, 0x40, 0x2b, 0xdb, 0xaa,
+		0x5e, 0xc3, 0xac, 0x11, 0xba, 0x05, 0x5a, 0xb8, 0xb8, 0xef, 0x46, 0x0e, 0x7b, 0x8d, 0xf8, 0xd8,
+		0xc9, 0xca, 0x48, 0x43, 0xdd, 0x9d, 0xa3, 0x00, 0xd2, 0x62, 0x2e, 0xf1, 0xb1, 0x57, 0xa6, 0x07,
+		0xe8, 0x89, 0xee, 0xb7, 0x25, 0x00, 0x4f, 0x63, 0xe8, 0x1d, 0x90, 0xae, 0xb8, 0x25, 0x4a, 0x2b,
+		0xce, 0x26, 0xef, 0xed, 0x34, 0x16, 0x21, 0x7d, 0xb3, 0xb9, 0xf9, 0x5b, 0x37, 0xa6, 0x25, 0x65,
+		0xac, 0x12, 0x1a, 0x8a, 0xb7, 0xc3, 0x70, 0xd3, 0xac, 0xaa, 0x0e, 0x2e, 0xd3, 0x75, 0x5c, 0xa4,
+		0xe7, 0x3c, 0x3f, 0x45, 0x78, 0xdd, 0xbc, 0x31, 0x8d, 0x58, 0xb7, 0x7c, 0xc4, 0x32, 0x9d, 0xfd,
+		0x81, 0x41, 0x08, 0x81, 0xaf, 0x4f, 0xdf, 0x90, 0x60, 0xb8, 0xe8, 0xbb, 0x53, 0x99, 0x81, 0xa1,
+		0x86, 0xa1, 0x6b, 0x3b, 0xdc, 0x1e, 0x93, 0x8a, 0x28, 0xa2, 0x2c, 0x24, 0xd8, 0x63, 0x56, 0x67,
+		0x4f, 0x6c, 0x85, 0x8a, 0x32, 0xa1, 0xba, 0x8a, 0x37, 0x6d, 0x4d, 0x8c, 0x86, 0x22, 0x8a, 0xe8,
+		0x02, 0xa4, 0x6d, 0x5c, 0x69, 0x5a, 0x9a, 0xb3, 0x57, 0xae, 0x18, 0xba, 0xa3, 0x56, 0x1c, 0xf6,
+		0x2c, 0xb2, 0x70, 0xec, 0xe6, 0x8d, 0xe9, 0x23, 0x4c, 0xd6, 0x30, 0x86, 0xac, 0x8c, 0x09, 0xd0,
+		0x1c, 0x83, 0x90, 0x16, 0xaa, 0xd8, 0x51, 0xb5, 0xba, 0x9d, 0x61, 0x97, 0x13, 0x44, 0xd1, 0xd7,
+		0x97, 0xcf, 0x0f, 0xf9, 0x37, 0xb6, 0x2e, 0x40, 0xda, 0x30, 0xb1, 0x15, 0x48, 0x44, 0xa5, 0x70,
+		0xcb, 0x61, 0x0c, 0x59, 0x19, 0x13, 0x20, 0x91, 0xa4, 0x3a, 0x64, 0x98, 0xc5, 0x42, 0xd1, 0x6c,
+		0x6e, 0x7a, 0xfb, 0x61, 0x93, 0x2d, 0xa3, 0x91, 0xd7, 0xf7, 0x0a, 0x8f, 0x78, 0xdc, 0xc3, 0x74,
+		0xf2, 0x37, 0xbf, 0xfc, 0xe0, 0x24, 0x37, 0x0d, 0x6f, 0x7f, 0xea, 0x12, 0xde, 0x23, 0xc3, 0xcf,
+		0x51, 0x57, 0x29, 0x26, 0x49, 0x3b, 0x9f, 0x57, 0xb5, 0xba, 0x78, 0xde, 0xaf, 0xf0, 0x12, 0xca,
+		0xc1, 0xa0, 0xed, 0xa8, 0x4e, 0xd3, 0xe6, 0x27, 0xbd, 0x72, 0x27, 0x53, 0x2b, 0x18, 0x7a, 0x75,
+		0x8d, 0x62, 0x2a, 0x9c, 0x02, 0x5d, 0x80, 0x41, 0x7e, 0x84, 0x1e, 0xdf, 0xb7, 0x7f, 0xd3, 0xbb,
+		0x12, 0x8c, 0x9a, 0x68, 0xa4, 0x8a, 0xeb, 0xb8, 0xc6, 0xd2, 0xaa, 0x6d, 0x95, 0xac, 0x3e, 0xe8,
+		0xb7, 0xf7, 0x0a, 0x0b, 0xfb, 0x76, 0x42, 0xae, 0xa9, 0x30, 0x3f, 0x59, 0x19, 0x73, 0x41, 0x6b,
+		0x14, 0x82, 0x2e, 0x05, 0x2e, 0xff, 0xf2, 0x0f, 0x54, 0xde, 0xd9, 0xa9, 0xfb, 0x3e, 0x9b, 0x16,
+		0xfb, 0x13, 0xfe, 0xab, 0xc3, 0x17, 0x20, 0xdd, 0xd4, 0x37, 0x0d, 0x9d, 0xbe, 0xc1, 0xe5, 0xf9,
+		0x3d, 0x59, 0xdf, 0x45, 0xfd, 0xc6, 0x11, 0xc6, 0x90, 0x95, 0x31, 0x17, 0x74, 0x91, 0xad, 0x02,
+		0xaa, 0x30, 0xea, 0x61, 0x51, 0x47, 0x4d, 0xf6, 0x74, 0xd4, 0x3b, 0xb8, 0xa3, 0x1e, 0x0a, 0xb7,
+		0xe2, 0xf9, 0xea, 0x88, 0x0b, 0x24, 0x64, 0xe8, 0x22, 0x80, 0x17, 0x1e, 0xe8, 0x3e, 0xc5, 0x70,
+		0xe7, 0x81, 0xf7, 0x62, 0x8c, 0x58, 0xef, 0x79, 0xb4, 0xe8, 0x5d, 0x30, 0xd1, 0xd0, 0xf4, 0xb2,
+		0x8d, 0xeb, 0x5b, 0x65, 0xae, 0x60, 0xc2, 0x92, 0x7e, 0x42, 0xa9, 0xb0, 0xb8, 0x3f, 0x7b, 0xb8,
+		0x79, 0x63, 0x3a, 0xcb, 0x43, 0x68, 0x2b, 0x4b, 0x59, 0x19, 0x6f, 0x68, 0xfa, 0x1a, 0xae, 0x6f,
+		0x15, 0x5d, 0x58, 0x2e, 0xf5, 0xc1, 0x57, 0xa6, 0x07, 0xb8, 0xbb, 0x0e, 0xc8, 0xe7, 0xe8, 0xde,
+		0x39, 0x77, 0x33, 0x6c, 0x93, 0x35, 0x89, 0x2a, 0x0a, 0xfc, 0xaa, 0x81, 0x07, 0x60, 0x6e, 0xfe,
+		0xd2, 0x1f, 0xce, 0x48, 0xf2, 0xe7, 0x25, 0x18, 0x2c, 0x5e, 0x5e, 0x55, 0x35, 0x0b, 0x2d, 0xc0,
+		0xb8, 0x67, 0x39, 0x41, 0x27, 0x3f, 0x7e, 0xf3, 0xc6, 0x74, 0x26, 0x6c, 0x5c, 0xae, 0x97, 0x7b,
+		0x06, 0x2c, 0xdc, 0x7c, 0xa1, 0xd3, 0xc2, 0x35, 0xc0, 0xaa, 0x05, 0x45, 0x6e, 0x5d, 0xd6, 0x86,
+		0xba, 0x59, 0x82, 0x21, 0x26, 0xad, 0x8d, 0x72, 0x10, 0x37, 0xc9, 0x0f, 0x7e, 0x30, 0x30, 0xd5,
+		0xd1, 0x78, 0x29, 0xbe, 0xbb, 0x91, 0x49, 0x48, 0xe4, 0x8f, 0x44, 0x00, 0x8a, 0x97, 0x2f, 0xaf,
+		0x5b, 0x9a, 0x59, 0xc7, 0xce, 0xad, 0xec, 0xf9, 0x3a, 0x1c, 0xf2, 0xad, 0x92, 0xac, 0x4a, 0xa8,
+		0xf7, 0x33, 0x37, 0x6f, 0x4c, 0x1f, 0x0f, 0xf7, 0xde, 0x87, 0x26, 0x2b, 0x13, 0xde, 0x7a, 0xc9,
+		0xaa, 0xb4, 0xe5, 0x5a, 0xb5, 0x1d, 0x97, 0x6b, 0xb4, 0x33, 0x57, 0x1f, 0x9a, 0x9f, 0x6b, 0xd1,
+		0x76, 0xda, 0xab, 0x76, 0x0d, 0x86, 0x3d, 0x95, 0xd8, 0xa8, 0x08, 0x09, 0x87, 0xff, 0xe6, 0x1a,
+		0x96, 0x3b, 0x6b, 0x58, 0x90, 0x71, 0x2d, 0xbb, 0x94, 0xf2, 0x9f, 0x49, 0x00, 0x9e, 0xcd, 0xfe,
+		0x6c, 0x9a, 0x18, 0x09, 0xe5, 0x3c, 0xf0, 0x46, 0x0f, 0x94, 0xaa, 0x71, 0xea, 0x90, 0x3e, 0x7f,
+		0x3e, 0x02, 0x13, 0x1b, 0x22, 0xf2, 0xfc, 0xcc, 0xeb, 0x60, 0x15, 0x86, 0xb0, 0xee, 0x58, 0x1a,
+		0x55, 0x02, 0x19, 0xed, 0x87, 0x3a, 0x8d, 0x76, 0x9b, 0x3e, 0xd1, 0x8f, 0x48, 0x89, 0x4d, 0x77,
+		0xce, 0x26, 0xa4, 0x8d, 0x5f, 0x8c, 0x42, 0xa6, 0x13, 0x25, 0x9a, 0x83, 0xb1, 0x8a, 0x85, 0xd9,
+		0xc5, 0x2b, 0xff, 0xce, 0x5f, 0x21, 0xeb, 0x65, 0x96, 0x21, 0x04, 0x59, 0x19, 0x15, 0x10, 0x3e,
+		0x7b, 0xd4, 0x80, 0xa4, 0x7d, 0xc4, 0xec, 0xe8, 0xfd, 0xad, 0xfe, 0xf2, 0x3c, 0x99, 0x4f, 0x1f,
+		0xa2, 0x91, 0x20, 0x03, 0x36, 0x7f, 0x8c, 0x7a, 0x50, 0x3a, 0x81, 0xbc, 0x00, 0x63, 0x9a, 0xae,
+		0x39, 0x9a, 0x5a, 0x2f, 0x6f, 0xaa, 0x75, 0x55, 0xaf, 0x1c, 0x24, 0x6b, 0x66, 0x21, 0x9f, 0x37,
+		0x1b, 0x62, 0x27, 0x2b, 0xa3, 0x1c, 0x52, 0x60, 0x00, 0x74, 0x11, 0x86, 0x44, 0x53, 0xb1, 0x03,
+		0x65, 0x1b, 0x82, 0xdc, 0x97, 0xe0, 0xfd, 0x42, 0x14, 0xc6, 0x15, 0x5c, 0xfd, 0xff, 0x43, 0xb1,
+		0xbf, 0xa1, 0x58, 0x02, 0x60, 0xee, 0x4e, 0x02, 0xec, 0x01, 0x46, 0x83, 0x04, 0x8c, 0x24, 0xe3,
+		0x50, 0xb4, 0x1d, 0xdf, 0x78, 0xdc, 0x88, 0x40, 0xca, 0x3f, 0x1e, 0x7f, 0x41, 0x67, 0x25, 0xb4,
+		0xe0, 0x45, 0xa2, 0x18, 0xff, 0xf4, 0x6e, 0x87, 0x48, 0xd4, 0x62, 0xbd, 0xdd, 0x43, 0xd0, 0x1f,
+		0x47, 0x61, 0x70, 0x55, 0xb5, 0xd4, 0x86, 0x8d, 0x2a, 0x2d, 0x99, 0xa6, 0xd8, 0x7e, 0x6c, 0xf9,
+		0xc0, 0x3a, 0xdf, 0xed, 0xe8, 0x91, 0x68, 0x7e, 0xac, 0x4d, 0xa2, 0xf9, 0x56, 0x18, 0x25, 0xcb,
+		0x61, 0xdf, 0x15, 0x06, 0xa2, 0xed, 0x91, 0xc2, 0x51, 0x8f, 0x4b, 0xb0, 0x9e, 0xad, 0x96, 0x2f,
+		0xfb, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0x2f, 0x30, 0x13, 0xf2, 0xc3, 0xde, 0xb2, 0xd4, 0x57, 0x29,
+		0x2b, 0xd0, 0x50, 0x77, 0x4b, 0xac, 0x80, 0x16, 0x01, 0x6d, 0xbb, 0x3b, 0x23, 0x65, 0x4f, 0x9d,
+		0x84, 0xfe, 0xc4, 0xcd, 0x1b, 0xd3, 0x47, 0x19, 0x7d, 0x2b, 0x8e, 0xac, 0x8c, 0x7b, 0x40, 0xc1,
+		0xed, 0x51, 0x00, 0xd2, 0xaf, 0x32, 0xbb, 0xc2, 0xcd, 0x96, 0x3b, 0x87, 0x6e, 0xde, 0x98, 0x1e,
+		0x67, 0x5c, 0xbc, 0x3a, 0x59, 0x49, 0x92, 0x42, 0x91, 0xde, 0xee, 0x7e, 0x01, 0xc6, 0xe8, 0x9d,
+		0x80, 0xb2, 0x85, 0xab, 0x4d, 0xfa, 0x69, 0x18, 0xbe, 0xae, 0x39, 0xb0, 0x6f, 0x86, 0xd8, 0xc9,
+		0xca, 0x28, 0x85, 0x28, 0x02, 0xe0, 0x73, 0xa6, 0xcf, 0x48, 0x80, 0xbc, 0x59, 0x46, 0xc1, 0xb6,
+		0x49, 0x96, 0x84, 0x24, 0xf7, 0xf7, 0x25, 0xea, 0x52, 0xf7, 0xdc, 0xdf, 0xa3, 0x17, 0xb9, 0xbf,
+		0xcf, 0x39, 0x9f, 0xf0, 0x22, 0x72, 0xa4, 0xd7, 0x15, 0x6a, 0x6e, 0x95, 0xe1, 0x10, 0x3c, 0x20,
+		0xff, 0x2b, 0x09, 0x8e, 0xb6, 0x18, 0xb1, 0x2b, 0xec, 0x5f, 0x02, 0x64, 0xf9, 0x2a, 0xf9, 0xa7,
+		0x1b, 0x99, 0xd0, 0xfb, 0xf6, 0x89, 0x71, 0xab, 0x25, 0xd4, 0xdf, 0xba, 0x49, 0x85, 0xdd, 0xd1,
+		0xff, 0x67, 0x12, 0x4c, 0xfa, 0x9b, 0x77, 0x3b, 0xb2, 0x0c, 0x29, 0x7f, 0xeb, 0xbc, 0x0b, 0x77,
+		0xf5, 0xd3, 0x05, 0x2e, 0x7d, 0x80, 0x1e, 0x3d, 0xed, 0x45, 0x08, 0xb6, 0x5d, 0xf7, 0x70, 0xdf,
+		0xda, 0x10, 0x32, 0x85, 0x23, 0x45, 0x8c, 0x8e, 0xc7, 0xff, 0x91, 0x20, 0xb6, 0x6a, 0x18, 0x75,
+		0x64, 0xc0, 0xb8, 0x6e, 0x38, 0x65, 0x62, 0xcc, 0xb8, 0xea, 0xbf, 0x2a, 0x9f, 0x2c, 0xcc, 0xed,
+		0x4f, 0x49, 0x3f, 0xb8, 0x31, 0xdd, 0xca, 0x4a, 0x19, 0xd3, 0x0d, 0xa7, 0x40, 0x21, 0xfc, 0xb6,
+		0xfc, 0xbb, 0x60, 0x24, 0xd8, 0x18, 0x0b, 0xcc, 0xcf, 0xec, 0xbb, 0xb1, 0x20, 0x9b, 0x9b, 0x37,
+		0xa6, 0x27, 0x3d, 0x27, 0x75, 0xc1, 0xb2, 0x92, 0xda, 0xf4, 0xb5, 0xce, 0x6e, 0x94, 0xfd, 0xe8,
+		0x95, 0x69, 0xe9, 0xd4, 0x57, 0x24, 0x00, 0x6f, 0xb3, 0x03, 0x3d, 0x00, 0x47, 0x0a, 0x2b, 0xcb,
+		0xc5, 0xf2, 0xda, 0x7a, 0x7e, 0x7d, 0x63, 0x2d, 0x78, 0xad, 0x5c, 0xec, 0xc8, 0xdb, 0x26, 0xae,
+		0x68, 0x5b, 0x1a, 0xae, 0xa2, 0x7b, 0x60, 0x32, 0x88, 0x4d, 0x4a, 0xa5, 0x62, 0x5a, 0xca, 0xa6,
+		0xae, 0x5d, 0x9f, 0x49, 0xb0, 0xf4, 0x0f, 0x57, 0xd1, 0x49, 0x38, 0xd4, 0x8a, 0xb7, 0xb0, 0x3c,
+		0x9f, 0x8e, 0x64, 0x47, 0xae, 0x5d, 0x9f, 0x49, 0xba, 0x79, 0x22, 0x92, 0x01, 0xf9, 0x31, 0x39,
+		0xbf, 0x68, 0x16, 0xae, 0x5d, 0x9f, 0x19, 0x64, 0x0a, 0xcc, 0xc6, 0x3e, 0xf8, 0x99, 0xa9, 0x81,
+		0x5b, 0x7e, 0xf9, 0xfc, 0x4f, 0x87, 0x3a, 0x6e, 0xb4, 0xd7, 0xb0, 0x8e, 0x6d, 0xcd, 0x3e, 0xd0,
+		0x46, 0x7b, 0x5f, 0x9b, 0xf7, 0xf2, 0xef, 0xc5, 0x21, 0x35, 0xcf, 0x5a, 0x21, 0x03, 0x81, 0xd1,
+		0x9b, 0x60, 0xd0, 0xa4, 0x33, 0x97, 0x7b, 0x72, 0xd7, 0xc1, 0xe0, 0xd9, 0xfc, 0xe6, 0x5e, 0x1f,
+		0x63, 0xb3, 0x9d, 0xcd, 0xef, 0x8f, 0xb0, 0x6b, 0x6d, 0xde, 0x45, 0xad, 0xd4, 0xbe, 0xb6, 0x98,
+		0x58, 0x28, 0xe6, 0xbb, 0x39, 0x61, 0x7e, 0x32, 0xbb, 0x8a, 0xb2, 0x4e, 0x20, 0xec, 0x42, 0xda,
+		0xfb, 0x25, 0x38, 0x44, 0xb1, 0xbc, 0xb9, 0x9f, 0x62, 0x8a, 0xf5, 0xc5, 0xa9, 0x4e, 0x5d, 0x58,
+		0x54, 0x6d, 0xef, 0x7a, 0x09, 0xbb, 0x42, 0x76, 0x17, 0x9f, 0x7b, 0x8f, 0xfb, 0x1a, 0x0f, 0xb3,
+		0x95, 0x95, 0x89, 0x7a, 0x0b, 0xa5, 0x8d, 0xe6, 0x03, 0x77, 0x08, 0x63, 0xfb, 0xdb, 0xdd, 0xf7,
+		0xdf, 0x27, 0x7c, 0x0a, 0x86, 0xbd, 0x58, 0x62, 0xf3, 0x7f, 0x35, 0xd3, 0xff, 0xdc, 0xe1, 0x27,
+		0x46, 0x1f, 0x90, 0xe0, 0x90, 0x97, 0x40, 0xf8, 0xd9, 0xb2, 0x7f, 0xc9, 0x73, 0xff, 0x3e, 0xd6,
+		0x5e, 0x61, 0xe5, 0xb4, 0xe5, 0x2b, 0x2b, 0x93, 0xcd, 0x56, 0x52, 0xb2, 0xea, 0x1b, 0xf1, 0x47,
+		0x56, 0x3b, 0x23, 0xbe, 0x3a, 0xd9, 0x7f, 0x68, 0x0e, 0x32, 0x60, 0xff, 0x26, 0xc4, 0x34, 0x2c,
+		0x07, 0x57, 0xe9, 0x1e, 0x60, 0x42, 0x71, 0xcb, 0xf2, 0x32, 0xa0, 0xd6, 0xc1, 0x0d, 0xdf, 0x99,
+		0xf4, 0x9e, 0xc4, 0xa0, 0x49, 0x88, 0xfb, 0x6f, 0x15, 0xb2, 0x42, 0x2e, 0xf1, 0x41, 0x3e, 0x7d,
+		0xde, 0x72, 0x9f, 0xff, 0x17, 0x11, 0x38, 0xe5, 0x3f, 0x91, 0x7a, 0xa1, 0x89, 0xad, 0x3d, 0xd7,
+		0x45, 0x4d, 0xb5, 0xa6, 0xe9, 0xfe, 0x87, 0x17, 0x47, 0xfd, 0x13, 0x3e, 0xc5, 0x15, 0x7a, 0x92,
+		0x75, 0x18, 0x5e, 0x55, 0x6b, 0x58, 0xc1, 0x2f, 0x34, 0xb1, 0xed, 0xb4, 0xb9, 0xd7, 0x7e, 0x18,
+		0x06, 0x8d, 0xad, 0x2d, 0x71, 0x8a, 0x1e, 0x53, 0x78, 0x89, 0x74, 0xb9, 0xae, 0x35, 0x34, 0x76,
+		0x01, 0x2d, 0xa6, 0xb0, 0x02, 0x9a, 0x86, 0xe1, 0x8a, 0xd1, 0xd4, 0xb9, 0xc7, 0x65, 0x62, 0xe2,
+		0xeb, 0x2e, 0x4d, 0x9d, 0x79, 0x9c, 0xfc, 0x24, 0xa4, 0x58, 0x7b, 0x7c, 0xc6, 0x3d, 0x0a, 0x09,
+		0x7a, 0x83, 0xcb, 0x6b, 0x75, 0x88, 0x94, 0x2f, 0xb1, 0x3b, 0xf0, 0x8c, 0x0b, 0x6b, 0x98, 0x15,
+		0x0a, 0x85, 0x8e, 0xaa, 0x3c, 0xd9, 0x3b, 0x34, 0x30, 0x45, 0xb9, 0x6a, 0xfc, 0xad, 0x38, 0x1c,
+		0xe2, 0x87, 0x82, 0xaa, 0xa9, 0x9d, 0xde, 0x76, 0x1c, 0xf1, 0x26, 0x03, 0x78, 0x76, 0xad, 0x9a,
+		0x9a, 0xbc, 0x07, 0xb1, 0x8b, 0x8e, 0x63, 0xa2, 0x53, 0x10, 0xb7, 0x9a, 0x75, 0x2c, 0x36, 0x99,
+		0xdc, 0x63, 0x00, 0xd5, 0xd4, 0x66, 0x09, 0x82, 0xd2, 0xac, 0x63, 0x85, 0xa1, 0xa0, 0x12, 0x4c,
+		0x6f, 0x35, 0xeb, 0xf5, 0xbd, 0x72, 0x15, 0xd3, 0x7f, 0xc3, 0xe5, 0xfe, 0x23, 0x0b, 0xbc, 0x6b,
+		0xaa, 0xe2, 0x73, 0x98, 0x44, 0x37, 0xc7, 0x29, 0x5a, 0x91, 0x62, 0x89, 0x7f, 0x62, 0x51, 0x12,
+		0x38, 0xf2, 0x1f, 0x44, 0x20, 0x21, 0x58, 0xd3, 0x4b, 0xe9, 0xb8, 0x8e, 0x2b, 0x8e, 0x21, 0x0e,
+		0x69, 0xdc, 0x32, 0x42, 0x10, 0xad, 0xf1, 0x21, 0x4a, 0x5e, 0x1c, 0x50, 0x48, 0x81, 0xc0, 0xdc,
+		0xa7, 0x02, 0x04, 0x66, 0x36, 0xc9, 0xa8, 0xc5, 0x4c, 0x43, 0xac, 0x06, 0x2f, 0x0e, 0x28, 0xb4,
+		0x84, 0x32, 0x30, 0x48, 0x3c, 0xc3, 0x61, 0xdf, 0x18, 0x25, 0x70, 0x5e, 0x46, 0x87, 0x21, 0x6e,
+		0xaa, 0x4e, 0x85, 0xdd, 0xe2, 0x23, 0x15, 0xac, 0x88, 0x1e, 0x83, 0x41, 0xf6, 0xda, 0x3b, 0xfc,
+		0x3f, 0x6e, 0x88, 0x32, 0xd8, 0x67, 0xf5, 0x88, 0xdc, 0xab, 0xaa, 0xe3, 0x60, 0x4b, 0x27, 0x0c,
+		0x19, 0x3a, 0x42, 0x10, 0xdb, 0x34, 0xaa, 0x7b, 0xfc, 0xff, 0xee, 0xd0, 0xdf, 0xfc, 0x1f, 0x7d,
+		0x50, 0x7b, 0x28, 0xd3, 0x4a, 0xf6, 0xef, 0xc6, 0x52, 0x02, 0x58, 0x20, 0x48, 0x25, 0x98, 0x50,
+		0xab, 0x55, 0x8d, 0xfd, 0x0b, 0x9c, 0xf2, 0xa6, 0x46, 0x23, 0x84, 0x4d, 0xff, 0x99, 0x5c, 0xa7,
+		0xb1, 0x40, 0x1e, 0x41, 0x81, 0xe3, 0x17, 0x92, 0x30, 0x64, 0x32, 0xa1, 0xe4, 0xf3, 0x30, 0xde,
+		0x22, 0x29, 0x91, 0x6f, 0x47, 0xd3, 0xab, 0xe2, 0xfd, 0x04, 0xf9, 0x4d, 0x60, 0xf4, 0x43, 0x98,
+		0xec, 0xf8, 0x8b, 0xfe, 0x2e, 0xbc, 0xb7, 0xf3, 0x33, 0x9b, 0x51, 0xdf, 0x33, 0x1b, 0xd5, 0xd4,
+		0x0a, 0x49, 0xca, 0x9f, 0x3f, 0xae, 0xc9, 0xb7, 0x3e, 0xae, 0xa9, 0x61, 0x5d, 0xcc, 0xbe, 0xa4,
+		0x4a, 0x35, 0x35, 0x9b, 0x9a, 0xa3, 0xf7, 0x61, 0x4e, 0xfb, 0xbc, 0xef, 0x37, 0x7d, 0x6b, 0x13,
+		0x9b, 0xcf, 0xaf, 0x2e, 0xb8, 0x76, 0xfc, 0xb5, 0x08, 0x1c, 0xf7, 0xd9, 0xb1, 0x0f, 0xb9, 0xd5,
+		0x9c, 0xb3, 0xed, 0x2d, 0xbe, 0x8f, 0x37, 0xcf, 0x97, 0x20, 0x46, 0xf0, 0x51, 0x8f, 0x7f, 0xc3,
+		0x91, 0xf9, 0xc2, 0x37, 0xff, 0xa9, 0x1c, 0x3c, 0x28, 0x0b, 0x8c, 0x0a, 0x65, 0x52, 0xf8, 0x40,
+		0xff, 0xfa, 0x4b, 0x7b, 0xdf, 0x24, 0xb5, 0x6f, 0x9d, 0x1a, 0xc3, 0x3a, 0xfc, 0xde, 0xd9, 0x8e,
+		0x6f, 0x62, 0x59, 0xc4, 0xec, 0x9e, 0x44, 0xed, 0x23, 0x1c, 0x77, 0x7a, 0x72, 0xd0, 0x6d, 0x04,
+		0xfb, 0x4c, 0xc7, 0x76, 0xe1, 0xf0, 0xd3, 0xa4, 0x6d, 0x6f, 0x65, 0x2e, 0x02, 0xfb, 0x61, 0xf7,
+		0x00, 0x51, 0xe2, 0xff, 0xcb, 0x4f, 0x1c, 0x0e, 0x82, 0x27, 0x1f, 0x5f, 0x20, 0xde, 0x33, 0xdb,
+		0x71, 0xbe, 0x98, 0xf5, 0x4d, 0x16, 0x8a, 0x8f, 0x52, 0xfe, 0x35, 0x09, 0x8e, 0xb4, 0x34, 0xcd,
+		0x63, 0xfc, 0x7c, 0x9b, 0xd7, 0x11, 0x07, 0xca, 0x6c, 0xe6, 0xdb, 0x08, 0x7b, 0x6f, 0x4f, 0x61,
+		0x99, 0x14, 0x01, 0x69, 0xdf, 0x02, 0x87, 0x82, 0xc2, 0x0a, 0x35, 0xdd, 0x0d, 0xa3, 0xc1, 0x4d,
+		0x68, 0xae, 0xae, 0x91, 0xc0, 0x36, 0xb4, 0x5c, 0x0e, 0xeb, 0xd9, 0xed, 0x6b, 0x09, 0x92, 0x2e,
+		0x2a, 0x4f, 0x81, 0xfb, 0xee, 0xaa, 0x47, 0x29, 0x7f, 0x44, 0x82, 0x99, 0x60, 0x0b, 0xbe, 0x64,
+		0x68, 0x7f, 0xc2, 0xde, 0xb2, 0x21, 0x7e, 0x4d, 0x82, 0x3b, 0xba, 0xc8, 0xc4, 0x15, 0xf0, 0x22,
+		0x4c, 0xfa, 0x76, 0x02, 0x44, 0x08, 0x17, 0xc3, 0x7e, 0xaa, 0x77, 0x1a, 0xea, 0x2e, 0x7c, 0x8f,
+		0x11, 0xa5, 0x7c, 0xee, 0x3b, 0xd3, 0x13, 0xad, 0x75, 0xb6, 0x32, 0xd1, 0xba, 0x7a, 0xbf, 0x85,
+		0xf6, 0xf1, 0xb2, 0x04, 0xf7, 0x05, 0xbb, 0xda, 0x26, 0x9f, 0x7d, 0xa3, 0xc6, 0xe1, 0x3f, 0x48,
+		0x70, 0xaa, 0x1f, 0xe1, 0xf8, 0x80, 0x6c, 0xc2, 0x84, 0x97, 0x69, 0x87, 0xc7, 0x63, 0x5f, 0xf9,
+		0x3b, 0xb3, 0x52, 0xe4, 0x72, 0xbb, 0x0d, 0x8a, 0x37, 0xb9, 0x63, 0xf9, 0x87, 0xdc, 0x55, 0x72,
+		0x70, 0x03, 0x59, 0x28, 0x39, 0xb0, 0x85, 0xdc, 0x66, 0x2c, 0x22, 0x6d, 0xc6, 0xc2, 0x4b, 0xcd,
+		0xe5, 0x2b, 0x3c, 0x6e, 0xb5, 0xd9, 0x83, 0x7b, 0x3b, 0x4c, 0xb4, 0x31, 0x65, 0xee, 0xd5, 0xfb,
+		0xb0, 0x64, 0x05, 0xb5, 0x1a, 0xab, 0xbc, 0x07, 0xd3, 0xb4, 0xdd, 0x36, 0x8a, 0xbe, 0xdd, 0x5d,
+		0x6e, 0xf0, 0xd8, 0xd2, 0xb6, 0x69, 0xde, 0xf7, 0x05, 0x18, 0x64, 0xe3, 0xcc, 0xbb, 0x7b, 0x00,
+		0x43, 0xe1, 0x0c, 0xe4, 0x4f, 0x88, 0x58, 0x56, 0x14, 0x62, 0xb7, 0xf7, 0xa1, 0x7e, 0xfa, 0x7a,
+		0x8b, 0x7c, 0xc8, 0xa7, 0x8c, 0x6f, 0x8b, 0xa8, 0xd6, 0x5e, 0x3a, 0xae, 0x8e, 0xca, 0x2d, 0x8b,
+		0x6a, 0x4c, 0x37, 0xb7, 0x37, 0x7c, 0xfd, 0x8a, 0x08, 0x5f, 0x6e, 0x9f, 0x7a, 0x84, 0xaf, 0x37,
+		0x46, 0xf5, 0x6e, 0x20, 0xeb, 0x21, 0xe6, 0x9f, 0xc7, 0x40, 0xf6, 0x23, 0x09, 0x8e, 0xd2, 0xbe,
+		0xf9, 0x37, 0x22, 0xf6, 0xab, 0xf2, 0x07, 0x00, 0xd9, 0x56, 0xa5, 0xdc, 0xd6, 0xbb, 0xd3, 0xb6,
+		0x55, 0xb9, 0x1c, 0x98, 0x5f, 0x1e, 0x00, 0x54, 0x0d, 0x6c, 0x37, 0x51, 0x6c, 0x76, 0x31, 0x2f,
+		0x5d, 0xf5, 0xed, 0x66, 0xb4, 0x19, 0xce, 0xd8, 0x2d, 0x18, 0xce, 0x6f, 0x49, 0x90, 0x6d, 0xd7,
+		0x65, 0x3e, 0x7c, 0x1a, 0x1c, 0x0e, 0x1c, 0x12, 0x84, 0x47, 0xf0, 0x81, 0x7e, 0xb6, 0x72, 0x42,
+		0x6e, 0x74, 0xc8, 0xc2, 0xb7, 0x3b, 0x0f, 0x98, 0x0e, 0x5a, 0x68, 0x6b, 0x66, 0xfd, 0x86, 0xb9,
+		0xcf, 0x97, 0x5b, 0xe2, 0xea, 0x9f, 0x8b, 0xdc, 0x7b, 0x17, 0xa6, 0x3a, 0x48, 0x7d, 0xbb, 0xe7,
+		0xbd, 0xed, 0x8e, 0x83, 0x79, 0xab, 0xd3, 0xf7, 0x47, 0xb9, 0x27, 0x04, 0x2f, 0x7d, 0xfb, 0xd6,
+		0x62, 0xed, 0x5e, 0x8d, 0xc9, 0x6f, 0x83, 0x63, 0x6d, 0xa9, 0xb8, 0x6c, 0x39, 0x88, 0x6d, 0x6b,
+		0xb6, 0xc3, 0xc5, 0xba, 0xa7, 0x93, 0x58, 0x21, 0x6a, 0x4a, 0x23, 0x23, 0x48, 0x53, 0xd6, 0xab,
+		0x86, 0x51, 0xe7, 0x62, 0xc8, 0x97, 0x60, 0xdc, 0x07, 0xe3, 0x8d, 0x9c, 0x83, 0x98, 0x69, 0xf0,
+		0x2f, 0x22, 0x0c, 0x9f, 0x39, 0xde, 0x71, 0xf7, 0xde, 0x30, 0xea, 0xbc, 0xdb, 0x14, 0x5f, 0x9e,
+		0x04, 0xc4, 0x98, 0xd1, 0x8d, 0x7c, 0xd1, 0xc4, 0x1a, 0x4c, 0x04, 0xa0, 0xbc, 0x91, 0xd7, 0x75,
+		0x48, 0x70, 0xe6, 0x07, 0x87, 0x20, 0x4e, 0xb9, 0xa2, 0x8f, 0x4b, 0x81, 0x4f, 0x16, 0xcd, 0x76,
+		0x62, 0xd3, 0x7e, 0x4d, 0x9c, 0x3d, 0xdd, 0x37, 0x3e, 0xcf, 0xd9, 0x4e, 0xbd, 0xf7, 0xdf, 0x7e,
+		0xef, 0xa3, 0x91, 0xbb, 0x90, 0x7c, 0xba, 0xc3, 0x6a, 0xdc, 0xe7, 0x2f, 0x9f, 0x0d, 0x3c, 0xb7,
+		0x7f, 0xb0, 0xbf, 0xa6, 0x84, 0x64, 0xb3, 0xfd, 0xa2, 0x73, 0xc1, 0xce, 0x53, 0xc1, 0xce, 0xa2,
+		0x47, 0x7a, 0x0b, 0x76, 0xfa, 0x9d, 0x41, 0xa7, 0x79, 0x37, 0xfa, 0x3d, 0x09, 0x26, 0xdb, 0x2d,
+		0xe9, 0xd0, 0xe3, 0xfd, 0x49, 0xd1, 0x9a, 0x52, 0x64, 0x9f, 0x38, 0x00, 0x25, 0xef, 0xca, 0x3c,
+		0xed, 0x4a, 0x1e, 0x3d, 0x79, 0x80, 0xae, 0x9c, 0xf6, 0xef, 0xef, 0xff, 0x2f, 0x09, 0x4e, 0x74,
+		0x5d, 0x21, 0xa1, 0x7c, 0x7f, 0x52, 0x76, 0xc9, 0x9d, 0xb2, 0x85, 0xd7, 0xc3, 0x82, 0xf7, 0xf8,
+		0x69, 0xda, 0xe3, 0x4b, 0x68, 0xe1, 0x20, 0x3d, 0x6e, 0x7b, 0x88, 0x82, 0x7e, 0x3b, 0x78, 0x99,
+		0xb1, 0xbb, 0x39, 0xb5, 0x2c, 0x3c, 0x7a, 0x38, 0x46, 0x6b, 0x52, 0x2b, 0x3f, 0x4b, 0xbb, 0xa0,
+		0xa0, 0xd5, 0xd7, 0x39, 0x68, 0xa7, 0xdf, 0x19, 0x0c, 0xfc, 0xef, 0x46, 0xff, 0x53, 0x6a, 0x7f,
+		0x37, 0xf1, 0xb1, 0xae, 0x22, 0x76, 0x5e, 0x54, 0x65, 0x1f, 0xdf, 0x3f, 0x21, 0xef, 0x64, 0x83,
+		0x76, 0xb2, 0x86, 0xf0, 0xad, 0xee, 0x64, 0xdb, 0x41, 0x44, 0xdf, 0x90, 0x60, 0xb2, 0xdd, 0x9a,
+		0xa4, 0x87, 0x5b, 0x76, 0x59, 0x64, 0xf5, 0x70, 0xcb, 0x6e, 0x0b, 0x20, 0xf9, 0x4d, 0xb4, 0xf3,
+		0xe7, 0xd0, 0xa3, 0x9d, 0x3a, 0xdf, 0x75, 0x14, 0x89, 0x2f, 0x76, 0x4d, 0xf2, 0x7b, 0xf8, 0x62,
+		0x3f, 0xeb, 0x98, 0x1e, 0xbe, 0xd8, 0xd7, 0x1a, 0xa3, 0xb7, 0x2f, 0xba, 0x3d, 0xeb, 0x73, 0x18,
+		0x6d, 0xf4, 0x35, 0x09, 0x46, 0x02, 0x19, 0x31, 0x7a, 0xb8, 0xab, 0xa0, 0xed, 0x16, 0x0c, 0xd9,
+		0x33, 0xfb, 0x21, 0xe1, 0x7d, 0x59, 0xa0, 0x7d, 0x99, 0x43, 0xf9, 0x83, 0xf4, 0x25, 0x78, 0x56,
+		0xfa, 0x2d, 0x09, 0x26, 0xda, 0x64, 0x99, 0x3d, 0xbc, 0xb0, 0x73, 0xd2, 0x9c, 0x7d, 0x7c, 0xff,
+		0x84, 0xbc, 0x57, 0x17, 0x68, 0xaf, 0xde, 0x8a, 0xde, 0x72, 0x90, 0x5e, 0xf9, 0xe6, 0xe7, 0x1b,
+		0xde, 0xbd, 0x2b, 0x5f, 0x3b, 0xe8, 0xdc, 0x3e, 0x05, 0x13, 0x1d, 0x7a, 0x6c, 0xdf, 0x74, 0xbc,
+		0x3f, 0xcf, 0xd0, 0xfe, 0x3c, 0x8d, 0x56, 0x5e, 0x5f, 0x7f, 0x5a, 0xa7, 0xf5, 0x2f, 0xb5, 0x3e,
+		0x3a, 0xec, 0x6e, 0x45, 0x6d, 0x93, 0xd5, 0xec, 0x23, 0xfb, 0xa2, 0xe1, 0x9d, 0x7a, 0x9c, 0x76,
+		0xea, 0x0c, 0x7a, 0xa8, 0x53, 0xa7, 0x7c, 0xf7, 0xf9, 0x34, 0x7d, 0xcb, 0x38, 0xfd, 0x4e, 0x96,
+		0x02, 0xbf, 0x1b, 0xbd, 0x47, 0x5c, 0x6c, 0x3a, 0xd9, 0xb5, 0x5d, 0x5f, 0x1e, 0x9b, 0xbd, 0xaf,
+		0x0f, 0x4c, 0x2e, 0xd7, 0x5d, 0x54, 0xae, 0x29, 0x74, 0xbc, 0x93, 0x5c, 0x24, 0x97, 0x45, 0x1f,
+		0x92, 0xdc, 0xeb, 0x97, 0xa7, 0xba, 0xf3, 0xf6, 0x27, 0xbb, 0xd9, 0xfb, 0xfb, 0xc2, 0xe5, 0x92,
+		0xdc, 0x43, 0x25, 0x99, 0x41, 0x53, 0x1d, 0x25, 0x61, 0xa9, 0xef, 0xad, 0xbe, 0x39, 0x70, 0xed,
+		0x08, 0x4c, 0x77, 0x68, 0xd1, 0xd9, 0xed, 0x71, 0xc6, 0xd5, 0xe5, 0xed, 0x6d, 0xcf, 0xb7, 0xb5,
+		0xb7, 0xfa, 0x9b, 0xb1, 0x7d, 0x1e, 0x88, 0xfd, 0x4e, 0x0c, 0xd0, 0x92, 0x5d, 0x9b, 0xb3, 0x30,
+		0xfb, 0xff, 0x95, 0xdc, 0xcb, 0x43, 0x8f, 0xca, 0xa4, 0xd7, 0xf5, 0xa8, 0x6c, 0x29, 0xf0, 0x4c,
+		0x2b, 0xb2, 0xbf, 0xa7, 0xa0, 0x7d, 0xbf, 0xd5, 0x8a, 0xfe, 0x54, 0xde, 0x6a, 0xb5, 0xbf, 0xca,
+		0x1d, 0xbb, 0x75, 0x6f, 0x3e, 0xe2, 0x07, 0x7d, 0xf7, 0xc2, 0x9f, 0x60, 0x0e, 0x76, 0x79, 0x82,
+		0x99, 0xe9, 0xf8, 0xce, 0x92, 0x53, 0xa3, 0xb3, 0xe2, 0x0b, 0xaa, 0x43, 0xfd, 0xdd, 0x84, 0xe5,
+		0x9f, 0x58, 0xf5, 0xb6, 0x10, 0x8e, 0x43, 0xb6, 0xd5, 0x9c, 0x5c, 0xa7, 0xfe, 0x68, 0x14, 0xd2,
+		0x4b, 0x76, 0xad, 0x54, 0xd5, 0x9c, 0xdb, 0x64, 0x6b, 0x4f, 0x76, 0x7e, 0x47, 0x83, 0x6e, 0xde,
+		0x98, 0x1e, 0x65, 0x3a, 0xed, 0xa2, 0xc9, 0x06, 0x8c, 0x85, 0x5e, 0x2f, 0x73, 0xcb, 0x2a, 0x1e,
+		0xe4, 0x11, 0x75, 0x88, 0x95, 0x4c, 0x9f, 0x3d, 0xf8, 0xec, 0x1b, 0xed, 0xb6, 0x37, 0x66, 0x66,
+		0x50, 0x17, 0x6f, 0xe7, 0xa3, 0x43, 0x6f, 0xcc, 0xb2, 0x90, 0x09, 0x0f, 0x8a, 0x3b, 0x62, 0xdf,
+		0x97, 0x60, 0x78, 0xc9, 0x16, 0xa9, 0x20, 0xfe, 0x19, 0x7d, 0xf2, 0xf4, 0x98, 0xfb, 0xf9, 0xf1,
+		0x68, 0x7f, 0x76, 0x2b, 0x3e, 0x49, 0xee, 0x29, 0xe1, 0x10, 0x4c, 0xf8, 0xfa, 0xe9, 0xf6, 0xff,
+		0x77, 0x23, 0x34, 0x3e, 0x16, 0x70, 0x4d, 0xd3, 0xdd, 0x2c, 0x12, 0xff, 0x45, 0x7d, 0xd0, 0xe1,
+		0xe9, 0x39, 0x76, 0x50, 0x3d, 0xef, 0xd0, 0x00, 0x11, 0xd2, 0xa7, 0xbb, 0xf1, 0xb5, 0xd4, 0xfa,
+		0xdc, 0x48, 0xda, 0xc7, 0x97, 0x7c, 0x42, 0x8f, 0x8a, 0xe4, 0xd7, 0x24, 0x18, 0x59, 0xb2, 0x6b,
+		0x1b, 0x7a, 0xf5, 0xff, 0x79, 0xfb, 0xdd, 0x82, 0x43, 0x81, 0x9e, 0xde, 0x26, 0x95, 0x9e, 0x79,
+		0x39, 0x06, 0xd1, 0x25, 0xbb, 0x86, 0x5e, 0x80, 0xb1, 0x70, 0xd2, 0xd0, 0x31, 0x17, 0x6c, 0x9d,
+		0x11, 0x3a, 0xaf, 0xd7, 0x3a, 0xcf, 0x1e, 0x68, 0x07, 0x46, 0x82, 0x33, 0xc7, 0xc9, 0x2e, 0x4c,
+		0x02, 0x98, 0xd9, 0x87, 0xfa, 0xc5, 0x74, 0x1b, 0x7b, 0x07, 0x24, 0xdc, 0xa0, 0x77, 0x67, 0x17,
+		0x6a, 0x81, 0xd4, 0x39, 0xbb, 0x6d, 0x13, 0x56, 0x88, 0xf6, 0xc2, 0x21, 0xa5, 0x9b, 0xf6, 0x42,
+		0xb8, 0x5d, 0xb5, 0xd7, 0xc9, 0xb5, 0x36, 0x01, 0x7c, 0x7e, 0x70, 0x77, 0x17, 0x0e, 0x1e, 0x5a,
+		0xf6, 0xc1, 0xbe, 0xd0, 0xdc, 0x43, 0xa7, 0x5b, 0x9c, 0x8c, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff,
+		0xff, 0xb5, 0x95, 0x49, 0x9c, 0x35, 0x98, 0x00, 0x00,
 	}
 	r := bytes.NewReader(gzipped)
 	gzipr, err := compress_gzip.NewReader(r)

From ca9bfbd7911e65a42b51a5dc47d2e265c78f2f8e Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Sun, 21 Mar 2021 18:39:23 -0400
Subject: [PATCH 15/23] fix merge conflicts

---
 x/staking/genesis_test.go          | 14 ---------
 x/staking/keeper/validator_test.go | 49 +++++-------------------------
 x/staking/spec/08_params.md        |  6 +---
 3 files changed, 8 insertions(+), 61 deletions(-)

diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go
index 7bb622326471..a77b3612398f 100644
--- a/x/staking/genesis_test.go
+++ b/x/staking/genesis_test.go
@@ -25,20 +25,6 @@ func bootstrapGenesisTest(numAddrs int) (*simapp.SimApp, sdk.Context, []sdk.AccA
 	_, app, ctx := getBaseSimappWithCustomKeeper()
 
 	addrDels, _ := generateAddresses(app, ctx, numAddrs, sdk.NewInt(10000))
-<<<<<<< HEAD
-
-	amt := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
-	totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), amt.MulRaw(int64(len(addrDels)))))
-
-	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
-	err := app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), totalSupply)
-	require.NoError(t, err)
-
-	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
-	app.BankKeeper.SetSupply(ctx, banktypes.NewSupply(totalSupply))
-
-=======
->>>>>>> upstream/master
 	return app, ctx, addrDels
 }
 
diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go
index c4715908a2fe..49b311d983dc 100644
--- a/x/staking/keeper/validator_test.go
+++ b/x/staking/keeper/validator_test.go
@@ -47,13 +47,8 @@ func initValidators(t testing.TB, power int64, numAddrs int, powers []int64) (*s
 
 	vs := make([]types.Validator, len(powers))
 	for i, power := range powers {
-<<<<<<< HEAD
-		vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), PKs[i])
-		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
-=======
 		vs[i] = teststaking.NewValidator(t, sdk.ValAddress(addrs[i]), pks[i])
-		tokens := sdk.TokensFromConsensusPower(power)
->>>>>>> upstream/master
+		tokens := app.StakingKeeper.TokensFromConsensusPower(ctx, power)
 		vs[i], _ = vs[i].AddTokensFromDel(tokens)
 	}
 	return app, ctx, addrs, valAddrs, vs
@@ -118,17 +113,9 @@ func TestUpdateValidatorByPowerIndex(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-<<<<<<< HEAD
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
-	require.NoError(t, err)
-
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
-	require.NoError(t, err)
-=======
-	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))))
+	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234)))))
 
-	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))))
->>>>>>> upstream/master
+	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000)))))
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -176,17 +163,9 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	app.StakingKeeper.SetParams(ctx, params)
 
 	// create a random pool
-<<<<<<< HEAD
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234))))
-	require.NoError(t, err)
+	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 1234)))))
 
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000))))
-	require.NoError(t, err)
-=======
-	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(1234)))))
-
-	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(10000)))))
->>>>>>> upstream/master
+	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 10000)))))
 
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
@@ -445,17 +424,9 @@ func TestGetValidatorSortingMixed(t *testing.T) {
 	bondedPool := app.StakingKeeper.GetBondedPool(ctx)
 	notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
 
-<<<<<<< HEAD
-	err := app.BankKeeper.SetBalances(ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 501))))
-	require.NoError(t, err)
-
-	err = app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 0))))
-	require.NoError(t, err)
-=======
-	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(501)))))
+	require.NoError(t, simapp.FundAccount(app, ctx, bondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 501)))))
 
-	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), sdk.TokensFromConsensusPower(0)))))
->>>>>>> upstream/master
+	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), app.StakingKeeper.TokensFromConsensusPower(ctx, 0)))))
 
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
 	app.AccountKeeper.SetModuleAccount(ctx, bondedPool)
@@ -579,14 +550,8 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	validators[3], _ = validators[3].AddTokensFromDel(app.StakingKeeper.TokensFromConsensusPower(ctx, 1))
 
 	notBondedPool = app.StakingKeeper.GetNotBondedPool(ctx)
-<<<<<<< HEAD
 	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, app.StakingKeeper.TokensFromConsensusPower(ctx, 1)))
-	balances = app.BankKeeper.GetAllBalances(ctx, notBondedPool.GetAddress())
-	require.NoError(t, app.BankKeeper.SetBalances(ctx, notBondedPool.GetAddress(), balances.Add(newTokens...)))
-=======
-	newTokens = sdk.NewCoins(sdk.NewCoin(params.BondDenom, sdk.TokensFromConsensusPower(1)))
 	require.NoError(t, simapp.FundAccount(app, ctx, notBondedPool.GetAddress(), newTokens))
->>>>>>> upstream/master
 	app.AccountKeeper.SetModuleAccount(ctx, notBondedPool)
 
 	validators[3] = keeper.TestingUpdateValidator(app.StakingKeeper, ctx, validators[3], true)
diff --git a/x/staking/spec/08_params.md b/x/staking/spec/08_params.md
index d70224c684c8..a7f2c592631e 100644
--- a/x/staking/spec/08_params.md
+++ b/x/staking/spec/08_params.md
@@ -12,9 +12,5 @@ The staking module contains the following parameters:
 | MaxValidators     | uint16           | 100               |
 | KeyMaxEntries     | uint16           | 7                 |
 | HistoricalEntries | uint16           | 3                 |
-<<<<<<< HEAD
-| BondDenom         | string           | "uatom"           |
-| PowerReduction    | string           | "1000000"         |
-=======
 | BondDenom         | string           | "stake"           |
->>>>>>> upstream/master
+| PowerReduction    | string           | "1000000"         |

From 83efad3c309203a1b85ba971b962eb5c0175da07 Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Sun, 21 Mar 2021 19:18:46 -0400
Subject: [PATCH 16/23] fixing merge conflicts

---
 x/bank/types/balance_test.go             | 4 ++--
 x/feegrant/simulation/operations_test.go | 2 +-
 x/staking/legacy/v040/migrate.go         | 1 +
 x/staking/legacy/v040/migrate_test.go    | 1 +
 x/staking/legacy/v043/store_test.go      | 2 +-
 5 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/x/bank/types/balance_test.go b/x/bank/types/balance_test.go
index 9736c847baa0..f328314910b7 100644
--- a/x/bank/types/balance_test.go
+++ b/x/bank/types/balance_test.go
@@ -106,7 +106,7 @@ func TestBalance_GetAddress(t *testing.T) {
 
 func TestSanitizeBalances(t *testing.T) {
 	// 1. Generate balances
-	tokens := sdk.TokensFromConsensusPower(81)
+	tokens := sdk.TokensFromConsensusPower(81, sdk.DefaultPowerReduction)
 	coin := sdk.NewCoin("benchcoin", tokens)
 	coins := sdk.Coins{coin}
 	addrs, _ := makeRandomAddressesAndPublicKeys(20)
@@ -158,7 +158,7 @@ func BenchmarkSanitizeBalances1000(b *testing.B) {
 
 func benchmarkSanitizeBalances(b *testing.B, nAddresses int) {
 	b.ReportAllocs()
-	tokens := sdk.TokensFromConsensusPower(81)
+	tokens := sdk.TokensFromConsensusPower(81, sdk.DefaultPowerReduction)
 	coin := sdk.NewCoin("benchcoin", tokens)
 	coins := sdk.Coins{coin}
 	addrs, _ := makeRandomAddressesAndPublicKeys(nAddresses)
diff --git a/x/feegrant/simulation/operations_test.go b/x/feegrant/simulation/operations_test.go
index 5d6560b26c25..d9c0fffaebd7 100644
--- a/x/feegrant/simulation/operations_test.go
+++ b/x/feegrant/simulation/operations_test.go
@@ -39,7 +39,7 @@ func (suite *SimTestSuite) SetupTest() {
 func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
 	accounts := simtypes.RandomAccounts(r, n)
 
-	initAmt := app.StakingKeeper.TokensFromConsensusPower(ctx, 200)
+	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
 	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
 
 	// add coins to the accounts
diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go
index b0746fa363a4..1ade9288ece1 100644
--- a/x/staking/legacy/v040/migrate.go
+++ b/x/staking/legacy/v040/migrate.go
@@ -129,6 +129,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			MaxEntries:        uint32(stakingState.Params.MaxEntries),
 			HistoricalEntries: uint32(stakingState.Params.HistoricalEntries),
 			BondDenom:         stakingState.Params.BondDenom,
+			PowerReduction:    v040staking.DefaultParams().PowerReduction,
 		},
 		LastTotalPower:       stakingState.LastTotalPower,
 		LastValidatorPowers:  newLastValidatorPowers,
diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go
index 2be5e80dbc31..16bb4374b503 100644
--- a/x/staking/legacy/v040/migrate_test.go
+++ b/x/staking/legacy/v040/migrate_test.go
@@ -55,6 +55,7 @@ func TestMigrate(t *testing.T) {
     "historical_entries": 0,
     "max_entries": 0,
     "max_validators": 0,
+    "power_reduction": "1000000",
     "unbonding_time": "0s"
   },
   "redelegations": [],
diff --git a/x/staking/legacy/v043/store_test.go b/x/staking/legacy/v043/store_test.go
index 0abe8f3b1e86..32b6bb181e05 100644
--- a/x/staking/legacy/v043/store_test.go
+++ b/x/staking/legacy/v043/store_test.go
@@ -61,7 +61,7 @@ func TestStoreMigration(t *testing.T) {
 		{
 			"ValidatorsByPowerIndexKey",
 			v040staking.GetValidatorsByPowerIndexKey(val),
-			types.GetValidatorsByPowerIndexKey(val),
+			types.GetValidatorsByPowerIndexKey(val, sdk.DefaultPowerReduction),
 		},
 		{
 			"DelegationKey",

From b54e2763db61d6c1811c8279ed926bcc2e0f8225 Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Sun, 21 Mar 2021 20:29:39 -0400
Subject: [PATCH 17/23] simply default power reduction definition

---
 types/staking.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/types/staking.go b/types/staking.go
index 563f94176ce9..2f17bb1dd85f 100644
--- a/types/staking.go
+++ b/types/staking.go
@@ -1,9 +1,5 @@
 package types
 
-import (
-	"math/big"
-)
-
 // staking constants
 const (
 
@@ -23,7 +19,7 @@ const (
 )
 
 // DefaultPowerReduction is the default amount of staking tokens required for 1 unit of consensus-engine power
-var DefaultPowerReduction = NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
+var DefaultPowerReduction = NewIntFromUint64(1000000)
 
 // TokensToConsensusPower - convert input tokens to potential consensus-engine power
 func TokensToConsensusPower(tokens Int, powerReduction Int) int64 {

From babe920e072a766b97edcf8b6136e43dadb1b82f Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Mon, 22 Mar 2021 12:14:14 -0400
Subject: [PATCH 18/23] added CHANGELOG

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 551ab5614ebf..1c2a973c3092 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -73,6 +73,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/bank) [\#8656](https://github.com/cosmos/cosmos-sdk/pull/8656) balance and supply are now correctly tracked via `coin_spent`, `coin_received`, `coinbase` and `burn` events.
 * (x/bank) [\#8517](https://github.com/cosmos/cosmos-sdk/pull/8517) Supply is now stored and tracked as `sdk.Coins`
 * (store) [\#8790](https://github.com/cosmos/cosmos-sdk/pull/8790) Reduce gas costs by 10x for transient store operations.
+* (x/staking) [\#8505](https://github.com/cosmos/cosmos-sdk/pull/8505) Convert staking power reduction into an on-chain parameter rather than a hardcoded in-code variable.
 
 ### Improvements
 

From aee3ca8c20d0a88ab80027d6525942398a2c76df Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Wed, 7 Apr 2021 13:59:42 -0400
Subject: [PATCH 19/23] fix merge conflict

---
 CHANGELOG.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bad3a5bbf5e8..89b3583e7f67 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -89,11 +89,8 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/bank) [\#8656](https://github.com/cosmos/cosmos-sdk/pull/8656) balance and supply are now correctly tracked via `coin_spent`, `coin_received`, `coinbase` and `burn` events.
 * (x/bank) [\#8517](https://github.com/cosmos/cosmos-sdk/pull/8517) Supply is now stored and tracked as `sdk.Coins`
 * (store) [\#8790](https://github.com/cosmos/cosmos-sdk/pull/8790) Reduce gas costs by 10x for transient store operations.
-<<<<<<< HEAD
 * (x/staking) [\#8505](https://github.com/cosmos/cosmos-sdk/pull/8505) Convert staking power reduction into an on-chain parameter rather than a hardcoded in-code variable.
-=======
 * (x/bank) [\#9051](https://github.com/cosmos/cosmos-sdk/pull/9051) Supply value is stored as `sdk.Int` rather than `string`.
->>>>>>> master
 
 ### Improvements
 

From 04e483dd693a9b7f64dc51117b4b634673874370 Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Wed, 7 Apr 2021 19:56:39 -0400
Subject: [PATCH 20/23] fixed migrations

---
 x/staking/keeper/migrations.go        |    2 +-
 x/staking/legacy/v040/genesis.pb.go   |  945 ++++
 x/staking/legacy/v040/migrate.go      |   50 +-
 x/staking/legacy/v040/migrate_test.go |    1 -
 x/staking/legacy/v040/staking.pb.go   | 6526 +++++++++++++++++++++++++
 x/staking/legacy/v040/types.go        |  201 +
 x/staking/legacy/v043/json.go         |  138 +
 x/staking/legacy/v043/json_test.go    |   67 +
 x/staking/legacy/v043/store.go        |   14 +-
 x/staking/legacy/v043/store_test.go   |   14 +-
 x/staking/types/params.go             |    4 +-
 11 files changed, 7927 insertions(+), 35 deletions(-)
 create mode 100644 x/staking/legacy/v040/genesis.pb.go
 create mode 100644 x/staking/legacy/v040/staking.pb.go
 create mode 100644 x/staking/legacy/v040/types.go
 create mode 100644 x/staking/legacy/v043/json.go
 create mode 100644 x/staking/legacy/v043/json_test.go

diff --git a/x/staking/keeper/migrations.go b/x/staking/keeper/migrations.go
index 101ca195b390..859344918173 100644
--- a/x/staking/keeper/migrations.go
+++ b/x/staking/keeper/migrations.go
@@ -17,5 +17,5 @@ func NewMigrator(keeper Keeper) Migrator {
 
 // Migrate1to2 migrates from version 1 to 2.
 func (m Migrator) Migrate1to2(ctx sdk.Context) error {
-	return v043.MigrateStore(ctx, m.keeper.storeKey)
+	return v043.MigrateStore(ctx, m.keeper.storeKey, m.keeper.paramstore)
 }
diff --git a/x/staking/legacy/v040/genesis.pb.go b/x/staking/legacy/v040/genesis.pb.go
new file mode 100644
index 000000000000..04644e17ea64
--- /dev/null
+++ b/x/staking/legacy/v040/genesis.pb.go
@@ -0,0 +1,945 @@
+// Package v040 is taken from:
+// https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/x/staking/types/genesis.pb.go
+// by copy-pasted only the relevants parts for Genesis.
+//nolint
+
+package v040
+
+import (
+	fmt "fmt"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	proto "github.com/gogo/protobuf/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// GenesisState defines the staking module's genesis state.
+type GenesisState struct {
+	// params defines all the paramaters of related to deposit.
+	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	// last_total_power tracks the total amounts of bonded tokens recorded during
+	// the previous end block.
+	LastTotalPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=last_total_power,json=lastTotalPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"last_total_power" yaml:"last_total_power"`
+	// last_validator_powers is a special index that provides a historical list
+	// of the last-block's bonded validators.
+	LastValidatorPowers []LastValidatorPower `protobuf:"bytes,3,rep,name=last_validator_powers,json=lastValidatorPowers,proto3" json:"last_validator_powers" yaml:"last_validator_powers"`
+	// delegations defines the validator set at genesis.
+	Validators []Validator `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"`
+	// delegations defines the delegations active at genesis.
+	Delegations []Delegation `protobuf:"bytes,5,rep,name=delegations,proto3" json:"delegations"`
+	// unbonding_delegations defines the unbonding delegations active at genesis.
+	UnbondingDelegations []UnbondingDelegation `protobuf:"bytes,6,rep,name=unbonding_delegations,json=unbondingDelegations,proto3" json:"unbonding_delegations" yaml:"unbonding_delegations"`
+	// redelegations defines the redelegations active at genesis.
+	Redelegations []Redelegation `protobuf:"bytes,7,rep,name=redelegations,proto3" json:"redelegations"`
+	Exported      bool           `protobuf:"varint,8,opt,name=exported,proto3" json:"exported,omitempty"`
+}
+
+func (m *GenesisState) Reset()         { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage()    {}
+func (*GenesisState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9b3dec8894f2831b, []int{0}
+}
+func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *GenesisState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GenesisState.Merge(m, src)
+}
+func (m *GenesisState) XXX_Size() int {
+	return m.Size()
+}
+func (m *GenesisState) XXX_DiscardUnknown() {
+	xxx_messageInfo_GenesisState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+
+func (m *GenesisState) GetParams() Params {
+	if m != nil {
+		return m.Params
+	}
+	return Params{}
+}
+
+func (m *GenesisState) GetLastValidatorPowers() []LastValidatorPower {
+	if m != nil {
+		return m.LastValidatorPowers
+	}
+	return nil
+}
+
+func (m *GenesisState) GetValidators() []Validator {
+	if m != nil {
+		return m.Validators
+	}
+	return nil
+}
+
+func (m *GenesisState) GetDelegations() []Delegation {
+	if m != nil {
+		return m.Delegations
+	}
+	return nil
+}
+
+func (m *GenesisState) GetUnbondingDelegations() []UnbondingDelegation {
+	if m != nil {
+		return m.UnbondingDelegations
+	}
+	return nil
+}
+
+func (m *GenesisState) GetRedelegations() []Redelegation {
+	if m != nil {
+		return m.Redelegations
+	}
+	return nil
+}
+
+func (m *GenesisState) GetExported() bool {
+	if m != nil {
+		return m.Exported
+	}
+	return false
+}
+
+// LastValidatorPower required for validator set update logic.
+type LastValidatorPower struct {
+	// address is the address of the validator.
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	// power defines the power of the validator.
+	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
+}
+
+func (m *LastValidatorPower) Reset()         { *m = LastValidatorPower{} }
+func (m *LastValidatorPower) String() string { return proto.CompactTextString(m) }
+func (*LastValidatorPower) ProtoMessage()    {}
+func (*LastValidatorPower) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9b3dec8894f2831b, []int{1}
+}
+func (m *LastValidatorPower) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *LastValidatorPower) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_LastValidatorPower.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *LastValidatorPower) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_LastValidatorPower.Merge(m, src)
+}
+func (m *LastValidatorPower) XXX_Size() int {
+	return m.Size()
+}
+func (m *LastValidatorPower) XXX_DiscardUnknown() {
+	xxx_messageInfo_LastValidatorPower.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LastValidatorPower proto.InternalMessageInfo
+
+func init() {
+	// proto.RegisterType((*GenesisState)(nil), "cosmos.staking.v1beta1.GenesisState")
+	// proto.RegisterType((*LastValidatorPower)(nil), "cosmos.staking.v1beta1.LastValidatorPower")
+}
+
+func init() {
+	// proto.RegisterFile("cosmos/staking/v1beta1/genesis.proto", fileDescriptor_9b3dec8894f2831b)
+}
+
+var fileDescriptor_9b3dec8894f2831b = []byte{
+	// 493 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x3d, 0x6f, 0xd3, 0x40,
+	0x18, 0xc7, 0x7d, 0xa4, 0x49, 0xc3, 0xa5, 0x20, 0x74, 0xa4, 0x60, 0x45, 0xc8, 0x0e, 0x56, 0x84,
+	0x22, 0x5e, 0x6c, 0xb5, 0x6c, 0x15, 0x53, 0x84, 0xa8, 0x8a, 0x10, 0x8a, 0x8e, 0x97, 0x81, 0x25,
+	0xba, 0xd4, 0x27, 0x63, 0xd5, 0xf1, 0x59, 0x7e, 0x2e, 0xa5, 0xdd, 0x11, 0x62, 0xe4, 0x23, 0xf4,
+	0xe3, 0x74, 0xec, 0xc0, 0x80, 0x18, 0x2c, 0x94, 0x2c, 0xcc, 0xfd, 0x04, 0xc8, 0xe7, 0x17, 0x4c,
+	0x52, 0x33, 0x25, 0x77, 0xfa, 0xfd, 0x7f, 0x7f, 0xfb, 0xfc, 0x1c, 0x1e, 0x1c, 0x0a, 0x98, 0x09,
+	0x70, 0x40, 0xb2, 0x23, 0x3f, 0xf4, 0x9c, 0xe3, 0x9d, 0x29, 0x97, 0x6c, 0xc7, 0xf1, 0x78, 0xc8,
+	0xc1, 0x07, 0x3b, 0x8a, 0x85, 0x14, 0xe4, 0x4e, 0x46, 0xd9, 0x39, 0x65, 0xe7, 0x54, 0xaf, 0xeb,
+	0x09, 0x4f, 0x28, 0xc4, 0x49, 0xff, 0x65, 0x74, 0xaf, 0xce, 0x59, 0xa4, 0x15, 0x65, 0x7d, 0x6f,
+	0xe2, 0xad, 0xfd, 0xac, 0xe5, 0x8d, 0x64, 0x92, 0x93, 0x67, 0xb8, 0x15, 0xb1, 0x98, 0xcd, 0x40,
+	0x47, 0x7d, 0x34, 0xec, 0xec, 0x1a, 0xf6, 0xd5, 0xad, 0xf6, 0x58, 0x51, 0xa3, 0x8d, 0xf3, 0xc4,
+	0xd4, 0x68, 0x9e, 0x21, 0x80, 0x6f, 0x05, 0x0c, 0xe4, 0x44, 0x0a, 0xc9, 0x82, 0x49, 0x24, 0x3e,
+	0xf1, 0x58, 0xbf, 0xd6, 0x47, 0xc3, 0xad, 0xd1, 0x41, 0xca, 0xfd, 0x4c, 0xcc, 0x07, 0x9e, 0x2f,
+	0x3f, 0xce, 0xa7, 0xf6, 0xa1, 0x98, 0x39, 0xf9, 0x13, 0x66, 0x3f, 0x4f, 0xc0, 0x3d, 0x72, 0xe4,
+	0x69, 0xc4, 0xc1, 0x3e, 0x08, 0xe5, 0x65, 0x62, 0xde, 0x3d, 0x65, 0xb3, 0x60, 0xcf, 0x5a, 0xf5,
+	0x59, 0xf4, 0x66, 0xba, 0xf5, 0x36, 0xdd, 0x19, 0xa7, 0x1b, 0xe4, 0x33, 0xc2, 0xdb, 0x8a, 0x3a,
+	0x66, 0x81, 0xef, 0x32, 0x29, 0xe2, 0x8c, 0x04, 0xbd, 0xd1, 0x6f, 0x0c, 0x3b, 0xbb, 0x0f, 0xeb,
+	0x5e, 0xe1, 0x15, 0x03, 0xf9, 0xbe, 0xc8, 0x28, 0xd7, 0x68, 0x90, 0x3e, 0xe6, 0x65, 0x62, 0xde,
+	0xab, 0x94, 0xaf, 0x6a, 0x2d, 0x7a, 0x3b, 0x58, 0x4b, 0x02, 0xd9, 0xc7, 0xb8, 0x24, 0x41, 0xdf,
+	0x50, 0xd5, 0xf7, 0xeb, 0xaa, 0xcb, 0x70, 0x7e, 0x80, 0x95, 0x28, 0x79, 0x89, 0x3b, 0x2e, 0x0f,
+	0xb8, 0xc7, 0xa4, 0x2f, 0x42, 0xd0, 0x9b, 0xca, 0x64, 0xd5, 0x99, 0x9e, 0x97, 0x68, 0xae, 0xaa,
+	0x86, 0xc9, 0x17, 0x84, 0xb7, 0xe7, 0xe1, 0x54, 0x84, 0xae, 0x1f, 0x7a, 0x93, 0xaa, 0xb6, 0xa5,
+	0xb4, 0x8f, 0xea, 0xb4, 0xef, 0x8a, 0x50, 0xc5, 0xbf, 0x72, 0x38, 0x57, 0x7a, 0x2d, 0xda, 0x9d,
+	0xaf, 0x47, 0x81, 0x8c, 0xf1, 0x8d, 0x98, 0x57, 0xfb, 0x37, 0x55, 0xff, 0xa0, 0xae, 0x9f, 0x56,
+	0xe0, 0xfc, 0xc5, 0xfe, 0x15, 0x90, 0x1e, 0x6e, 0xf3, 0x93, 0x48, 0xc4, 0x92, 0xbb, 0x7a, 0xbb,
+	0x8f, 0x86, 0x6d, 0x5a, 0xae, 0xad, 0xd7, 0x98, 0xac, 0x7f, 0x5c, 0xa2, 0xe3, 0x4d, 0xe6, 0xba,
+	0x31, 0x87, 0x6c, 0xb8, 0xaf, 0xd3, 0x62, 0x49, 0xba, 0xb8, 0xf9, 0x77, 0x58, 0x1b, 0x34, 0x5b,
+	0xec, 0xb5, 0xbf, 0x9e, 0x99, 0xda, 0xef, 0x33, 0x53, 0x1b, 0xbd, 0x38, 0x5f, 0x18, 0xe8, 0x62,
+	0x61, 0xa0, 0x5f, 0x0b, 0x03, 0x7d, 0x5b, 0x1a, 0xda, 0xc5, 0xd2, 0xd0, 0x7e, 0x2c, 0x0d, 0xed,
+	0xc3, 0xe3, 0xff, 0xce, 0xf3, 0x49, 0x79, 0xfd, 0xd4, 0x64, 0x4f, 0x5b, 0xea, 0xd6, 0x3d, 0xfd,
+	0x13, 0x00, 0x00, 0xff, 0xff, 0xff, 0x85, 0xad, 0xc8, 0xf1, 0x03, 0x00, 0x00,
+}
+
+func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Exported {
+		i--
+		if m.Exported {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x40
+	}
+	if len(m.Redelegations) > 0 {
+		for iNdEx := len(m.Redelegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Redelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x3a
+		}
+	}
+	if len(m.UnbondingDelegations) > 0 {
+		for iNdEx := len(m.UnbondingDelegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.UnbondingDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if len(m.Delegations) > 0 {
+		for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
+	if len(m.Validators) > 0 {
+		for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.LastValidatorPowers) > 0 {
+		for iNdEx := len(m.LastValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.LastValidatorPowers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	{
+		size := m.LastTotalPower.Size()
+		i -= size
+		if _, err := m.LastTotalPower.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *LastValidatorPower) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LastValidatorPower) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LastValidatorPower) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Power != 0 {
+		i = encodeVarintGenesis(dAtA, i, uint64(m.Power))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+	offset -= sovGenesis(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GenesisState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Params.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	l = m.LastTotalPower.Size()
+	n += 1 + l + sovGenesis(uint64(l))
+	if len(m.LastValidatorPowers) > 0 {
+		for _, e := range m.LastValidatorPowers {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Validators) > 0 {
+		for _, e := range m.Validators {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Delegations) > 0 {
+		for _, e := range m.Delegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.UnbondingDelegations) > 0 {
+		for _, e := range m.UnbondingDelegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if len(m.Redelegations) > 0 {
+		for _, e := range m.Redelegations {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
+	if m.Exported {
+		n += 2
+	}
+	return n
+}
+
+func (m *LastValidatorPower) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovGenesis(uint64(l))
+	}
+	if m.Power != 0 {
+		n += 1 + sovGenesis(uint64(m.Power))
+	}
+	return n
+}
+
+func sovGenesis(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastTotalPower", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.LastTotalPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastValidatorPowers", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.LastValidatorPowers = append(m.LastValidatorPowers, LastValidatorPower{})
+			if err := m.LastValidatorPowers[len(m.LastValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Validators = append(m.Validators, Validator{})
+			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Delegations = append(m.Delegations, Delegation{})
+			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.UnbondingDelegations = append(m.UnbondingDelegations, UnbondingDelegation{})
+			if err := m.UnbondingDelegations[len(m.UnbondingDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Redelegations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Redelegations = append(m.Redelegations, Redelegation{})
+			if err := m.Redelegations[len(m.Redelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Exported", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Exported = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LastValidatorPower) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LastValidatorPower: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LastValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
+			}
+			m.Power = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Power |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenesis(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowGenesis
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthGenesis
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupGenesis
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthGenesis
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/staking/legacy/v040/migrate.go b/x/staking/legacy/v040/migrate.go
index 1ade9288ece1..a0d9b4c90378 100644
--- a/x/staking/legacy/v040/migrate.go
+++ b/x/staking/legacy/v040/migrate.go
@@ -6,19 +6,18 @@ import (
 	codectypes "github.com/cosmos/cosmos-sdk/codec/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) v040staking.BondStatus {
+func migrateBondStatus(oldStatus v034staking.BondStatus) BondStatus {
 	switch oldStatus {
 	case v034staking.Unbonded:
-		return v040staking.Unbonded
+		return Unbonded
 
 	case v034staking.Unbonding:
-		return v040staking.Unbonding
+		return Unbonding
 
 	case v034staking.Bonded:
-		return v040staking.Bonded
+		return Bonded
 
 	default:
 		panic(fmt.Errorf("invalid bond status %d", oldStatus))
@@ -31,29 +30,29 @@ func migrateBondStatus(oldStatus v034staking.BondStatus) v040staking.BondStatus
 // - 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))
+func Migrate(stakingState v038staking.GenesisState) *GenesisState {
+	newLastValidatorPowers := make([]LastValidatorPower, len(stakingState.LastValidatorPowers))
 	for i, oldLastValidatorPower := range stakingState.LastValidatorPowers {
-		newLastValidatorPowers[i] = v040staking.LastValidatorPower{
+		newLastValidatorPowers[i] = LastValidatorPower{
 			Address: oldLastValidatorPower.Address.String(),
 			Power:   oldLastValidatorPower.Power,
 		}
 	}
 
-	newValidators := make([]v040staking.Validator, len(stakingState.Validators))
+	newValidators := make([]Validator, len(stakingState.Validators))
 	for i, oldValidator := range stakingState.Validators {
 		pkAny, err := codectypes.NewAnyWithValue(oldValidator.ConsPubKey)
 		if err != nil {
 			panic(fmt.Sprintf("Can't pack validator consensus PK as Any: %s", err))
 		}
-		newValidators[i] = v040staking.Validator{
+		newValidators[i] = Validator{
 			OperatorAddress: oldValidator.OperatorAddress.String(),
 			ConsensusPubkey: pkAny,
 			Jailed:          oldValidator.Jailed,
 			Status:          migrateBondStatus(oldValidator.Status),
 			Tokens:          oldValidator.Tokens,
 			DelegatorShares: oldValidator.DelegatorShares,
-			Description: v040staking.Description{
+			Description: Description{
 				Moniker:         oldValidator.Description.Moniker,
 				Identity:        oldValidator.Description.Identity,
 				Website:         oldValidator.Description.Website,
@@ -62,8 +61,8 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			},
 			UnbondingHeight: oldValidator.UnbondingHeight,
 			UnbondingTime:   oldValidator.UnbondingCompletionTime,
-			Commission: v040staking.Commission{
-				CommissionRates: v040staking.CommissionRates{
+			Commission: Commission{
+				CommissionRates: CommissionRates{
 					Rate:          oldValidator.Commission.Rate,
 					MaxRate:       oldValidator.Commission.MaxRate,
 					MaxChangeRate: oldValidator.Commission.MaxChangeRate,
@@ -74,20 +73,20 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 		}
 	}
 
-	newDelegations := make([]v040staking.Delegation, len(stakingState.Delegations))
+	newDelegations := make([]Delegation, len(stakingState.Delegations))
 	for i, oldDelegation := range stakingState.Delegations {
-		newDelegations[i] = v040staking.Delegation{
+		newDelegations[i] = Delegation{
 			DelegatorAddress: oldDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldDelegation.ValidatorAddress.String(),
 			Shares:           oldDelegation.Shares,
 		}
 	}
 
-	newUnbondingDelegations := make([]v040staking.UnbondingDelegation, len(stakingState.UnbondingDelegations))
+	newUnbondingDelegations := make([]UnbondingDelegation, len(stakingState.UnbondingDelegations))
 	for i, oldUnbondingDelegation := range stakingState.UnbondingDelegations {
-		newEntries := make([]v040staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
+		newEntries := make([]UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
 		for j, oldEntry := range oldUnbondingDelegation.Entries {
-			newEntries[j] = v040staking.UnbondingDelegationEntry{
+			newEntries[j] = UnbondingDelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -95,18 +94,18 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			}
 		}
 
-		newUnbondingDelegations[i] = v040staking.UnbondingDelegation{
+		newUnbondingDelegations[i] = UnbondingDelegation{
 			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress.String(),
 			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress.String(),
 			Entries:          newEntries,
 		}
 	}
 
-	newRedelegations := make([]v040staking.Redelegation, len(stakingState.Redelegations))
+	newRedelegations := make([]Redelegation, len(stakingState.Redelegations))
 	for i, oldRedelegation := range stakingState.Redelegations {
-		newEntries := make([]v040staking.RedelegationEntry, len(oldRedelegation.Entries))
+		newEntries := make([]RedelegationEntry, len(oldRedelegation.Entries))
 		for j, oldEntry := range oldRedelegation.Entries {
-			newEntries[j] = v040staking.RedelegationEntry{
+			newEntries[j] = RedelegationEntry{
 				CreationHeight: oldEntry.CreationHeight,
 				CompletionTime: oldEntry.CompletionTime,
 				InitialBalance: oldEntry.InitialBalance,
@@ -114,7 +113,7 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 			}
 		}
 
-		newRedelegations[i] = v040staking.Redelegation{
+		newRedelegations[i] = Redelegation{
 			DelegatorAddress:    oldRedelegation.DelegatorAddress.String(),
 			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress.String(),
 			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress.String(),
@@ -122,14 +121,13 @@ func Migrate(stakingState v038staking.GenesisState) *v040staking.GenesisState {
 		}
 	}
 
-	return &v040staking.GenesisState{
-		Params: v040staking.Params{
+	return &GenesisState{
+		Params: Params{
 			UnbondingTime:     stakingState.Params.UnbondingTime,
 			MaxValidators:     uint32(stakingState.Params.MaxValidators),
 			MaxEntries:        uint32(stakingState.Params.MaxEntries),
 			HistoricalEntries: uint32(stakingState.Params.HistoricalEntries),
 			BondDenom:         stakingState.Params.BondDenom,
-			PowerReduction:    v040staking.DefaultParams().PowerReduction,
 		},
 		LastTotalPower:       stakingState.LastTotalPower,
 		LastValidatorPowers:  newLastValidatorPowers,
diff --git a/x/staking/legacy/v040/migrate_test.go b/x/staking/legacy/v040/migrate_test.go
index 16bb4374b503..2be5e80dbc31 100644
--- a/x/staking/legacy/v040/migrate_test.go
+++ b/x/staking/legacy/v040/migrate_test.go
@@ -55,7 +55,6 @@ func TestMigrate(t *testing.T) {
     "historical_entries": 0,
     "max_entries": 0,
     "max_validators": 0,
-    "power_reduction": "1000000",
     "unbonding_time": "0s"
   },
   "redelegations": [],
diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
new file mode 100644
index 000000000000..71ae65fe3a4e
--- /dev/null
+++ b/x/staking/legacy/v040/staking.pb.go
@@ -0,0 +1,6526 @@
+// Package v040 is taken from:
+// https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/x/staking/types/staking.pb.go
+//nolint
+
+package v040
+
+import (
+	bytes "bytes"
+	compress_gzip "compress/gzip"
+	fmt "fmt"
+	io "io"
+	io_ioutil "io/ioutil"
+	math "math"
+	math_bits "math/bits"
+	reflect "reflect"
+	strings "strings"
+	time "time"
+
+	types1 "github.com/cosmos/cosmos-sdk/codec/types"
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	types2 "github.com/cosmos/cosmos-sdk/types"
+	_ "github.com/gogo/protobuf/gogoproto"
+	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	_ "github.com/golang/protobuf/ptypes/duration"
+	_ "github.com/golang/protobuf/ptypes/timestamp"
+	_ "github.com/regen-network/cosmos-proto"
+	types "github.com/tendermint/tendermint/proto/tendermint/types"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+var _ = time.Kitchen
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.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: "BOND_STATUS_UNSPECIFIED",
+	1: "BOND_STATUS_UNBONDED",
+	2: "BOND_STATUS_UNBONDING",
+	3: "BOND_STATUS_BONDED",
+}
+
+var BondStatus_value = map[string]int32{
+	"BOND_STATUS_UNSPECIFIED": 0,
+	"BOND_STATUS_UNBONDED":    1,
+	"BOND_STATUS_UNBONDING":   2,
+	"BOND_STATUS_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
+// (`n` is set by the staking module's `historical_entries` parameter).
+type HistoricalInfo struct {
+	Header types.Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header"`
+	Valset []Validator  `protobuf:"bytes,2,rep,name=valset,proto3" json:"valset"`
+}
+
+func (m *HistoricalInfo) Reset()         { *m = HistoricalInfo{} }
+func (m *HistoricalInfo) String() string { return proto.CompactTextString(m) }
+func (*HistoricalInfo) ProtoMessage()    {}
+func (*HistoricalInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{0}
+}
+func (m *HistoricalInfo) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *HistoricalInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_HistoricalInfo.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *HistoricalInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HistoricalInfo.Merge(m, src)
+}
+func (m *HistoricalInfo) XXX_Size() int {
+	return m.Size()
+}
+func (m *HistoricalInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_HistoricalInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HistoricalInfo proto.InternalMessageInfo
+
+func (m *HistoricalInfo) GetHeader() types.Header {
+	if m != nil {
+		return m.Header
+	}
+	return types.Header{}
+}
+
+func (m *HistoricalInfo) GetValset() []Validator {
+	if m != nil {
+		return m.Valset
+	}
+	return nil
+}
+
+// CommissionRates defines the initial commission rates to be used for creating
+// a validator.
+type CommissionRates struct {
+	Rate          github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate"`
+	MaxRate       github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=max_rate,json=maxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_rate" yaml:"max_rate"`
+	MaxChangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=max_change_rate,json=maxChangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_change_rate" yaml:"max_change_rate"`
+}
+
+func (m *CommissionRates) Reset()      { *m = CommissionRates{} }
+func (*CommissionRates) ProtoMessage() {}
+func (*CommissionRates) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{1}
+}
+func (m *CommissionRates) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CommissionRates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CommissionRates.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *CommissionRates) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CommissionRates.Merge(m, src)
+}
+func (m *CommissionRates) XXX_Size() int {
+	return m.Size()
+}
+func (m *CommissionRates) XXX_DiscardUnknown() {
+	xxx_messageInfo_CommissionRates.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommissionRates proto.InternalMessageInfo
+
+// Commission defines commission parameters for a given validator.
+type Commission struct {
+	CommissionRates `protobuf:"bytes,1,opt,name=commission_rates,json=commissionRates,proto3,embedded=commission_rates" json:"commission_rates"`
+	UpdateTime      time.Time `protobuf:"bytes,2,opt,name=update_time,json=updateTime,proto3,stdtime" json:"update_time" yaml:"update_time"`
+}
+
+func (m *Commission) Reset()      { *m = Commission{} }
+func (*Commission) ProtoMessage() {}
+func (*Commission) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{2}
+}
+func (m *Commission) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Commission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Commission.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Commission) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Commission.Merge(m, src)
+}
+func (m *Commission) XXX_Size() int {
+	return m.Size()
+}
+func (m *Commission) XXX_DiscardUnknown() {
+	xxx_messageInfo_Commission.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Commission proto.InternalMessageInfo
+
+func (m *Commission) GetUpdateTime() time.Time {
+	if m != nil {
+		return m.UpdateTime
+	}
+	return time.Time{}
+}
+
+// Description defines a validator description.
+type Description struct {
+	Moniker         string `protobuf:"bytes,1,opt,name=moniker,proto3" json:"moniker,omitempty"`
+	Identity        string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
+	Website         string `protobuf:"bytes,3,opt,name=website,proto3" json:"website,omitempty"`
+	SecurityContact string `protobuf:"bytes,4,opt,name=security_contact,json=securityContact,proto3" json:"security_contact,omitempty" yaml:"security_contact"`
+	Details         string `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
+}
+
+func (m *Description) Reset()      { *m = Description{} }
+func (*Description) ProtoMessage() {}
+func (*Description) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{3}
+}
+func (m *Description) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Description) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Description.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Description) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Description.Merge(m, src)
+}
+func (m *Description) XXX_Size() int {
+	return m.Size()
+}
+func (m *Description) XXX_DiscardUnknown() {
+	xxx_messageInfo_Description.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Description proto.InternalMessageInfo
+
+func (m *Description) GetMoniker() string {
+	if m != nil {
+		return m.Moniker
+	}
+	return ""
+}
+
+func (m *Description) GetIdentity() string {
+	if m != nil {
+		return m.Identity
+	}
+	return ""
+}
+
+func (m *Description) GetWebsite() string {
+	if m != nil {
+		return m.Website
+	}
+	return ""
+}
+
+func (m *Description) GetSecurityContact() string {
+	if m != nil {
+		return m.SecurityContact
+	}
+	return ""
+}
+
+func (m *Description) GetDetails() string {
+	if m != nil {
+		return m.Details
+	}
+	return ""
+}
+
+// Validator defines a validator, together with the total amount of the
+// Validator's bond shares and their exchange rate to coins. Slashing results in
+// a decrease in the exchange rate, allowing correct calculation of future
+// undelegations without iterating over delegators. When coins are delegated to
+// this validator, the validator is credited with a delegation whose number of
+// bond shares is based on the amount of coins delegated divided by the current
+// 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   *types1.Any                            `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{} }
+func (*Validator) ProtoMessage() {}
+func (*Validator) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{4}
+}
+func (m *Validator) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Validator) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Validator.Merge(m, src)
+}
+func (m *Validator) XXX_Size() int {
+	return m.Size()
+}
+func (m *Validator) XXX_DiscardUnknown() {
+	xxx_messageInfo_Validator.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Validator proto.InternalMessageInfo
+
+// ValAddresses defines a repeated set of validator addresses.
+type ValAddresses struct {
+	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
+}
+
+func (m *ValAddresses) Reset()      { *m = ValAddresses{} }
+func (*ValAddresses) ProtoMessage() {}
+func (*ValAddresses) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{5}
+}
+func (m *ValAddresses) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ValAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ValAddresses.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ValAddresses) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValAddresses.Merge(m, src)
+}
+func (m *ValAddresses) XXX_Size() int {
+	return m.Size()
+}
+func (m *ValAddresses) XXX_DiscardUnknown() {
+	xxx_messageInfo_ValAddresses.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ValAddresses proto.InternalMessageInfo
+
+func (m *ValAddresses) GetAddresses() []string {
+	if m != nil {
+		return m.Addresses
+	}
+	return nil
+}
+
+// DVPair is struct that just has a delegator-validator pair with no other data.
+// It is intended to be used as a marshalable pointer. For example, a DVPair can
+// be used to construct the key to getting an UnbondingDelegation from state.
+type DVPair struct {
+	DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+}
+
+func (m *DVPair) Reset()      { *m = DVPair{} }
+func (*DVPair) ProtoMessage() {}
+func (*DVPair) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{6}
+}
+func (m *DVPair) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DVPair.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DVPair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DVPair.Merge(m, src)
+}
+func (m *DVPair) XXX_Size() int {
+	return m.Size()
+}
+func (m *DVPair) XXX_DiscardUnknown() {
+	xxx_messageInfo_DVPair.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DVPair proto.InternalMessageInfo
+
+// DVPairs defines an array of DVPair objects.
+type DVPairs struct {
+	Pairs []DVPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs"`
+}
+
+func (m *DVPairs) Reset()         { *m = DVPairs{} }
+func (m *DVPairs) String() string { return proto.CompactTextString(m) }
+func (*DVPairs) ProtoMessage()    {}
+func (*DVPairs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{7}
+}
+func (m *DVPairs) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DVPairs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DVPairs.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DVPairs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DVPairs.Merge(m, src)
+}
+func (m *DVPairs) XXX_Size() int {
+	return m.Size()
+}
+func (m *DVPairs) XXX_DiscardUnknown() {
+	xxx_messageInfo_DVPairs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DVPairs proto.InternalMessageInfo
+
+func (m *DVPairs) GetPairs() []DVPair {
+	if m != nil {
+		return m.Pairs
+	}
+	return nil
+}
+
+// DVVTriplet is struct that just has a delegator-validator-validator triplet
+// with no other data. It is intended to be used as a marshalable pointer. For
+// example, a DVVTriplet can be used to construct the key to getting a
+// Redelegation from state.
+type DVVTriplet struct {
+	DelegatorAddress    string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorSrcAddress string `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
+	ValidatorDstAddress string `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
+}
+
+func (m *DVVTriplet) Reset()      { *m = DVVTriplet{} }
+func (*DVVTriplet) ProtoMessage() {}
+func (*DVVTriplet) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{8}
+}
+func (m *DVVTriplet) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DVVTriplet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DVVTriplet.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DVVTriplet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DVVTriplet.Merge(m, src)
+}
+func (m *DVVTriplet) XXX_Size() int {
+	return m.Size()
+}
+func (m *DVVTriplet) XXX_DiscardUnknown() {
+	xxx_messageInfo_DVVTriplet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DVVTriplet proto.InternalMessageInfo
+
+// DVVTriplets defines an array of DVVTriplet objects.
+type DVVTriplets struct {
+	Triplets []DVVTriplet `protobuf:"bytes,1,rep,name=triplets,proto3" json:"triplets"`
+}
+
+func (m *DVVTriplets) Reset()         { *m = DVVTriplets{} }
+func (m *DVVTriplets) String() string { return proto.CompactTextString(m) }
+func (*DVVTriplets) ProtoMessage()    {}
+func (*DVVTriplets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{9}
+}
+func (m *DVVTriplets) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DVVTriplets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DVVTriplets.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DVVTriplets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DVVTriplets.Merge(m, src)
+}
+func (m *DVVTriplets) XXX_Size() int {
+	return m.Size()
+}
+func (m *DVVTriplets) XXX_DiscardUnknown() {
+	xxx_messageInfo_DVVTriplets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DVVTriplets proto.InternalMessageInfo
+
+func (m *DVVTriplets) GetTriplets() []DVVTriplet {
+	if m != nil {
+		return m.Triplets
+	}
+	return nil
+}
+
+// Delegation represents the bond with tokens held by an account. It is
+// owned by one delegator, and is associated with the voting power of one
+// validator.
+type Delegation struct {
+	DelegatorAddress string                                 `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string                                 `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	Shares           github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=shares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares"`
+}
+
+func (m *Delegation) Reset()      { *m = Delegation{} }
+func (*Delegation) ProtoMessage() {}
+func (*Delegation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{10}
+}
+func (m *Delegation) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Delegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Delegation.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Delegation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Delegation.Merge(m, src)
+}
+func (m *Delegation) XXX_Size() int {
+	return m.Size()
+}
+func (m *Delegation) XXX_DiscardUnknown() {
+	xxx_messageInfo_Delegation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Delegation proto.InternalMessageInfo
+
+// UnbondingDelegation stores all of a single delegator's unbonding bonds
+// for a single validator in an time-ordered list.
+type UnbondingDelegation struct {
+	DelegatorAddress string                     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorAddress string                     `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
+	Entries          []UnbondingDelegationEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *UnbondingDelegation) Reset()      { *m = UnbondingDelegation{} }
+func (*UnbondingDelegation) ProtoMessage() {}
+func (*UnbondingDelegation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{11}
+}
+func (m *UnbondingDelegation) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *UnbondingDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_UnbondingDelegation.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *UnbondingDelegation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UnbondingDelegation.Merge(m, src)
+}
+func (m *UnbondingDelegation) XXX_Size() int {
+	return m.Size()
+}
+func (m *UnbondingDelegation) XXX_DiscardUnknown() {
+	xxx_messageInfo_UnbondingDelegation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnbondingDelegation proto.InternalMessageInfo
+
+// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
+type UnbondingDelegationEntry struct {
+	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	Balance        github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
+}
+
+func (m *UnbondingDelegationEntry) Reset()      { *m = UnbondingDelegationEntry{} }
+func (*UnbondingDelegationEntry) ProtoMessage() {}
+func (*UnbondingDelegationEntry) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{12}
+}
+func (m *UnbondingDelegationEntry) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *UnbondingDelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_UnbondingDelegationEntry.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *UnbondingDelegationEntry) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UnbondingDelegationEntry.Merge(m, src)
+}
+func (m *UnbondingDelegationEntry) XXX_Size() int {
+	return m.Size()
+}
+func (m *UnbondingDelegationEntry) XXX_DiscardUnknown() {
+	xxx_messageInfo_UnbondingDelegationEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnbondingDelegationEntry proto.InternalMessageInfo
+
+func (m *UnbondingDelegationEntry) GetCreationHeight() int64 {
+	if m != nil {
+		return m.CreationHeight
+	}
+	return 0
+}
+
+func (m *UnbondingDelegationEntry) GetCompletionTime() time.Time {
+	if m != nil {
+		return m.CompletionTime
+	}
+	return time.Time{}
+}
+
+// RedelegationEntry defines a redelegation object with relevant metadata.
+type RedelegationEntry struct {
+	CreationHeight int64                                  `protobuf:"varint,1,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height,omitempty" yaml:"creation_height"`
+	CompletionTime time.Time                              `protobuf:"bytes,2,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"`
+	InitialBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=initial_balance,json=initialBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"initial_balance" yaml:"initial_balance"`
+	SharesDst      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=shares_dst,json=sharesDst,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"shares_dst"`
+}
+
+func (m *RedelegationEntry) Reset()      { *m = RedelegationEntry{} }
+func (*RedelegationEntry) ProtoMessage() {}
+func (*RedelegationEntry) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{13}
+}
+func (m *RedelegationEntry) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RedelegationEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RedelegationEntry.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *RedelegationEntry) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RedelegationEntry.Merge(m, src)
+}
+func (m *RedelegationEntry) XXX_Size() int {
+	return m.Size()
+}
+func (m *RedelegationEntry) XXX_DiscardUnknown() {
+	xxx_messageInfo_RedelegationEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RedelegationEntry proto.InternalMessageInfo
+
+func (m *RedelegationEntry) GetCreationHeight() int64 {
+	if m != nil {
+		return m.CreationHeight
+	}
+	return 0
+}
+
+func (m *RedelegationEntry) GetCompletionTime() time.Time {
+	if m != nil {
+		return m.CompletionTime
+	}
+	return time.Time{}
+}
+
+// Redelegation contains the list of a particular delegator's redelegating bonds
+// from a particular source validator to a particular destination validator.
+type Redelegation struct {
+	DelegatorAddress    string              `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"`
+	ValidatorSrcAddress string              `protobuf:"bytes,2,opt,name=validator_src_address,json=validatorSrcAddress,proto3" json:"validator_src_address,omitempty" yaml:"validator_src_address"`
+	ValidatorDstAddress string              `protobuf:"bytes,3,opt,name=validator_dst_address,json=validatorDstAddress,proto3" json:"validator_dst_address,omitempty" yaml:"validator_dst_address"`
+	Entries             []RedelegationEntry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *Redelegation) Reset()      { *m = Redelegation{} }
+func (*Redelegation) ProtoMessage() {}
+func (*Redelegation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{14}
+}
+func (m *Redelegation) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Redelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Redelegation.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Redelegation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Redelegation.Merge(m, src)
+}
+func (m *Redelegation) XXX_Size() int {
+	return m.Size()
+}
+func (m *Redelegation) XXX_DiscardUnknown() {
+	xxx_messageInfo_Redelegation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Redelegation proto.InternalMessageInfo
+
+// Params defines the parameters for the staking module.
+type Params struct {
+	UnbondingTime     time.Duration `protobuf:"bytes,1,opt,name=unbonding_time,json=unbondingTime,proto3,stdduration" json:"unbonding_time" yaml:"unbonding_time"`
+	MaxValidators     uint32        `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty" yaml:"max_validators"`
+	MaxEntries        uint32        `protobuf:"varint,3,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty" yaml:"max_entries"`
+	HistoricalEntries uint32        `protobuf:"varint,4,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty" yaml:"historical_entries"`
+	BondDenom         string        `protobuf:"bytes,5,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
+}
+
+func (m *Params) Reset()      { *m = Params{} }
+func (*Params) ProtoMessage() {}
+func (*Params) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{15}
+}
+func (m *Params) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Params) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Params.Merge(m, src)
+}
+func (m *Params) XXX_Size() int {
+	return m.Size()
+}
+func (m *Params) XXX_DiscardUnknown() {
+	xxx_messageInfo_Params.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Params proto.InternalMessageInfo
+
+func (m *Params) GetUnbondingTime() time.Duration {
+	if m != nil {
+		return m.UnbondingTime
+	}
+	return 0
+}
+
+func (m *Params) GetMaxValidators() uint32 {
+	if m != nil {
+		return m.MaxValidators
+	}
+	return 0
+}
+
+func (m *Params) GetMaxEntries() uint32 {
+	if m != nil {
+		return m.MaxEntries
+	}
+	return 0
+}
+
+func (m *Params) GetHistoricalEntries() uint32 {
+	if m != nil {
+		return m.HistoricalEntries
+	}
+	return 0
+}
+
+func (m *Params) GetBondDenom() string {
+	if m != nil {
+		return m.BondDenom
+	}
+	return ""
+}
+
+// DelegationResponse is equivalent to Delegation except that it contains a
+// balance in addition to shares which is more suitable for client responses.
+type DelegationResponse struct {
+	Delegation Delegation  `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"`
+	Balance    types2.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"`
+}
+
+func (m *DelegationResponse) Reset()      { *m = DelegationResponse{} }
+func (*DelegationResponse) ProtoMessage() {}
+func (*DelegationResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{16}
+}
+func (m *DelegationResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DelegationResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DelegationResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DelegationResponse.Merge(m, src)
+}
+func (m *DelegationResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *DelegationResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_DelegationResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DelegationResponse proto.InternalMessageInfo
+
+func (m *DelegationResponse) GetDelegation() Delegation {
+	if m != nil {
+		return m.Delegation
+	}
+	return Delegation{}
+}
+
+func (m *DelegationResponse) GetBalance() types2.Coin {
+	if m != nil {
+		return m.Balance
+	}
+	return types2.Coin{}
+}
+
+// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it
+// contains a balance in addition to shares which is more suitable for client
+// responses.
+type RedelegationEntryResponse struct {
+	RedelegationEntry RedelegationEntry                      `protobuf:"bytes,1,opt,name=redelegation_entry,json=redelegationEntry,proto3" json:"redelegation_entry"`
+	Balance           github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"`
+}
+
+func (m *RedelegationEntryResponse) Reset()         { *m = RedelegationEntryResponse{} }
+func (m *RedelegationEntryResponse) String() string { return proto.CompactTextString(m) }
+func (*RedelegationEntryResponse) ProtoMessage()    {}
+func (*RedelegationEntryResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{17}
+}
+func (m *RedelegationEntryResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RedelegationEntryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RedelegationEntryResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *RedelegationEntryResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RedelegationEntryResponse.Merge(m, src)
+}
+func (m *RedelegationEntryResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *RedelegationEntryResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RedelegationEntryResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RedelegationEntryResponse proto.InternalMessageInfo
+
+func (m *RedelegationEntryResponse) GetRedelegationEntry() RedelegationEntry {
+	if m != nil {
+		return m.RedelegationEntry
+	}
+	return RedelegationEntry{}
+}
+
+// RedelegationResponse is equivalent to a Redelegation except that its entries
+// contain a balance in addition to shares which is more suitable for client
+// responses.
+type RedelegationResponse struct {
+	Redelegation Redelegation                `protobuf:"bytes,1,opt,name=redelegation,proto3" json:"redelegation"`
+	Entries      []RedelegationEntryResponse `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *RedelegationResponse) Reset()         { *m = RedelegationResponse{} }
+func (m *RedelegationResponse) String() string { return proto.CompactTextString(m) }
+func (*RedelegationResponse) ProtoMessage()    {}
+func (*RedelegationResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{18}
+}
+func (m *RedelegationResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RedelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RedelegationResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *RedelegationResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RedelegationResponse.Merge(m, src)
+}
+func (m *RedelegationResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *RedelegationResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RedelegationResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RedelegationResponse proto.InternalMessageInfo
+
+func (m *RedelegationResponse) GetRedelegation() Redelegation {
+	if m != nil {
+		return m.Redelegation
+	}
+	return Redelegation{}
+}
+
+func (m *RedelegationResponse) GetEntries() []RedelegationEntryResponse {
+	if m != nil {
+		return m.Entries
+	}
+	return nil
+}
+
+// Pool is used for tracking bonded and not-bonded token supply of the bond
+// denomination.
+type Pool struct {
+	NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"`
+	BondedTokens    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"`
+}
+
+func (m *Pool) Reset()         { *m = Pool{} }
+func (m *Pool) String() string { return proto.CompactTextString(m) }
+func (*Pool) ProtoMessage()    {}
+func (*Pool) Descriptor() ([]byte, []int) {
+	return fileDescriptor_64c30c6cf92913c9, []int{19}
+}
+func (m *Pool) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Pool.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Pool) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pool.Merge(m, src)
+}
+func (m *Pool) XXX_Size() int {
+	return m.Size()
+}
+func (m *Pool) XXX_DiscardUnknown() {
+	xxx_messageInfo_Pool.DiscardUnknown(m)
+}
+
+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")
+	// proto.RegisterType((*Description)(nil), "cosmos.staking.v1beta1.Description")
+	// proto.RegisterType((*Validator)(nil), "cosmos.staking.v1beta1.Validator")
+	// proto.RegisterType((*ValAddresses)(nil), "cosmos.staking.v1beta1.ValAddresses")
+	// proto.RegisterType((*DVPair)(nil), "cosmos.staking.v1beta1.DVPair")
+	// proto.RegisterType((*DVPairs)(nil), "cosmos.staking.v1beta1.DVPairs")
+	// proto.RegisterType((*DVVTriplet)(nil), "cosmos.staking.v1beta1.DVVTriplet")
+	// proto.RegisterType((*DVVTriplets)(nil), "cosmos.staking.v1beta1.DVVTriplets")
+	// proto.RegisterType((*Delegation)(nil), "cosmos.staking.v1beta1.Delegation")
+	// proto.RegisterType((*UnbondingDelegation)(nil), "cosmos.staking.v1beta1.UnbondingDelegation")
+	// proto.RegisterType((*UnbondingDelegationEntry)(nil), "cosmos.staking.v1beta1.UnbondingDelegationEntry")
+	// proto.RegisterType((*RedelegationEntry)(nil), "cosmos.staking.v1beta1.RedelegationEntry")
+	// proto.RegisterType((*Redelegation)(nil), "cosmos.staking.v1beta1.Redelegation")
+	// proto.RegisterType((*Params)(nil), "cosmos.staking.v1beta1.Params")
+	// proto.RegisterType((*DelegationResponse)(nil), "cosmos.staking.v1beta1.DelegationResponse")
+	// proto.RegisterType((*RedelegationEntryResponse)(nil), "cosmos.staking.v1beta1.RedelegationEntryResponse")
+	// proto.RegisterType((*RedelegationResponse)(nil), "cosmos.staking.v1beta1.RedelegationResponse")
+	// proto.RegisterType((*Pool)(nil), "cosmos.staking.v1beta1.Pool")
+}
+
+func init() {
+	proto.RegisterFile("cosmos/staking/v1beta1/staking.proto", fileDescriptor_64c30c6cf92913c9)
+}
+
+var fileDescriptor_64c30c6cf92913c9 = []byte{
+	// 1796 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0x4d, 0x6c, 0x23, 0x49,
+	0x15, 0x76, 0x3b, 0x5e, 0xc7, 0x7e, 0x4e, 0xe2, 0xa4, 0x26, 0x33, 0xeb, 0x98, 0xc1, 0xed, 0x6d,
+	0x56, 0x4b, 0x40, 0xbb, 0x0e, 0x93, 0x45, 0x8b, 0xc8, 0x05, 0xc6, 0x71, 0x86, 0x58, 0xbb, 0x0c,
+	0xa1, 0x93, 0x09, 0x12, 0xac, 0xb0, 0xca, 0xdd, 0x15, 0xa7, 0x89, 0xbb, 0xdb, 0x74, 0x95, 0x87,
+	0x58, 0xda, 0x03, 0xc7, 0x65, 0x10, 0x62, 0xb9, 0xed, 0x65, 0xa4, 0x91, 0xf6, 0xba, 0x12, 0x17,
+	0xc4, 0x95, 0xeb, 0x02, 0x97, 0xe1, 0x86, 0x10, 0x32, 0x68, 0xe6, 0x82, 0x38, 0x21, 0x1f, 0x10,
+	0x37, 0x50, 0xfd, 0xf4, 0x4f, 0xda, 0xf1, 0xcc, 0x78, 0xb4, 0x87, 0x91, 0xd8, 0x4b, 0xe2, 0x7a,
+	0xf5, 0xde, 0xf7, 0xea, 0xfd, 0xd6, 0xab, 0x86, 0x57, 0x2d, 0x9f, 0xba, 0x3e, 0xdd, 0xa2, 0x0c,
+	0x9f, 0x39, 0x5e, 0x6f, 0xeb, 0xee, 0x8d, 0x2e, 0x61, 0xf8, 0x46, 0xb8, 0x6e, 0x0c, 0x02, 0x9f,
+	0xf9, 0xe8, 0x9a, 0xe4, 0x6a, 0x84, 0x54, 0xc5, 0x55, 0x5d, 0xef, 0xf9, 0x3d, 0x5f, 0xb0, 0x6c,
+	0xf1, 0x5f, 0x92, 0xbb, 0xba, 0xd1, 0xf3, 0xfd, 0x5e, 0x9f, 0x6c, 0x89, 0x55, 0x77, 0x78, 0xb2,
+	0x85, 0xbd, 0x91, 0xda, 0xaa, 0xa5, 0xb7, 0xec, 0x61, 0x80, 0x99, 0xe3, 0x7b, 0x6a, 0x5f, 0x4f,
+	0xef, 0x33, 0xc7, 0x25, 0x94, 0x61, 0x77, 0x10, 0x62, 0xcb, 0x93, 0x74, 0xa4, 0x52, 0x75, 0x2c,
+	0x85, 0xad, 0x4c, 0xe9, 0x62, 0x4a, 0x22, 0x3b, 0x2c, 0xdf, 0x09, 0xb1, 0xaf, 0x33, 0xe2, 0xd9,
+	0x24, 0x70, 0x1d, 0x8f, 0x6d, 0xb1, 0xd1, 0x80, 0x50, 0xf9, 0x57, 0xee, 0x1a, 0x3f, 0xd3, 0x60,
+	0x65, 0xdf, 0xa1, 0xcc, 0x0f, 0x1c, 0x0b, 0xf7, 0xdb, 0xde, 0x89, 0x8f, 0xde, 0x82, 0xfc, 0x29,
+	0xc1, 0x36, 0x09, 0x2a, 0x5a, 0x5d, 0xdb, 0x2c, 0x6d, 0x57, 0x1a, 0x31, 0x42, 0x43, 0xca, 0xee,
+	0x8b, 0xfd, 0x66, 0xee, 0x93, 0xb1, 0x9e, 0x31, 0x15, 0x37, 0xfa, 0x06, 0xe4, 0xef, 0xe2, 0x3e,
+	0x25, 0xac, 0x92, 0xad, 0x2f, 0x6c, 0x96, 0xb6, 0x5f, 0x69, 0x5c, 0xee, 0xbe, 0xc6, 0x31, 0xee,
+	0x3b, 0x36, 0x66, 0x7e, 0x04, 0x20, 0xc5, 0x8c, 0x5f, 0x67, 0xa1, 0xbc, 0xeb, 0xbb, 0xae, 0x43,
+	0xa9, 0xe3, 0x7b, 0x26, 0x66, 0x84, 0xa2, 0x26, 0xe4, 0x02, 0xcc, 0x88, 0x38, 0x4a, 0xb1, 0xd9,
+	0xe0, 0xfc, 0x7f, 0x19, 0xeb, 0xaf, 0xf5, 0x1c, 0x76, 0x3a, 0xec, 0x36, 0x2c, 0xdf, 0x55, 0xce,
+	0x50, 0xff, 0xde, 0xa0, 0xf6, 0x99, 0xb2, 0xaf, 0x45, 0x2c, 0x53, 0xc8, 0xa2, 0x77, 0xa1, 0xe0,
+	0xe2, 0xf3, 0x8e, 0xc0, 0xc9, 0x0a, 0x9c, 0x9b, 0xf3, 0xe1, 0x4c, 0xc6, 0x7a, 0x79, 0x84, 0xdd,
+	0xfe, 0x8e, 0x11, 0xe2, 0x18, 0xe6, 0xa2, 0x8b, 0xcf, 0xf9, 0x11, 0xd1, 0x00, 0xca, 0x9c, 0x6a,
+	0x9d, 0x62, 0xaf, 0x47, 0xa4, 0x92, 0x05, 0xa1, 0x64, 0x7f, 0x6e, 0x25, 0xd7, 0x62, 0x25, 0x09,
+	0x38, 0xc3, 0x5c, 0x76, 0xf1, 0xf9, 0xae, 0x20, 0x70, 0x8d, 0x3b, 0x85, 0x0f, 0x1f, 0xe8, 0x99,
+	0x7f, 0x3c, 0xd0, 0x35, 0xe3, 0x4f, 0x1a, 0x40, 0xec, 0x31, 0xf4, 0x2e, 0xac, 0x5a, 0xd1, 0x4a,
+	0xc8, 0x52, 0x15, 0xc3, 0x2f, 0xce, 0x8a, 0x45, 0xca, 0xdf, 0xcd, 0x02, 0x3f, 0xf4, 0xc3, 0xb1,
+	0xae, 0x99, 0x65, 0x2b, 0x15, 0x8a, 0x1f, 0x40, 0x69, 0x38, 0xb0, 0x31, 0x23, 0x1d, 0x9e, 0x9d,
+	0xc2, 0x93, 0xa5, 0xed, 0x6a, 0x43, 0xa6, 0x6e, 0x23, 0x4c, 0xdd, 0xc6, 0x51, 0x98, 0xba, 0xcd,
+	0x1a, 0xc7, 0x9a, 0x8c, 0x75, 0x24, 0xcd, 0x4a, 0x08, 0x1b, 0x1f, 0xfc, 0x4d, 0xd7, 0x4c, 0x90,
+	0x14, 0x2e, 0x90, 0xb0, 0xe9, 0xf7, 0x1a, 0x94, 0x5a, 0x84, 0x5a, 0x81, 0x33, 0xe0, 0x15, 0x82,
+	0x2a, 0xb0, 0xe8, 0xfa, 0x9e, 0x73, 0xa6, 0xf2, 0xb1, 0x68, 0x86, 0x4b, 0x54, 0x85, 0x82, 0x63,
+	0x13, 0x8f, 0x39, 0x6c, 0x24, 0xe3, 0x6a, 0x46, 0x6b, 0x2e, 0xf5, 0x13, 0xd2, 0xa5, 0x4e, 0x18,
+	0x0d, 0x33, 0x5c, 0xa2, 0x5b, 0xb0, 0x4a, 0x89, 0x35, 0x0c, 0x1c, 0x36, 0xea, 0x58, 0xbe, 0xc7,
+	0xb0, 0xc5, 0x2a, 0x39, 0x11, 0xb0, 0xcf, 0x4d, 0xc6, 0xfa, 0xcb, 0xf2, 0xac, 0x69, 0x0e, 0xc3,
+	0x2c, 0x87, 0xa4, 0x5d, 0x49, 0xe1, 0x1a, 0x6c, 0xc2, 0xb0, 0xd3, 0xa7, 0x95, 0x97, 0xa4, 0x06,
+	0xb5, 0x4c, 0xd8, 0xf2, 0xf1, 0x22, 0x14, 0xa3, 0x6c, 0xe7, 0x9a, 0xfd, 0x01, 0x09, 0xf8, 0xef,
+	0x0e, 0xb6, 0xed, 0x80, 0x50, 0xaa, 0xf2, 0x3a, 0xa1, 0x39, 0xcd, 0x61, 0x98, 0xe5, 0x90, 0x74,
+	0x53, 0x52, 0x10, 0xe3, 0x61, 0xf6, 0x28, 0xf1, 0xe8, 0x90, 0x76, 0x06, 0xc3, 0xee, 0x19, 0x19,
+	0xa9, 0x68, 0xac, 0x4f, 0x45, 0xe3, 0xa6, 0x37, 0x6a, 0xbe, 0x19, 0xa3, 0xa7, 0xe5, 0x8c, 0x3f,
+	0xfc, 0xe6, 0x8d, 0x75, 0x95, 0x1a, 0x56, 0x30, 0x1a, 0x30, 0xbf, 0x71, 0x30, 0xec, 0xbe, 0x4d,
+	0x46, 0x3c, 0xfc, 0x8a, 0xf5, 0x40, 0x70, 0xa2, 0x6b, 0x90, 0xff, 0x11, 0x76, 0xfa, 0xc4, 0x16,
+	0x0e, 0x2d, 0x98, 0x6a, 0x85, 0x76, 0x20, 0x4f, 0x19, 0x66, 0x43, 0x2a, 0xbc, 0xb8, 0xb2, 0x6d,
+	0xcc, 0x4a, 0xb5, 0xa6, 0xef, 0xd9, 0x87, 0x82, 0xd3, 0x54, 0x12, 0xe8, 0x16, 0xe4, 0x99, 0x7f,
+	0x46, 0x3c, 0xe5, 0xc2, 0xb9, 0xea, 0xbb, 0xed, 0x31, 0x53, 0x49, 0x73, 0x8f, 0xd8, 0xa4, 0x4f,
+	0x7a, 0xc2, 0x71, 0xf4, 0x14, 0x07, 0x84, 0x56, 0xf2, 0x02, 0xb1, 0x3d, 0x77, 0x11, 0x2a, 0x4f,
+	0xa5, 0xf1, 0x0c, 0xb3, 0x1c, 0x91, 0x0e, 0x05, 0x05, 0xbd, 0x0d, 0x25, 0x3b, 0x4e, 0xd4, 0xca,
+	0xa2, 0x08, 0xc1, 0x17, 0x66, 0x99, 0x9f, 0xc8, 0x69, 0xd5, 0xf7, 0x92, 0xd2, 0x3c, 0x39, 0x86,
+	0x5e, 0xd7, 0xf7, 0x6c, 0xc7, 0xeb, 0x75, 0x4e, 0x89, 0xd3, 0x3b, 0x65, 0x95, 0x42, 0x5d, 0xdb,
+	0x5c, 0x48, 0x26, 0x47, 0x9a, 0xc3, 0x30, 0xcb, 0x11, 0x69, 0x5f, 0x50, 0x90, 0x0d, 0x2b, 0x31,
+	0x97, 0x28, 0xd4, 0xe2, 0x53, 0x0b, 0xf5, 0x15, 0x55, 0xa8, 0x57, 0xd3, 0x5a, 0xe2, 0x5a, 0x5d,
+	0x8e, 0x88, 0x5c, 0x0c, 0xed, 0x03, 0xc4, 0xed, 0xa1, 0x02, 0x42, 0x83, 0xf1, 0xf4, 0x1e, 0xa3,
+	0x0c, 0x4f, 0xc8, 0xa2, 0xf7, 0xe0, 0x8a, 0xeb, 0x78, 0x1d, 0x4a, 0xfa, 0x27, 0x1d, 0xe5, 0x60,
+	0x0e, 0x59, 0x12, 0xd1, 0x7b, 0x67, 0xbe, 0x7c, 0x98, 0x8c, 0xf5, 0xaa, 0x6a, 0xa1, 0xd3, 0x90,
+	0x86, 0xb9, 0xe6, 0x3a, 0xde, 0x21, 0xe9, 0x9f, 0xb4, 0x22, 0xda, 0xce, 0xd2, 0xfb, 0x0f, 0xf4,
+	0x8c, 0x2a, 0xd7, 0x8c, 0xf1, 0x16, 0x2c, 0x1d, 0xe3, 0xbe, 0x2a, 0x33, 0x42, 0xd1, 0x75, 0x28,
+	0xe2, 0x70, 0x51, 0xd1, 0xea, 0x0b, 0x9b, 0x45, 0x33, 0x26, 0xc8, 0x32, 0xff, 0xe9, 0x5f, 0xeb,
+	0x9a, 0xf1, 0xb1, 0x06, 0xf9, 0xd6, 0xf1, 0x01, 0x76, 0x02, 0xd4, 0x86, 0xb5, 0x38, 0x73, 0x2e,
+	0x16, 0xf9, 0xf5, 0xc9, 0x58, 0xaf, 0xa4, 0x93, 0x2b, 0xaa, 0xf2, 0x38, 0x81, 0xc3, 0x32, 0x6f,
+	0xc3, 0xda, 0xdd, 0xb0, 0x77, 0x44, 0x50, 0xd9, 0x34, 0xd4, 0x14, 0x8b, 0x61, 0xae, 0x46, 0x34,
+	0x05, 0x95, 0x32, 0x73, 0x0f, 0x16, 0xe5, 0x69, 0x29, 0xda, 0x81, 0x97, 0x06, 0xfc, 0x87, 0xb0,
+	0xae, 0xb4, 0x5d, 0x9b, 0x99, 0xbc, 0x82, 0x5f, 0x85, 0x4f, 0x8a, 0x18, 0xbf, 0xca, 0x02, 0xb4,
+	0x8e, 0x8f, 0x8f, 0x02, 0x67, 0xd0, 0x27, 0xec, 0xd3, 0xb4, 0xfc, 0x08, 0xae, 0xc6, 0x66, 0xd1,
+	0xc0, 0x4a, 0x59, 0x5f, 0x9f, 0x8c, 0xf5, 0xeb, 0x69, 0xeb, 0x13, 0x6c, 0x86, 0x79, 0x25, 0xa2,
+	0x1f, 0x06, 0xd6, 0xa5, 0xa8, 0x36, 0x65, 0x11, 0xea, 0xc2, 0x6c, 0xd4, 0x04, 0x5b, 0x12, 0xb5,
+	0x45, 0xd9, 0xe5, 0xae, 0x3d, 0x84, 0x52, 0xec, 0x12, 0x8a, 0x5a, 0x50, 0x60, 0xea, 0xb7, 0xf2,
+	0xb0, 0x31, 0xdb, 0xc3, 0xa1, 0x98, 0xf2, 0x72, 0x24, 0x69, 0xfc, 0x47, 0x03, 0x88, 0x73, 0xf6,
+	0xc5, 0x4c, 0x31, 0xde, 0xca, 0x55, 0xe3, 0x5d, 0x78, 0xae, 0x51, 0x4d, 0x49, 0xa7, 0xfc, 0xf9,
+	0xf3, 0x2c, 0x5c, 0xb9, 0x13, 0x76, 0x9e, 0x17, 0xde, 0x07, 0x07, 0xb0, 0x48, 0x3c, 0x16, 0x38,
+	0xc2, 0x09, 0x3c, 0xda, 0x5f, 0x99, 0x15, 0xed, 0x4b, 0x6c, 0xda, 0xf3, 0x58, 0x30, 0x52, 0xb1,
+	0x0f, 0x61, 0x52, 0xde, 0xf8, 0xe5, 0x02, 0x54, 0x66, 0x49, 0xa2, 0x5d, 0x28, 0x5b, 0x01, 0x11,
+	0x84, 0xf0, 0xfe, 0xd0, 0xc4, 0xfd, 0x51, 0x8d, 0x27, 0xcb, 0x14, 0x83, 0x61, 0xae, 0x84, 0x14,
+	0x75, 0x7b, 0xf4, 0x80, 0x8f, 0x7d, 0x3c, 0xed, 0x38, 0xd7, 0x33, 0xce, 0x79, 0x86, 0xba, 0x3e,
+	0x42, 0x25, 0x17, 0x01, 0xe4, 0xfd, 0xb1, 0x12, 0x53, 0xc5, 0x05, 0xf2, 0x63, 0x28, 0x3b, 0x9e,
+	0xc3, 0x1c, 0xdc, 0xef, 0x74, 0x71, 0x1f, 0x7b, 0xd6, 0xf3, 0x4c, 0xcd, 0xb2, 0xe5, 0x2b, 0xb5,
+	0x29, 0x38, 0xc3, 0x5c, 0x51, 0x94, 0xa6, 0x24, 0xa0, 0x7d, 0x58, 0x0c, 0x55, 0xe5, 0x9e, 0x6b,
+	0xda, 0x08, 0xc5, 0x13, 0x03, 0xde, 0x2f, 0x16, 0x60, 0xcd, 0x24, 0xf6, 0x67, 0xa1, 0x98, 0x2f,
+	0x14, 0xdf, 0x06, 0x90, 0xe5, 0xce, 0x1b, 0xec, 0x73, 0x44, 0x83, 0x37, 0x8c, 0xa2, 0x44, 0x68,
+	0x51, 0x96, 0x88, 0xc7, 0x38, 0x0b, 0x4b, 0xc9, 0x78, 0xfc, 0x9f, 0xde, 0x4a, 0xa8, 0x1d, 0x77,
+	0xa2, 0x9c, 0xe8, 0x44, 0x5f, 0x9a, 0xd5, 0x89, 0xa6, 0xb2, 0xf7, 0xc9, 0x2d, 0xe8, 0xdf, 0x59,
+	0xc8, 0x1f, 0xe0, 0x00, 0xbb, 0x14, 0x59, 0x53, 0x93, 0xa6, 0x7c, 0x6b, 0x6e, 0x4c, 0xe5, 0x67,
+	0x4b, 0x7d, 0xed, 0x78, 0xca, 0xa0, 0xf9, 0xe1, 0x25, 0x83, 0xe6, 0x37, 0x61, 0x85, 0x3f, 0x87,
+	0x23, 0x1b, 0xa5, 0xb7, 0x97, 0x9b, 0x1b, 0x31, 0xca, 0xc5, 0x7d, 0xf9, 0x5a, 0x8e, 0x1e, 0x5d,
+	0x14, 0x7d, 0x0d, 0x4a, 0x9c, 0x23, 0x6e, 0xcc, 0x5c, 0xfc, 0x5a, 0xfc, 0x2c, 0x4d, 0x6c, 0x1a,
+	0x26, 0xb8, 0xf8, 0x7c, 0x4f, 0x2e, 0xd0, 0x3b, 0x80, 0x4e, 0xa3, 0x2f, 0x23, 0x9d, 0xd8, 0x9d,
+	0x5c, 0xfe, 0xf3, 0x93, 0xb1, 0xbe, 0x21, 0xe5, 0xa7, 0x79, 0x0c, 0x73, 0x2d, 0x26, 0x86, 0x68,
+	0x5f, 0x05, 0xe0, 0x76, 0x75, 0x6c, 0xe2, 0xf9, 0xae, 0x7a, 0xee, 0x5c, 0x9d, 0x8c, 0xf5, 0x35,
+	0x89, 0x12, 0xef, 0x19, 0x66, 0x91, 0x2f, 0x5a, 0xfc, 0x77, 0x22, 0xb3, 0x3f, 0xd2, 0x00, 0xc5,
+	0x2d, 0xdf, 0x24, 0x74, 0xc0, 0xdf, 0x67, 0x7c, 0x10, 0x4f, 0x4c, 0xcd, 0xda, 0x93, 0x07, 0xf1,
+	0x58, 0x3e, 0x1c, 0xc4, 0x13, 0x95, 0xf2, 0xf5, 0xb8, 0x3d, 0x66, 0x55, 0x1c, 0x15, 0x4c, 0x17,
+	0x53, 0x92, 0x18, 0xe6, 0x9d, 0x50, 0x7a, 0xaa, 0x1f, 0x66, 0x8c, 0x3f, 0x6a, 0xb0, 0x31, 0x95,
+	0x51, 0xd1, 0x61, 0x7f, 0x08, 0x28, 0x48, 0x6c, 0x0a, 0x7f, 0x8d, 0xd4, 0xa1, 0xe7, 0x4e, 0xd0,
+	0xb5, 0x60, 0xaa, 0xef, 0x7e, 0x7a, 0x1d, 0x3e, 0x27, 0x7c, 0xfe, 0x3b, 0x0d, 0xd6, 0x93, 0xea,
+	0x23, 0x43, 0x6e, 0xc3, 0x52, 0x52, 0xbb, 0x32, 0xe1, 0xd5, 0x67, 0x31, 0x41, 0x9d, 0xfe, 0x82,
+	0x3c, 0xfa, 0x6e, 0x5c, 0xae, 0xf2, 0xdb, 0xd9, 0x8d, 0x67, 0xf6, 0x46, 0x78, 0xa6, 0x74, 0xd9,
+	0xe6, 0x44, 0x3c, 0xfe, 0xab, 0x41, 0xee, 0xc0, 0xf7, 0xfb, 0xc8, 0x87, 0x35, 0xcf, 0x67, 0x1d,
+	0x9e, 0x59, 0xc4, 0xee, 0xa8, 0x47, 0xb7, 0xec, 0x83, 0xbb, 0xf3, 0x39, 0xe9, 0x9f, 0x63, 0x7d,
+	0x1a, 0xca, 0x2c, 0x7b, 0x3e, 0x6b, 0x0a, 0xca, 0x91, 0x7c, 0x92, 0xbf, 0x07, 0xcb, 0x17, 0x95,
+	0xc9, 0x2e, 0xf9, 0xbd, 0xb9, 0x95, 0x5d, 0x84, 0x99, 0x8c, 0xf5, 0xf5, 0xb8, 0x62, 0x22, 0xb2,
+	0x61, 0x2e, 0x75, 0x13, 0xda, 0x77, 0x0a, 0x3c, 0x7e, 0xff, 0x7a, 0xa0, 0x6b, 0x5f, 0xfe, 0xad,
+	0x06, 0x10, 0x7f, 0x79, 0x40, 0xaf, 0xc3, 0xcb, 0xcd, 0xef, 0xdc, 0x6e, 0x75, 0x0e, 0x8f, 0x6e,
+	0x1e, 0xdd, 0x39, 0xec, 0xdc, 0xb9, 0x7d, 0x78, 0xb0, 0xb7, 0xdb, 0xbe, 0xd5, 0xde, 0x6b, 0xad,
+	0x66, 0xaa, 0xe5, 0x7b, 0xf7, 0xeb, 0xa5, 0x3b, 0x1e, 0x1d, 0x10, 0xcb, 0x39, 0x71, 0x88, 0x8d,
+	0x5e, 0x83, 0xf5, 0x8b, 0xdc, 0x7c, 0xb5, 0xd7, 0x5a, 0xd5, 0xaa, 0x4b, 0xf7, 0xee, 0xd7, 0x0b,
+	0x72, 0x16, 0x23, 0x36, 0xda, 0x84, 0xab, 0xd3, 0x7c, 0xed, 0xdb, 0xdf, 0x5a, 0xcd, 0x56, 0x97,
+	0xef, 0xdd, 0xaf, 0x17, 0xa3, 0xa1, 0x0d, 0x19, 0x80, 0x92, 0x9c, 0x0a, 0x6f, 0xa1, 0x0a, 0xf7,
+	0xee, 0xd7, 0xf3, 0xd2, 0x81, 0xd5, 0xdc, 0xfb, 0x1f, 0xd5, 0x32, 0xcd, 0x5b, 0x9f, 0x3c, 0xaa,
+	0x69, 0x0f, 0x1f, 0xd5, 0xb4, 0xbf, 0x3f, 0xaa, 0x69, 0x1f, 0x3c, 0xae, 0x65, 0x1e, 0x3e, 0xae,
+	0x65, 0xfe, 0xfc, 0xb8, 0x96, 0xf9, 0xfe, 0xeb, 0x4f, 0xf4, 0xdd, 0x79, 0xf4, 0x51, 0x5b, 0x78,
+	0xb1, 0x9b, 0x17, 0x6d, 0xf8, 0xcd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x48, 0x4c, 0x86,
+	0xf3, 0x16, 0x00, 0x00,
+}
+
+func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
+	return StakingDescription()
+}
+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{
+		// 9603 bytes of a gzipped FileDescriptorSet
+		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x24, 0xd7,
+		0x71, 0xd8, 0xcd, 0xee, 0x02, 0xd8, 0x6d, 0x2c, 0x80, 0xc5, 0x03, 0xee, 0x6e, 0x6f, 0x79, 0x04,
+		0xc0, 0xe1, 0xd7, 0xf1, 0x48, 0x02, 0xe4, 0x91, 0x77, 0x24, 0xf7, 0x24, 0xd2, 0x58, 0x60, 0x0f,
+		0x07, 0x1e, 0xbe, 0x38, 0x00, 0x8e, 0xd4, 0x87, 0xb3, 0x35, 0x98, 0x7d, 0x58, 0x0c, 0xb1, 0x3b,
+		0x33, 0x9c, 0x99, 0xbd, 0x3b, 0x50, 0x52, 0x15, 0x2d, 0x29, 0x8a, 0x44, 0xc7, 0x91, 0x14, 0xb9,
+		0x1c, 0x89, 0xd6, 0x29, 0x92, 0xe5, 0x44, 0x8e, 0xac, 0xc4, 0x1f, 0x52, 0x94, 0x38, 0x49, 0x55,
+		0xa4, 0x24, 0x8e, 0x25, 0xa5, 0xe2, 0x92, 0x2a, 0xae, 0xc4, 0x71, 0x25, 0x67, 0x87, 0x52, 0x39,
+		0x8c, 0xa2, 0xc4, 0xf2, 0x59, 0x4e, 0x9c, 0x52, 0xa5, 0x92, 0x7a, 0x5f, 0xf3, 0xb5, 0x1f, 0xb3,
+		0x0b, 0xdd, 0x49, 0x72, 0x9c, 0x5f, 0xd8, 0xd7, 0xaf, 0xbb, 0x5f, 0xbf, 0x7e, 0xfd, 0xba, 0xfb,
+		0x7d, 0x0d, 0xe0, 0x9f, 0x9f, 0x87, 0x99, 0x9a, 0x69, 0xd6, 0xea, 0x78, 0xce, 0xb2, 0x4d, 0xd7,
+		0xdc, 0x69, 0xee, 0xce, 0x55, 0xb1, 0xa3, 0xd9, 0xba, 0xe5, 0x9a, 0xf6, 0x2c, 0x85, 0xa1, 0x31,
+		0x86, 0x31, 0x2b, 0x30, 0xe4, 0x55, 0x18, 0xbf, 0xa0, 0xd7, 0xf1, 0xa2, 0x87, 0xb8, 0x89, 0x5d,
+		0xf4, 0x24, 0xa4, 0x76, 0xf5, 0x3a, 0xce, 0x4b, 0x33, 0xc9, 0x53, 0xc3, 0x67, 0xee, 0x99, 0x8d,
+		0x10, 0xcd, 0x86, 0x29, 0x36, 0x08, 0x58, 0xa1, 0x14, 0xf2, 0xb7, 0x52, 0x30, 0xd1, 0xa6, 0x16,
+		0x21, 0x48, 0x19, 0x6a, 0x83, 0x70, 0x94, 0x4e, 0x65, 0x14, 0xfa, 0x1b, 0xe5, 0x61, 0xc8, 0x52,
+		0xb5, 0x7d, 0xb5, 0x86, 0xf3, 0x09, 0x0a, 0x16, 0x45, 0x34, 0x05, 0x50, 0xc5, 0x16, 0x36, 0xaa,
+		0xd8, 0xd0, 0x0e, 0xf2, 0xc9, 0x99, 0xe4, 0xa9, 0x8c, 0x12, 0x80, 0xa0, 0x07, 0x61, 0xdc, 0x6a,
+		0xee, 0xd4, 0x75, 0xad, 0x12, 0x40, 0x83, 0x99, 0xe4, 0xa9, 0x01, 0x25, 0xc7, 0x2a, 0x16, 0x7d,
+		0xe4, 0xfb, 0x61, 0xec, 0x2a, 0x56, 0xf7, 0x83, 0xa8, 0xc3, 0x14, 0x75, 0x94, 0x80, 0x03, 0x88,
+		0x0b, 0x90, 0x6d, 0x60, 0xc7, 0x51, 0x6b, 0xb8, 0xe2, 0x1e, 0x58, 0x38, 0x9f, 0xa2, 0xbd, 0x9f,
+		0x69, 0xe9, 0x7d, 0xb4, 0xe7, 0xc3, 0x9c, 0x6a, 0xeb, 0xc0, 0xc2, 0x68, 0x1e, 0x32, 0xd8, 0x68,
+		0x36, 0x18, 0x87, 0x81, 0x0e, 0xfa, 0x2b, 0x1b, 0xcd, 0x46, 0x94, 0x4b, 0x9a, 0x90, 0x71, 0x16,
+		0x43, 0x0e, 0xb6, 0xaf, 0xe8, 0x1a, 0xce, 0x0f, 0x52, 0x06, 0xf7, 0xb7, 0x30, 0xd8, 0x64, 0xf5,
+		0x51, 0x1e, 0x82, 0x0e, 0x2d, 0x40, 0x06, 0x5f, 0x73, 0xb1, 0xe1, 0xe8, 0xa6, 0x91, 0x1f, 0xa2,
+		0x4c, 0xee, 0x6d, 0x33, 0x8a, 0xb8, 0x5e, 0x8d, 0xb2, 0xf0, 0xe9, 0xd0, 0x39, 0x18, 0x32, 0x2d,
+		0x57, 0x37, 0x0d, 0x27, 0x9f, 0x9e, 0x91, 0x4e, 0x0d, 0x9f, 0x39, 0xd9, 0xd6, 0x10, 0xd6, 0x19,
+		0x8e, 0x22, 0x90, 0xd1, 0x32, 0xe4, 0x1c, 0xb3, 0x69, 0x6b, 0xb8, 0xa2, 0x99, 0x55, 0x5c, 0xd1,
+		0x8d, 0x5d, 0x33, 0x9f, 0xa1, 0x0c, 0xa6, 0x5b, 0x3b, 0x42, 0x11, 0x17, 0xcc, 0x2a, 0x5e, 0x36,
+		0x76, 0x4d, 0x65, 0xd4, 0x09, 0x95, 0xd1, 0x31, 0x18, 0x74, 0x0e, 0x0c, 0x57, 0xbd, 0x96, 0xcf,
+		0x52, 0x0b, 0xe1, 0x25, 0xf9, 0x37, 0x06, 0x61, 0xac, 0x17, 0x13, 0x3b, 0x0f, 0x03, 0xbb, 0xa4,
+		0x97, 0xf9, 0x44, 0x3f, 0x3a, 0x60, 0x34, 0x61, 0x25, 0x0e, 0x1e, 0x52, 0x89, 0xf3, 0x30, 0x6c,
+		0x60, 0xc7, 0xc5, 0x55, 0x66, 0x11, 0xc9, 0x1e, 0x6d, 0x0a, 0x18, 0x51, 0xab, 0x49, 0xa5, 0x0e,
+		0x65, 0x52, 0x2f, 0xc0, 0x98, 0x27, 0x52, 0xc5, 0x56, 0x8d, 0x9a, 0xb0, 0xcd, 0xb9, 0x38, 0x49,
+		0x66, 0xcb, 0x82, 0x4e, 0x21, 0x64, 0xca, 0x28, 0x0e, 0x95, 0xd1, 0x22, 0x80, 0x69, 0x60, 0x73,
+		0xb7, 0x52, 0xc5, 0x5a, 0x3d, 0x9f, 0xee, 0xa0, 0xa5, 0x75, 0x82, 0xd2, 0xa2, 0x25, 0x93, 0x41,
+		0xb5, 0x3a, 0x7a, 0xca, 0x37, 0xb5, 0xa1, 0x0e, 0x96, 0xb2, 0xca, 0x26, 0x59, 0x8b, 0xb5, 0x6d,
+		0xc3, 0xa8, 0x8d, 0x89, 0xdd, 0xe3, 0x2a, 0xef, 0x59, 0x86, 0x0a, 0x31, 0x1b, 0xdb, 0x33, 0x85,
+		0x93, 0xb1, 0x8e, 0x8d, 0xd8, 0xc1, 0x22, 0xba, 0x1b, 0x3c, 0x40, 0x85, 0x9a, 0x15, 0x50, 0x2f,
+		0x94, 0x15, 0xc0, 0x35, 0xb5, 0x81, 0x0b, 0x2f, 0xc3, 0x68, 0x58, 0x3d, 0x68, 0x12, 0x06, 0x1c,
+		0x57, 0xb5, 0x5d, 0x6a, 0x85, 0x03, 0x0a, 0x2b, 0xa0, 0x1c, 0x24, 0xb1, 0x51, 0xa5, 0x5e, 0x6e,
+		0x40, 0x21, 0x3f, 0xd1, 0x4f, 0xf8, 0x1d, 0x4e, 0xd2, 0x0e, 0xdf, 0xd7, 0x3a, 0xa2, 0x21, 0xce,
+		0xd1, 0x7e, 0x17, 0x9e, 0x80, 0x91, 0x50, 0x07, 0x7a, 0x6d, 0x5a, 0x7e, 0x27, 0x1c, 0x6d, 0xcb,
+		0x1a, 0xbd, 0x00, 0x93, 0x4d, 0x43, 0x37, 0x5c, 0x6c, 0x5b, 0x36, 0x26, 0x16, 0xcb, 0x9a, 0xca,
+		0xff, 0xe7, 0xa1, 0x0e, 0x36, 0xb7, 0x1d, 0xc4, 0x66, 0x5c, 0x94, 0x89, 0x66, 0x2b, 0xf0, 0x74,
+		0x26, 0xfd, 0xc6, 0x50, 0xee, 0x95, 0x57, 0x5e, 0x79, 0x25, 0x21, 0x7f, 0x79, 0x10, 0x26, 0xdb,
+		0xcd, 0x99, 0xb6, 0xd3, 0xf7, 0x18, 0x0c, 0x1a, 0xcd, 0xc6, 0x0e, 0xb6, 0xa9, 0x92, 0x06, 0x14,
+		0x5e, 0x42, 0xf3, 0x30, 0x50, 0x57, 0x77, 0x70, 0x3d, 0x9f, 0x9a, 0x91, 0x4e, 0x8d, 0x9e, 0x79,
+		0xb0, 0xa7, 0x59, 0x39, 0xbb, 0x42, 0x48, 0x14, 0x46, 0x89, 0x9e, 0x86, 0x14, 0x77, 0xd1, 0x84,
+		0xc3, 0xe9, 0xde, 0x38, 0x90, 0xb9, 0xa4, 0x50, 0x3a, 0x74, 0x07, 0x64, 0xc8, 0x5f, 0x66, 0x1b,
+		0x83, 0x54, 0xe6, 0x34, 0x01, 0x10, 0xbb, 0x40, 0x05, 0x48, 0xd3, 0x69, 0x52, 0xc5, 0x22, 0xb4,
+		0x79, 0x65, 0x62, 0x58, 0x55, 0xbc, 0xab, 0x36, 0xeb, 0x6e, 0xe5, 0x8a, 0x5a, 0x6f, 0x62, 0x6a,
+		0xf0, 0x19, 0x25, 0xcb, 0x81, 0x97, 0x09, 0x0c, 0x4d, 0xc3, 0x30, 0x9b, 0x55, 0xba, 0x51, 0xc5,
+		0xd7, 0xa8, 0xf7, 0x1c, 0x50, 0xd8, 0x44, 0x5b, 0x26, 0x10, 0xd2, 0xfc, 0x8b, 0x8e, 0x69, 0x08,
+		0xd3, 0xa4, 0x4d, 0x10, 0x00, 0x6d, 0xfe, 0x89, 0xa8, 0xe3, 0xbe, 0xb3, 0x7d, 0xf7, 0x5a, 0xe6,
+		0xd2, 0xfd, 0x30, 0x46, 0x31, 0x1e, 0xe3, 0x43, 0xaf, 0xd6, 0xf3, 0xe3, 0x33, 0xd2, 0xa9, 0xb4,
+		0x32, 0xca, 0xc0, 0xeb, 0x1c, 0x2a, 0x7f, 0x31, 0x01, 0x29, 0xea, 0x58, 0xc6, 0x60, 0x78, 0xeb,
+		0x2d, 0x1b, 0xe5, 0xca, 0xe2, 0xfa, 0x76, 0x69, 0xa5, 0x9c, 0x93, 0xd0, 0x28, 0x00, 0x05, 0x5c,
+		0x58, 0x59, 0x9f, 0xdf, 0xca, 0x25, 0xbc, 0xf2, 0xf2, 0xda, 0xd6, 0xb9, 0xc7, 0x73, 0x49, 0x8f,
+		0x60, 0x9b, 0x01, 0x52, 0x41, 0x84, 0xc7, 0xce, 0xe4, 0x06, 0x50, 0x0e, 0xb2, 0x8c, 0xc1, 0xf2,
+		0x0b, 0xe5, 0xc5, 0x73, 0x8f, 0xe7, 0x06, 0xc3, 0x90, 0xc7, 0xce, 0xe4, 0x86, 0xd0, 0x08, 0x64,
+		0x28, 0xa4, 0xb4, 0xbe, 0xbe, 0x92, 0x4b, 0x7b, 0x3c, 0x37, 0xb7, 0x94, 0xe5, 0xb5, 0xa5, 0x5c,
+		0xc6, 0xe3, 0xb9, 0xa4, 0xac, 0x6f, 0x6f, 0xe4, 0xc0, 0xe3, 0xb0, 0x5a, 0xde, 0xdc, 0x9c, 0x5f,
+		0x2a, 0xe7, 0x86, 0x3d, 0x8c, 0xd2, 0x5b, 0xb6, 0xca, 0x9b, 0xb9, 0x6c, 0x48, 0xac, 0xc7, 0xce,
+		0xe4, 0x46, 0xbc, 0x26, 0xca, 0x6b, 0xdb, 0xab, 0xb9, 0x51, 0x34, 0x0e, 0x23, 0xac, 0x09, 0x21,
+		0xc4, 0x58, 0x04, 0x74, 0xee, 0xf1, 0x5c, 0xce, 0x17, 0x84, 0x71, 0x19, 0x0f, 0x01, 0xce, 0x3d,
+		0x9e, 0x43, 0xf2, 0x02, 0x0c, 0x50, 0x33, 0x44, 0x08, 0x46, 0x57, 0xe6, 0x4b, 0xe5, 0x95, 0xca,
+		0xfa, 0xc6, 0xd6, 0xf2, 0xfa, 0xda, 0xfc, 0x4a, 0x4e, 0xf2, 0x61, 0x4a, 0xf9, 0xb9, 0xed, 0x65,
+		0xa5, 0xbc, 0x98, 0x4b, 0x04, 0x61, 0x1b, 0xe5, 0xf9, 0xad, 0xf2, 0x62, 0x2e, 0x29, 0x6b, 0x30,
+		0xd9, 0xce, 0xa1, 0xb6, 0x9d, 0x42, 0x01, 0x5b, 0x48, 0x74, 0xb0, 0x05, 0xca, 0x2b, 0x6a, 0x0b,
+		0xf2, 0x37, 0x13, 0x30, 0xd1, 0x26, 0xa8, 0xb4, 0x6d, 0xe4, 0x19, 0x18, 0x60, 0xb6, 0xcc, 0xc2,
+		0xec, 0x03, 0x6d, 0xa3, 0x13, 0xb5, 0xec, 0x96, 0x50, 0x4b, 0xe9, 0x82, 0xa9, 0x46, 0xb2, 0x43,
+		0xaa, 0x41, 0x58, 0xb4, 0x18, 0xec, 0x4f, 0xb6, 0x38, 0x7f, 0x16, 0x1f, 0xcf, 0xf5, 0x12, 0x1f,
+		0x29, 0xac, 0xbf, 0x20, 0x30, 0xd0, 0x26, 0x08, 0x9c, 0x87, 0xf1, 0x16, 0x46, 0x3d, 0x3b, 0xe3,
+		0xf7, 0x48, 0x90, 0xef, 0xa4, 0x9c, 0x18, 0x97, 0x98, 0x08, 0xb9, 0xc4, 0xf3, 0x51, 0x0d, 0xde,
+		0xd5, 0x79, 0x10, 0x5a, 0xc6, 0xfa, 0x33, 0x12, 0x1c, 0x6b, 0x9f, 0x52, 0xb6, 0x95, 0xe1, 0x69,
+		0x18, 0x6c, 0x60, 0x77, 0xcf, 0x14, 0x69, 0xd5, 0x7d, 0x6d, 0x82, 0x35, 0xa9, 0x8e, 0x0e, 0x36,
+		0xa7, 0x0a, 0x46, 0xfb, 0x64, 0xa7, 0xbc, 0x90, 0x49, 0xd3, 0x22, 0xe9, 0x07, 0x12, 0x70, 0xb4,
+		0x2d, 0xf3, 0xb6, 0x82, 0xde, 0x09, 0xa0, 0x1b, 0x56, 0xd3, 0x65, 0xa9, 0x13, 0xf3, 0xc4, 0x19,
+		0x0a, 0xa1, 0xce, 0x8b, 0x78, 0xd9, 0xa6, 0xeb, 0xd5, 0x27, 0x69, 0x3d, 0x30, 0x10, 0x45, 0x78,
+		0xd2, 0x17, 0x34, 0x45, 0x05, 0x9d, 0xea, 0xd0, 0xd3, 0x16, 0xc3, 0x7c, 0x04, 0x72, 0x5a, 0x5d,
+		0xc7, 0x86, 0x5b, 0x71, 0x5c, 0x1b, 0xab, 0x0d, 0xdd, 0xa8, 0xd1, 0x50, 0x93, 0x2e, 0x0e, 0xec,
+		0xaa, 0x75, 0x07, 0x2b, 0x63, 0xac, 0x7a, 0x53, 0xd4, 0x12, 0x0a, 0x6a, 0x40, 0x76, 0x80, 0x62,
+		0x30, 0x44, 0xc1, 0xaa, 0x3d, 0x0a, 0xf9, 0xc3, 0x19, 0x18, 0x0e, 0x24, 0xe0, 0xe8, 0x2e, 0xc8,
+		0xbe, 0xa8, 0x5e, 0x51, 0x2b, 0x62, 0x51, 0xc5, 0x34, 0x31, 0x4c, 0x60, 0x1b, 0x7c, 0x61, 0xf5,
+		0x08, 0x4c, 0x52, 0x14, 0xb3, 0xe9, 0x62, 0xbb, 0xa2, 0xd5, 0x55, 0xc7, 0xa1, 0x4a, 0x4b, 0x53,
+		0x54, 0x44, 0xea, 0xd6, 0x49, 0xd5, 0x82, 0xa8, 0x41, 0x67, 0x61, 0x82, 0x52, 0x34, 0x9a, 0x75,
+		0x57, 0xb7, 0xea, 0xb8, 0x42, 0x96, 0x79, 0x0e, 0x0d, 0x39, 0x9e, 0x64, 0xe3, 0x04, 0x63, 0x95,
+		0x23, 0x10, 0x89, 0x1c, 0xb4, 0x08, 0x77, 0x52, 0xb2, 0x1a, 0x36, 0xb0, 0xad, 0xba, 0xb8, 0x82,
+		0x5f, 0x6a, 0xaa, 0x75, 0xa7, 0xa2, 0x1a, 0xd5, 0xca, 0x9e, 0xea, 0xec, 0xe5, 0x27, 0x09, 0x83,
+		0x52, 0x22, 0x2f, 0x29, 0x27, 0x08, 0xe2, 0x12, 0xc7, 0x2b, 0x53, 0xb4, 0x79, 0xa3, 0x7a, 0x51,
+		0x75, 0xf6, 0x50, 0x11, 0x8e, 0x51, 0x2e, 0x8e, 0x6b, 0xeb, 0x46, 0xad, 0xa2, 0xed, 0x61, 0x6d,
+		0xbf, 0xd2, 0x74, 0x77, 0x9f, 0xcc, 0xdf, 0x11, 0x6c, 0x9f, 0x4a, 0xb8, 0x49, 0x71, 0x16, 0x08,
+		0xca, 0xb6, 0xbb, 0xfb, 0x24, 0xda, 0x84, 0x2c, 0x19, 0x8c, 0x86, 0xfe, 0x32, 0xae, 0xec, 0x9a,
+		0x36, 0x8d, 0xa1, 0xa3, 0x6d, 0x5c, 0x53, 0x40, 0x83, 0xb3, 0xeb, 0x9c, 0x60, 0xd5, 0xac, 0xe2,
+		0xe2, 0xc0, 0xe6, 0x46, 0xb9, 0xbc, 0xa8, 0x0c, 0x0b, 0x2e, 0x17, 0x4c, 0x9b, 0x18, 0x54, 0xcd,
+		0xf4, 0x14, 0x3c, 0xcc, 0x0c, 0xaa, 0x66, 0x0a, 0xf5, 0x9e, 0x85, 0x09, 0x4d, 0x63, 0x7d, 0xd6,
+		0xb5, 0x0a, 0x5f, 0x8c, 0x39, 0xf9, 0x5c, 0x48, 0x59, 0x9a, 0xb6, 0xc4, 0x10, 0xb8, 0x8d, 0x3b,
+		0xe8, 0x29, 0x38, 0xea, 0x2b, 0x2b, 0x48, 0x38, 0xde, 0xd2, 0xcb, 0x28, 0xe9, 0x59, 0x98, 0xb0,
+		0x0e, 0x5a, 0x09, 0x51, 0xa8, 0x45, 0xeb, 0x20, 0x4a, 0xf6, 0x04, 0x4c, 0x5a, 0x7b, 0x56, 0x2b,
+		0xdd, 0xe9, 0x20, 0x1d, 0xb2, 0xf6, 0xac, 0x28, 0xe1, 0xbd, 0x74, 0x65, 0x6e, 0x63, 0x4d, 0x75,
+		0x71, 0x35, 0x7f, 0x3c, 0x88, 0x1e, 0xa8, 0x40, 0xb3, 0x90, 0xd3, 0xb4, 0x0a, 0x36, 0xd4, 0x9d,
+		0x3a, 0xae, 0xa8, 0x36, 0x36, 0x54, 0x27, 0x3f, 0x4d, 0x91, 0x53, 0xae, 0xdd, 0xc4, 0xca, 0xa8,
+		0xa6, 0x95, 0x69, 0xe5, 0x3c, 0xad, 0x43, 0xa7, 0x61, 0xdc, 0xdc, 0x79, 0x51, 0x63, 0x16, 0x59,
+		0xb1, 0x6c, 0xbc, 0xab, 0x5f, 0xcb, 0xdf, 0x43, 0xd5, 0x3b, 0x46, 0x2a, 0xa8, 0x3d, 0x6e, 0x50,
+		0x30, 0x7a, 0x00, 0x72, 0x9a, 0xb3, 0xa7, 0xda, 0x16, 0x75, 0xc9, 0x8e, 0xa5, 0x6a, 0x38, 0x7f,
+		0x2f, 0x43, 0x65, 0xf0, 0x35, 0x01, 0x26, 0x33, 0xc2, 0xb9, 0xaa, 0xef, 0xba, 0x82, 0xe3, 0xfd,
+		0x6c, 0x46, 0x50, 0x18, 0xe7, 0x76, 0x0a, 0x72, 0x44, 0x13, 0xa1, 0x86, 0x4f, 0x51, 0xb4, 0x51,
+		0x6b, 0xcf, 0x0a, 0xb6, 0x7b, 0x37, 0x8c, 0x10, 0x4c, 0xbf, 0xd1, 0x07, 0x58, 0xe2, 0x66, 0xed,
+		0x05, 0x5a, 0x7c, 0x1c, 0x8e, 0x11, 0xa4, 0x06, 0x76, 0xd5, 0xaa, 0xea, 0xaa, 0x01, 0xec, 0x87,
+		0x28, 0x36, 0x51, 0xfb, 0x2a, 0xaf, 0x0c, 0xc9, 0x69, 0x37, 0x77, 0x0e, 0x3c, 0xc3, 0x7a, 0x98,
+		0xc9, 0x49, 0x60, 0xc2, 0xb4, 0x6e, 0x5b, 0x72, 0x2e, 0x17, 0x21, 0x1b, 0xb4, 0x7b, 0x94, 0x01,
+		0x66, 0xf9, 0x39, 0x89, 0x24, 0x41, 0x0b, 0xeb, 0x8b, 0x24, 0x7d, 0x79, 0x6b, 0x39, 0x97, 0x20,
+		0x69, 0xd4, 0xca, 0xf2, 0x56, 0xb9, 0xa2, 0x6c, 0xaf, 0x6d, 0x2d, 0xaf, 0x96, 0x73, 0xc9, 0x40,
+		0x62, 0xff, 0x6c, 0x2a, 0x7d, 0x5f, 0xee, 0x7e, 0xf9, 0x1b, 0x09, 0x18, 0x0d, 0xaf, 0xd4, 0xd0,
+		0x9b, 0xe0, 0xb8, 0xd8, 0x56, 0x71, 0xb0, 0x5b, 0xb9, 0xaa, 0xdb, 0x74, 0x42, 0x36, 0x54, 0x16,
+		0x1c, 0x3d, 0xfb, 0x99, 0xe4, 0x58, 0x9b, 0xd8, 0x7d, 0x5e, 0xb7, 0xc9, 0x74, 0x6b, 0xa8, 0x2e,
+		0x5a, 0x81, 0x69, 0xc3, 0xac, 0x38, 0xae, 0x6a, 0x54, 0x55, 0xbb, 0x5a, 0xf1, 0x37, 0xb4, 0x2a,
+		0xaa, 0xa6, 0x61, 0xc7, 0x31, 0x59, 0x20, 0xf4, 0xb8, 0x9c, 0x34, 0xcc, 0x4d, 0x8e, 0xec, 0x47,
+		0x88, 0x79, 0x8e, 0x1a, 0x31, 0xdf, 0x64, 0x27, 0xf3, 0xbd, 0x03, 0x32, 0x0d, 0xd5, 0xaa, 0x60,
+		0xc3, 0xb5, 0x0f, 0x68, 0x7e, 0x9e, 0x56, 0xd2, 0x0d, 0xd5, 0x2a, 0x93, 0xf2, 0x0f, 0x65, 0x99,
+		0xf4, 0x6c, 0x2a, 0x9d, 0xce, 0x65, 0x9e, 0x4d, 0xa5, 0x33, 0x39, 0x90, 0x5f, 0x4f, 0x42, 0x36,
+		0x98, 0xaf, 0x93, 0xe5, 0x8f, 0x46, 0x23, 0x96, 0x44, 0x7d, 0xda, 0xdd, 0x5d, 0xb3, 0xfb, 0xd9,
+		0x05, 0x12, 0xca, 0x8a, 0x83, 0x2c, 0x39, 0x56, 0x18, 0x25, 0x49, 0x23, 0x88, 0xb1, 0x61, 0x96,
+		0x8c, 0xa4, 0x15, 0x5e, 0x42, 0x4b, 0x30, 0xf8, 0xa2, 0x43, 0x79, 0x0f, 0x52, 0xde, 0xf7, 0x74,
+		0xe7, 0xfd, 0xec, 0x26, 0x65, 0x9e, 0x79, 0x76, 0xb3, 0xb2, 0xb6, 0xae, 0xac, 0xce, 0xaf, 0x28,
+		0x9c, 0x1c, 0x9d, 0x80, 0x54, 0x5d, 0x7d, 0xf9, 0x20, 0x1c, 0xf4, 0x28, 0xa8, 0xd7, 0x41, 0x38,
+		0x01, 0xa9, 0xab, 0x58, 0xdd, 0x0f, 0x87, 0x1a, 0x0a, 0xba, 0x8d, 0x93, 0x61, 0x0e, 0x06, 0xa8,
+		0xbe, 0x10, 0x00, 0xd7, 0x58, 0xee, 0x08, 0x4a, 0x43, 0x6a, 0x61, 0x5d, 0x21, 0x13, 0x22, 0x07,
+		0x59, 0x06, 0xad, 0x6c, 0x2c, 0x97, 0x17, 0xca, 0xb9, 0x84, 0x7c, 0x16, 0x06, 0x99, 0x12, 0xc8,
+		0x64, 0xf1, 0xd4, 0x90, 0x3b, 0xc2, 0x8b, 0x9c, 0x87, 0x24, 0x6a, 0xb7, 0x57, 0x4b, 0x65, 0x25,
+		0x97, 0x08, 0x0f, 0x75, 0x2a, 0x37, 0x20, 0x3b, 0x90, 0x0d, 0xe6, 0xe1, 0x3f, 0x9c, 0xc5, 0xf8,
+		0x97, 0x24, 0x18, 0x0e, 0xe4, 0xd5, 0x24, 0x21, 0x52, 0xeb, 0x75, 0xf3, 0x6a, 0x45, 0xad, 0xeb,
+		0xaa, 0xc3, 0x4d, 0x03, 0x28, 0x68, 0x9e, 0x40, 0x7a, 0x1d, 0xba, 0x1f, 0xd2, 0x14, 0x19, 0xc8,
+		0x0d, 0xca, 0x9f, 0x90, 0x20, 0x17, 0x4d, 0x6c, 0x23, 0x62, 0x4a, 0x3f, 0x4a, 0x31, 0xe5, 0x8f,
+		0x4b, 0x30, 0x1a, 0xce, 0x66, 0x23, 0xe2, 0xdd, 0xf5, 0x23, 0x15, 0xef, 0x0f, 0x12, 0x30, 0x12,
+		0xca, 0x61, 0x7b, 0x95, 0xee, 0x25, 0x18, 0xd7, 0xab, 0xb8, 0x61, 0x99, 0x2e, 0x36, 0xb4, 0x83,
+		0x4a, 0x1d, 0x5f, 0xc1, 0xf5, 0xbc, 0x4c, 0x9d, 0xc6, 0x5c, 0xf7, 0x2c, 0x79, 0x76, 0xd9, 0xa7,
+		0x5b, 0x21, 0x64, 0xc5, 0x89, 0xe5, 0xc5, 0xf2, 0xea, 0xc6, 0xfa, 0x56, 0x79, 0x6d, 0xe1, 0x2d,
+		0x95, 0xed, 0xb5, 0x4b, 0x6b, 0xeb, 0xcf, 0xaf, 0x29, 0x39, 0x3d, 0x82, 0x76, 0x1b, 0xa7, 0xfd,
+		0x06, 0xe4, 0xa2, 0x42, 0xa1, 0xe3, 0xd0, 0x4e, 0xac, 0xdc, 0x11, 0x34, 0x01, 0x63, 0x6b, 0xeb,
+		0x95, 0xcd, 0xe5, 0xc5, 0x72, 0xa5, 0x7c, 0xe1, 0x42, 0x79, 0x61, 0x6b, 0x93, 0xed, 0x7b, 0x78,
+		0xd8, 0x5b, 0xa1, 0x09, 0x2e, 0xbf, 0x96, 0x84, 0x89, 0x36, 0x92, 0xa0, 0x79, 0xbe, 0x62, 0x61,
+		0x8b, 0xa8, 0x87, 0x7b, 0x91, 0x7e, 0x96, 0xe4, 0x0c, 0x1b, 0xaa, 0xed, 0xf2, 0x05, 0xce, 0x03,
+		0x40, 0xb4, 0x64, 0xb8, 0xfa, 0xae, 0x8e, 0x6d, 0xbe, 0x9f, 0xc4, 0x96, 0x31, 0x63, 0x3e, 0x9c,
+		0x6d, 0x29, 0x3d, 0x04, 0xc8, 0x32, 0x1d, 0xdd, 0xd5, 0xaf, 0xe0, 0x8a, 0x6e, 0x88, 0xcd, 0x27,
+		0xb2, 0xac, 0x49, 0x29, 0x39, 0x51, 0xb3, 0x6c, 0xb8, 0x1e, 0xb6, 0x81, 0x6b, 0x6a, 0x04, 0x9b,
+		0x38, 0xf3, 0xa4, 0x92, 0x13, 0x35, 0x1e, 0xf6, 0x5d, 0x90, 0xad, 0x9a, 0x4d, 0x92, 0xeb, 0x31,
+		0x3c, 0x12, 0x3b, 0x24, 0x65, 0x98, 0xc1, 0x3c, 0x14, 0x9e, 0xc5, 0xfb, 0xbb, 0x5e, 0x59, 0x65,
+		0x98, 0xc1, 0x18, 0xca, 0xfd, 0x30, 0xa6, 0xd6, 0x6a, 0x36, 0x61, 0x2e, 0x18, 0xb1, 0x75, 0xc9,
+		0xa8, 0x07, 0xa6, 0x88, 0x85, 0x67, 0x21, 0x2d, 0xf4, 0x40, 0x42, 0x35, 0xd1, 0x44, 0xc5, 0x62,
+		0x8b, 0xed, 0xc4, 0xa9, 0x8c, 0x92, 0x36, 0x44, 0xe5, 0x5d, 0x90, 0xd5, 0x9d, 0x8a, 0xbf, 0x89,
+		0x9f, 0x98, 0x49, 0x9c, 0x4a, 0x2b, 0xc3, 0xba, 0xe3, 0x6d, 0x80, 0xca, 0x9f, 0x49, 0xc0, 0x68,
+		0xf8, 0x10, 0x02, 0x2d, 0x42, 0xba, 0x6e, 0x6a, 0x2a, 0x35, 0x2d, 0x76, 0x02, 0x76, 0x2a, 0xe6,
+		0xdc, 0x62, 0x76, 0x85, 0xe3, 0x2b, 0x1e, 0x65, 0xe1, 0xb7, 0x25, 0x48, 0x0b, 0x30, 0x3a, 0x06,
+		0x29, 0x4b, 0x75, 0xf7, 0x28, 0xbb, 0x81, 0x52, 0x22, 0x27, 0x29, 0xb4, 0x4c, 0xe0, 0x8e, 0xa5,
+		0x1a, 0xd4, 0x04, 0x38, 0x9c, 0x94, 0xc9, 0xb8, 0xd6, 0xb1, 0x5a, 0xa5, 0x8b, 0x1e, 0xb3, 0xd1,
+		0xc0, 0x86, 0xeb, 0x88, 0x71, 0xe5, 0xf0, 0x05, 0x0e, 0x46, 0x0f, 0xc2, 0xb8, 0x6b, 0xab, 0x7a,
+		0x3d, 0x84, 0x9b, 0xa2, 0xb8, 0x39, 0x51, 0xe1, 0x21, 0x17, 0xe1, 0x84, 0xe0, 0x5b, 0xc5, 0xae,
+		0xaa, 0xed, 0xe1, 0xaa, 0x4f, 0x34, 0x48, 0x37, 0x37, 0x8e, 0x73, 0x84, 0x45, 0x5e, 0x2f, 0x68,
+		0xe5, 0x6f, 0x48, 0x30, 0x2e, 0x96, 0x69, 0x55, 0x4f, 0x59, 0xab, 0x00, 0xaa, 0x61, 0x98, 0x6e,
+		0x50, 0x5d, 0xad, 0xa6, 0xdc, 0x42, 0x37, 0x3b, 0xef, 0x11, 0x29, 0x01, 0x06, 0x85, 0x06, 0x80,
+		0x5f, 0xd3, 0x51, 0x6d, 0xd3, 0x30, 0xcc, 0x4f, 0x98, 0xe8, 0x31, 0x25, 0x5b, 0xd8, 0x03, 0x03,
+		0x91, 0xf5, 0x1c, 0x9a, 0x84, 0x81, 0x1d, 0x5c, 0xd3, 0x0d, 0xbe, 0x6f, 0xcc, 0x0a, 0x62, 0xfb,
+		0x25, 0xe5, 0x6d, 0xbf, 0x94, 0x3e, 0x28, 0xc1, 0x84, 0x66, 0x36, 0xa2, 0xf2, 0x96, 0x72, 0x91,
+		0xdd, 0x05, 0xe7, 0xa2, 0xf4, 0xd6, 0xa7, 0x6b, 0xba, 0xbb, 0xd7, 0xdc, 0x99, 0xd5, 0xcc, 0xc6,
+		0x5c, 0xcd, 0xac, 0xab, 0x46, 0xcd, 0x3f, 0x67, 0xa5, 0x3f, 0xb4, 0x87, 0x6b, 0xd8, 0x78, 0xb8,
+		0x66, 0x06, 0x4e, 0x5d, 0xcf, 0xfb, 0x3f, 0xff, 0x4c, 0x92, 0x7e, 0x21, 0x91, 0x5c, 0xda, 0x28,
+		0x7d, 0x36, 0x51, 0x58, 0x62, 0xcd, 0x6d, 0x08, 0xf5, 0x28, 0x78, 0xb7, 0x8e, 0x35, 0xd2, 0x65,
+		0xf8, 0xf6, 0x83, 0x30, 0x59, 0x33, 0x6b, 0x26, 0xe5, 0x38, 0x47, 0x7e, 0xf1, 0x93, 0xdb, 0x8c,
+		0x07, 0x2d, 0xc4, 0x1e, 0xf3, 0x16, 0xd7, 0x60, 0x82, 0x23, 0x57, 0xe8, 0xd1, 0x11, 0x5b, 0xd8,
+		0xa0, 0xae, 0xbb, 0x6a, 0xf9, 0x5f, 0xfb, 0x16, 0x0d, 0xe8, 0xca, 0x38, 0x27, 0x25, 0x75, 0x6c,
+		0xed, 0x53, 0x54, 0xe0, 0x68, 0x88, 0x1f, 0x9b, 0xb6, 0xd8, 0x8e, 0xe1, 0xf8, 0x9b, 0x9c, 0xe3,
+		0x44, 0x80, 0xe3, 0x26, 0x27, 0x2d, 0x2e, 0xc0, 0x48, 0x3f, 0xbc, 0xfe, 0x25, 0xe7, 0x95, 0xc5,
+		0x41, 0x26, 0x4b, 0x30, 0x46, 0x99, 0x68, 0x4d, 0xc7, 0x35, 0x1b, 0xd4, 0x27, 0x76, 0x67, 0xf3,
+		0x5b, 0xdf, 0x62, 0xf3, 0x68, 0x94, 0x90, 0x2d, 0x78, 0x54, 0xc5, 0x22, 0xd0, 0xd3, 0xb2, 0x2a,
+		0xd6, 0xea, 0x31, 0x1c, 0xbe, 0xc2, 0x05, 0xf1, 0xf0, 0x8b, 0x97, 0x61, 0x92, 0xfc, 0xa6, 0x2e,
+		0x2b, 0x28, 0x49, 0xfc, 0x16, 0x5c, 0xfe, 0x1b, 0xef, 0x61, 0x53, 0x75, 0xc2, 0x63, 0x10, 0x90,
+		0x29, 0x30, 0x8a, 0x35, 0xec, 0xba, 0xd8, 0x76, 0x2a, 0x6a, 0xbd, 0x9d, 0x78, 0x81, 0x3d, 0x8c,
+		0xfc, 0xc7, 0xbe, 0x13, 0x1e, 0xc5, 0x25, 0x46, 0x39, 0x5f, 0xaf, 0x17, 0xb7, 0xe1, 0x78, 0x1b,
+		0xab, 0xe8, 0x81, 0xe7, 0x6b, 0x9c, 0xe7, 0x64, 0x8b, 0x65, 0x10, 0xb6, 0x1b, 0x20, 0xe0, 0xde,
+		0x58, 0xf6, 0xc0, 0xf3, 0xe7, 0x39, 0x4f, 0xc4, 0x69, 0xc5, 0x90, 0x12, 0x8e, 0xcf, 0xc2, 0xf8,
+		0x15, 0x6c, 0xef, 0x98, 0x0e, 0xdf, 0x37, 0xea, 0x81, 0xdd, 0xc7, 0x39, 0xbb, 0x31, 0x4e, 0x48,
+		0x37, 0x92, 0x08, 0xaf, 0xa7, 0x20, 0xbd, 0xab, 0x6a, 0xb8, 0x07, 0x16, 0xd7, 0x39, 0x8b, 0x21,
+		0x82, 0x4f, 0x48, 0xe7, 0x21, 0x5b, 0x33, 0x79, 0xd4, 0x8a, 0x27, 0xff, 0x04, 0x27, 0x1f, 0x16,
+		0x34, 0x9c, 0x85, 0x65, 0x5a, 0xcd, 0x3a, 0x09, 0x69, 0xf1, 0x2c, 0xfe, 0xa6, 0x60, 0x21, 0x68,
+		0x38, 0x8b, 0x3e, 0xd4, 0xfa, 0x49, 0xc1, 0xc2, 0x09, 0xe8, 0xf3, 0x19, 0x18, 0x36, 0x8d, 0xfa,
+		0x81, 0x69, 0xf4, 0x22, 0xc4, 0xa7, 0x38, 0x07, 0xe0, 0x24, 0x84, 0xc1, 0x79, 0xc8, 0xf4, 0x3a,
+		0x10, 0x7f, 0xeb, 0x3b, 0x62, 0x7a, 0x88, 0x11, 0x58, 0x82, 0x31, 0xe1, 0xa0, 0x74, 0xd3, 0xe8,
+		0x81, 0xc5, 0xdf, 0xe6, 0x2c, 0x46, 0x03, 0x64, 0xbc, 0x1b, 0x2e, 0x76, 0xdc, 0x1a, 0xee, 0x85,
+		0xc9, 0x67, 0x44, 0x37, 0x38, 0x09, 0x57, 0xe5, 0x0e, 0x36, 0xb4, 0xbd, 0xde, 0x38, 0xfc, 0x92,
+		0x50, 0xa5, 0xa0, 0x21, 0x2c, 0x16, 0x60, 0xa4, 0xa1, 0xda, 0xce, 0x9e, 0x5a, 0xef, 0x69, 0x38,
+		0xfe, 0x0e, 0xe7, 0x91, 0xf5, 0x88, 0xb8, 0x46, 0x9a, 0x46, 0x3f, 0x6c, 0x3e, 0x2b, 0x34, 0x12,
+		0x20, 0xe3, 0x53, 0xcf, 0x71, 0xe9, 0x26, 0x5b, 0x3f, 0xdc, 0x7e, 0x59, 0x4c, 0x3d, 0x46, 0xbb,
+		0x1a, 0xe4, 0x78, 0x1e, 0x32, 0x8e, 0xfe, 0x72, 0x4f, 0x6c, 0x3e, 0x27, 0x46, 0x9a, 0x12, 0x10,
+		0xe2, 0xb7, 0xc0, 0x89, 0xb6, 0x61, 0xa2, 0x07, 0x66, 0x7f, 0x97, 0x33, 0x3b, 0xd6, 0x26, 0x54,
+		0x70, 0x97, 0xd0, 0x2f, 0xcb, 0xbf, 0x27, 0x5c, 0x02, 0x8e, 0xf0, 0xda, 0x20, 0xeb, 0x08, 0x47,
+		0xdd, 0xed, 0x4f, 0x6b, 0xbf, 0x22, 0xb4, 0xc6, 0x68, 0x43, 0x5a, 0xdb, 0x82, 0x63, 0x9c, 0x63,
+		0x7f, 0xe3, 0xfa, 0xab, 0xc2, 0xb1, 0x32, 0xea, 0xed, 0xf0, 0xe8, 0xbe, 0x0d, 0x0a, 0x9e, 0x3a,
+		0x45, 0xc2, 0xea, 0x54, 0x1a, 0xaa, 0xd5, 0x03, 0xe7, 0x5f, 0xe3, 0x9c, 0x85, 0xc7, 0xf7, 0x32,
+		0x5e, 0x67, 0x55, 0xb5, 0x08, 0xf3, 0x17, 0x20, 0x2f, 0x98, 0x37, 0x0d, 0x1b, 0x6b, 0x66, 0xcd,
+		0xd0, 0x5f, 0xc6, 0xd5, 0x1e, 0x58, 0xff, 0x7a, 0x64, 0xa8, 0xb6, 0x03, 0xe4, 0x84, 0xf3, 0x32,
+		0xe4, 0xbc, 0x5c, 0xa5, 0xa2, 0x37, 0x2c, 0xd3, 0x76, 0x63, 0x38, 0x7e, 0x5e, 0x8c, 0x94, 0x47,
+		0xb7, 0x4c, 0xc9, 0x8a, 0x65, 0x60, 0x27, 0xcf, 0xbd, 0x9a, 0xe4, 0x17, 0x38, 0xa3, 0x11, 0x9f,
+		0x8a, 0x3b, 0x0e, 0xcd, 0x6c, 0x58, 0xaa, 0xdd, 0x8b, 0xff, 0xfb, 0xfb, 0xc2, 0x71, 0x70, 0x12,
+		0xee, 0x38, 0xdc, 0x03, 0x0b, 0x93, 0x68, 0xdf, 0x03, 0x87, 0x2f, 0x0a, 0xc7, 0x21, 0x68, 0x38,
+		0x0b, 0x91, 0x30, 0xf4, 0xc0, 0xe2, 0x1f, 0x08, 0x16, 0x82, 0x86, 0xb0, 0x78, 0xce, 0x0f, 0xb4,
+		0x36, 0xae, 0xe9, 0x8e, 0x6b, 0xb3, 0x34, 0xb9, 0x3b, 0xab, 0x7f, 0xf8, 0x9d, 0x70, 0x12, 0xa6,
+		0x04, 0x48, 0x89, 0x27, 0xe2, 0xdb, 0xae, 0x74, 0x15, 0x15, 0x2f, 0xd8, 0x6f, 0x08, 0x4f, 0x14,
+		0x20, 0x23, 0xb2, 0x05, 0x32, 0x44, 0xa2, 0x76, 0x8d, 0xac, 0x1d, 0x7a, 0x60, 0xf7, 0x8f, 0x22,
+		0xc2, 0x6d, 0x0a, 0x5a, 0xc2, 0x33, 0x90, 0xff, 0x34, 0x8d, 0x7d, 0x7c, 0xd0, 0x93, 0x75, 0xfe,
+		0xe3, 0x48, 0xfe, 0xb3, 0xcd, 0x28, 0x99, 0x0f, 0x19, 0x8b, 0xe4, 0x53, 0x28, 0xee, 0x9e, 0x51,
+		0xfe, 0xa7, 0xbe, 0xc7, 0xfb, 0x1b, 0x4e, 0xa7, 0x8a, 0x2b, 0xc4, 0xc8, 0xc3, 0x49, 0x4f, 0x3c,
+		0xb3, 0xf7, 0x7c, 0xcf, 0xb3, 0xf3, 0x50, 0xce, 0x53, 0xbc, 0x00, 0x23, 0xa1, 0x84, 0x27, 0x9e,
+		0xd5, 0x7b, 0x39, 0xab, 0x6c, 0x30, 0xdf, 0x29, 0x9e, 0x85, 0x14, 0x49, 0x5e, 0xe2, 0xc9, 0xff,
+		0x32, 0x27, 0xa7, 0xe8, 0xc5, 0x37, 0x43, 0x5a, 0x24, 0x2d, 0xf1, 0xa4, 0xef, 0xe3, 0xa4, 0x1e,
+		0x09, 0x21, 0x17, 0x09, 0x4b, 0x3c, 0xf9, 0x5f, 0x11, 0xe4, 0x82, 0x84, 0x90, 0xf7, 0xae, 0xc2,
+		0x2f, 0xfd, 0x74, 0x8a, 0x07, 0x1d, 0xa1, 0xbb, 0xf3, 0x30, 0xc4, 0x33, 0x95, 0x78, 0xea, 0x0f,
+		0xf0, 0xc6, 0x05, 0x45, 0xf1, 0x09, 0x18, 0xe8, 0x51, 0xe1, 0x3f, 0xc3, 0x49, 0x19, 0x7e, 0x71,
+		0x01, 0x86, 0x03, 0xd9, 0x49, 0x3c, 0xf9, 0x5f, 0xe3, 0xe4, 0x41, 0x2a, 0x22, 0x3a, 0xcf, 0x4e,
+		0xe2, 0x19, 0x7c, 0x50, 0x88, 0xce, 0x29, 0x88, 0xda, 0x44, 0x62, 0x12, 0x4f, 0xfd, 0x21, 0xa1,
+		0x75, 0x41, 0x52, 0x7c, 0x06, 0x32, 0x5e, 0xb0, 0x89, 0xa7, 0xff, 0x30, 0xa7, 0xf7, 0x69, 0x88,
+		0x06, 0x02, 0xc1, 0x2e, 0x9e, 0xc5, 0x5f, 0x17, 0x1a, 0x08, 0x50, 0x91, 0x69, 0x14, 0x4d, 0x60,
+		0xe2, 0x39, 0x7d, 0x44, 0x4c, 0xa3, 0x48, 0xfe, 0x42, 0x46, 0x93, 0xfa, 0xfc, 0x78, 0x16, 0x3f,
+		0x2b, 0x46, 0x93, 0xe2, 0x13, 0x31, 0xa2, 0x19, 0x41, 0x3c, 0x8f, 0xbf, 0x21, 0xc4, 0x88, 0x24,
+		0x04, 0xc5, 0x0d, 0x40, 0xad, 0xd9, 0x40, 0x3c, 0xbf, 0x8f, 0x72, 0x7e, 0xe3, 0x2d, 0xc9, 0x40,
+		0xf1, 0x79, 0x38, 0xd6, 0x3e, 0x13, 0x88, 0xe7, 0xfa, 0xb1, 0xef, 0x45, 0xd6, 0x6e, 0xc1, 0x44,
+		0xa0, 0xb8, 0xe5, 0x87, 0x94, 0x60, 0x16, 0x10, 0xcf, 0xf6, 0xb5, 0xef, 0x85, 0x1d, 0x77, 0x30,
+		0x09, 0x28, 0xce, 0x03, 0xf8, 0x01, 0x38, 0x9e, 0xd7, 0xc7, 0x39, 0xaf, 0x00, 0x11, 0x99, 0x1a,
+		0x3c, 0xfe, 0xc6, 0xd3, 0x5f, 0x17, 0x53, 0x83, 0x53, 0x90, 0xa9, 0x21, 0x42, 0x6f, 0x3c, 0xf5,
+		0x27, 0xc4, 0xd4, 0x10, 0x24, 0xc4, 0xb2, 0x03, 0xd1, 0x2d, 0x9e, 0xc3, 0xa7, 0x84, 0x65, 0x07,
+		0xa8, 0x8a, 0x6b, 0x30, 0xde, 0x12, 0x10, 0xe3, 0x59, 0xfd, 0x02, 0x67, 0x95, 0x8b, 0xc6, 0xc3,
+		0x60, 0xf0, 0xe2, 0xc1, 0x30, 0x9e, 0xdb, 0xa7, 0x23, 0xc1, 0x8b, 0xc7, 0xc2, 0xe2, 0x79, 0x48,
+		0x1b, 0xcd, 0x7a, 0x9d, 0x4c, 0x1e, 0xd4, 0xfd, 0x6e, 0x60, 0xfe, 0xbf, 0x7c, 0x9f, 0x6b, 0x47,
+		0x10, 0x14, 0xcf, 0xc2, 0x00, 0x6e, 0xec, 0xe0, 0x6a, 0x1c, 0xe5, 0xb7, 0xbf, 0x2f, 0x1c, 0x26,
+		0xc1, 0x2e, 0x3e, 0x03, 0xc0, 0xb6, 0x46, 0xe8, 0xf1, 0x60, 0x0c, 0xed, 0x7f, 0xfd, 0x3e, 0xbf,
+		0x8c, 0xe3, 0x93, 0xf8, 0x0c, 0xd8, 0xd5, 0x9e, 0xee, 0x0c, 0xbe, 0x13, 0x66, 0x40, 0x47, 0xe4,
+		0x29, 0x18, 0x7a, 0xd1, 0x31, 0x0d, 0x57, 0xad, 0xc5, 0x51, 0xff, 0x37, 0x4e, 0x2d, 0xf0, 0x89,
+		0xc2, 0x1a, 0xa6, 0x8d, 0x5d, 0xb5, 0xe6, 0xc4, 0xd1, 0xfe, 0x77, 0x4e, 0xeb, 0x11, 0x10, 0x62,
+		0x4d, 0x75, 0xdc, 0x5e, 0xfa, 0xfd, 0x47, 0x82, 0x58, 0x10, 0x10, 0xa1, 0xc9, 0xef, 0x7d, 0x7c,
+		0x10, 0x47, 0xfb, 0x5d, 0x21, 0x34, 0xc7, 0x2f, 0xbe, 0x19, 0x32, 0xe4, 0x27, 0xbb, 0x61, 0x17,
+		0x43, 0xfc, 0xc7, 0x9c, 0xd8, 0xa7, 0x20, 0x2d, 0x3b, 0x6e, 0xd5, 0xd5, 0xe3, 0x95, 0x7d, 0x93,
+		0x8f, 0xb4, 0xc0, 0x2f, 0xce, 0xc3, 0xb0, 0xe3, 0x56, 0xab, 0x4d, 0x9e, 0x9f, 0xc6, 0x90, 0xff,
+		0xc9, 0xf7, 0xbd, 0x2d, 0x0b, 0x8f, 0x86, 0x8c, 0xf6, 0xd5, 0x7d, 0xd7, 0x32, 0xe9, 0x11, 0x48,
+		0x1c, 0x87, 0xef, 0x71, 0x0e, 0x01, 0x92, 0xe2, 0x02, 0x64, 0x49, 0x5f, 0x6c, 0x6c, 0x61, 0x7a,
+		0x5e, 0x15, 0xc3, 0xe2, 0x4f, 0xb9, 0x02, 0x42, 0x44, 0xa5, 0x9f, 0xfc, 0xca, 0xeb, 0x53, 0xd2,
+		0xd7, 0x5f, 0x9f, 0x92, 0xfe, 0xe0, 0xf5, 0x29, 0xe9, 0x43, 0xdf, 0x9c, 0x3a, 0xf2, 0xf5, 0x6f,
+		0x4e, 0x1d, 0xf9, 0xdd, 0x6f, 0x4e, 0x1d, 0x69, 0xbf, 0x6d, 0x0c, 0x4b, 0xe6, 0x92, 0xc9, 0x36,
+		0x8c, 0xdf, 0x2a, 0x87, 0xb6, 0x8b, 0x6b, 0xa6, 0xbf, 0x5b, 0xeb, 0x2d, 0x72, 0xe0, 0x4f, 0x25,
+		0xb2, 0x60, 0x0e, 0xef, 0xe5, 0xaa, 0xc6, 0x41, 0x87, 0xb7, 0x3a, 0x85, 0xb6, 0x1b, 0xc3, 0xf2,
+		0x9b, 0x20, 0x39, 0x6f, 0x1c, 0xa0, 0x13, 0xcc, 0xe7, 0x55, 0x9a, 0x76, 0x9d, 0xdf, 0xfc, 0x1a,
+		0x22, 0xe5, 0x6d, 0xbb, 0x8e, 0x26, 0xfd, 0xeb, 0x99, 0xd2, 0xa9, 0x2c, 0xbf, 0x73, 0x59, 0x4c,
+		0x7d, 0xf7, 0x53, 0xd3, 0x47, 0x4a, 0xfb, 0xd1, 0x1e, 0x7e, 0x29, 0xb6, 0x97, 0xe9, 0x79, 0xe3,
+		0x80, 0x76, 0x72, 0x43, 0x7a, 0xeb, 0x00, 0x69, 0xc3, 0x11, 0x1b, 0xdb, 0x53, 0xd1, 0x8d, 0xed,
+		0xe7, 0x71, 0xbd, 0x7e, 0xc9, 0x30, 0xaf, 0x1a, 0x5b, 0x04, 0x6d, 0x67, 0x90, 0x5d, 0x23, 0x86,
+		0xbf, 0x9a, 0x80, 0xa9, 0x96, 0x3d, 0x6c, 0x3e, 0xf2, 0x9d, 0x1e, 0x2a, 0x15, 0x21, 0xbd, 0x28,
+		0x0c, 0x2a, 0x0f, 0x43, 0x0e, 0xd6, 0x4c, 0xa3, 0xea, 0xd0, 0xae, 0x26, 0x15, 0x51, 0x24, 0x5d,
+		0x35, 0x54, 0xc3, 0x74, 0xf8, 0xed, 0x48, 0x56, 0x28, 0xfd, 0xac, 0xd4, 0xdf, 0x38, 0x8e, 0x88,
+		0x96, 0x44, 0x37, 0x4f, 0x77, 0xdb, 0xfb, 0xa7, 0x2a, 0xf0, 0xe4, 0x0f, 0xec, 0xf3, 0xf7, 0xaa,
+		0x8e, 0x0f, 0x25, 0x60, 0x3a, 0xaa, 0x0e, 0x32, 0x8f, 0x1c, 0x57, 0x6d, 0x58, 0x9d, 0xf4, 0x71,
+		0x1e, 0x32, 0x5b, 0x02, 0xa7, 0x6f, 0x85, 0xfc, 0x5c, 0x9f, 0x0a, 0x19, 0xf5, 0x9a, 0x12, 0x1a,
+		0x79, 0x30, 0x5e, 0x23, 0x5e, 0x17, 0x0e, 0xa1, 0x92, 0x77, 0x27, 0xe1, 0x84, 0x66, 0x3a, 0x0d,
+		0xd3, 0xa9, 0x30, 0x83, 0x67, 0x05, 0xae, 0x8c, 0x6c, 0xb0, 0xaa, 0x87, 0xe3, 0x90, 0x8b, 0x30,
+		0x4a, 0x9d, 0x02, 0xdd, 0x08, 0xa6, 0x7e, 0x38, 0x36, 0x74, 0x7e, 0xf5, 0xdf, 0x0e, 0xd0, 0x49,
+		0x34, 0xe2, 0x11, 0xd2, 0x9b, 0x2e, 0x5b, 0x30, 0xa9, 0x37, 0xac, 0x3a, 0xa6, 0x47, 0x62, 0x15,
+		0xaf, 0x2e, 0x9e, 0xdf, 0xd7, 0x38, 0xbf, 0x09, 0x9f, 0x7c, 0x59, 0x50, 0x17, 0x57, 0x60, 0x5c,
+		0xd5, 0x34, 0x6c, 0x85, 0x58, 0xc6, 0x38, 0x2c, 0x21, 0x60, 0x8e, 0x53, 0x7a, 0xdc, 0x4a, 0xcf,
+		0x74, 0x1a, 0xdb, 0xb7, 0xde, 0x1b, 0x18, 0x34, 0x1b, 0xd7, 0xb0, 0xf1, 0xb0, 0x81, 0xdd, 0xab,
+		0xa6, 0xbd, 0xcf, 0xd5, 0xfb, 0x30, 0x6b, 0x4a, 0x0c, 0xc2, 0x7b, 0x93, 0x30, 0xc5, 0x2a, 0xe6,
+		0x76, 0x54, 0x07, 0xcf, 0x5d, 0x79, 0x74, 0x07, 0xbb, 0xea, 0xa3, 0x73, 0x9a, 0xa9, 0x8b, 0x69,
+		0x3a, 0xc1, 0xc7, 0x85, 0xd4, 0xcf, 0xf2, 0xfa, 0x0e, 0x7e, 0x6a, 0x09, 0x52, 0x0b, 0xa6, 0x6e,
+		0x10, 0x8b, 0xac, 0x62, 0xc3, 0x6c, 0x70, 0x2f, 0xc5, 0x0a, 0xe8, 0x6e, 0x18, 0x54, 0x1b, 0x66,
+		0xd3, 0x70, 0xd9, 0x69, 0x5e, 0x69, 0xf8, 0x2b, 0x37, 0xa6, 0x8f, 0xfc, 0xde, 0x8d, 0xe9, 0xe4,
+		0xb2, 0xe1, 0x2a, 0xbc, 0xaa, 0x98, 0x7a, 0xe3, 0x93, 0xd3, 0x92, 0xfc, 0x2c, 0x0c, 0x2d, 0x62,
+		0xed, 0x30, 0xbc, 0x16, 0xb1, 0x16, 0xe1, 0xf5, 0x00, 0xa4, 0x97, 0x0d, 0x97, 0xdd, 0x20, 0xbe,
+		0x13, 0x92, 0xba, 0xc1, 0x2e, 0xa5, 0x45, 0xda, 0x27, 0x70, 0x82, 0xba, 0x88, 0x35, 0x0f, 0xb5,
+		0x8a, 0xb5, 0x28, 0x2a, 0x61, 0x4f, 0xe0, 0xa5, 0xc5, 0xdf, 0xfd, 0x4f, 0x53, 0x47, 0x5e, 0x79,
+		0x7d, 0xea, 0x48, 0xc7, 0x91, 0x08, 0x46, 0x07, 0xae, 0x62, 0x3e, 0x04, 0x4e, 0x75, 0x7f, 0xce,
+		0x0d, 0xcd, 0x85, 0xcf, 0xa6, 0xe0, 0x4e, 0xfa, 0x78, 0xc4, 0x6e, 0xe8, 0x86, 0x3b, 0xa7, 0xd9,
+		0x07, 0x96, 0x4b, 0xc3, 0x89, 0xb9, 0xcb, 0x47, 0x61, 0xdc, 0xaf, 0x9e, 0x65, 0xd5, 0x1d, 0xc6,
+		0x60, 0x17, 0x06, 0x36, 0x08, 0x1d, 0x51, 0x9c, 0x6b, 0xba, 0x6a, 0x9d, 0xbb, 0x0b, 0x56, 0x20,
+		0x50, 0xf6, 0xe0, 0x24, 0xc1, 0xa0, 0xba, 0x78, 0x6b, 0x52, 0xc7, 0xea, 0x2e, 0xbb, 0xb7, 0x9b,
+		0xa4, 0x21, 0x24, 0x4d, 0x00, 0xf4, 0x8a, 0xee, 0x24, 0x0c, 0xa8, 0x4d, 0x76, 0xe4, 0x9c, 0x24,
+		0xb1, 0x85, 0x16, 0xe4, 0x4b, 0x30, 0xc4, 0x8f, 0xb9, 0x50, 0x0e, 0x92, 0xfb, 0xf8, 0x80, 0xb6,
+		0x93, 0x55, 0xc8, 0x4f, 0x34, 0x0b, 0x03, 0x54, 0x78, 0xfe, 0x20, 0x21, 0x3f, 0xdb, 0x22, 0xfd,
+		0x2c, 0x15, 0x52, 0x61, 0x68, 0xf2, 0xb3, 0x90, 0x5e, 0x34, 0x1b, 0xba, 0x61, 0x86, 0xb9, 0x65,
+		0x18, 0x37, 0x2a, 0xb3, 0xd5, 0xe4, 0x63, 0xad, 0xb0, 0x02, 0x3a, 0x06, 0x83, 0xec, 0x1e, 0x37,
+		0x3f, 0x36, 0xe7, 0x25, 0x79, 0x01, 0x86, 0x28, 0xef, 0x75, 0x0b, 0x21, 0xfe, 0x02, 0x88, 0x5f,
+		0x18, 0xa7, 0x6e, 0x81, 0xb3, 0x4f, 0xf8, 0xc2, 0x22, 0x48, 0x55, 0x55, 0x57, 0xe5, 0xfd, 0xa6,
+		0xbf, 0xe5, 0xa7, 0x21, 0xcd, 0x99, 0x38, 0xe8, 0x0c, 0x24, 0x4d, 0xcb, 0xe1, 0x07, 0xdf, 0x85,
+		0x4e, 0x5d, 0x59, 0xb7, 0x4a, 0x29, 0x62, 0x25, 0x0a, 0x41, 0x2e, 0x29, 0x1d, 0xcd, 0xe2, 0xc9,
+		0x80, 0x59, 0x04, 0x86, 0x3c, 0xf0, 0x93, 0x0d, 0x69, 0x8b, 0x39, 0x78, 0xc6, 0xf2, 0xa9, 0x04,
+		0x4c, 0x05, 0x6a, 0xaf, 0x60, 0x9b, 0xac, 0xf5, 0x98, 0x45, 0x71, 0x6b, 0x41, 0x01, 0x21, 0x79,
+		0x7d, 0x07, 0x73, 0x79, 0x33, 0x24, 0xe7, 0x2d, 0x0b, 0x15, 0x20, 0xcd, 0x0e, 0xb8, 0x4d, 0x66,
+		0x2f, 0x29, 0xc5, 0x2b, 0x93, 0x3a, 0xc7, 0xdc, 0x75, 0xaf, 0xaa, 0xb6, 0xf7, 0xd4, 0x49, 0x94,
+		0xe5, 0xa7, 0x20, 0xb3, 0x60, 0x1a, 0x0e, 0x36, 0x9c, 0x26, 0x0d, 0x44, 0x3b, 0x75, 0x53, 0xdb,
+		0xe7, 0x1c, 0x58, 0x81, 0x28, 0x5c, 0xb5, 0x2c, 0x4a, 0x99, 0x52, 0xc8, 0x4f, 0x36, 0x2f, 0x4b,
+		0x9b, 0x1d, 0x55, 0xf4, 0x54, 0xff, 0x2a, 0xe2, 0x9d, 0xf4, 0x74, 0xf4, 0xbf, 0x25, 0x38, 0xd9,
+		0x3a, 0xa1, 0xf6, 0xf1, 0x81, 0xd3, 0xef, 0x7c, 0x7a, 0x01, 0x32, 0x1b, 0xf4, 0xbd, 0xf1, 0x25,
+		0x7c, 0x80, 0x0a, 0x30, 0x84, 0xab, 0x67, 0xce, 0x9e, 0x7d, 0xf4, 0x29, 0x66, 0xed, 0x17, 0x8f,
+		0x28, 0x02, 0x80, 0xa6, 0x20, 0xe3, 0x60, 0xcd, 0x3a, 0x73, 0xf6, 0xdc, 0xfe, 0xa3, 0xcc, 0xbc,
+		0x2e, 0x1e, 0x51, 0x7c, 0x50, 0x31, 0x4d, 0x7a, 0xfd, 0xc6, 0xa7, 0xa6, 0xa5, 0xd2, 0x00, 0x24,
+		0x9d, 0x66, 0xe3, 0xb6, 0xda, 0xc8, 0x6b, 0x03, 0x30, 0x13, 0xa4, 0xa4, 0xd1, 0xfa, 0x8a, 0x5a,
+		0xd7, 0xab, 0xaa, 0xff, 0x52, 0x3c, 0x17, 0xd0, 0x01, 0xc5, 0x68, 0xaf, 0x82, 0x42, 0x57, 0x4d,
+		0xca, 0xbf, 0x2e, 0x41, 0xf6, 0xb2, 0xe0, 0xbc, 0x89, 0x5d, 0x74, 0x1e, 0xc0, 0x6b, 0x49, 0x4c,
+		0x9b, 0x3b, 0x66, 0xa3, 0x6d, 0xcd, 0x7a, 0x34, 0x4a, 0x00, 0x1d, 0x3d, 0x41, 0x0d, 0xd1, 0x32,
+		0x1d, 0xfe, 0xfc, 0x25, 0x86, 0xd4, 0x43, 0x46, 0x0f, 0x01, 0xa2, 0x1e, 0xae, 0x72, 0xc5, 0x74,
+		0x75, 0xa3, 0x56, 0xb1, 0xcc, 0xab, 0xfc, 0x51, 0x61, 0x52, 0xc9, 0xd1, 0x9a, 0xcb, 0xb4, 0x62,
+		0x83, 0xc0, 0x89, 0xd0, 0x19, 0x8f, 0x0b, 0xc9, 0xad, 0xd4, 0x6a, 0xd5, 0xc6, 0x8e, 0xc3, 0x9d,
+		0x98, 0x28, 0xa2, 0xf3, 0x30, 0x64, 0x35, 0x77, 0x2a, 0xc2, 0x63, 0x0c, 0x9f, 0x39, 0xd9, 0x6e,
+		0xfe, 0x0b, 0xfb, 0xe0, 0x1e, 0x60, 0xd0, 0x6a, 0xee, 0x10, 0x6b, 0xb9, 0x0b, 0xb2, 0x6d, 0x84,
+		0x19, 0xbe, 0xe2, 0xcb, 0x41, 0x9f, 0xb9, 0xf3, 0x1e, 0x54, 0x2c, 0x5b, 0x37, 0x6d, 0xdd, 0x3d,
+		0xa0, 0xb7, 0x57, 0x92, 0x4a, 0x4e, 0x54, 0x6c, 0x70, 0xb8, 0xbc, 0x0f, 0x63, 0x9b, 0x34, 0xb7,
+		0xf0, 0x25, 0x3f, 0xeb, 0xcb, 0x27, 0xc5, 0xcb, 0xd7, 0x51, 0xb2, 0x44, 0x8b, 0x64, 0xa5, 0xe7,
+		0x3a, 0x5a, 0xe7, 0x13, 0xfd, 0x5b, 0x67, 0x38, 0xda, 0xfd, 0xd1, 0x89, 0xd0, 0xe4, 0xe4, 0xa9,
+		0x64, 0xc0, 0x7d, 0xf5, 0x6a, 0x98, 0x71, 0x29, 0x75, 0xa1, 0x7b, 0x50, 0x2d, 0xc4, 0xb8, 0xd1,
+		0x42, 0xec, 0x14, 0x92, 0x9f, 0x82, 0x91, 0x0d, 0xd5, 0x76, 0x37, 0xb1, 0x7b, 0x11, 0xab, 0x55,
+		0x6c, 0x87, 0xa3, 0xee, 0x88, 0x88, 0xba, 0x08, 0x52, 0x34, 0xb4, 0xb2, 0xa8, 0x43, 0x7f, 0xcb,
+		0x7b, 0x90, 0xa2, 0x37, 0xd8, 0xbc, 0x88, 0xcc, 0x29, 0x58, 0x44, 0x26, 0xbe, 0xf4, 0xc0, 0xc5,
+		0x8e, 0x58, 0xd0, 0xd1, 0x02, 0x7a, 0x5c, 0xc4, 0xd5, 0x64, 0xf7, 0xb8, 0xca, 0x0d, 0x91, 0x47,
+		0xd7, 0x3a, 0x0c, 0x95, 0x88, 0x2b, 0x5e, 0x5e, 0xf4, 0x04, 0x91, 0x7c, 0x41, 0xd0, 0x2a, 0x8c,
+		0x59, 0xaa, 0xed, 0xd2, 0xab, 0xfb, 0x7b, 0xb4, 0x17, 0xdc, 0xd6, 0xa7, 0x5b, 0x67, 0x5e, 0xa8,
+		0xb3, 0xbc, 0x95, 0x11, 0x2b, 0x08, 0x94, 0xff, 0x30, 0x05, 0x83, 0x5c, 0x19, 0x6f, 0x86, 0x21,
+		0xae, 0x56, 0x6e, 0x9d, 0x77, 0xce, 0xb6, 0x06, 0xa6, 0x59, 0x2f, 0x80, 0x70, 0x7e, 0x82, 0x06,
+		0xdd, 0x07, 0x69, 0x6d, 0x4f, 0xd5, 0x8d, 0x8a, 0x5e, 0x15, 0x69, 0xde, 0xeb, 0x37, 0xa6, 0x87,
+		0x16, 0x08, 0x6c, 0x79, 0x51, 0x19, 0xa2, 0x95, 0xcb, 0x55, 0x92, 0x09, 0xec, 0x61, 0xbd, 0xb6,
+		0xe7, 0xf2, 0x19, 0xc6, 0x4b, 0xe8, 0x49, 0x48, 0x11, 0x83, 0xe0, 0x0f, 0xbb, 0x0a, 0x2d, 0xc9,
+		0xb6, 0xb7, 0xe2, 0x29, 0xa5, 0x49, 0xc3, 0x1f, 0xfa, 0xfd, 0x69, 0x49, 0xa1, 0x14, 0x68, 0x01,
+		0x46, 0xea, 0xaa, 0xe3, 0x56, 0x68, 0x04, 0x23, 0xcd, 0x0f, 0x50, 0x16, 0x27, 0x5a, 0x15, 0xc2,
+		0x15, 0xcb, 0x45, 0x1f, 0x26, 0x54, 0x0c, 0x54, 0x45, 0xa7, 0x20, 0x47, 0x99, 0x68, 0x66, 0xa3,
+		0xa1, 0xbb, 0x2c, 0xb7, 0x1a, 0xa4, 0x7a, 0x1f, 0x25, 0xf0, 0x05, 0x0a, 0xa6, 0x19, 0xd6, 0x1d,
+		0x90, 0xa1, 0x4f, 0x49, 0x28, 0x0a, 0xbb, 0x36, 0x99, 0x26, 0x00, 0x5a, 0x79, 0x3f, 0x8c, 0xf9,
+		0xfe, 0x91, 0xa1, 0xa4, 0x19, 0x17, 0x1f, 0x4c, 0x11, 0x1f, 0x81, 0x49, 0x03, 0x5f, 0xa3, 0x17,
+		0x39, 0x43, 0xd8, 0x19, 0x8a, 0x8d, 0x48, 0xdd, 0xe5, 0x30, 0xc5, 0xbd, 0x30, 0xaa, 0x09, 0xe5,
+		0x33, 0x5c, 0xa0, 0xb8, 0x23, 0x1e, 0x94, 0xa2, 0x9d, 0x80, 0xb4, 0x6a, 0x59, 0x0c, 0x61, 0x98,
+		0xfb, 0x47, 0xcb, 0xa2, 0x55, 0xa7, 0x61, 0x9c, 0xf6, 0xd1, 0xc6, 0x4e, 0xb3, 0xee, 0x72, 0x26,
+		0x59, 0x8a, 0x33, 0x46, 0x2a, 0x14, 0x06, 0xa7, 0xb8, 0x77, 0xc3, 0x08, 0xbe, 0xa2, 0x57, 0xb1,
+		0xa1, 0x61, 0x86, 0x37, 0x42, 0xf1, 0xb2, 0x02, 0x48, 0x91, 0x1e, 0x00, 0xcf, 0xef, 0x55, 0x84,
+		0x4f, 0x1e, 0x65, 0xfc, 0x04, 0x7c, 0x9e, 0x81, 0xe5, 0x3c, 0xa4, 0x16, 0x55, 0x57, 0x25, 0x09,
+		0x86, 0x7b, 0x8d, 0x05, 0x9a, 0xac, 0x42, 0x7e, 0xca, 0x6f, 0x24, 0x20, 0x75, 0xd9, 0x74, 0x31,
+		0x7a, 0x2c, 0x90, 0x00, 0x8e, 0xb6, 0xb3, 0xe7, 0x4d, 0xbd, 0x66, 0xe0, 0xea, 0xaa, 0x53, 0x0b,
+		0xbc, 0xfb, 0xf6, 0xcd, 0x29, 0x11, 0x32, 0xa7, 0x49, 0x18, 0xb0, 0xcd, 0xa6, 0x51, 0x15, 0x37,
+		0x0e, 0x69, 0x01, 0x95, 0x21, 0xed, 0x59, 0x49, 0x2a, 0xce, 0x4a, 0xc6, 0x88, 0x95, 0x10, 0x1b,
+		0xe6, 0x00, 0x65, 0x68, 0x87, 0x1b, 0x4b, 0x09, 0x32, 0x9e, 0xf3, 0xe2, 0xd6, 0xd6, 0x9b, 0xc1,
+		0xfa, 0x64, 0x24, 0x98, 0x78, 0x63, 0xef, 0x29, 0x8f, 0x59, 0x5c, 0xce, 0xab, 0xe0, 0xda, 0x0b,
+		0x99, 0x15, 0x7f, 0x83, 0x3e, 0x44, 0xfb, 0xe5, 0x9b, 0x15, 0x7b, 0x87, 0x7e, 0x12, 0x32, 0x8e,
+		0x5e, 0x33, 0x54, 0xb7, 0x69, 0x63, 0x6e, 0x79, 0x3e, 0x40, 0xfe, 0x92, 0x04, 0x83, 0xcc, 0x92,
+		0x03, 0x7a, 0x93, 0xda, 0xeb, 0x2d, 0xd1, 0x49, 0x6f, 0xc9, 0xc3, 0xeb, 0x6d, 0x1e, 0xc0, 0x13,
+		0xc6, 0xe1, 0x4f, 0x83, 0xdb, 0x64, 0x0c, 0x4c, 0xc4, 0x4d, 0xbd, 0xc6, 0x27, 0x6a, 0x80, 0x48,
+		0xfe, 0x8f, 0x12, 0x49, 0x62, 0x79, 0x3d, 0x9a, 0x87, 0x11, 0x21, 0x57, 0x65, 0xb7, 0xae, 0xd6,
+		0xb8, 0xed, 0xdc, 0xd9, 0x51, 0xb8, 0x0b, 0x75, 0xb5, 0xa6, 0x0c, 0x73, 0x79, 0x48, 0xa1, 0xfd,
+		0x38, 0x24, 0x3a, 0x8c, 0x43, 0x68, 0xe0, 0x93, 0x87, 0x1b, 0xf8, 0xd0, 0x10, 0xa5, 0xa2, 0x43,
+		0xf4, 0xf9, 0x04, 0x5d, 0xcc, 0x58, 0xa6, 0xa3, 0xd6, 0x7f, 0x18, 0x33, 0xe2, 0x0e, 0xc8, 0x58,
+		0x66, 0xbd, 0xc2, 0x6a, 0xd8, 0x4d, 0xdc, 0xb4, 0x65, 0xd6, 0x95, 0x96, 0x61, 0x1f, 0xb8, 0x45,
+		0xd3, 0x65, 0xf0, 0x16, 0x68, 0x6d, 0x28, 0xaa, 0x35, 0x1b, 0xb2, 0x4c, 0x15, 0x3c, 0x96, 0x3d,
+		0x42, 0x74, 0x40, 0x83, 0xa3, 0xd4, 0x1a, 0x7b, 0x99, 0xd8, 0x0c, 0x53, 0xe1, 0x78, 0x84, 0x82,
+		0xb9, 0xfe, 0x76, 0xab, 0xe0, 0xa0, 0x59, 0x2a, 0x1c, 0x4f, 0xfe, 0x39, 0x09, 0x60, 0x85, 0x68,
+		0x96, 0xf6, 0x97, 0x44, 0x21, 0x87, 0x8a, 0x50, 0x09, 0xb5, 0x3c, 0xd5, 0x69, 0xd0, 0x78, 0xfb,
+		0x59, 0x27, 0x28, 0xf7, 0x02, 0x8c, 0xf8, 0xc6, 0xe8, 0x60, 0x21, 0xcc, 0x54, 0x97, 0xac, 0x7a,
+		0x13, 0xbb, 0x4a, 0xf6, 0x4a, 0xa0, 0x24, 0xff, 0x33, 0x09, 0x32, 0x54, 0xa6, 0x55, 0xec, 0xaa,
+		0xa1, 0x31, 0x94, 0x0e, 0x3f, 0x86, 0x77, 0x02, 0x30, 0x36, 0x8e, 0xfe, 0x32, 0xe6, 0x96, 0x95,
+		0xa1, 0x90, 0x4d, 0xfd, 0x65, 0x8c, 0xce, 0x79, 0x0a, 0x4f, 0x76, 0x57, 0xb8, 0xc8, 0xba, 0xb9,
+		0xda, 0x8f, 0xc3, 0x10, 0xfd, 0x94, 0xce, 0x35, 0x87, 0x27, 0xd2, 0x83, 0x46, 0xb3, 0xb1, 0x75,
+		0xcd, 0x91, 0x5f, 0x84, 0xa1, 0xad, 0x6b, 0x6c, 0x6f, 0xe4, 0x0e, 0xc8, 0xd8, 0xa6, 0xc9, 0x63,
+		0x32, 0xcb, 0x85, 0xd2, 0x04, 0x40, 0x43, 0x90, 0xd8, 0x0f, 0x48, 0xf8, 0xfb, 0x01, 0xfe, 0x86,
+		0x46, 0xb2, 0xa7, 0x0d, 0x8d, 0xd3, 0xff, 0x4e, 0x82, 0xe1, 0x80, 0x7f, 0x40, 0x8f, 0xc2, 0xd1,
+		0xd2, 0xca, 0xfa, 0xc2, 0xa5, 0xca, 0xf2, 0x62, 0xe5, 0xc2, 0xca, 0xfc, 0x92, 0xff, 0xd6, 0xa4,
+		0x70, 0xec, 0xd5, 0xeb, 0x33, 0x28, 0x80, 0xbb, 0x6d, 0xec, 0x1b, 0xe6, 0x55, 0x03, 0xcd, 0xc1,
+		0x64, 0x98, 0x64, 0xbe, 0xb4, 0x59, 0x5e, 0xdb, 0xca, 0x49, 0x85, 0xa3, 0xaf, 0x5e, 0x9f, 0x19,
+		0x0f, 0x50, 0xcc, 0xef, 0x38, 0xd8, 0x70, 0x5b, 0x09, 0x16, 0xd6, 0x57, 0x57, 0x97, 0xb7, 0x72,
+		0x89, 0x16, 0x02, 0xee, 0xb0, 0x1f, 0x80, 0xf1, 0x30, 0xc1, 0xda, 0xf2, 0x4a, 0x2e, 0x59, 0x40,
+		0xaf, 0x5e, 0x9f, 0x19, 0x0d, 0x60, 0xaf, 0xe9, 0xf5, 0x42, 0xfa, 0xfd, 0x9f, 0x9e, 0x3a, 0xf2,
+		0x4b, 0xbf, 0x38, 0x25, 0x91, 0x9e, 0x8d, 0x84, 0x7c, 0x04, 0x7a, 0x08, 0x8e, 0x6f, 0x2e, 0x2f,
+		0xad, 0x95, 0x17, 0x2b, 0xab, 0x9b, 0x4b, 0x15, 0xf6, 0x8d, 0x0d, 0xaf, 0x77, 0x63, 0xaf, 0x5e,
+		0x9f, 0x19, 0xe6, 0x5d, 0xea, 0x84, 0xbd, 0xa1, 0x94, 0x2f, 0xaf, 0x6f, 0x95, 0x73, 0x12, 0xc3,
+		0xde, 0xb0, 0xf1, 0x15, 0xd3, 0x65, 0xdf, 0xda, 0x7a, 0x04, 0x4e, 0xb4, 0xc1, 0xf6, 0x3a, 0x36,
+		0xfe, 0xea, 0xf5, 0x99, 0x91, 0x0d, 0x1b, 0xb3, 0xf9, 0x43, 0x29, 0x66, 0x21, 0xdf, 0x4a, 0xb1,
+		0xbe, 0xb1, 0xbe, 0x39, 0xbf, 0x92, 0x9b, 0x29, 0xe4, 0x5e, 0xbd, 0x3e, 0x93, 0x15, 0xce, 0x90,
+		0xe0, 0xfb, 0x3d, 0xbb, 0x9d, 0x2b, 0x9e, 0x3f, 0x79, 0x18, 0xee, 0xe1, 0x7b, 0x80, 0x8e, 0xab,
+		0xee, 0xeb, 0x46, 0xcd, 0xdb, 0x69, 0xe5, 0x65, 0xbe, 0xf2, 0x39, 0xc6, 0x37, 0x5b, 0x05, 0xb4,
+		0xeb, 0x7e, 0x6b, 0xa1, 0xf3, 0xc9, 0x52, 0x21, 0xe6, 0xf0, 0x25, 0x7e, 0xe9, 0xd4, 0x79, 0x6f,
+		0xbe, 0x10, 0xb3, 0x63, 0x5c, 0xe8, 0xba, 0xb8, 0x93, 0x3f, 0x20, 0xc1, 0xe8, 0x45, 0xdd, 0x71,
+		0x4d, 0x5b, 0xd7, 0xd4, 0x3a, 0x7d, 0x61, 0x72, 0xae, 0x57, 0xdf, 0x1a, 0x99, 0xea, 0xcf, 0xc0,
+		0xe0, 0x15, 0xb5, 0xce, 0x9c, 0x5a, 0x92, 0x7e, 0x10, 0xa3, 0xbd, 0xfa, 0x7c, 0xd7, 0x26, 0x18,
+		0x30, 0x32, 0xf9, 0x57, 0x12, 0x30, 0x46, 0x27, 0x83, 0xc3, 0x3e, 0x95, 0x44, 0xd6, 0x58, 0x25,
+		0x48, 0xd9, 0xaa, 0xcb, 0x37, 0x0d, 0x4b, 0xb3, 0x7c, 0xe7, 0xf7, 0xbe, 0xf8, 0xdd, 0xdc, 0xd9,
+		0x45, 0xac, 0x29, 0x94, 0x16, 0xbd, 0x1d, 0xd2, 0x0d, 0xf5, 0x5a, 0x85, 0xf2, 0x61, 0x2b, 0x97,
+		0xf9, 0xfe, 0xf8, 0xdc, 0xbc, 0x31, 0x3d, 0x76, 0xa0, 0x36, 0xea, 0x45, 0x59, 0xf0, 0x91, 0x95,
+		0xa1, 0x86, 0x7a, 0x8d, 0x88, 0x88, 0x2c, 0x18, 0x23, 0x50, 0x6d, 0x4f, 0x35, 0x6a, 0x98, 0x35,
+		0x42, 0xb7, 0x40, 0x4b, 0x17, 0xfb, 0x6e, 0xe4, 0x98, 0xdf, 0x48, 0x80, 0x9d, 0xac, 0x8c, 0x34,
+		0xd4, 0x6b, 0x0b, 0x14, 0x40, 0x5a, 0x2c, 0xa6, 0x3f, 0xfa, 0xc9, 0xe9, 0x23, 0x74, 0x37, 0xfd,
+		0x1b, 0x12, 0x80, 0xaf, 0x31, 0xf4, 0x76, 0xc8, 0x69, 0x5e, 0x89, 0xd2, 0x3a, 0x7c, 0x0c, 0xef,
+		0xef, 0x34, 0x16, 0x11, 0x7d, 0xb3, 0xd8, 0xfc, 0xf5, 0x1b, 0xd3, 0x92, 0x32, 0xa6, 0x45, 0x86,
+		0xe2, 0x6d, 0x30, 0xdc, 0xb4, 0xaa, 0xaa, 0x8b, 0x2b, 0x74, 0x1d, 0x97, 0x88, 0x8d, 0xf3, 0x53,
+		0x84, 0xd7, 0xcd, 0x1b, 0xd3, 0x88, 0x75, 0x2b, 0x40, 0x2c, 0xd3, 0xe8, 0x0f, 0x0c, 0x42, 0x08,
+		0x02, 0x7d, 0xfa, 0xaa, 0x04, 0xc3, 0x8b, 0x81, 0x9b, 0x5e, 0x79, 0x18, 0x6a, 0x98, 0x86, 0xbe,
+		0xcf, 0xed, 0x31, 0xa3, 0x88, 0x22, 0x2a, 0x40, 0x9a, 0x3d, 0xba, 0x73, 0x0f, 0xc4, 0x56, 0xa8,
+		0x28, 0x13, 0xaa, 0xab, 0x78, 0xc7, 0xd1, 0xc5, 0x68, 0x28, 0xa2, 0x88, 0x2e, 0x40, 0xce, 0xc1,
+		0x5a, 0xd3, 0xd6, 0xdd, 0x83, 0x8a, 0x66, 0x1a, 0xae, 0xaa, 0xb9, 0xec, 0xf9, 0x56, 0xe9, 0x8e,
+		0x9b, 0x37, 0xa6, 0x8f, 0x33, 0x59, 0xa3, 0x18, 0xb2, 0x32, 0x26, 0x40, 0x0b, 0x0c, 0x42, 0x5a,
+		0xa8, 0x62, 0x57, 0xd5, 0xeb, 0x4e, 0x9e, 0x1d, 0x0c, 0x89, 0x62, 0xa0, 0x2f, 0x9f, 0x1b, 0x0a,
+		0x6e, 0x6c, 0x5d, 0x80, 0x9c, 0x69, 0x61, 0x3b, 0x94, 0x88, 0x4a, 0xd1, 0x96, 0xa3, 0x18, 0xb2,
+		0x32, 0x26, 0x40, 0x22, 0x49, 0x75, 0xc9, 0x30, 0x8b, 0x85, 0xa2, 0xd5, 0xdc, 0xf1, 0xf7, 0xc3,
+		0x26, 0x5b, 0x46, 0x63, 0xde, 0x38, 0x28, 0x3d, 0xe6, 0x73, 0x8f, 0xd2, 0xc9, 0x5f, 0xfb, 0xc2,
+		0xc3, 0x93, 0xdc, 0x34, 0xfc, 0xfd, 0xa9, 0x4b, 0xf8, 0x80, 0x0c, 0x3f, 0x47, 0xdd, 0xa0, 0x98,
+		0x24, 0xed, 0x7c, 0x51, 0xd5, 0xeb, 0xe2, 0x19, 0xb2, 0xc2, 0x4b, 0xa8, 0x08, 0x83, 0x8e, 0xab,
+		0xba, 0x4d, 0x87, 0x7f, 0x1c, 0x4c, 0xee, 0x64, 0x6a, 0x25, 0xd3, 0xa8, 0x6e, 0x52, 0x4c, 0x85,
+		0x53, 0xa0, 0x0b, 0x30, 0xe8, 0x9a, 0xfb, 0xd8, 0xe0, 0x2a, 0xec, 0x6b, 0x7e, 0xd3, 0x73, 0x2a,
+		0x46, 0x4d, 0x34, 0x52, 0xc5, 0x75, 0x5c, 0x63, 0x69, 0xd5, 0x9e, 0x4a, 0x56, 0x1f, 0xf4, 0x1b,
+		0x61, 0xa5, 0xe5, 0xbe, 0x27, 0x21, 0xd7, 0x54, 0x94, 0x9f, 0xac, 0x8c, 0x79, 0xa0, 0x4d, 0x0a,
+		0x41, 0x97, 0x42, 0x57, 0x12, 0xf9, 0x87, 0xf4, 0xee, 0xee, 0xd4, 0xfd, 0x80, 0x4d, 0x8b, 0xfd,
+		0x89, 0xe0, 0x85, 0xc6, 0x0b, 0x90, 0x6b, 0x1a, 0x3b, 0xa6, 0x41, 0xdf, 0x0a, 0xf2, 0xfc, 0x9e,
+		0xac, 0xef, 0x92, 0x41, 0xe3, 0x88, 0x62, 0xc8, 0xca, 0x98, 0x07, 0xba, 0xc8, 0x56, 0x01, 0x55,
+		0x18, 0xf5, 0xb1, 0xe8, 0x44, 0xcd, 0xc4, 0x4e, 0xd4, 0xbb, 0xf8, 0x44, 0x3d, 0x1a, 0x6d, 0xc5,
+		0x9f, 0xab, 0x23, 0x1e, 0x90, 0x90, 0xa1, 0x8b, 0x00, 0xbe, 0x7b, 0xa0, 0xfb, 0x14, 0xc3, 0x9d,
+		0x07, 0xde, 0xf7, 0x31, 0x62, 0xbd, 0xe7, 0xd3, 0xa2, 0x77, 0xc2, 0x44, 0x43, 0x37, 0x2a, 0x0e,
+		0xae, 0xef, 0x56, 0xb8, 0x82, 0x09, 0x4b, 0xfa, 0xa9, 0x97, 0xd2, 0x4a, 0x7f, 0xf6, 0x70, 0xf3,
+		0xc6, 0x74, 0x81, 0xbb, 0xd0, 0x56, 0x96, 0xb2, 0x32, 0xde, 0xd0, 0x8d, 0x4d, 0x5c, 0xdf, 0x5d,
+		0xf4, 0x60, 0xc5, 0xec, 0xfb, 0x3f, 0x39, 0x7d, 0x84, 0x4f, 0xd7, 0x23, 0xf2, 0x39, 0xba, 0x77,
+		0xce, 0xa7, 0x19, 0x76, 0xc8, 0x9a, 0x44, 0x15, 0x05, 0xba, 0xa3, 0x91, 0x51, 0x7c, 0x00, 0x9b,
+		0xe6, 0xaf, 0xfc, 0x87, 0x19, 0x49, 0xfe, 0x9c, 0x04, 0x83, 0x8b, 0x97, 0x37, 0x54, 0xdd, 0x46,
+		0xcb, 0x30, 0xee, 0x5b, 0x4e, 0x78, 0x92, 0x9f, 0xbc, 0x79, 0x63, 0x3a, 0x1f, 0x35, 0x2e, 0x6f,
+		0x96, 0xfb, 0x06, 0x2c, 0xa6, 0xf9, 0x72, 0xa7, 0x85, 0x6b, 0x88, 0x55, 0x0b, 0x8a, 0xdc, 0xba,
+		0xac, 0x8d, 0x74, 0xb3, 0x0c, 0x43, 0x4c, 0x5a, 0x07, 0x15, 0x61, 0xc0, 0x22, 0x3f, 0xf8, 0xc1,
+		0xc0, 0x54, 0x47, 0xe3, 0xa5, 0xf8, 0xde, 0x46, 0x26, 0x21, 0x91, 0x3f, 0x9c, 0x00, 0x58, 0xbc,
+		0x7c, 0x79, 0xcb, 0xd6, 0xad, 0x3a, 0x76, 0x6f, 0x65, 0xcf, 0xb7, 0xe0, 0x68, 0x60, 0x95, 0x64,
+		0x6b, 0x91, 0xde, 0xcf, 0xdc, 0xbc, 0x31, 0x7d, 0x32, 0xda, 0xfb, 0x00, 0x9a, 0xac, 0x4c, 0xf8,
+		0xeb, 0x25, 0x5b, 0x6b, 0xcb, 0xb5, 0xea, 0xb8, 0x1e, 0xd7, 0x64, 0x67, 0xae, 0x01, 0xb4, 0x20,
+		0xd7, 0x45, 0xc7, 0x6d, 0xaf, 0xda, 0x4d, 0x18, 0xf6, 0x55, 0xe2, 0xa0, 0x45, 0x48, 0xbb, 0xfc,
+		0x37, 0xd7, 0xb0, 0xdc, 0x59, 0xc3, 0x82, 0x8c, 0x6b, 0xd9, 0xa3, 0x94, 0xff, 0x4c, 0x02, 0xf0,
+		0x6d, 0xf6, 0xc7, 0xd3, 0xc4, 0x88, 0x2b, 0xe7, 0x8e, 0x37, 0x79, 0xa8, 0x54, 0x8d, 0x53, 0x47,
+		0xf4, 0xf9, 0xd3, 0x09, 0x98, 0xd8, 0x16, 0x9e, 0xe7, 0xc7, 0x5e, 0x07, 0x1b, 0x30, 0x84, 0x0d,
+		0xd7, 0xd6, 0xa9, 0x12, 0xc8, 0x68, 0x3f, 0xd2, 0x69, 0xb4, 0xdb, 0xf4, 0x89, 0x7e, 0xec, 0x46,
+		0x6c, 0xba, 0x73, 0x36, 0x11, 0x6d, 0x7c, 0x30, 0x09, 0xf9, 0x4e, 0x94, 0x68, 0x01, 0xc6, 0x34,
+		0x1b, 0x53, 0x40, 0x25, 0xb8, 0xf3, 0x57, 0x2a, 0xf8, 0x99, 0x65, 0x04, 0x41, 0x56, 0x46, 0x05,
+		0x84, 0x47, 0x8f, 0x1a, 0x90, 0xb4, 0x8f, 0x98, 0x1d, 0xc1, 0xea, 0x31, 0xcf, 0x93, 0x79, 0xf8,
+		0x10, 0x8d, 0x84, 0x19, 0xb0, 0xf8, 0x31, 0xea, 0x43, 0x69, 0x00, 0x79, 0x09, 0xc6, 0x74, 0x43,
+		0x77, 0x75, 0xb5, 0x5e, 0xd9, 0x51, 0xeb, 0xaa, 0xa1, 0x1d, 0x26, 0x6b, 0x66, 0x2e, 0x9f, 0x37,
+		0x1b, 0x61, 0x27, 0x2b, 0xa3, 0x1c, 0x52, 0x62, 0x00, 0x74, 0x11, 0x86, 0x44, 0x53, 0xa9, 0x43,
+		0x65, 0x1b, 0x82, 0x3c, 0x90, 0xe0, 0xfd, 0x4c, 0x12, 0xc6, 0x15, 0x5c, 0xfd, 0xff, 0x43, 0xd1,
+		0xdf, 0x50, 0xac, 0x02, 0xb0, 0xe9, 0x4e, 0x1c, 0xec, 0x21, 0x46, 0x83, 0x38, 0x8c, 0x0c, 0xe3,
+		0xb0, 0xe8, 0xb8, 0x81, 0xf1, 0xb8, 0x91, 0x80, 0x6c, 0x70, 0x3c, 0xfe, 0x82, 0x46, 0x25, 0xb4,
+		0xec, 0x7b, 0xa2, 0x14, 0xff, 0x44, 0x68, 0x07, 0x4f, 0xd4, 0x62, 0xbd, 0xdd, 0x5d, 0xd0, 0xff,
+		0x48, 0xc0, 0xe0, 0x86, 0x6a, 0xab, 0x0d, 0x07, 0x69, 0x2d, 0x99, 0xa6, 0xd8, 0x7e, 0x6c, 0xf9,
+		0x10, 0x34, 0xdf, 0xed, 0x88, 0x49, 0x34, 0x3f, 0xda, 0x26, 0xd1, 0xfc, 0x09, 0x18, 0x25, 0xcb,
+		0xe1, 0xc0, 0x15, 0x06, 0xa2, 0xed, 0x91, 0xd2, 0x09, 0x9f, 0x4b, 0xb8, 0x9e, 0xad, 0x96, 0x2f,
+		0x07, 0xef, 0x30, 0x0c, 0x13, 0x0c, 0xdf, 0x31, 0x13, 0xf2, 0x63, 0xfe, 0xb2, 0x34, 0x50, 0x29,
+		0x2b, 0xd0, 0x50, 0xaf, 0x95, 0x59, 0x01, 0xad, 0x00, 0xda, 0xf3, 0x76, 0x46, 0x2a, 0xbe, 0x3a,
+		0x09, 0xfd, 0x9d, 0x37, 0x6f, 0x4c, 0x9f, 0x60, 0xf4, 0xad, 0x38, 0xb2, 0x32, 0xee, 0x03, 0x05,
+		0xb7, 0xc7, 0x01, 0x48, 0xbf, 0x2a, 0xec, 0xfa, 0x1c, 0x5b, 0xee, 0x1c, 0xbd, 0x79, 0x63, 0x7a,
+		0x9c, 0x71, 0xf1, 0xeb, 0x64, 0x25, 0x43, 0x0a, 0x8b, 0xe4, 0x77, 0xc0, 0xb2, 0x3f, 0x2d, 0x01,
+		0xf2, 0x5d, 0xbe, 0x82, 0x1d, 0x8b, 0xac, 0xcf, 0x48, 0x22, 0x1e, 0xc8, 0x9a, 0xa5, 0xee, 0x89,
+		0xb8, 0x4f, 0x2f, 0x12, 0xf1, 0xc0, 0x4c, 0x79, 0xca, 0x77, 0x8f, 0x09, 0x3e, 0x8e, 0x6d, 0xee,
+		0x1a, 0xce, 0x2e, 0x98, 0xba, 0xa0, 0x6e, 0xf1, 0x87, 0x47, 0xe4, 0x7f, 0x25, 0xc1, 0x89, 0x16,
+		0x8b, 0xf2, 0x84, 0xfd, 0x4b, 0x80, 0xec, 0x40, 0x25, 0xff, 0xde, 0x1b, 0x13, 0xba, 0x6f, 0x03,
+		0x1d, 0xb7, 0x5b, 0xfc, 0xee, 0xad, 0xf3, 0xf0, 0xec, 0xb2, 0xe2, 0x3f, 0x95, 0x60, 0x32, 0xd8,
+		0xbc, 0xd7, 0x91, 0x35, 0xc8, 0x06, 0x5b, 0xe7, 0x5d, 0xb8, 0xa7, 0x97, 0x2e, 0x70, 0xe9, 0x43,
+		0xf4, 0xe8, 0x39, 0x7f, 0xba, 0xb2, 0xbd, 0xb3, 0x47, 0x7b, 0xd6, 0x86, 0x90, 0x29, 0x3a, 0x6d,
+		0x53, 0x74, 0x3c, 0xfe, 0x8f, 0x04, 0xa9, 0x0d, 0xd3, 0xac, 0x23, 0x13, 0xc6, 0x0d, 0xd3, 0xad,
+		0x10, 0xcb, 0xc2, 0xd5, 0x0a, 0x5f, 0x74, 0x33, 0x3f, 0xb8, 0xd0, 0x9f, 0x92, 0xbe, 0x7d, 0x63,
+		0xba, 0x95, 0x95, 0x32, 0x66, 0x98, 0x6e, 0x89, 0x42, 0xb6, 0xd8, 0x92, 0xfc, 0x9d, 0x30, 0x12,
+		0x6e, 0x8c, 0x79, 0xc9, 0xe7, 0xfb, 0x6e, 0x2c, 0xcc, 0xe6, 0xe6, 0x8d, 0xe9, 0x49, 0x7f, 0xc6,
+		0x78, 0x60, 0x59, 0xc9, 0xee, 0x04, 0x5a, 0x67, 0xd7, 0xbb, 0xbe, 0xfb, 0xc9, 0x69, 0xe9, 0xf4,
+		0x17, 0x25, 0x00, 0x7f, 0xe7, 0x01, 0x3d, 0x04, 0xc7, 0x4b, 0xeb, 0x6b, 0x8b, 0x95, 0xcd, 0xad,
+		0xf9, 0xad, 0xed, 0xcd, 0xca, 0xf6, 0xda, 0xe6, 0x46, 0x79, 0x61, 0xf9, 0xc2, 0x72, 0x79, 0xd1,
+		0xdf, 0x1e, 0x77, 0x2c, 0xac, 0xe9, 0xbb, 0x3a, 0xae, 0xa2, 0xfb, 0x60, 0x32, 0x8c, 0x4d, 0x4a,
+		0xe5, 0xc5, 0x9c, 0x54, 0xc8, 0xbe, 0x7a, 0x7d, 0x26, 0xcd, 0x72, 0x31, 0x5c, 0x45, 0xa7, 0xe0,
+		0x68, 0x2b, 0xde, 0xf2, 0xda, 0x52, 0x2e, 0x51, 0x18, 0x79, 0xf5, 0xfa, 0x4c, 0xc6, 0x4b, 0xda,
+		0x90, 0x0c, 0x28, 0x88, 0xc9, 0xf9, 0x25, 0x0b, 0xf0, 0xea, 0xf5, 0x99, 0x41, 0xa6, 0xc0, 0x42,
+		0xea, 0xfd, 0x9f, 0x9e, 0x3a, 0x52, 0xba, 0xd0, 0x71, 0x03, 0xfc, 0xa1, 0xae, 0xba, 0xbb, 0xe6,
+		0x6d, 0x6a, 0x87, 0x77, 0xbd, 0xff, 0x78, 0xa8, 0xe3, 0xae, 0x77, 0x0d, 0x1b, 0xd8, 0xd1, 0x9d,
+		0x43, 0xed, 0x7a, 0xf7, 0xb4, 0x93, 0x2e, 0xff, 0xce, 0x00, 0x64, 0x97, 0x58, 0x2b, 0x64, 0x20,
+		0x30, 0x7a, 0x13, 0x0c, 0x5a, 0x34, 0x8c, 0x78, 0xc7, 0x68, 0x1d, 0x0c, 0x9e, 0x05, 0x1b, 0xef,
+		0x2e, 0x17, 0x0b, 0x3d, 0x0e, 0xbf, 0xcc, 0xc1, 0xee, 0x98, 0xf9, 0xb7, 0xa6, 0xb2, 0x7d, 0xed,
+		0xf7, 0xb0, 0x9c, 0x85, 0x6f, 0xad, 0x44, 0xf9, 0xc9, 0xec, 0x5e, 0xc8, 0x16, 0x81, 0xb0, 0xdb,
+		0x61, 0xef, 0x95, 0xe0, 0x28, 0xc5, 0xf2, 0x03, 0x31, 0xc5, 0x14, 0xc9, 0xfe, 0xe9, 0x4e, 0x5d,
+		0x58, 0x51, 0x1d, 0xff, 0xae, 0x07, 0xbb, 0xcf, 0x75, 0x0f, 0x0f, 0x84, 0x27, 0x03, 0x8d, 0x47,
+		0xd9, 0xca, 0xca, 0x44, 0xbd, 0x85, 0xd2, 0x41, 0x4b, 0xa1, 0x0b, 0x7d, 0xa9, 0xfe, 0xb6, 0xda,
+		0x83, 0x97, 0xfb, 0x9e, 0x85, 0x61, 0xdf, 0x97, 0x38, 0xfc, 0xff, 0x53, 0xf4, 0x1e, 0x3b, 0x82,
+		0xc4, 0xe8, 0x7d, 0x12, 0x1c, 0xf5, 0xa3, 0x79, 0x90, 0x2d, 0xfb, 0x3f, 0x1e, 0x0f, 0xf6, 0xb1,
+		0x10, 0x8a, 0x2a, 0xa7, 0x2d, 0x5f, 0x59, 0x99, 0x6c, 0xb6, 0x92, 0x92, 0x25, 0xd8, 0x48, 0xd0,
+		0xb3, 0x3a, 0x79, 0xf1, 0xa9, 0xba, 0xde, 0x5d, 0x73, 0x98, 0x01, 0xfb, 0xdf, 0x02, 0x96, 0x69,
+		0xbb, 0xb8, 0x4a, 0x37, 0xe4, 0xd2, 0x8a, 0x57, 0x96, 0xd7, 0x00, 0xb5, 0x0e, 0x6e, 0xf4, 0x02,
+		0x63, 0xc6, 0xbf, 0xc0, 0x38, 0x09, 0x03, 0xc1, 0x2b, 0x7e, 0xac, 0x50, 0x4c, 0xbf, 0x9f, 0x87,
+		0xcf, 0x5b, 0x3e, 0xe7, 0xff, 0x45, 0x02, 0x4e, 0x07, 0x8f, 0x87, 0x5e, 0x6a, 0x62, 0xfb, 0xc0,
+		0x9b, 0xa2, 0x96, 0x5a, 0xd3, 0x8d, 0xe0, 0x1b, 0xa0, 0x13, 0xc1, 0x80, 0x4f, 0x71, 0x85, 0x9e,
+		0x64, 0x03, 0x86, 0x37, 0xd4, 0x1a, 0x56, 0xf0, 0x4b, 0x4d, 0xec, 0xb8, 0x6d, 0x2e, 0x99, 0x1f,
+		0x83, 0x41, 0x73, 0x77, 0x57, 0x1c, 0x69, 0xa7, 0x14, 0x5e, 0x22, 0x5d, 0xae, 0xeb, 0x0d, 0x9d,
+		0xdd, 0x06, 0x4b, 0x29, 0xac, 0x80, 0xa6, 0x61, 0x58, 0x33, 0x9b, 0x06, 0x9f, 0x71, 0xf9, 0x94,
+		0xf8, 0x00, 0x44, 0xd3, 0x60, 0x33, 0x4e, 0x7e, 0x06, 0xb2, 0xac, 0x3d, 0x1e, 0x71, 0x4f, 0x40,
+		0x9a, 0x5e, 0xa7, 0xf2, 0x5b, 0x1d, 0x22, 0xe5, 0x4b, 0xec, 0x42, 0x3a, 0xe3, 0xc2, 0x1a, 0x66,
+		0x85, 0x52, 0xa9, 0xa3, 0x2a, 0x4f, 0xc5, 0xbb, 0x06, 0xa6, 0x28, 0x4f, 0x8d, 0xbf, 0x39, 0x00,
+		0x47, 0xf9, 0x09, 0x9d, 0x6a, 0xe9, 0x73, 0x7b, 0xae, 0x2b, 0x5e, 0x09, 0x01, 0x4f, 0x75, 0x55,
+		0x4b, 0x97, 0x0f, 0x20, 0x75, 0xd1, 0x75, 0x2d, 0x74, 0x1a, 0x06, 0xec, 0x66, 0x1d, 0x8b, 0x1d,
+		0x1f, 0x6f, 0x4f, 0x5e, 0xb5, 0xf4, 0x59, 0x82, 0xa0, 0x34, 0xeb, 0x58, 0x61, 0x28, 0xa8, 0x0c,
+		0xd3, 0xbb, 0xcd, 0x7a, 0xfd, 0xa0, 0x52, 0xc5, 0xf4, 0x7f, 0xf7, 0x78, 0x5f, 0xbf, 0xc7, 0xd7,
+		0x2c, 0x55, 0x7c, 0x43, 0x8f, 0xe8, 0xe6, 0x24, 0x45, 0x5b, 0xa4, 0x58, 0xe2, 0xcb, 0xf7, 0x65,
+		0x81, 0x23, 0xff, 0x5e, 0x02, 0xd2, 0x82, 0x35, 0xbd, 0x21, 0x8e, 0xeb, 0x58, 0x73, 0x4d, 0x71,
+		0x62, 0xe2, 0x95, 0x11, 0x82, 0x64, 0x8d, 0x0f, 0x51, 0xe6, 0xe2, 0x11, 0x85, 0x14, 0x08, 0xcc,
+		0xbb, 0xb7, 0x4f, 0x60, 0x56, 0x93, 0x8c, 0x5a, 0xca, 0x32, 0xc5, 0xd2, 0xec, 0xe2, 0x11, 0x85,
+		0x96, 0x50, 0x1e, 0x06, 0xc9, 0xcc, 0x70, 0xd9, 0x87, 0x09, 0x09, 0x9c, 0x97, 0xd1, 0x31, 0x18,
+		0xb0, 0x54, 0x57, 0x63, 0x57, 0xea, 0x48, 0x05, 0x2b, 0xa2, 0x27, 0x60, 0x90, 0x3d, 0x08, 0x8d,
+		0xfe, 0x63, 0x0c, 0xa2, 0x0c, 0xf6, 0xe5, 0x2d, 0x22, 0xf7, 0x86, 0xea, 0xba, 0xd8, 0x36, 0x08,
+		0x43, 0x86, 0x8e, 0x10, 0xa4, 0x76, 0xcc, 0xea, 0x01, 0xff, 0x67, 0x1d, 0xf4, 0x37, 0xff, 0xef,
+		0x00, 0xd4, 0x1e, 0x2a, 0xb4, 0x92, 0xfd, 0x8f, 0xa2, 0xac, 0x00, 0x96, 0x08, 0x52, 0x19, 0x26,
+		0xd4, 0x6a, 0x55, 0x67, 0xff, 0x37, 0xa3, 0xb2, 0xa3, 0x53, 0x0f, 0xe1, 0xd0, 0xff, 0x40, 0xd5,
+		0x69, 0x2c, 0x90, 0x4f, 0x50, 0xe2, 0xf8, 0xa5, 0x0c, 0x0c, 0x59, 0x4c, 0x28, 0xf9, 0x3c, 0x8c,
+		0xb7, 0x48, 0x4a, 0xe4, 0xdb, 0xd7, 0x8d, 0xaa, 0x78, 0xcc, 0x40, 0x7e, 0x13, 0x18, 0xfd, 0x7a,
+		0x1e, 0x3b, 0x8b, 0xa2, 0xbf, 0x4b, 0xef, 0xee, 0xfc, 0xf0, 0x6b, 0x34, 0xf0, 0xf0, 0x4b, 0xb5,
+		0xf4, 0x52, 0x86, 0xf2, 0xe7, 0xcf, 0xbd, 0xe6, 0x79, 0x05, 0x7b, 0xea, 0x35, 0x6b, 0xda, 0x35,
+		0x12, 0xa5, 0x45, 0xf4, 0x25, 0x55, 0xaa, 0xa5, 0x3b, 0xd4, 0x1c, 0xfd, 0xaf, 0xf9, 0x39, 0xe7,
+		0x03, 0xbf, 0xe9, 0x23, 0xb0, 0xd4, 0xd2, 0xfc, 0xc6, 0xb2, 0x67, 0xc7, 0x5f, 0x4e, 0xc0, 0xc9,
+		0x80, 0x1d, 0x07, 0x90, 0x5b, 0xcd, 0xb9, 0xd0, 0xde, 0xe2, 0x7b, 0x78, 0xfc, 0x75, 0x09, 0x52,
+		0x04, 0x1f, 0xc5, 0x7c, 0xbb, 0x3f, 0xff, 0xab, 0x5f, 0xfb, 0x27, 0x72, 0xf8, 0xd4, 0x2a, 0x34,
+		0x2a, 0x94, 0x49, 0xe9, 0x7d, 0xbd, 0xeb, 0x2f, 0xe7, 0x7f, 0xc8, 0xd0, 0xb9, 0x75, 0x6a, 0x8c,
+		0xea, 0xf0, 0x5b, 0x67, 0x41, 0xee, 0x90, 0xf2, 0x30, 0x8f, 0xd9, 0x3d, 0x89, 0xea, 0xc3, 0x1d,
+		0x77, 0xba, 0xff, 0xdf, 0x6d, 0x04, 0x7b, 0x4c, 0xc7, 0xae, 0xc1, 0xb1, 0xe7, 0x48, 0xdb, 0xfe,
+		0x32, 0x59, 0x38, 0xf6, 0x63, 0xde, 0x69, 0x9e, 0xc4, 0xff, 0x01, 0x98, 0x38, 0xa9, 0x03, 0x5f,
+		0x3e, 0xbe, 0x40, 0xbc, 0x6f, 0xb6, 0x63, 0xbc, 0x98, 0x0d, 0x04, 0x0b, 0x25, 0x40, 0x29, 0xff,
+		0xb2, 0x04, 0xc7, 0x5b, 0x9a, 0xe6, 0x3e, 0x7e, 0xa9, 0xcd, 0x53, 0x85, 0x43, 0x65, 0x36, 0x4b,
+		0x6d, 0x84, 0xbd, 0x3f, 0x56, 0x58, 0x26, 0x45, 0x48, 0xda, 0xa7, 0xe1, 0x68, 0x58, 0x58, 0xa1,
+		0xa6, 0x7b, 0x61, 0x34, 0xbc, 0x23, 0xcc, 0xd5, 0x35, 0x12, 0xda, 0x13, 0x96, 0x2b, 0x51, 0x3d,
+		0x7b, 0x7d, 0x2d, 0x43, 0xc6, 0x43, 0xe5, 0x29, 0x70, 0xcf, 0x5d, 0xf5, 0x29, 0xe5, 0x0f, 0x4b,
+		0x30, 0x13, 0x6e, 0x21, 0x90, 0x0c, 0xf5, 0x27, 0xec, 0x2d, 0x1b, 0xe2, 0x37, 0x24, 0xb8, 0xab,
+		0x8b, 0x4c, 0x5c, 0x01, 0x2f, 0xc3, 0x64, 0x60, 0x27, 0x40, 0xb8, 0x70, 0x31, 0xec, 0xa7, 0xe3,
+		0xd3, 0x50, 0x6f, 0xe1, 0x7b, 0x07, 0x51, 0xca, 0x67, 0x7f, 0x7f, 0x7a, 0xa2, 0xb5, 0xce, 0x51,
+		0x26, 0x5a, 0x57, 0xef, 0xb7, 0xd0, 0x3e, 0x5e, 0x93, 0xe0, 0x81, 0x70, 0x57, 0xdb, 0xe4, 0xb3,
+		0x3f, 0xaa, 0x71, 0xf8, 0xf7, 0x12, 0x9c, 0xee, 0x45, 0x38, 0x3e, 0x20, 0x3b, 0x30, 0xe1, 0x67,
+		0xda, 0xd1, 0xf1, 0xe8, 0x2b, 0x7f, 0x67, 0x56, 0x8a, 0x3c, 0x6e, 0xb7, 0x41, 0xf1, 0x16, 0x9f,
+		0x58, 0xc1, 0x21, 0xf7, 0x94, 0x1c, 0xde, 0xcd, 0x15, 0x4a, 0x0e, 0xed, 0xe7, 0xb6, 0x19, 0x8b,
+		0x44, 0x9b, 0xb1, 0xf0, 0x53, 0x73, 0xf9, 0x0a, 0xf7, 0x5b, 0x6d, 0xf6, 0xe0, 0xde, 0x06, 0x13,
+		0x6d, 0x4c, 0x99, 0xcf, 0xea, 0x3e, 0x2c, 0x59, 0x41, 0xad, 0xc6, 0x2a, 0x1f, 0xc0, 0x34, 0x6d,
+		0xb7, 0x8d, 0xa2, 0x6f, 0x77, 0x97, 0x1b, 0xdc, 0xb7, 0xb4, 0x6d, 0x9a, 0xf7, 0x7d, 0x19, 0x06,
+		0xd9, 0x38, 0xf3, 0xee, 0x1e, 0xc2, 0x50, 0x38, 0x03, 0xf9, 0xe7, 0x85, 0x2f, 0x5b, 0x14, 0x62,
+		0xb7, 0x9f, 0x43, 0xbd, 0xf4, 0xf5, 0x16, 0xcd, 0xa1, 0x80, 0x32, 0xbe, 0x21, 0xbc, 0x5a, 0x7b,
+		0xe9, 0xb8, 0x3a, 0xb4, 0x5b, 0xe6, 0xd5, 0x98, 0x6e, 0x6e, 0xaf, 0xfb, 0xfa, 0x45, 0xe1, 0xbe,
+		0xbc, 0x3e, 0xc5, 0xb8, 0xaf, 0x1f, 0x8d, 0xea, 0x3d, 0x47, 0x16, 0x23, 0xe6, 0x9f, 0x47, 0x47,
+		0xf6, 0x5d, 0x09, 0x4e, 0xd0, 0xbe, 0x05, 0x37, 0x22, 0xfa, 0x55, 0xf9, 0x43, 0x80, 0x1c, 0x5b,
+		0xab, 0xb4, 0x9d, 0xdd, 0x39, 0xc7, 0xd6, 0x2e, 0x87, 0xe2, 0xcb, 0x43, 0x80, 0xaa, 0xa1, 0xed,
+		0x26, 0x8a, 0xcd, 0x6e, 0xc9, 0xe5, 0xaa, 0x81, 0xdd, 0x8c, 0x36, 0xc3, 0x99, 0xba, 0x05, 0xc3,
+		0xf9, 0x75, 0x09, 0x0a, 0xed, 0xba, 0xcc, 0x87, 0x4f, 0x87, 0x63, 0xa1, 0x43, 0x82, 0xe8, 0x08,
+		0x3e, 0xd4, 0xcb, 0x56, 0x4e, 0x64, 0x1a, 0x1d, 0xb5, 0xf1, 0xed, 0xce, 0x03, 0xa6, 0xc3, 0x16,
+		0xda, 0x9a, 0x59, 0xff, 0xc8, 0xa6, 0xcf, 0x17, 0x5a, 0xfc, 0xea, 0x9f, 0x8b, 0xdc, 0xfb, 0x1a,
+		0x4c, 0x75, 0x90, 0xfa, 0x76, 0xc7, 0xbd, 0xbd, 0x8e, 0x83, 0x79, 0xab, 0xd3, 0xf7, 0xc7, 0xf9,
+		0x4c, 0x08, 0xdf, 0xc0, 0x0e, 0xac, 0xc5, 0xda, 0x3d, 0xe1, 0x92, 0xdf, 0x02, 0x77, 0xb4, 0xa5,
+		0xe2, 0xb2, 0x15, 0x21, 0xb5, 0xa7, 0x3b, 0x2e, 0x17, 0xeb, 0xbe, 0x4e, 0x62, 0x45, 0xa8, 0x29,
+		0x8d, 0x8c, 0x20, 0x47, 0x59, 0x6f, 0x98, 0x66, 0x9d, 0x8b, 0x21, 0x5f, 0x82, 0xf1, 0x00, 0x8c,
+		0x37, 0x72, 0x0e, 0x52, 0x96, 0xc9, 0x3f, 0x4f, 0x30, 0x7c, 0xe6, 0x64, 0xc7, 0xdd, 0x7b, 0xd3,
+		0xac, 0xf3, 0x6e, 0x53, 0x7c, 0x79, 0x12, 0x10, 0x63, 0x46, 0x37, 0xf2, 0x45, 0x13, 0x9b, 0x30,
+		0x11, 0x82, 0xf2, 0x46, 0x7e, 0xa0, 0x43, 0x82, 0x33, 0xdf, 0x3e, 0x0a, 0x03, 0x94, 0x2b, 0xfa,
+		0x98, 0x04, 0x10, 0x38, 0x11, 0x9e, 0xed, 0xc4, 0xa6, 0xfd, 0x9a, 0xb8, 0x30, 0xd7, 0x33, 0x3e,
+		0xcf, 0xd9, 0x4e, 0xbf, 0xfb, 0xdf, 0x7c, 0xeb, 0x23, 0x89, 0x7b, 0x90, 0x3c, 0xd7, 0x61, 0x35,
+		0x1e, 0x98, 0x2f, 0x9f, 0x09, 0xbd, 0x7d, 0x7f, 0xb8, 0xb7, 0xa6, 0x84, 0x64, 0xb3, 0xbd, 0xa2,
+		0x73, 0xc1, 0xce, 0x53, 0xc1, 0xce, 0xa2, 0xc7, 0xe2, 0x05, 0x9b, 0x7b, 0x47, 0x78, 0xd2, 0xbc,
+		0x0b, 0xfd, 0x8e, 0x04, 0x93, 0xed, 0x96, 0x74, 0xe8, 0xc9, 0xde, 0xa4, 0x68, 0x4d, 0x29, 0x0a,
+		0x4f, 0x1d, 0x82, 0x92, 0x77, 0x65, 0x89, 0x76, 0x65, 0x1e, 0x3d, 0x73, 0x88, 0xae, 0xcc, 0x05,
+		0xf7, 0xf7, 0xff, 0x97, 0x04, 0x77, 0x76, 0x5d, 0x21, 0xa1, 0xf9, 0xde, 0xa4, 0xec, 0x92, 0x3b,
+		0x15, 0x4a, 0x3f, 0x08, 0x0b, 0xde, 0xe3, 0xe7, 0x68, 0x8f, 0x2f, 0xa1, 0xe5, 0xc3, 0xf4, 0xb8,
+		0xed, 0x21, 0x0a, 0xfa, 0xad, 0xf0, 0xcd, 0xc2, 0xee, 0xe6, 0xd4, 0xb2, 0xf0, 0x88, 0x99, 0x18,
+		0xad, 0x49, 0xad, 0xfc, 0x02, 0xed, 0x82, 0x82, 0x36, 0x7e, 0xc0, 0x41, 0x9b, 0x7b, 0x47, 0xd8,
+		0xf1, 0xbf, 0x0b, 0xfd, 0x4f, 0xa9, 0xfd, 0x45, 0xc1, 0x27, 0xba, 0x8a, 0xd8, 0x79, 0x51, 0x55,
+		0x78, 0xb2, 0x7f, 0x42, 0xde, 0xc9, 0x06, 0xed, 0x64, 0x0d, 0xe1, 0x5b, 0xdd, 0xc9, 0xb6, 0x83,
+		0x88, 0xbe, 0x2a, 0xc1, 0x64, 0xbb, 0x35, 0x49, 0xcc, 0xb4, 0xec, 0xb2, 0xc8, 0x8a, 0x99, 0x96,
+		0xdd, 0x16, 0x40, 0xf2, 0x9b, 0x68, 0xe7, 0xcf, 0xa1, 0xc7, 0x3b, 0x75, 0xbe, 0xeb, 0x28, 0x92,
+		0xb9, 0xd8, 0x35, 0xc9, 0x8f, 0x99, 0x8b, 0xbd, 0xac, 0x63, 0x62, 0xe6, 0x62, 0x4f, 0x6b, 0x8c,
+		0xf8, 0xb9, 0xe8, 0xf5, 0xac, 0xc7, 0x61, 0x74, 0xd0, 0x97, 0x25, 0x18, 0x09, 0x65, 0xc4, 0xe8,
+		0xd1, 0xae, 0x82, 0xb6, 0x5b, 0x30, 0x14, 0xce, 0xf4, 0x43, 0xc2, 0xfb, 0xb2, 0x4c, 0xfb, 0xb2,
+		0x80, 0xe6, 0x0f, 0xd3, 0x97, 0xf0, 0x59, 0xe9, 0xd7, 0x25, 0x98, 0x68, 0x93, 0x65, 0xc6, 0xcc,
+		0xc2, 0xce, 0x49, 0x73, 0xe1, 0xc9, 0xfe, 0x09, 0x79, 0xaf, 0x2e, 0xd0, 0x5e, 0xfd, 0x04, 0x7a,
+		0xfa, 0x30, 0xbd, 0x0a, 0xc4, 0xe7, 0x1b, 0xfe, 0xbd, 0xab, 0x40, 0x3b, 0xe8, 0x5c, 0x9f, 0x82,
+		0x89, 0x0e, 0x3d, 0xd1, 0x37, 0x1d, 0xef, 0xcf, 0xf3, 0xb4, 0x3f, 0xcf, 0xa1, 0xf5, 0x1f, 0xac,
+		0x3f, 0xad, 0x61, 0xfd, 0xf3, 0xad, 0x2f, 0x00, 0xbb, 0x5b, 0x51, 0xdb, 0x64, 0xb5, 0xf0, 0x58,
+		0x5f, 0x34, 0xbc, 0x53, 0x4f, 0xd2, 0x4e, 0x9d, 0x41, 0x8f, 0x74, 0xea, 0x54, 0xe0, 0x72, 0x9d,
+		0x6e, 0xec, 0x9a, 0x73, 0xef, 0x60, 0x29, 0xf0, 0xbb, 0xd0, 0x4f, 0x89, 0x8b, 0x4d, 0xa7, 0xba,
+		0xb6, 0x1b, 0xc8, 0x63, 0x0b, 0x0f, 0xf4, 0x80, 0xc9, 0xe5, 0xba, 0x87, 0xca, 0x35, 0x85, 0x4e,
+		0x76, 0x92, 0x8b, 0xe4, 0xb2, 0xe8, 0x03, 0x92, 0x77, 0x17, 0xf2, 0x74, 0x77, 0xde, 0xc1, 0x64,
+		0xb7, 0xf0, 0x60, 0x4f, 0xb8, 0x5c, 0x92, 0xfb, 0xa8, 0x24, 0x33, 0x68, 0xaa, 0xa3, 0x24, 0x2c,
+		0xf5, 0xbd, 0xd5, 0x37, 0x07, 0x5e, 0x3d, 0x0e, 0xd3, 0x1d, 0x5a, 0x74, 0xaf, 0xc5, 0x9c, 0x71,
+		0x75, 0x79, 0x08, 0x1b, 0xfb, 0xd0, 0xb5, 0xc3, 0xd3, 0xda, 0xc3, 0x3f, 0x7f, 0xed, 0xed, 0x40,
+		0xec, 0x5f, 0xa7, 0x00, 0xad, 0x3a, 0xb5, 0x05, 0x1b, 0xb3, 0x7f, 0x7a, 0xc7, 0x67, 0x79, 0xe4,
+		0x85, 0x97, 0xf4, 0x03, 0xbd, 0xf0, 0x5a, 0x0d, 0xbd, 0x99, 0x4a, 0xf4, 0xf7, 0x2e, 0xb3, 0xe7,
+		0x87, 0x53, 0xc9, 0x1f, 0xca, 0xc3, 0xa9, 0xf6, 0xf7, 0xaa, 0x53, 0xb7, 0xee, 0x01, 0xc6, 0xc0,
+		0x61, 0x1f, 0xa1, 0xf0, 0xf7, 0x90, 0x83, 0x5d, 0xde, 0x43, 0xe6, 0x3b, 0x3e, 0x7a, 0xe4, 0xd4,
+		0xe8, 0xac, 0xf8, 0x80, 0xef, 0x50, 0x6f, 0x37, 0x61, 0xf9, 0x17, 0x7e, 0xfd, 0x2d, 0x84, 0x93,
+		0x50, 0x68, 0x35, 0x27, 0x6f, 0x52, 0x7f, 0x24, 0x09, 0xb9, 0x55, 0xa7, 0x56, 0xae, 0xea, 0xee,
+		0x6d, 0xb2, 0xb5, 0x67, 0x3a, 0x3f, 0x6a, 0x41, 0x37, 0x6f, 0x4c, 0x8f, 0x32, 0x9d, 0x76, 0xd1,
+		0x64, 0x03, 0xc6, 0x22, 0x4f, 0x89, 0xb9, 0x65, 0x2d, 0x1e, 0xe6, 0x45, 0x73, 0x84, 0x95, 0x4c,
+		0xdf, 0x20, 0x04, 0xec, 0x1b, 0x5d, 0x6b, 0x6f, 0xcc, 0xcc, 0xa0, 0x2e, 0xde, 0xce, 0x17, 0x80,
+		0xfe, 0x98, 0x15, 0x20, 0x1f, 0x1d, 0x14, 0x6f, 0xc4, 0xfe, 0x50, 0x82, 0xe1, 0x55, 0x47, 0xa4,
+		0x82, 0xf8, 0xc7, 0xf4, 0xfd, 0xd1, 0x13, 0xde, 0x77, 0x58, 0x93, 0xbd, 0xd9, 0xad, 0xf8, 0x36,
+		0xab, 0xaf, 0x84, 0xa3, 0x30, 0x11, 0xe8, 0xa7, 0xd7, 0xff, 0xdf, 0x4e, 0x50, 0xff, 0x58, 0xc2,
+		0x35, 0xdd, 0xf0, 0xb2, 0x48, 0xfc, 0x17, 0xf5, 0x75, 0x85, 0xaf, 0xe7, 0xd4, 0x61, 0xf5, 0xbc,
+		0x4f, 0x1d, 0x44, 0x44, 0x9f, 0xde, 0xc6, 0xd7, 0x6a, 0xeb, 0xdb, 0x1f, 0xa9, 0x8f, 0xcf, 0xea,
+		0x44, 0x5e, 0xf8, 0xc8, 0x6f, 0x48, 0x30, 0xb2, 0xea, 0xd4, 0xb6, 0x8d, 0xea, 0xff, 0xf3, 0xf6,
+		0xbb, 0x0b, 0x47, 0x43, 0x3d, 0xbd, 0x4d, 0x2a, 0x3d, 0xf3, 0x5a, 0x0a, 0x92, 0xab, 0x4e, 0x0d,
+		0xbd, 0x04, 0x63, 0xd1, 0xa4, 0xa1, 0x63, 0x2e, 0xd8, 0x1a, 0x11, 0x3a, 0xaf, 0xd7, 0x3a, 0x47,
+		0x0f, 0xb4, 0x0f, 0x23, 0xe1, 0xc8, 0x71, 0xaa, 0x0b, 0x93, 0x10, 0x66, 0xe1, 0x91, 0x5e, 0x31,
+		0xbd, 0xc6, 0xde, 0x0e, 0x69, 0xcf, 0xe9, 0xdd, 0xdd, 0x85, 0x5a, 0x20, 0x75, 0xce, 0x6e, 0xdb,
+		0xb8, 0x15, 0xa2, 0xbd, 0xa8, 0x4b, 0xe9, 0xa6, 0xbd, 0x08, 0x6e, 0x57, 0xed, 0x75, 0x9a, 0x5a,
+		0x3b, 0x00, 0x81, 0x79, 0x70, 0x6f, 0x17, 0x0e, 0x3e, 0x5a, 0xe1, 0xe1, 0x9e, 0xd0, 0xbc, 0x43,
+		0xa7, 0x5b, 0x9c, 0x8c, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xca, 0x34, 0x9e, 0x6a,
+		0x94, 0x00, 0x00,
+	}
+	r := bytes.NewReader(gzipped)
+	gzipr, err := compress_gzip.NewReader(r)
+	if err != nil {
+		panic(err)
+	}
+	ungzipped, err := io_ioutil.ReadAll(gzipr)
+	if err != nil {
+		panic(err)
+	}
+	if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
+		panic(err)
+	}
+	return d
+}
+func (this *CommissionRates) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*CommissionRates)
+	if !ok {
+		that2, ok := that.(CommissionRates)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if !this.Rate.Equal(that1.Rate) {
+		return false
+	}
+	if !this.MaxRate.Equal(that1.MaxRate) {
+		return false
+	}
+	if !this.MaxChangeRate.Equal(that1.MaxChangeRate) {
+		return false
+	}
+	return true
+}
+func (this *Commission) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*Commission)
+	if !ok {
+		that2, ok := that.(Commission)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if !this.CommissionRates.Equal(&that1.CommissionRates) {
+		return false
+	}
+	if !this.UpdateTime.Equal(that1.UpdateTime) {
+		return false
+	}
+	return true
+}
+func (this *Description) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*Description)
+	if !ok {
+		that2, ok := that.(Description)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.Moniker != that1.Moniker {
+		return false
+	}
+	if this.Identity != that1.Identity {
+		return false
+	}
+	if this.Website != that1.Website {
+		return false
+	}
+	if this.SecurityContact != that1.SecurityContact {
+		return false
+	}
+	if this.Details != that1.Details {
+		return false
+	}
+	return true
+}
+func (this *UnbondingDelegationEntry) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*UnbondingDelegationEntry)
+	if !ok {
+		that2, ok := that.(UnbondingDelegationEntry)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.CreationHeight != that1.CreationHeight {
+		return false
+	}
+	if !this.CompletionTime.Equal(that1.CompletionTime) {
+		return false
+	}
+	if !this.InitialBalance.Equal(that1.InitialBalance) {
+		return false
+	}
+	if !this.Balance.Equal(that1.Balance) {
+		return false
+	}
+	return true
+}
+func (this *RedelegationEntry) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*RedelegationEntry)
+	if !ok {
+		that2, ok := that.(RedelegationEntry)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.CreationHeight != that1.CreationHeight {
+		return false
+	}
+	if !this.CompletionTime.Equal(that1.CompletionTime) {
+		return false
+	}
+	if !this.InitialBalance.Equal(that1.InitialBalance) {
+		return false
+	}
+	if !this.SharesDst.Equal(that1.SharesDst) {
+		return false
+	}
+	return true
+}
+func (this *Params) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*Params)
+	if !ok {
+		that2, ok := that.(Params)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.UnbondingTime != that1.UnbondingTime {
+		return false
+	}
+	if this.MaxValidators != that1.MaxValidators {
+		return false
+	}
+	if this.MaxEntries != that1.MaxEntries {
+		return false
+	}
+	if this.HistoricalEntries != that1.HistoricalEntries {
+		return false
+	}
+	if this.BondDenom != that1.BondDenom {
+		return false
+	}
+	return true
+}
+func (this *RedelegationEntryResponse) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*RedelegationEntryResponse)
+	if !ok {
+		that2, ok := that.(RedelegationEntryResponse)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if !this.RedelegationEntry.Equal(&that1.RedelegationEntry) {
+		return false
+	}
+	if !this.Balance.Equal(that1.Balance) {
+		return false
+	}
+	return true
+}
+func (this *Pool) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*Pool)
+	if !ok {
+		that2, ok := that.(Pool)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if !this.NotBondedTokens.Equal(that1.NotBondedTokens) {
+		return false
+	}
+	if !this.BondedTokens.Equal(that1.BondedTokens) {
+		return false
+	}
+	return true
+}
+func (m *HistoricalInfo) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HistoricalInfo) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *HistoricalInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Valset) > 0 {
+		for iNdEx := len(m.Valset) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Valset[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	{
+		size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *CommissionRates) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *CommissionRates) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CommissionRates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.MaxChangeRate.Size()
+		i -= size
+		if _, err := m.MaxChangeRate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size := m.MaxRate.Size()
+		i -= size
+		if _, err := m.MaxRate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size := m.Rate.Size()
+		i -= size
+		if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Commission) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Commission) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):])
+	if err2 != nil {
+		return 0, err2
+	}
+	i -= n2
+	i = encodeVarintStaking(dAtA, i, uint64(n2))
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.CommissionRates.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Description) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Description) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Description) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Details) > 0 {
+		i -= len(m.Details)
+		copy(dAtA[i:], m.Details)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Details)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.SecurityContact) > 0 {
+		i -= len(m.SecurityContact)
+		copy(dAtA[i:], m.SecurityContact)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.SecurityContact)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Website) > 0 {
+		i -= len(m.Website)
+		copy(dAtA[i:], m.Website)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Website)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Identity) > 0 {
+		i -= len(m.Identity)
+		copy(dAtA[i:], m.Identity)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Identity)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Moniker) > 0 {
+		i -= len(m.Moniker)
+		copy(dAtA[i:], m.Moniker)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.Moniker)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Validator) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.MinSelfDelegation.Size()
+		i -= size
+		if _, err := m.MinSelfDelegation.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x5a
+	{
+		size, err := m.Commission.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x52
+	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):])
+	if err5 != nil {
+		return 0, err5
+	}
+	i -= n5
+	i = encodeVarintStaking(dAtA, i, uint64(n5))
+	i--
+	dAtA[i] = 0x4a
+	if m.UnbondingHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.UnbondingHeight))
+		i--
+		dAtA[i] = 0x40
+	}
+	{
+		size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x3a
+	{
+		size := m.DelegatorShares.Size()
+		i -= size
+		if _, err := m.DelegatorShares.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x32
+	{
+		size := m.Tokens.Size()
+		i -= size
+		if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x2a
+	if m.Status != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.Status))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.Jailed {
+		i--
+		if m.Jailed {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.ConsensusPubkey != nil {
+		{
+			size, err := m.ConsensusPubkey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStaking(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.OperatorAddress) > 0 {
+		i -= len(m.OperatorAddress)
+		copy(dAtA[i:], m.OperatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.OperatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValAddresses) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ValAddresses) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Addresses) > 0 {
+		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Addresses[iNdEx])
+			copy(dAtA[i:], m.Addresses[iNdEx])
+			i = encodeVarintStaking(dAtA, i, uint64(len(m.Addresses[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DVPair) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DVPair) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DVPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DVPairs) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DVPairs) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DVPairs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Pairs) > 0 {
+		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DVVTriplet) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DVVTriplet) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DVVTriplet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ValidatorDstAddress) > 0 {
+		i -= len(m.ValidatorDstAddress)
+		copy(dAtA[i:], m.ValidatorDstAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.ValidatorSrcAddress) > 0 {
+		i -= len(m.ValidatorSrcAddress)
+		copy(dAtA[i:], m.ValidatorSrcAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DVVTriplets) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DVVTriplets) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DVVTriplets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Triplets) > 0 {
+		for iNdEx := len(m.Triplets) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Triplets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Delegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Delegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Delegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Shares.Size()
+		i -= size
+		if _, err := m.Shares.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *UnbondingDelegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnbondingDelegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnbondingDelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *UnbondingDelegationEntry) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnbondingDelegationEntry) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Balance.Size()
+		i -= size
+		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	{
+		size := m.InitialBalance.Size()
+		i -= size
+		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
+	if err8 != nil {
+		return 0, err8
+	}
+	i -= n8
+	i = encodeVarintStaking(dAtA, i, uint64(n8))
+	i--
+	dAtA[i] = 0x12
+	if m.CreationHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *RedelegationEntry) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RedelegationEntry) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.SharesDst.Size()
+		i -= size
+		if _, err := m.SharesDst.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	{
+		size := m.InitialBalance.Size()
+		i -= size
+		if _, err := m.InitialBalance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):])
+	if err9 != nil {
+		return 0, err9
+	}
+	i -= n9
+	i = encodeVarintStaking(dAtA, i, uint64(n9))
+	i--
+	dAtA[i] = 0x12
+	if m.CreationHeight != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.CreationHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Redelegation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Redelegation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Redelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.ValidatorDstAddress) > 0 {
+		i -= len(m.ValidatorDstAddress)
+		copy(dAtA[i:], m.ValidatorDstAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorDstAddress)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.ValidatorSrcAddress) > 0 {
+		i -= len(m.ValidatorSrcAddress)
+		copy(dAtA[i:], m.ValidatorSrcAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.ValidatorSrcAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.DelegatorAddress) > 0 {
+		i -= len(m.DelegatorAddress)
+		copy(dAtA[i:], m.DelegatorAddress)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.DelegatorAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Params) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Params) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.BondDenom) > 0 {
+		i -= len(m.BondDenom)
+		copy(dAtA[i:], m.BondDenom)
+		i = encodeVarintStaking(dAtA, i, uint64(len(m.BondDenom)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.HistoricalEntries != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.HistoricalEntries))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.MaxEntries != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.MaxEntries))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.MaxValidators != 0 {
+		i = encodeVarintStaking(dAtA, i, uint64(m.MaxValidators))
+		i--
+		dAtA[i] = 0x10
+	}
+	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):])
+	if err10 != nil {
+		return 0, err10
+	}
+	i -= n10
+	i = encodeVarintStaking(dAtA, i, uint64(n10))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *DelegationResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DelegationResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Delegation.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *RedelegationEntryResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RedelegationEntryResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RedelegationEntryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Balance.Size()
+		i -= size
+		if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	{
+		size, err := m.RedelegationEntry.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *RedelegationResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RedelegationResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RedelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStaking(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	{
+		size, err := m.Redelegation.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *Pool) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Pool) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.BondedTokens.Size()
+		i -= size
+		if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size := m.NotBondedTokens.Size()
+		i -= size
+		if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintStaking(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintStaking(dAtA []byte, offset int, v uint64) int {
+	offset -= sovStaking(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *HistoricalInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Header.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	if len(m.Valset) > 0 {
+		for _, e := range m.Valset {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *CommissionRates) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Rate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MaxRate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MaxChangeRate.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Commission) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.CommissionRates.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime)
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Description) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Moniker)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Identity)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Website)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.SecurityContact)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.Details)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	return n
+}
+
+func (m *Validator) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.OperatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if m.ConsensusPubkey != nil {
+		l = m.ConsensusPubkey.Size()
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if m.Jailed {
+		n += 2
+	}
+	if m.Status != 0 {
+		n += 1 + sovStaking(uint64(m.Status))
+	}
+	l = m.Tokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.DelegatorShares.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Description.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	if m.UnbondingHeight != 0 {
+		n += 1 + sovStaking(uint64(m.UnbondingHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Commission.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.MinSelfDelegation.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *ValAddresses) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Addresses) > 0 {
+		for _, s := range m.Addresses {
+			l = len(s)
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *DVPair) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	return n
+}
+
+func (m *DVPairs) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Pairs) > 0 {
+		for _, e := range m.Pairs {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *DVVTriplet) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorSrcAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorDstAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	return n
+}
+
+func (m *DVVTriplets) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Triplets) > 0 {
+		for _, e := range m.Triplets {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Delegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = m.Shares.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *UnbondingDelegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *UnbondingDelegationEntry) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreationHeight != 0 {
+		n += 1 + sovStaking(uint64(m.CreationHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.InitialBalance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Balance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *RedelegationEntry) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreationHeight != 0 {
+		n += 1 + sovStaking(uint64(m.CreationHeight))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime)
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.InitialBalance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.SharesDst.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *Redelegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.DelegatorAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorSrcAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	l = len(m.ValidatorDstAddress)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Params) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime)
+	n += 1 + l + sovStaking(uint64(l))
+	if m.MaxValidators != 0 {
+		n += 1 + sovStaking(uint64(m.MaxValidators))
+	}
+	if m.MaxEntries != 0 {
+		n += 1 + sovStaking(uint64(m.MaxEntries))
+	}
+	if m.HistoricalEntries != 0 {
+		n += 1 + sovStaking(uint64(m.HistoricalEntries))
+	}
+	l = len(m.BondDenom)
+	if l > 0 {
+		n += 1 + l + sovStaking(uint64(l))
+	}
+	return n
+}
+
+func (m *DelegationResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Delegation.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Balance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *RedelegationEntryResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.RedelegationEntry.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.Balance.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func (m *RedelegationResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Redelegation.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovStaking(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Pool) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.NotBondedTokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	l = m.BondedTokens.Size()
+	n += 1 + l + sovStaking(uint64(l))
+	return n
+}
+
+func sovStaking(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozStaking(x uint64) (n int) {
+	return sovStaking(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (this *ValAddresses) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&ValAddresses{`,
+		`Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func valueToStringStaking(v interface{}) string {
+	rv := reflect.ValueOf(v)
+	if rv.IsNil() {
+		return "nil"
+	}
+	pv := reflect.Indirect(rv).Interface()
+	return fmt.Sprintf("*%v", pv)
+}
+func (m *HistoricalInfo) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HistoricalInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HistoricalInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Valset", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Valset = append(m.Valset, Validator{})
+			if err := m.Valset[len(m.Valset)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CommissionRates) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: CommissionRates: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CommissionRates: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxRate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxChangeRate", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxChangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Commission) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Commission: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Commission: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CommissionRates", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.CommissionRates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Description) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Description: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Moniker = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Identity = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Website = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SecurityContact", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SecurityContact = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Details = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Validator) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusPubkey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ConsensusPubkey == nil {
+				m.ConsensusPubkey = &types1.Any{}
+			}
+			if err := m.ConsensusPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Jailed = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+			}
+			m.Status = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Status |= BondStatus(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Tokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorShares", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.DelegatorShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingHeight", wireType)
+			}
+			m.UnbondingHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Commission", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Commission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinSelfDelegation", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MinSelfDelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ValAddresses) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ValAddresses: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DVPair) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DVPair: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DVPair: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DVPairs) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DVPairs: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DVPairs: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Pairs = append(m.Pairs, DVPair{})
+			if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DVVTriplet) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DVVTriplet: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DVVTriplet: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DVVTriplets) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DVVTriplets: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DVVTriplets: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Triplets", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Triplets = append(m.Triplets, DVVTriplet{})
+			if err := m.Triplets[len(m.Triplets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Delegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Delegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Delegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Shares", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Shares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *UnbondingDelegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnbondingDelegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnbondingDelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, UnbondingDelegationEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnbondingDelegationEntry: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnbondingDelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+			}
+			m.CreationHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreationHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RedelegationEntry) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RedelegationEntry: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RedelegationEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreationHeight", wireType)
+			}
+			m.CreationHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreationHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SharesDst", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.SharesDst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Redelegation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Redelegation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Redelegation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DelegatorAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSrcAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorSrcAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDstAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorDstAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, RedelegationEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Params) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Params: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
+			}
+			m.MaxValidators = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxValidators |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxEntries", wireType)
+			}
+			m.MaxEntries = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxEntries |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
+			}
+			m.HistoricalEntries = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.HistoricalEntries |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.BondDenom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DelegationResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DelegationResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Delegation", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Delegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RedelegationEntryResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RedelegationEntryResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RedelegationEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RedelegationEntry", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.RedelegationEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RedelegationResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RedelegationResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RedelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Redelegation", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Redelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, RedelegationEntryResponse{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Pool) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Pool: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStaking
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStaking(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStaking
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipStaking(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowStaking
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowStaking
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthStaking
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupStaking
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthStaking
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthStaking        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowStaking          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupStaking = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/staking/legacy/v040/types.go b/x/staking/legacy/v040/types.go
new file mode 100644
index 000000000000..8964296fa97d
--- /dev/null
+++ b/x/staking/legacy/v040/types.go
@@ -0,0 +1,201 @@
+package v040
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	yaml "gopkg.in/yaml.v2"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// Staking params default values
+const (
+	// DefaultUnbondingTime reflects three weeks in seconds as the default
+	// unbonding time.
+	// TODO: Justify our choice of default here.
+	DefaultUnbondingTime time.Duration = time.Hour * 24 * 7 * 3
+
+	// Default maximum number of bonded validators
+	DefaultMaxValidators uint32 = 100
+
+	// Default maximum entries in a UBD/RED pair
+	DefaultMaxEntries uint32 = 7
+
+	// DefaultHistorical entries is 10000. Apps that don't use IBC can ignore this
+	// value by not adding the staking module to the application module manager's
+	// SetOrderBeginBlockers.
+	DefaultHistoricalEntries uint32 = 10000
+)
+
+// NewParams creates a new Params instance
+func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string) Params {
+	return Params{
+		UnbondingTime:     unbondingTime,
+		MaxValidators:     maxValidators,
+		MaxEntries:        maxEntries,
+		HistoricalEntries: historicalEntries,
+		BondDenom:         bondDenom,
+	}
+}
+
+// String returns a human readable string representation of the parameters.
+func (p Params) String() string {
+	out, _ := yaml.Marshal(p)
+	return string(out)
+}
+
+func DefaultParams() Params {
+	return NewParams(
+		DefaultUnbondingTime,
+		DefaultMaxValidators,
+		DefaultMaxEntries,
+		DefaultHistoricalEntries,
+		sdk.DefaultBondDenom,
+	)
+}
+
+// String implements the Stringer interface for a Commission object.
+func (c Commission) String() string {
+	out, _ := yaml.Marshal(c)
+	return string(out)
+}
+
+// String implements the Stringer interface for a CommissionRates object.
+func (cr CommissionRates) String() string {
+	out, _ := yaml.Marshal(cr)
+	return string(out)
+}
+
+// String implements the Stringer interface for a DVPair object.
+func (dv DVPair) String() string {
+	out, _ := yaml.Marshal(dv)
+	return string(out)
+}
+
+// String implements the Stringer interface for a DVVTriplet object.
+func (dvv DVVTriplet) String() string {
+	out, _ := yaml.Marshal(dvv)
+	return string(out)
+}
+
+// String returns a human readable string representation of a Delegation.
+func (d Delegation) String() string {
+	out, _ := yaml.Marshal(d)
+	return string(out)
+}
+
+// Delegations is a collection of delegations
+type Delegations []Delegation
+
+func (d Delegations) String() (out string) {
+	for _, del := range d {
+		out += del.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the stringer interface for a UnbondingDelegationEntry.
+func (e UnbondingDelegationEntry) String() string {
+	out, _ := yaml.Marshal(e)
+	return string(out)
+}
+
+// String returns a human readable string representation of an UnbondingDelegation.
+func (ubd UnbondingDelegation) String() string {
+	out := fmt.Sprintf(`Unbonding Delegations between:
+  Delegator:                 %s
+  Validator:                 %s
+	Entries:`, ubd.DelegatorAddress, ubd.ValidatorAddress)
+	for i, entry := range ubd.Entries {
+		out += fmt.Sprintf(`    Unbonding Delegation %d:
+      Creation Height:           %v
+      Min time to unbond (unix): %v
+      Expected balance:          %s`, i, entry.CreationHeight,
+			entry.CompletionTime, entry.Balance)
+	}
+
+	return out
+}
+
+// UnbondingDelegations is a collection of UnbondingDelegation
+type UnbondingDelegations []UnbondingDelegation
+
+func (ubds UnbondingDelegations) String() (out string) {
+	for _, u := range ubds {
+		out += u.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the Stringer interface for a RedelegationEntry object.
+func (e RedelegationEntry) String() string {
+	out, _ := yaml.Marshal(e)
+	return string(out)
+}
+
+// String returns a human readable string representation of a Redelegation.
+func (red Redelegation) String() string {
+	out := fmt.Sprintf(`Redelegations between:
+  Delegator:                 %s
+  Source Validator:          %s
+  Destination Validator:     %s
+  Entries:
+`,
+		red.DelegatorAddress, red.ValidatorSrcAddress, red.ValidatorDstAddress,
+	)
+
+	for i, entry := range red.Entries {
+		out += fmt.Sprintf(`    Redelegation Entry #%d:
+      Creation height:           %v
+      Min time to unbond (unix): %v
+      Dest Shares:               %s
+`,
+			i, entry.CreationHeight, entry.CompletionTime, entry.SharesDst,
+		)
+	}
+
+	return strings.TrimRight(out, "\n")
+}
+
+// Redelegations are a collection of Redelegation
+type Redelegations []Redelegation
+
+func (d Redelegations) String() (out string) {
+	for _, red := range d {
+		out += red.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the Stringer interface for DelegationResponse.
+func (d DelegationResponse) String() string {
+	return fmt.Sprintf("%s\n  Balance:   %s", d.Delegation.String(), d.Balance)
+}
+
+// String implements the Stringer interface for a Validator object.
+func (v Validator) String() string {
+	out, _ := yaml.Marshal(v)
+	return string(out)
+}
+
+// Validators is a collection of Validator
+type Validators []Validator
+
+func (v Validators) String() (out string) {
+	for _, val := range v {
+		out += val.String() + "\n"
+	}
+
+	return strings.TrimSpace(out)
+}
+
+// String implements the Stringer interface for a Description object.
+func (d Description) String() string {
+	out, _ := yaml.Marshal(d)
+	return string(out)
+}
diff --git a/x/staking/legacy/v043/json.go b/x/staking/legacy/v043/json.go
new file mode 100644
index 000000000000..a6334ee8b107
--- /dev/null
+++ b/x/staking/legacy/v043/json.go
@@ -0,0 +1,138 @@
+package v043
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
+	v043staking "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+// MigrateJSON accepts exported v0.40 x/gov genesis state and migrates it to
+// v0.43 x/gov genesis state. The migration includes:
+//
+// - Gov weighted votes.
+func MigrateJSON(oldState *v040staking.GenesisState) *v043staking.GenesisState {
+	return &v043staking.GenesisState{
+		Params:               migrateParams(oldState.Params),
+		LastTotalPower:       oldState.LastTotalPower,
+		LastValidatorPowers:  migrateLastValidatorPowers(oldState.LastValidatorPowers),
+		Validators:           migrateValidators(oldState.Validators),
+		Delegations:          migrateDelegations(oldState.Delegations),
+		UnbondingDelegations: migrateUnbondingDelegations(oldState.UnbondingDelegations),
+		Redelegations:        migrateRedelegations(oldState.Redelegations),
+		Exported:             oldState.Exported,
+	}
+}
+
+func migrateParams(oldParams v040staking.Params) v043staking.Params {
+	return v043staking.NewParams(
+		oldParams.UnbondingTime,
+		oldParams.MaxValidators,
+		oldParams.MaxEntries,
+		oldParams.HistoricalEntries,
+		oldParams.BondDenom,
+		sdk.DefaultPowerReduction,
+	)
+}
+
+func migrateLastValidatorPowers(oldLastValidatorPowers []v040staking.LastValidatorPower) []v043staking.LastValidatorPower {
+	newLastValidatorPowers := make([]v043staking.LastValidatorPower, len(oldLastValidatorPowers))
+	for i, oldLastValidatorPower := range oldLastValidatorPowers {
+		newLastValidatorPowers[i] = v043staking.LastValidatorPower{
+			Address: oldLastValidatorPower.Address,
+			Power:   oldLastValidatorPower.Power,
+		}
+	}
+	return newLastValidatorPowers
+}
+
+func migrateValidators(oldValidators []v040staking.Validator) []v043staking.Validator {
+	newValidators := make([]v043staking.Validator, len(oldValidators))
+
+	for i, oldValidator := range oldValidators {
+		newValidators[i] = v043staking.Validator{
+			OperatorAddress: oldValidator.OperatorAddress,
+			ConsensusPubkey: oldValidator.ConsensusPubkey,
+			Jailed:          oldValidator.Jailed,
+			Status:          v043staking.BondStatus(oldValidator.Status),
+			Tokens:          oldValidator.Tokens,
+			DelegatorShares: oldValidator.DelegatorShares,
+			Description: v043staking.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.UnbondingTime,
+			Commission: v043staking.Commission{
+				CommissionRates: v043staking.CommissionRates{
+					Rate:          oldValidator.Commission.CommissionRates.Rate,
+					MaxRate:       oldValidator.Commission.CommissionRates.MaxRate,
+					MaxChangeRate: oldValidator.Commission.CommissionRates.MaxChangeRate,
+				},
+				UpdateTime: oldValidator.Commission.UpdateTime,
+			},
+			MinSelfDelegation: oldValidator.MinSelfDelegation,
+		}
+	}
+
+	return newValidators
+}
+
+func migrateDelegations(oldDelegations []v040staking.Delegation) []v043staking.Delegation {
+	newDelegations := make([]v043staking.Delegation, len(oldDelegations))
+	for i, oldDelegation := range oldDelegations {
+		newDelegations[i] = v043staking.Delegation{
+			DelegatorAddress: oldDelegation.DelegatorAddress,
+			ValidatorAddress: oldDelegation.ValidatorAddress,
+			Shares:           oldDelegation.Shares,
+		}
+	}
+	return newDelegations
+}
+
+func migrateUnbondingDelegations(oldUnbondingDelegations []v040staking.UnbondingDelegation) []v043staking.UnbondingDelegation {
+	newUnbondingDelegations := make([]v043staking.UnbondingDelegation, len(oldUnbondingDelegations))
+	for i, oldUnbondingDelegation := range oldUnbondingDelegations {
+		newEntries := make([]v043staking.UnbondingDelegationEntry, len(oldUnbondingDelegation.Entries))
+		for j, oldEntry := range oldUnbondingDelegation.Entries {
+			newEntries[j] = v043staking.UnbondingDelegationEntry{
+				CreationHeight: oldEntry.CreationHeight,
+				CompletionTime: oldEntry.CompletionTime,
+				InitialBalance: oldEntry.InitialBalance,
+				Balance:        oldEntry.Balance,
+			}
+		}
+
+		newUnbondingDelegations[i] = v043staking.UnbondingDelegation{
+			DelegatorAddress: oldUnbondingDelegation.DelegatorAddress,
+			ValidatorAddress: oldUnbondingDelegation.ValidatorAddress,
+			Entries:          newEntries,
+		}
+	}
+	return newUnbondingDelegations
+}
+
+func migrateRedelegations(oldRedelegations []v040staking.Redelegation) []v043staking.Redelegation {
+	newRedelegations := make([]v043staking.Redelegation, len(oldRedelegations))
+	for i, oldRedelegation := range oldRedelegations {
+		newEntries := make([]v043staking.RedelegationEntry, len(oldRedelegation.Entries))
+		for j, oldEntry := range oldRedelegation.Entries {
+			newEntries[j] = v043staking.RedelegationEntry{
+				CreationHeight: oldEntry.CreationHeight,
+				CompletionTime: oldEntry.CompletionTime,
+				InitialBalance: oldEntry.InitialBalance,
+				SharesDst:      oldEntry.SharesDst,
+			}
+		}
+
+		newRedelegations[i] = v043staking.Redelegation{
+			DelegatorAddress:    oldRedelegation.DelegatorAddress,
+			ValidatorSrcAddress: oldRedelegation.ValidatorSrcAddress,
+			ValidatorDstAddress: oldRedelegation.ValidatorDstAddress,
+			Entries:             newEntries,
+		}
+	}
+	return newRedelegations
+}
diff --git a/x/staking/legacy/v043/json_test.go b/x/staking/legacy/v043/json_test.go
new file mode 100644
index 000000000000..82d2422417a1
--- /dev/null
+++ b/x/staking/legacy/v043/json_test.go
@@ -0,0 +1,67 @@
+package v043_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
+	v043staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v043"
+)
+
+func TestMigrateJSON(t *testing.T) {
+	encodingConfig := simapp.MakeTestEncodingConfig()
+	clientCtx := client.Context{}.
+		WithInterfaceRegistry(encodingConfig.InterfaceRegistry).
+		WithTxConfig(encodingConfig.TxConfig).
+		WithJSONMarshaler(encodingConfig.Marshaler)
+
+	// voter, err := sdk.AccAddressFromBech32("cosmos1fl48vsnmsdzcv85q5d2q4z5ajdha8yu34mf0eh")
+	// require.NoError(t, err)
+	stakingGenState := &v040staking.GenesisState{
+		Params: v040staking.DefaultParams(),
+	}
+
+	migrated := v043staking.MigrateJSON(stakingGenState)
+
+	require.True(t, migrated.Params.PowerReduction.Equal(sdk.DefaultPowerReduction))
+
+	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, "", "\t")
+	require.NoError(t, err)
+
+	// Make sure about:
+	// - Votes are all ADR-037 weighted votes with weight 1.
+	expected := `{
+	"delegations": [],
+	"exported": false,
+	"last_total_power": "0",
+	"last_validator_powers": [],
+	"params": {
+		"bond_denom": "stake",
+		"historical_entries": 10000,
+		"max_entries": 7,
+		"max_validators": 100,
+		"power_reduction": "1000000",
+		"unbonding_time": "1814400s"
+	},
+	"redelegations": [],
+	"unbonding_delegations": [],
+	"validators": []
+}`
+
+	fmt.Println(string(indentedBz))
+
+	require.Equal(t, expected, string(indentedBz))
+}
diff --git a/x/staking/legacy/v043/store.go b/x/staking/legacy/v043/store.go
index 4bd6b31e1f2d..f076a0675a97 100644
--- a/x/staking/legacy/v043/store.go
+++ b/x/staking/legacy/v043/store.go
@@ -6,6 +6,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/types/address"
 	v040auth "github.com/cosmos/cosmos-sdk/x/auth/legacy/v040"
 	v043distribution "github.com/cosmos/cosmos-sdk/x/distribution/legacy/v043"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
@@ -54,11 +55,16 @@ func migrateValidatorsByPowerIndexKey(store sdk.KVStore) {
 	}
 }
 
-// MigrateStore performs in-place store migrations from v0.40 to v0.42. The
+func migrateParamsStore(ctx sdk.Context, paramstore paramtypes.Subspace) {
+	paramstore.WithKeyTable(types.ParamKeyTable())
+	paramstore.Set(ctx, types.KeyPowerReduction, sdk.DefaultPowerReduction)
+}
+
+// MigrateStore performs in-place store migrations from v0.40 to v0.43. The
 // migration includes:
 //
-// - Change addresses to be length-prefixed.
-func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey) error {
+// - Setting the Power Reduction param in the paramstore
+func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey, paramstore paramtypes.Subspace) error {
 	store := ctx.KVStore(storeKey)
 
 	v043distribution.MigratePrefixAddress(store, v040staking.LastValidatorPowerKey)
@@ -74,5 +80,7 @@ func MigrateStore(ctx sdk.Context, storeKey sdk.StoreKey) error {
 	migratePrefixAddressAddressAddress(store, v040staking.RedelegationByValSrcIndexKey)
 	migratePrefixAddressAddressAddress(store, v040staking.RedelegationByValDstIndexKey)
 
+	migrateParamsStore(ctx, paramstore)
+
 	return nil
 }
diff --git a/x/staking/legacy/v043/store_test.go b/x/staking/legacy/v043/store_test.go
index 7c1861ffe86e..7d1422ebc014 100644
--- a/x/staking/legacy/v043/store_test.go
+++ b/x/staking/legacy/v043/store_test.go
@@ -7,9 +7,11 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/simapp"
 	"github.com/cosmos/cosmos-sdk/testutil"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	v040staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v040"
 	v043staking "github.com/cosmos/cosmos-sdk/x/staking/legacy/v043"
 	"github.com/cosmos/cosmos-sdk/x/staking/teststaking"
@@ -17,10 +19,14 @@ import (
 )
 
 func TestStoreMigration(t *testing.T) {
+	encCfg := simapp.MakeTestEncodingConfig()
 	stakingKey := sdk.NewKVStoreKey("staking")
-	ctx := testutil.DefaultContext(stakingKey, sdk.NewTransientStoreKey("transient_test"))
+	tStakingKey := sdk.NewTransientStoreKey("transient_test")
+	ctx := testutil.DefaultContext(stakingKey, tStakingKey)
 	store := ctx.KVStore(stakingKey)
 
+	paramSubspace := paramtypes.NewSubspace(encCfg.Marshaler, encCfg.Amino, stakingKey, tStakingKey, types.ModuleName)
+
 	_, pk1, addr1 := testdata.KeyTestPubAddr()
 	valAddr1 := sdk.ValAddress(addr1)
 	val := teststaking.NewValidator(t, valAddr1, pk1)
@@ -121,7 +127,7 @@ func TestStoreMigration(t *testing.T) {
 	}
 
 	// Run migrations.
-	err := v043staking.MigrateStore(ctx, stakingKey)
+	err := v043staking.MigrateStore(ctx, stakingKey, paramSubspace)
 	require.NoError(t, err)
 
 	// Make sure the new keys are set and old keys are deleted.
@@ -134,4 +140,8 @@ func TestStoreMigration(t *testing.T) {
 			require.Equal(t, value, store.Get(tc.newKey))
 		})
 	}
+
+	powerReduction := sdk.NewInt(0)
+	paramSubspace.Get(ctx, types.KeyPowerReduction, &powerReduction)
+	require.True(t, powerReduction.Equal(sdk.DefaultPowerReduction))
 }
diff --git a/x/staking/types/params.go b/x/staking/types/params.go
index 92fb0dad898d..1f5e81b44e05 100644
--- a/x/staking/types/params.go
+++ b/x/staking/types/params.go
@@ -68,7 +68,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(KeyMaxEntries, &p.MaxEntries, validateMaxEntries),
 		paramtypes.NewParamSetPair(KeyHistoricalEntries, &p.HistoricalEntries, validateHistoricalEntries),
 		paramtypes.NewParamSetPair(KeyBondDenom, &p.BondDenom, validateBondDenom),
-		paramtypes.NewParamSetPair(KeyPowerReduction, &p.PowerReduction, validatePowerReduction),
+		paramtypes.NewParamSetPair(KeyPowerReduction, &p.PowerReduction, ValidatePowerReduction),
 	}
 }
 
@@ -196,7 +196,7 @@ func validateBondDenom(i interface{}) error {
 	return nil
 }
 
-func validatePowerReduction(i interface{}) error {
+func ValidatePowerReduction(i interface{}) error {
 	v, ok := i.(sdk.Int)
 	if !ok {
 		return fmt.Errorf("invalid parameter type: %T", i)

From 8cf5fe0b9b3f55045e16ec9bd07e3efb2c576d4a Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Wed, 7 Apr 2021 20:07:52 -0400
Subject: [PATCH 21/23] add nolint to pb.go files

---
 x/staking/legacy/v040/genesis.pb.go | 3 +--
 x/staking/legacy/v040/staking.pb.go | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/x/staking/legacy/v040/genesis.pb.go b/x/staking/legacy/v040/genesis.pb.go
index 04644e17ea64..af9e607d28ac 100644
--- a/x/staking/legacy/v040/genesis.pb.go
+++ b/x/staking/legacy/v040/genesis.pb.go
@@ -1,8 +1,7 @@
 // Package v040 is taken from:
 // https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/x/staking/types/genesis.pb.go
 // by copy-pasted only the relevants parts for Genesis.
-//nolint
-
+// nolint
 package v040
 
 import (
diff --git a/x/staking/legacy/v040/staking.pb.go b/x/staking/legacy/v040/staking.pb.go
index 71ae65fe3a4e..3200520a71a4 100644
--- a/x/staking/legacy/v040/staking.pb.go
+++ b/x/staking/legacy/v040/staking.pb.go
@@ -1,7 +1,6 @@
 // Package v040 is taken from:
 // https://github.com/cosmos/cosmos-sdk/blob/v0.40.1/x/staking/types/staking.pb.go
-//nolint
-
+// nolint
 package v040
 
 import (

From cd8186e8e489f0303fc58f8ad59ccd1f76626abd Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Fri, 9 Apr 2021 13:32:14 -0400
Subject: [PATCH 22/23] fix rosetta-test

---
 contrib/rosetta/configuration/bootstrap.json |   2 +-
 contrib/rosetta/node/data.tar.gz             | Bin 36795 -> 36436 bytes
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/rosetta/configuration/bootstrap.json b/contrib/rosetta/configuration/bootstrap.json
index 1696d9bd8cf1..e014a1043261 100644
--- a/contrib/rosetta/configuration/bootstrap.json
+++ b/contrib/rosetta/configuration/bootstrap.json
@@ -1,7 +1,7 @@
 [
   {
     "account_identifier": {
-      "address":"cosmos1tqpwnlx558r36pmf5h8xxct94qcq00h2p5evag"
+      "address":"cosmos1kezmr2chzy7w00nhh7qxhpqphdwum3j0mgdaw0"
     },
     "currency":{
       "symbol":"stake",
diff --git a/contrib/rosetta/node/data.tar.gz b/contrib/rosetta/node/data.tar.gz
index 291681c89dc091faa0a0962c341eca0a8642eab1..d96715778251d8388d761d2bf3623bc96c99a8f3 100644
GIT binary patch
literal 36436
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
E0Ag?6Qvd(}

literal 36795
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


From 4b778abf91fbbb7a9f1dadbc76077eeecc3448ea Mon Sep 17 00:00:00 2001
From: Sunny Aggarwal <sunnya97@protonmail.ch>
Date: Sat, 10 Apr 2021 19:23:58 -0400
Subject: [PATCH 23/23] merged master

---
 x/auth/legacy/v043/store_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x/auth/legacy/v043/store_test.go b/x/auth/legacy/v043/store_test.go
index acd06fe8783c..3daa2d52fc53 100644
--- a/x/auth/legacy/v043/store_test.go
+++ b/x/auth/legacy/v043/store_test.go
@@ -657,7 +657,7 @@ func dirtyTrackingFields(ctx sdk.Context, vesting exported.VestingAccount, app *
 }
 
 func createValidator(t *testing.T, ctx sdk.Context, app *simapp.SimApp, powers int64) (sdk.AccAddress, sdk.ValAddress) {
-	valTokens := sdk.TokensFromConsensusPower(powers)
+	valTokens := sdk.TokensFromConsensusPower(powers, sdk.DefaultPowerReduction)
 	addrs := simapp.AddTestAddrsIncremental(app, ctx, 1, valTokens)
 	valAddrs := simapp.ConvertAddrsToValAddrs(addrs)
 	pks := simapp.CreateTestPubKeys(1)