diff --git a/proto/osmosis/poolmanager/v1beta1/query.proto b/proto/osmosis/poolmanager/v1beta1/query.proto
index 39c49eccb09..03d25dbec6d 100644
--- a/proto/osmosis/poolmanager/v1beta1/query.proto
+++ b/proto/osmosis/poolmanager/v1beta1/query.proto
@@ -91,6 +91,12 @@ service Query {
   rpc AllPools(AllPoolsRequest) returns (AllPoolsResponse) {
     option (google.api.http).get = "/osmosis/poolmanager/v1beta1/all-pools";
   }
+  // ListPoolsByDenom return all pools by denom
+  rpc ListPoolsByDenom(ListPoolsByDenomRequest)
+      returns (ListPoolsByDenomResponse) {
+    option (google.api.http).get =
+        "/osmosis/poolmanager/v1beta1/list-pools-by-denom";
+  }
 
   // SpotPrice defines a gRPC query handler that returns the spot price given
   // a base denomination and a quote denomination.
@@ -234,6 +240,17 @@ message AllPoolsResponse {
       [ (cosmos_proto.accepts_interface) = "PoolI" ];
 }
 
+// =======================================================
+// ListPoolsByDenomRequest
+message ListPoolsByDenomRequest {
+  string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+}
+
+message ListPoolsByDenomResponse {
+  repeated google.protobuf.Any pools = 1
+      [ (cosmos_proto.accepts_interface) = "PoolI" ];
+}
+// ==========================================================
 // SpotPriceRequest defines the gRPC request structure for a SpotPrice
 // query.
 message SpotPriceRequest {
diff --git a/scripts/setup_superfluid.sh b/scripts/setup_superfluid.sh
old mode 100644
new mode 100755
index ee5f4c94bee..ead323b8959
--- a/scripts/setup_superfluid.sh
+++ b/scripts/setup_superfluid.sh
@@ -33,4 +33,4 @@ sleep 7
 osmosisd tx gov vote 1 yes --from=validator1 --keyring-backend=test --chain-id=testing --yes --home=$HOME/.osmosisd/validator1
 sleep 7
 osmosisd tx gov vote 1 yes --from=validator2 --keyring-backend=test --chain-id=testing --yes --home=$HOME/.osmosisd/validator2
-sleep 7
+sleep 7
\ No newline at end of file
diff --git a/x/poolmanager/client/cli/query.go b/x/poolmanager/client/cli/query.go
index 47232192c45..5d676549615 100644
--- a/x/poolmanager/client/cli/query.go
+++ b/x/poolmanager/client/cli/query.go
@@ -32,6 +32,7 @@ func GetQueryCmd() *cobra.Command {
 	osmocli.AddQueryCmd(cmd, queryproto.NewQueryClient, GetCmdTotalVolumeForPool)
 	osmocli.AddQueryCmd(cmd, queryproto.NewQueryClient, GetCmdTradingPairTakerFee)
 	osmocli.AddQueryCmd(cmd, queryproto.NewQueryClient, GetCmdEstimateTradeBasedOnPriceImpact)
+	osmocli.AddQueryCmd(cmd, queryproto.NewQueryClient, GetCmdListPoolsByDenom)
 	cmd.AddCommand(
 		osmocli.GetParams[*queryproto.ParamsRequest](
 			types.ModuleName, queryproto.NewQueryClient),
@@ -105,6 +106,15 @@ func GetCmdSpotPrice() (*osmocli.QueryDescriptor, *queryproto.SpotPriceRequest)
 `,
 	}, &queryproto.SpotPriceRequest{}
 }
+func GetCmdListPoolsByDenom() (*osmocli.QueryDescriptor, *queryproto.ListPoolsByDenomRequest) {
+	return &osmocli.QueryDescriptor{
+		Use:   "list-pools-by-denom",
+		Short: "Query list-pools-by-denom",
+		Long: `Query list-pools-by-denom
+{{.CommandPrefix}} list-pools-by-denom uosmo 
+`,
+	}, &queryproto.ListPoolsByDenomRequest{}
+}
 
 func EstimateSwapExactAmountInParseArgs(args []string, fs *flag.FlagSet) (proto.Message, error) {
 	poolID, err := strconv.Atoi(args[0])
diff --git a/x/poolmanager/client/grpc/grpc_query.go b/x/poolmanager/client/grpc/grpc_query.go
index a47c7e9b9d3..4bdc58d6da4 100644
--- a/x/poolmanager/client/grpc/grpc_query.go
+++ b/x/poolmanager/client/grpc/grpc_query.go
@@ -71,6 +71,16 @@ func (q Querier) SpotPrice(grpcCtx context.Context,
 	return q.Q.SpotPrice(ctx, *req)
 }
 
+func (q Querier) ListPoolsByDenom(grpcCtx context.Context,
+	req *queryproto.ListPoolsByDenomRequest,
+) (*queryproto.ListPoolsByDenomResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+	ctx := sdk.UnwrapSDKContext(grpcCtx)
+	return q.Q.ListPoolsByDenom(ctx, *req)
+}
+
 func (q Querier) Pool(grpcCtx context.Context,
 	req *queryproto.PoolRequest,
 ) (*queryproto.PoolResponse, error) {
diff --git a/x/poolmanager/client/query_proto_wrap.go b/x/poolmanager/client/query_proto_wrap.go
index a88917012be..5425bbde0de 100644
--- a/x/poolmanager/client/query_proto_wrap.go
+++ b/x/poolmanager/client/query_proto_wrap.go
@@ -214,6 +214,30 @@ func (q Querier) AllPools(ctx sdk.Context, req queryproto.AllPoolsRequest) (*que
 	}, nil
 }
 
+// ListPoolsByDenom returns a list of pools filtered by denom
+func (q Querier) ListPoolsByDenom(ctx sdk.Context, req queryproto.ListPoolsByDenomRequest) (*queryproto.ListPoolsByDenomResponse, error) {
+	if req.Denom == "" {
+		return nil, status.Error(codes.InvalidArgument, "invalid denom")
+	}
+	pools, err := q.K.ListPoolsByDenom(ctx, req.Denom)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	var anyPools []*codectypes.Any
+	for _, pool := range pools {
+		any, err := codectypes.NewAnyWithValue(pool.AsSerializablePool())
+		if err != nil {
+			return nil, err
+		}
+		anyPools = append(anyPools, any)
+	}
+
+	return &queryproto.ListPoolsByDenomResponse{
+		Pools: anyPools,
+	}, nil
+}
+
 // SpotPrice returns the spot price of the pool with the given quote and base asset denoms. 18 decimals.
 func (q Querier) SpotPrice(ctx sdk.Context, req queryproto.SpotPriceRequest) (*queryproto.SpotPriceResponse, error) {
 	if req.BaseAssetDenom == "" {
diff --git a/x/poolmanager/client/queryproto/query.pb.go b/x/poolmanager/client/queryproto/query.pb.go
index b1854156588..006cc48510a 100644
--- a/x/poolmanager/client/queryproto/query.pb.go
+++ b/x/poolmanager/client/queryproto/query.pb.go
@@ -837,6 +837,97 @@ func (m *AllPoolsResponse) GetPools() []*types1.Any {
 	return nil
 }
 
+// =======================================================
+// ListPoolsByDenomRequest
+type ListPoolsByDenomRequest struct {
+	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
+}
+
+func (m *ListPoolsByDenomRequest) Reset()         { *m = ListPoolsByDenomRequest{} }
+func (m *ListPoolsByDenomRequest) String() string { return proto.CompactTextString(m) }
+func (*ListPoolsByDenomRequest) ProtoMessage()    {}
+func (*ListPoolsByDenomRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6256a4106f701b7d, []int{16}
+}
+func (m *ListPoolsByDenomRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListPoolsByDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListPoolsByDenomRequest.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 *ListPoolsByDenomRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListPoolsByDenomRequest.Merge(m, src)
+}
+func (m *ListPoolsByDenomRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListPoolsByDenomRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListPoolsByDenomRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListPoolsByDenomRequest proto.InternalMessageInfo
+
+func (m *ListPoolsByDenomRequest) GetDenom() string {
+	if m != nil {
+		return m.Denom
+	}
+	return ""
+}
+
+type ListPoolsByDenomResponse struct {
+	Pools []*types1.Any `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools,omitempty"`
+}
+
+func (m *ListPoolsByDenomResponse) Reset()         { *m = ListPoolsByDenomResponse{} }
+func (m *ListPoolsByDenomResponse) String() string { return proto.CompactTextString(m) }
+func (*ListPoolsByDenomResponse) ProtoMessage()    {}
+func (*ListPoolsByDenomResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6256a4106f701b7d, []int{17}
+}
+func (m *ListPoolsByDenomResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListPoolsByDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListPoolsByDenomResponse.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 *ListPoolsByDenomResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListPoolsByDenomResponse.Merge(m, src)
+}
+func (m *ListPoolsByDenomResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListPoolsByDenomResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListPoolsByDenomResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListPoolsByDenomResponse proto.InternalMessageInfo
+
+func (m *ListPoolsByDenomResponse) GetPools() []*types1.Any {
+	if m != nil {
+		return m.Pools
+	}
+	return nil
+}
+
+// ==========================================================
 // SpotPriceRequest defines the gRPC request structure for a SpotPrice
 // query.
 type SpotPriceRequest struct {
@@ -849,7 +940,7 @@ func (m *SpotPriceRequest) Reset()         { *m = SpotPriceRequest{} }
 func (m *SpotPriceRequest) String() string { return proto.CompactTextString(m) }
 func (*SpotPriceRequest) ProtoMessage()    {}
 func (*SpotPriceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{16}
+	return fileDescriptor_6256a4106f701b7d, []int{18}
 }
 func (m *SpotPriceRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -910,7 +1001,7 @@ func (m *SpotPriceResponse) Reset()         { *m = SpotPriceResponse{} }
 func (m *SpotPriceResponse) String() string { return proto.CompactTextString(m) }
 func (*SpotPriceResponse) ProtoMessage()    {}
 func (*SpotPriceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{17}
+	return fileDescriptor_6256a4106f701b7d, []int{19}
 }
 func (m *SpotPriceResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -955,7 +1046,7 @@ func (m *TotalPoolLiquidityRequest) Reset()         { *m = TotalPoolLiquidityReq
 func (m *TotalPoolLiquidityRequest) String() string { return proto.CompactTextString(m) }
 func (*TotalPoolLiquidityRequest) ProtoMessage()    {}
 func (*TotalPoolLiquidityRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{18}
+	return fileDescriptor_6256a4106f701b7d, []int{20}
 }
 func (m *TotalPoolLiquidityRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -999,7 +1090,7 @@ func (m *TotalPoolLiquidityResponse) Reset()         { *m = TotalPoolLiquidityRe
 func (m *TotalPoolLiquidityResponse) String() string { return proto.CompactTextString(m) }
 func (*TotalPoolLiquidityResponse) ProtoMessage()    {}
 func (*TotalPoolLiquidityResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{19}
+	return fileDescriptor_6256a4106f701b7d, []int{21}
 }
 func (m *TotalPoolLiquidityResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1043,7 +1134,7 @@ func (m *TotalLiquidityRequest) Reset()         { *m = TotalLiquidityRequest{} }
 func (m *TotalLiquidityRequest) String() string { return proto.CompactTextString(m) }
 func (*TotalLiquidityRequest) ProtoMessage()    {}
 func (*TotalLiquidityRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{20}
+	return fileDescriptor_6256a4106f701b7d, []int{22}
 }
 func (m *TotalLiquidityRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1080,7 +1171,7 @@ func (m *TotalLiquidityResponse) Reset()         { *m = TotalLiquidityResponse{}
 func (m *TotalLiquidityResponse) String() string { return proto.CompactTextString(m) }
 func (*TotalLiquidityResponse) ProtoMessage()    {}
 func (*TotalLiquidityResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{21}
+	return fileDescriptor_6256a4106f701b7d, []int{23}
 }
 func (m *TotalLiquidityResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1125,7 +1216,7 @@ func (m *TotalVolumeForPoolRequest) Reset()         { *m = TotalVolumeForPoolReq
 func (m *TotalVolumeForPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*TotalVolumeForPoolRequest) ProtoMessage()    {}
 func (*TotalVolumeForPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{22}
+	return fileDescriptor_6256a4106f701b7d, []int{24}
 }
 func (m *TotalVolumeForPoolRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1169,7 +1260,7 @@ func (m *TotalVolumeForPoolResponse) Reset()         { *m = TotalVolumeForPoolRe
 func (m *TotalVolumeForPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*TotalVolumeForPoolResponse) ProtoMessage()    {}
 func (*TotalVolumeForPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{23}
+	return fileDescriptor_6256a4106f701b7d, []int{25}
 }
 func (m *TotalVolumeForPoolResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1215,7 +1306,7 @@ func (m *TradingPairTakerFeeRequest) Reset()         { *m = TradingPairTakerFeeR
 func (m *TradingPairTakerFeeRequest) String() string { return proto.CompactTextString(m) }
 func (*TradingPairTakerFeeRequest) ProtoMessage()    {}
 func (*TradingPairTakerFeeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{24}
+	return fileDescriptor_6256a4106f701b7d, []int{26}
 }
 func (m *TradingPairTakerFeeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1266,7 +1357,7 @@ func (m *TradingPairTakerFeeResponse) Reset()         { *m = TradingPairTakerFee
 func (m *TradingPairTakerFeeResponse) String() string { return proto.CompactTextString(m) }
 func (*TradingPairTakerFeeResponse) ProtoMessage()    {}
 func (*TradingPairTakerFeeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{25}
+	return fileDescriptor_6256a4106f701b7d, []int{27}
 }
 func (m *TradingPairTakerFeeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1322,7 +1413,7 @@ func (m *EstimateTradeBasedOnPriceImpactRequest) Reset() {
 func (m *EstimateTradeBasedOnPriceImpactRequest) String() string { return proto.CompactTextString(m) }
 func (*EstimateTradeBasedOnPriceImpactRequest) ProtoMessage()    {}
 func (*EstimateTradeBasedOnPriceImpactRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{26}
+	return fileDescriptor_6256a4106f701b7d, []int{28}
 }
 func (m *EstimateTradeBasedOnPriceImpactRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1391,7 +1482,7 @@ func (m *EstimateTradeBasedOnPriceImpactResponse) Reset() {
 func (m *EstimateTradeBasedOnPriceImpactResponse) String() string { return proto.CompactTextString(m) }
 func (*EstimateTradeBasedOnPriceImpactResponse) ProtoMessage()    {}
 func (*EstimateTradeBasedOnPriceImpactResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6256a4106f701b7d, []int{27}
+	return fileDescriptor_6256a4106f701b7d, []int{29}
 }
 func (m *EstimateTradeBasedOnPriceImpactResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1451,6 +1542,8 @@ func init() {
 	proto.RegisterType((*PoolResponse)(nil), "osmosis.poolmanager.v1beta1.PoolResponse")
 	proto.RegisterType((*AllPoolsRequest)(nil), "osmosis.poolmanager.v1beta1.AllPoolsRequest")
 	proto.RegisterType((*AllPoolsResponse)(nil), "osmosis.poolmanager.v1beta1.AllPoolsResponse")
+	proto.RegisterType((*ListPoolsByDenomRequest)(nil), "osmosis.poolmanager.v1beta1.ListPoolsByDenomRequest")
+	proto.RegisterType((*ListPoolsByDenomResponse)(nil), "osmosis.poolmanager.v1beta1.ListPoolsByDenomResponse")
 	proto.RegisterType((*SpotPriceRequest)(nil), "osmosis.poolmanager.v1beta1.SpotPriceRequest")
 	proto.RegisterType((*SpotPriceResponse)(nil), "osmosis.poolmanager.v1beta1.SpotPriceResponse")
 	proto.RegisterType((*TotalPoolLiquidityRequest)(nil), "osmosis.poolmanager.v1beta1.TotalPoolLiquidityRequest")
@@ -1470,129 +1563,135 @@ func init() {
 }
 
 var fileDescriptor_6256a4106f701b7d = []byte{
-	// 1950 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcb, 0x73, 0x1b, 0x49,
-	0x19, 0xcf, 0xc8, 0x8a, 0xd7, 0xfa, 0x1c, 0x3f, 0xd2, 0x89, 0x13, 0x5b, 0x09, 0x96, 0xb7, 0xb3,
-	0x64, 0xbd, 0x71, 0x3c, 0x8a, 0xed, 0x2c, 0x09, 0x81, 0x7d, 0x58, 0xb6, 0xb3, 0x11, 0x2c, 0xc4,
-	0x4c, 0xbc, 0x0f, 0x16, 0xc2, 0xd4, 0xd8, 0xea, 0x28, 0x43, 0x34, 0xd3, 0x8a, 0xa6, 0xc7, 0xb1,
-	0x8b, 0xda, 0x0b, 0x55, 0x14, 0x9c, 0xa8, 0x05, 0x0e, 0x7b, 0xe0, 0x40, 0x71, 0xe0, 0xb2, 0x7b,
-	0x85, 0xff, 0x21, 0xb5, 0x55, 0x50, 0xae, 0x82, 0x2a, 0x28, 0x0e, 0x82, 0x4a, 0x38, 0x50, 0x45,
-	0x2e, 0xe8, 0x2f, 0xa0, 0xfa, 0x31, 0x23, 0x69, 0x2c, 0x8d, 0x46, 0xb2, 0x0f, 0x9c, 0x2c, 0x75,
-	0x7f, 0xaf, 0xdf, 0xaf, 0xbf, 0xaf, 0x67, 0x7e, 0x32, 0xbc, 0x4a, 0x3d, 0x87, 0x7a, 0xb6, 0x97,
-	0xaf, 0x52, 0x5a, 0x71, 0x2c, 0xd7, 0x2a, 0x93, 0x5a, 0x7e, 0x77, 0x69, 0x9b, 0x30, 0x6b, 0x29,
-	0xff, 0xd8, 0x27, 0xb5, 0x7d, 0xbd, 0x5a, 0xa3, 0x8c, 0xa2, 0x0b, 0xca, 0x50, 0x6f, 0x31, 0xd4,
-	0x95, 0x61, 0xf6, 0x6c, 0x99, 0x96, 0xa9, 0xb0, 0xcb, 0xf3, 0x4f, 0xd2, 0x25, 0xfb, 0x5a, 0x5c,
-	0xec, 0x32, 0x71, 0x89, 0x08, 0x27, 0x4c, 0x5f, 0x89, 0x33, 0x65, 0x7b, 0xca, 0xea, 0x6a, 0x9c,
-	0x95, 0xf7, 0xc4, 0xaa, 0x9a, 0x35, 0xea, 0x33, 0xa2, 0xac, 0x67, 0x77, 0x84, 0x79, 0x7e, 0xdb,
-	0xf2, 0x48, 0x68, 0xb5, 0x43, 0x6d, 0x57, 0xed, 0x5f, 0x69, 0xdd, 0x17, 0x50, 0x43, 0xab, 0xaa,
-	0x55, 0xb6, 0x5d, 0x8b, 0xd9, 0x34, 0xb0, 0xbd, 0x58, 0xa6, 0xb4, 0x5c, 0x21, 0x79, 0xab, 0x6a,
-	0xe7, 0x2d, 0xd7, 0xa5, 0x4c, 0x6c, 0x06, 0xd5, 0xcf, 0xa8, 0x5d, 0xf1, 0x6d, 0xdb, 0x7f, 0x90,
-	0xb7, 0xdc, 0xfd, 0x60, 0x4b, 0x26, 0x31, 0x25, 0x39, 0xf2, 0x8b, 0xda, 0xca, 0x45, 0xbd, 0x98,
-	0xed, 0x10, 0x8f, 0x59, 0x4e, 0x55, 0x1a, 0xe0, 0x09, 0x18, 0xdb, 0xb4, 0x6a, 0x96, 0xe3, 0x19,
-	0xe4, 0xb1, 0x4f, 0x3c, 0x86, 0xef, 0xc1, 0x78, 0xb0, 0xe0, 0x55, 0xa9, 0xeb, 0x11, 0xb4, 0x0a,
-	0xc3, 0x55, 0xb1, 0x32, 0xad, 0xcd, 0x69, 0xf3, 0xa3, 0xcb, 0x97, 0xf4, 0x98, 0x63, 0xd2, 0xa5,
-	0x73, 0x21, 0xfd, 0xb4, 0x9e, 0x3b, 0x61, 0x28, 0x47, 0xfc, 0x42, 0x83, 0xb9, 0x0d, 0x8f, 0xd9,
-	0x8e, 0xc5, 0xc8, 0xbd, 0x27, 0x56, 0x75, 0x63, 0xcf, 0xda, 0x61, 0xab, 0x0e, 0xf5, 0x5d, 0x56,
-	0x74, 0x55, 0x66, 0xb4, 0x00, 0x2f, 0xf1, 0x80, 0xa6, 0x5d, 0x9a, 0x4e, 0xcd, 0x69, 0xf3, 0xe9,
-	0x02, 0x6a, 0xd4, 0x73, 0xe3, 0xfb, 0x96, 0x53, 0xb9, 0x85, 0xd5, 0x06, 0x36, 0x86, 0xf9, 0xa7,
-	0x62, 0x09, 0xe9, 0x30, 0xc2, 0xe8, 0x23, 0xe2, 0x9a, 0xb6, 0x3b, 0x3d, 0x34, 0xa7, 0xcd, 0x67,
-	0x0a, 0x67, 0x1a, 0xf5, 0xdc, 0x84, 0xb4, 0x0e, 0x76, 0xb0, 0xf1, 0x92, 0xf8, 0x58, 0x74, 0xd1,
-	0x7d, 0x18, 0x16, 0xe7, 0xe6, 0x4d, 0xa7, 0xe7, 0x86, 0xe6, 0x47, 0x97, 0xf5, 0x58, 0x10, 0xbc,
-	0xc6, 0xb0, 0x3c, 0xee, 0x56, 0x98, 0xe2, 0x78, 0x1a, 0xf5, 0xdc, 0x98, 0xcc, 0x20, 0x63, 0x61,
-	0x43, 0x05, 0xfd, 0x46, 0x7a, 0x44, 0x9b, 0x4c, 0x19, 0xc3, 0x1e, 0x71, 0x4b, 0xa4, 0x86, 0x3f,
-	0x4b, 0xc1, 0x72, 0x57, 0xb8, 0x1f, 0xd8, 0xec, 0xe1, 0x66, 0xcd, 0x76, 0x6c, 0x66, 0xef, 0x92,
-	0xad, 0xfd, 0x2a, 0xf1, 0x3a, 0x10, 0xa0, 0xf5, 0x45, 0x40, 0x2a, 0x01, 0x01, 0x6f, 0xc1, 0xb8,
-	0xac, 0xd5, 0x0c, 0x72, 0x0c, 0xcd, 0x0d, 0xcd, 0xa7, 0x0b, 0x33, 0x8d, 0x7a, 0x6e, 0xaa, 0x15,
-	0x94, 0x19, 0xa6, 0x3a, 0x25, 0x17, 0x36, 0x65, 0xc2, 0xf7, 0xe1, 0x9c, 0x32, 0x90, 0xd1, 0xa9,
-	0xcf, 0xcc, 0x12, 0x71, 0xa9, 0x23, 0x18, 0xcd, 0x14, 0x5e, 0x6e, 0xd4, 0x73, 0x5f, 0x6a, 0x0b,
-	0x14, 0xb1, 0xc3, 0xc6, 0x19, 0xb9, 0xb1, 0xc5, 0xd7, 0xef, 0xfa, 0x6c, 0x5d, 0xac, 0xfe, 0x51,
-	0x83, 0x2b, 0x21, 0x59, 0xb6, 0x5b, 0xae, 0x10, 0x9e, 0x30, 0x49, 0x97, 0x1c, 0x3f, 0x49, 0x05,
-	0x98, 0x88, 0x82, 0x93, 0xcd, 0x95, 0x6d, 0xd4, 0x73, 0xe7, 0x5a, 0xdd, 0x5a, 0x50, 0x8d, 0xb1,
-	0x36, 0x3c, 0x3f, 0xd5, 0xe0, 0xe5, 0x98, 0x5e, 0x57, 0x43, 0xb5, 0x0d, 0x93, 0xcd, 0x40, 0x96,
-	0xd8, 0x15, 0x78, 0x32, 0x85, 0x9b, 0xbc, 0xd3, 0xfe, 0x5e, 0xcf, 0x4d, 0xc9, 0x41, 0xf6, 0x4a,
-	0x8f, 0x74, 0x9b, 0xe6, 0x1d, 0x8b, 0x3d, 0xd4, 0x8b, 0x2e, 0x6b, 0xd4, 0x73, 0xe7, 0xa3, 0x75,
-	0x48, 0x77, 0x6c, 0x8c, 0x07, 0x85, 0xc8, 0x6c, 0xf8, 0xbf, 0xdd, 0x2b, 0xb9, 0xeb, 0xb3, 0x81,
-	0xc6, 0xee, 0x07, 0xe1, 0x18, 0x0d, 0x89, 0x31, 0xca, 0x27, 0x1c, 0x23, 0x9e, 0x2f, 0xc1, 0x1c,
-	0xa1, 0x25, 0xc8, 0x84, 0xb8, 0xa6, 0xd3, 0x82, 0x8f, 0xb3, 0x8d, 0x7a, 0x6e, 0x32, 0x02, 0x19,
-	0x1b, 0x23, 0x01, 0xd6, 0xc8, 0xe8, 0x7d, 0x9e, 0x82, 0x95, 0xee, 0x98, 0x8f, 0x69, 0xf6, 0x0e,
-	0xcf, 0x52, 0xaa, 0xbf, 0x59, 0xba, 0x07, 0x53, 0x6d, 0x33, 0x62, 0xbb, 0x61, 0xb7, 0xf1, 0x51,
-	0x9a, 0x6b, 0xd4, 0x73, 0x17, 0x3b, 0x8c, 0x52, 0x60, 0x86, 0x0d, 0xd4, 0x32, 0x49, 0x45, 0x57,
-	0x34, 0xde, 0x00, 0xdc, 0xe1, 0x3f, 0x69, 0xb0, 0xd0, 0x73, 0xf6, 0x3a, 0xf7, 0x4a, 0x22, 0x96,
-	0x22, 0xe8, 0xe4, 0x08, 0xb6, 0xb0, 0x14, 0x85, 0x75, 0x8a, 0x75, 0x05, 0x34, 0x94, 0x08, 0xd0,
-	0x4f, 0x34, 0xc0, 0x71, 0x2d, 0xaf, 0xa6, 0xcf, 0x0c, 0xe6, 0xdc, 0x76, 0xdb, 0x87, 0xef, 0x46,
-	0xaf, 0xe1, 0x3b, 0x17, 0x29, 0x3c, 0x98, 0xbd, 0x31, 0x55, 0xb9, 0x1a, 0xbd, 0xd3, 0x30, 0xf1,
-	0x6d, 0xdf, 0xe1, 0x64, 0x86, 0x0f, 0xd6, 0x0d, 0x98, 0x6c, 0x2e, 0xa9, 0x3a, 0x96, 0x20, 0xe3,
-	0xfa, 0x8e, 0xe8, 0x12, 0x4f, 0x31, 0xda, 0x82, 0x30, 0xdc, 0xc2, 0xc6, 0x88, 0xab, 0x5c, 0xf1,
-	0x2d, 0x18, 0xe5, 0x1f, 0x06, 0x39, 0x11, 0xbc, 0x06, 0xa7, 0xa4, 0xaf, 0x4a, 0xbf, 0x02, 0x69,
-	0xbe, 0xa3, 0x9e, 0xeb, 0x67, 0x75, 0xf9, 0xb2, 0xa0, 0x07, 0x2f, 0x0b, 0xfa, 0xaa, 0xbb, 0x5f,
-	0xc8, 0x7c, 0xf1, 0xfb, 0xc5, 0x93, 0xa2, 0x6d, 0x0d, 0x61, 0xcc, 0xa1, 0xad, 0x56, 0x2a, 0x6d,
-	0xd0, 0x8a, 0x30, 0xd9, 0x5c, 0x52, 0xb1, 0x5f, 0x87, 0x93, 0x01, 0xac, 0xa1, 0x24, 0xc1, 0xa5,
-	0x35, 0x3e, 0xd0, 0x60, 0xf2, 0x5e, 0x95, 0xb2, 0xcd, 0x9a, 0xbd, 0x43, 0x06, 0x6a, 0xbb, 0x0d,
-	0x98, 0xe4, 0x6f, 0x5b, 0xa6, 0xe5, 0x79, 0x84, 0xb5, 0x35, 0xde, 0x85, 0xe6, 0xe5, 0x19, 0xb5,
-	0xc0, 0xc6, 0x38, 0x5f, 0x5a, 0xe5, 0x2b, 0xb2, 0xf9, 0xee, 0xc0, 0xe9, 0xc7, 0x3e, 0x65, 0xed,
-	0x71, 0x64, 0x13, 0x5e, 0x6c, 0xd4, 0x73, 0xd3, 0x32, 0xce, 0x21, 0x13, 0x6c, 0x4c, 0x88, 0xb5,
-	0x66, 0x24, 0x5c, 0x84, 0xd3, 0x2d, 0x88, 0x14, 0x3d, 0xd7, 0x01, 0xbc, 0x2a, 0x65, 0x66, 0x95,
-	0xaf, 0xaa, 0xe6, 0x9b, 0x6a, 0xd4, 0x73, 0xa7, 0x65, 0xdc, 0xe6, 0x1e, 0x36, 0x32, 0x5e, 0xe0,
-	0x8d, 0xef, 0xc0, 0xcc, 0x16, 0x65, 0x96, 0xa0, 0xfa, 0x5d, 0xfb, 0xb1, 0x6f, 0x97, 0x6c, 0xb6,
-	0x3f, 0x50, 0x2b, 0xfc, 0x5a, 0x83, 0x6c, 0xa7, 0x50, 0xaa, 0xbc, 0x8f, 0x21, 0x53, 0x09, 0x16,
-	0xd5, 0x09, 0xce, 0xe8, 0xea, 0xcd, 0x92, 0x13, 0x15, 0x5e, 0xf1, 0x6b, 0xd4, 0x76, 0x0b, 0xeb,
-	0xea, 0x52, 0x57, 0x7d, 0x1b, 0x7a, 0xe2, 0xcf, 0xfe, 0x91, 0x9b, 0x2f, 0xdb, 0xec, 0xa1, 0xbf,
-	0xad, 0xef, 0x50, 0x47, 0xbd, 0x9a, 0xaa, 0x3f, 0x8b, 0x5e, 0xe9, 0x51, 0x9e, 0xf1, 0x3b, 0x58,
-	0x04, 0xf1, 0x8c, 0x66, 0x46, 0x7c, 0x1e, 0xa6, 0x44, 0x71, 0x51, 0x8c, 0xf8, 0x53, 0x0d, 0xce,
-	0x45, 0x77, 0xfe, 0x3f, 0x4a, 0x0e, 0x8e, 0xe6, 0x7d, 0x5a, 0xf1, 0x1d, 0x72, 0x9b, 0xd6, 0x06,
-	0x9e, 0xd2, 0x5f, 0x06, 0x47, 0x13, 0x09, 0xa5, 0x70, 0x32, 0x18, 0xde, 0x15, 0x1b, 0xbd, 0x41,
-	0xae, 0xb6, 0x3f, 0x6c, 0xa5, 0x5b, 0x7f, 0x08, 0x55, 0x2e, 0xbc, 0x0b, 0xd9, 0xad, 0x9a, 0x55,
-	0xb2, 0xdd, 0xf2, 0xa6, 0x65, 0xd7, 0xb6, 0xac, 0x47, 0xa4, 0x76, 0x9b, 0xb4, 0x0e, 0xa8, 0xe8,
-	0x7e, 0xf3, 0x9a, 0x6a, 0xe5, 0x16, 0x7c, 0x6a, 0x03, 0x1b, 0xc3, 0xe2, 0xd3, 0xb5, 0xa6, 0xf1,
-	0x92, 0x9a, 0xcb, 0x43, 0xc6, 0x4b, 0x81, 0xf1, 0x12, 0xfe, 0x21, 0x5c, 0xe8, 0x98, 0x57, 0x91,
-	0xf1, 0x4d, 0xc8, 0x30, 0xbe, 0x66, 0x3e, 0x20, 0xc1, 0x14, 0xe9, 0xea, 0x0a, 0xbf, 0x9c, 0x00,
-	0xe3, 0x3a, 0xd9, 0x31, 0x46, 0x98, 0x0a, 0x8a, 0xff, 0x92, 0x82, 0xcb, 0xc1, 0xc3, 0x83, 0x27,
-	0x25, 0x05, 0xcb, 0x23, 0xa5, 0xbb, 0xae, 0x98, 0xbd, 0xa2, 0x53, 0xb5, 0x76, 0xc2, 0x07, 0xe1,
-	0xd7, 0x21, 0xf3, 0xa0, 0x46, 0x1d, 0x93, 0x4b, 0x3d, 0x75, 0x7d, 0xc6, 0x9c, 0x83, 0x14, 0x43,
-	0x23, 0xdc, 0x83, 0x7f, 0x47, 0x18, 0xc6, 0x18, 0x15, 0xbe, 0xad, 0xf7, 0x93, 0x31, 0xca, 0x28,
-	0xdf, 0x96, 0xf7, 0xcf, 0xf9, 0x66, 0xcb, 0xf0, 0x5b, 0x27, 0x1d, 0xde, 0x6f, 0x1f, 0xc2, 0xa4,
-	0x63, 0xed, 0xc9, 0xcb, 0xc1, 0xb4, 0x45, 0x55, 0xea, 0x69, 0xdf, 0x2f, 0xf2, 0x71, 0xc7, 0xda,
-	0x6b, 0xc1, 0x86, 0xde, 0x83, 0x71, 0xb2, 0xc7, 0x48, 0xcd, 0xb5, 0x2a, 0xea, 0x5e, 0x3a, 0x39,
-	0x50, 0xdc, 0xb1, 0x20, 0x8a, 0xbc, 0xb4, 0x3e, 0xd7, 0xe0, 0xd5, 0x9e, 0xb4, 0xaa, 0xf3, 0x7c,
-	0x13, 0xc0, 0x76, 0xab, 0x3e, 0xeb, 0x8b, 0xd8, 0x8c, 0x70, 0x11, 0xcc, 0xbe, 0x0d, 0xa3, 0xd4,
-	0x67, 0x61, 0x80, 0x54, 0xb2, 0x00, 0x20, 0x7d, 0xf8, 0xca, 0xf2, 0x5f, 0xb3, 0x70, 0xf2, 0x3b,
-	0x5c, 0xa8, 0xa3, 0x9f, 0x6b, 0x30, 0x2c, 0xd5, 0x2c, 0xba, 0x92, 0x40, 0xf2, 0xaa, 0xd6, 0xc8,
-	0x2e, 0x24, 0xb2, 0x95, 0x78, 0xf1, 0xc2, 0x8f, 0xff, 0xfc, 0xaf, 0x5f, 0xa5, 0xbe, 0x8c, 0x2e,
-	0xe5, 0xe3, 0x7e, 0x76, 0x50, 0x55, 0xfc, 0x5b, 0x83, 0x99, 0xae, 0xca, 0x02, 0xbd, 0x11, 0x9b,
-	0xb7, 0x97, 0xfa, 0xce, 0xbe, 0x39, 0xa8, 0xbb, 0x42, 0xf2, 0xae, 0x40, 0x72, 0x1b, 0xad, 0xc7,
-	0x22, 0xf9, 0x91, 0xea, 0xe9, 0x8f, 0xf3, 0x44, 0x45, 0x94, 0xbf, 0xa9, 0x10, 0x1e, 0x53, 0xbd,
-	0x4c, 0x99, 0xb6, 0x8b, 0x7e, 0x9b, 0x6a, 0x79, 0x31, 0xed, 0xad, 0xa0, 0xd1, 0xdd, 0xc1, 0xaa,
-	0xef, 0xaa, 0x07, 0x8e, 0x4c, 0x87, 0x25, 0xe8, 0xf8, 0x1e, 0xfa, 0xee, 0x71, 0xd0, 0x61, 0x3e,
-	0xb1, 0xd9, 0x43, 0x3e, 0x92, 0xb2, 0x50, 0x53, 0x8c, 0x1a, 0xfa, 0x59, 0x0a, 0x2e, 0x25, 0x10,
-	0xce, 0xe8, 0x9d, 0x64, 0x50, 0x7a, 0x4a, 0xef, 0x23, 0x73, 0xf2, 0xa1, 0xe0, 0xc4, 0x40, 0x9b,
-	0x7d, 0x73, 0x22, 0x6a, 0x93, 0x62, 0xaa, 0x63, 0xbb, 0xbc, 0xd0, 0x20, 0xdb, 0xfd, 0xb5, 0x1f,
-	0x0d, 0x54, 0x78, 0x53, 0xf6, 0x64, 0xdf, 0x1a, 0xd8, 0x5f, 0x21, 0xff, 0x96, 0x40, 0xfe, 0x0e,
-	0xda, 0x38, 0x7a, 0x37, 0x50, 0x9f, 0xa1, 0xdf, 0xa5, 0xe0, 0x6a, 0x3f, 0x22, 0x17, 0x6d, 0x0e,
-	0x08, 0xa0, 0xfb, 0x7c, 0x1c, 0x99, 0x92, 0x6d, 0x41, 0xc9, 0xf7, 0xd1, 0x47, 0xc7, 0x42, 0x49,
-	0xe7, 0x09, 0xf9, 0x24, 0x05, 0xaf, 0x24, 0x91, 0xb7, 0xe8, 0xce, 0xd1, 0x46, 0xe4, 0x38, 0x5b,
-	0xe5, 0xbe, 0xe0, 0xe5, 0x03, 0xf4, 0x5e, 0x9f, 0xbc, 0x70, 0x16, 0x7a, 0x0c, 0x0a, 0x6f, 0x9d,
-	0x4f, 0x35, 0x18, 0x09, 0x64, 0x28, 0xba, 0x1a, 0x5b, 0x6c, 0x44, 0xc0, 0x66, 0x17, 0x13, 0x5a,
-	0x2b, 0x20, 0xba, 0x00, 0x32, 0x8f, 0x2e, 0xc7, 0x02, 0x09, 0x35, 0x2e, 0xfa, 0x85, 0x06, 0x69,
-	0x1e, 0x01, 0xcd, 0xc7, 0x3f, 0x40, 0x9b, 0xaf, 0xd5, 0xd9, 0xd7, 0x12, 0x58, 0xaa, 0x6a, 0xae,
-	0x8b, 0x6a, 0x74, 0x74, 0x35, 0xb6, 0x1a, 0x51, 0x49, 0x93, 0x5c, 0xc1, 0x56, 0xa0, 0x6c, 0x7b,
-	0xb0, 0x15, 0xd1, 0xc4, 0x3d, 0xd8, 0x8a, 0xca, 0xe5, 0x84, 0x6c, 0x59, 0x95, 0xca, 0xa2, 0x64,
-	0xeb, 0x37, 0x1a, 0x64, 0x42, 0x55, 0x89, 0xe2, 0x93, 0x45, 0xf5, 0x74, 0x56, 0x4f, 0x6a, 0xae,
-	0x8a, 0x5b, 0x11, 0xc5, 0x2d, 0xa2, 0x85, 0x8e, 0xc5, 0x45, 0x48, 0xcb, 0x8b, 0x57, 0x47, 0x0f,
-	0x1d, 0x68, 0x80, 0x0e, 0x2b, 0x4c, 0xf4, 0x95, 0xd8, 0xdc, 0x5d, 0xd5, 0x6d, 0xf6, 0x46, 0xdf,
-	0x7e, 0xaa, 0xf8, 0xa2, 0x28, 0x7e, 0x0d, 0xad, 0xf6, 0x73, 0xf2, 0x79, 0xc6, 0x03, 0xca, 0x41,
-	0x0a, 0x35, 0x1e, 0xfa, 0x83, 0x06, 0xe3, 0xed, 0xea, 0x13, 0x2d, 0xf7, 0x2e, 0xeb, 0x10, 0x94,
-	0x95, 0xbe, 0x7c, 0x14, 0x8c, 0x5b, 0x02, 0xc6, 0x75, 0xb4, 0x9c, 0x00, 0x86, 0x2c, 0xbe, 0x59,
-	0xf7, 0xd3, 0xe0, 0x28, 0xda, 0x14, 0x65, 0x92, 0xa3, 0xe8, 0xa4, 0x66, 0x93, 0x1c, 0x45, 0x47,
-	0xe9, 0x8a, 0x57, 0x05, 0x86, 0xaf, 0xa1, 0xaf, 0x0e, 0x70, 0x14, 0x52, 0x87, 0xa2, 0x2f, 0x34,
-	0x38, 0xd3, 0x41, 0x10, 0xa2, 0x1e, 0x35, 0x75, 0x95, 0xae, 0xd9, 0x9b, 0xfd, 0x3b, 0x2a, 0x34,
-	0x6f, 0x0b, 0x34, 0xb7, 0xd0, 0xcd, 0x24, 0x27, 0x22, 0xe3, 0x98, 0x55, 0xcb, 0xae, 0x99, 0x42,
-	0x70, 0x3e, 0x20, 0x04, 0xfd, 0x47, 0x83, 0x5c, 0x0f, 0x65, 0x84, 0xd6, 0x12, 0x3d, 0x50, 0xe2,
-	0xe5, 0x6a, 0x76, 0xfd, 0x68, 0x41, 0x14, 0xe0, 0x37, 0x04, 0xe0, 0x1b, 0xe8, 0xf5, 0x7e, 0x1f,
-	0x4d, 0x4c, 0x04, 0xbe, 0xff, 0xf4, 0xd9, 0xac, 0x76, 0xf0, 0x6c, 0x56, 0xfb, 0xe7, 0xb3, 0x59,
-	0xed, 0x93, 0xe7, 0xb3, 0x27, 0x0e, 0x9e, 0xcf, 0x9e, 0xf8, 0xdb, 0xf3, 0xd9, 0x13, 0x1f, 0xad,
-	0xb5, 0x08, 0x4b, 0x15, 0x7a, 0xb1, 0x62, 0x6d, 0x7b, 0x61, 0x9e, 0xdd, 0xe5, 0x6b, 0xf9, 0xbd,
-	0xb6, 0x6c, 0x3b, 0x15, 0x9b, 0xb8, 0x4c, 0xfe, 0x4b, 0x55, 0xfe, 0xa4, 0x38, 0x2c, 0xfe, 0xac,
-	0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xae, 0xdc, 0x0c, 0xcf, 0x6e, 0x1e, 0x00, 0x00,
+	// 2046 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcd, 0x73, 0x1b, 0x49,
+	0x15, 0xcf, 0xc8, 0x1f, 0x6b, 0x3d, 0xc7, 0xb2, 0xd2, 0x1b, 0x27, 0xb6, 0x12, 0x2c, 0x6f, 0x67,
+	0xc9, 0x7a, 0xe3, 0x68, 0x14, 0xdb, 0x09, 0x09, 0x81, 0xdd, 0xac, 0x64, 0x3b, 0x1b, 0x41, 0x20,
+	0xde, 0x89, 0xf7, 0x83, 0x85, 0x30, 0x35, 0xb6, 0x3a, 0xca, 0x10, 0xcd, 0x8c, 0xa2, 0xe9, 0x71,
+	0xac, 0xa2, 0xf6, 0x42, 0x15, 0x05, 0x27, 0x6a, 0x61, 0x0f, 0x7b, 0xe0, 0x40, 0x71, 0xe0, 0xc2,
+	0xc7, 0x0d, 0x0e, 0xfc, 0x07, 0xa9, 0xad, 0x82, 0x4a, 0x15, 0x1c, 0x28, 0x0e, 0x82, 0x4a, 0x38,
+	0x50, 0x05, 0xc5, 0x41, 0xfc, 0x03, 0x54, 0x7f, 0xcc, 0x48, 0x1a, 0x4b, 0xa3, 0x91, 0x9c, 0x03,
+	0xa7, 0xc8, 0xdd, 0xef, 0xbd, 0x7e, 0xbf, 0x5f, 0xbf, 0x5f, 0x77, 0xbf, 0x09, 0xbc, 0xe6, 0xb8,
+	0x96, 0xe3, 0x9a, 0x6e, 0xbe, 0xe6, 0x38, 0x55, 0xcb, 0xb0, 0x8d, 0x0a, 0xa9, 0xe7, 0xf7, 0x57,
+	0x77, 0x09, 0x35, 0x56, 0xf3, 0x8f, 0x3c, 0x52, 0x6f, 0xa8, 0xb5, 0xba, 0x43, 0x1d, 0x74, 0x46,
+	0x1a, 0xaa, 0x1d, 0x86, 0xaa, 0x34, 0xcc, 0x9c, 0xac, 0x38, 0x15, 0x87, 0xdb, 0xe5, 0xd9, 0x2f,
+	0xe1, 0x92, 0x79, 0x3d, 0x2a, 0x76, 0x85, 0xd8, 0x84, 0x87, 0xe3, 0xa6, 0xaf, 0x46, 0x99, 0xd2,
+	0x03, 0x69, 0x75, 0x31, 0xca, 0xca, 0x7d, 0x6c, 0xd4, 0xf4, 0xba, 0xe3, 0x51, 0x22, 0xad, 0x17,
+	0xf7, 0xb8, 0x79, 0x7e, 0xd7, 0x70, 0x49, 0x60, 0xb5, 0xe7, 0x98, 0xb6, 0x9c, 0xbf, 0xd0, 0x39,
+	0xcf, 0xa1, 0x06, 0x56, 0x35, 0xa3, 0x62, 0xda, 0x06, 0x35, 0x1d, 0xdf, 0xf6, 0x6c, 0xc5, 0x71,
+	0x2a, 0x55, 0x92, 0x37, 0x6a, 0x66, 0xde, 0xb0, 0x6d, 0x87, 0xf2, 0x49, 0x3f, 0xfb, 0x05, 0x39,
+	0xcb, 0xff, 0xda, 0xf5, 0xee, 0xe7, 0x0d, 0xbb, 0xe1, 0x4f, 0x89, 0x45, 0x74, 0x41, 0x8e, 0xf8,
+	0x43, 0x4e, 0x65, 0xc3, 0x5e, 0xd4, 0xb4, 0x88, 0x4b, 0x0d, 0xab, 0x26, 0x0c, 0xf0, 0x2c, 0xcc,
+	0x6c, 0x1b, 0x75, 0xc3, 0x72, 0x35, 0xf2, 0xc8, 0x23, 0x2e, 0xc5, 0x77, 0x21, 0xe5, 0x0f, 0xb8,
+	0x35, 0xc7, 0x76, 0x09, 0x2a, 0xc0, 0x64, 0x8d, 0x8f, 0xcc, 0x2b, 0x4b, 0xca, 0xf2, 0xf4, 0xda,
+	0x39, 0x35, 0x62, 0x9b, 0x54, 0xe1, 0x5c, 0x1c, 0x7f, 0xd2, 0xcc, 0x1e, 0xd3, 0xa4, 0x23, 0xfe,
+	0x8f, 0x02, 0x4b, 0x5b, 0x2e, 0x35, 0x2d, 0x83, 0x92, 0xbb, 0x8f, 0x8d, 0xda, 0xd6, 0x81, 0xb1,
+	0x47, 0x0b, 0x96, 0xe3, 0xd9, 0xb4, 0x64, 0xcb, 0x95, 0x51, 0x0e, 0x5e, 0x62, 0x01, 0x75, 0xb3,
+	0x3c, 0x9f, 0x58, 0x52, 0x96, 0xc7, 0x8b, 0x27, 0x5b, 0xcd, 0x6c, 0xaa, 0x61, 0x58, 0xd5, 0xeb,
+	0x58, 0x4e, 0xe0, 0x79, 0x45, 0x9b, 0x64, 0xbf, 0x4b, 0x65, 0xa4, 0xc2, 0x14, 0x75, 0x1e, 0x12,
+	0x5b, 0x37, 0xed, 0xf9, 0xb1, 0x25, 0x65, 0x39, 0x59, 0x7c, 0xb9, 0xd5, 0xcc, 0xce, 0x0a, 0x7b,
+	0x7f, 0x06, 0x6b, 0x2f, 0xf1, 0x9f, 0x25, 0x1b, 0xdd, 0x83, 0x49, 0xbe, 0x73, 0xee, 0xfc, 0xf8,
+	0xd2, 0xd8, 0xf2, 0xf4, 0x9a, 0x1a, 0x09, 0x83, 0x65, 0x19, 0x24, 0xc8, 0xdc, 0x8a, 0x73, 0x0c,
+	0x51, 0xab, 0x99, 0x9d, 0x11, 0x2b, 0x88, 0x58, 0x58, 0x93, 0x41, 0xbf, 0x32, 0x3e, 0xa5, 0xa4,
+	0x13, 0xda, 0xa4, 0x4b, 0xec, 0x32, 0xa9, 0xe3, 0x5f, 0x27, 0x60, 0xad, 0x2f, 0xe0, 0xf7, 0x4d,
+	0xfa, 0x60, 0xbb, 0x6e, 0x5a, 0x26, 0x35, 0xf7, 0xc9, 0x4e, 0xa3, 0x46, 0xdc, 0x1e, 0x14, 0x28,
+	0x43, 0x52, 0x90, 0x88, 0x41, 0xc1, 0x0d, 0x48, 0x89, 0x6c, 0x75, 0x7f, 0x95, 0xb1, 0xa5, 0xb1,
+	0xe5, 0xf1, 0xe2, 0x42, 0xab, 0x99, 0x9d, 0xeb, 0x84, 0xe5, 0xcf, 0x63, 0xed, 0xb8, 0x18, 0xd8,
+	0x16, 0x0b, 0xbe, 0x07, 0xa7, 0xa4, 0x81, 0x88, 0xee, 0x78, 0x54, 0x2f, 0x13, 0xdb, 0xb1, 0x38,
+	0xa7, 0xc9, 0xe2, 0x2b, 0xad, 0x66, 0xf6, 0x73, 0x5d, 0x81, 0x42, 0x76, 0x58, 0x7b, 0x59, 0x4c,
+	0xec, 0xb0, 0xf1, 0x3b, 0x1e, 0xdd, 0xe4, 0xa3, 0x7f, 0x50, 0xe0, 0x42, 0x40, 0x97, 0x69, 0x57,
+	0xaa, 0x84, 0x2d, 0xd8, 0xb7, 0x52, 0x56, 0xc2, 0x34, 0xa1, 0xc3, 0x34, 0x8d, 0x4c, 0x52, 0x11,
+	0x66, 0xc3, 0xe0, 0x44, 0x79, 0x65, 0x5a, 0xcd, 0xec, 0xa9, 0x4e, 0xb7, 0x0e, 0x54, 0x33, 0xb4,
+	0x0b, 0xcf, 0x0f, 0x14, 0x78, 0x25, 0xa2, 0xde, 0xa5, 0xb0, 0x76, 0x21, 0xdd, 0x0e, 0x64, 0xf0,
+	0x59, 0x8e, 0x27, 0x59, 0xbc, 0xc6, 0x6a, 0xed, 0xaf, 0xcd, 0xec, 0x9c, 0x10, 0xb3, 0x5b, 0x7e,
+	0xa8, 0x9a, 0x4e, 0xde, 0x32, 0xe8, 0x03, 0xb5, 0x64, 0xd3, 0x56, 0x33, 0x7b, 0x3a, 0x9c, 0x87,
+	0x70, 0xc7, 0x5a, 0xca, 0x4f, 0x44, 0xac, 0x86, 0xff, 0xdb, 0x3f, 0x93, 0x3b, 0x1e, 0x1d, 0x51,
+	0x7a, 0xdf, 0x0e, 0xa4, 0x34, 0xc6, 0xa5, 0x94, 0x8f, 0x29, 0x25, 0xb6, 0x62, 0x0c, 0x2d, 0xa1,
+	0x55, 0x48, 0x06, 0xc8, 0xe6, 0xc7, 0x39, 0x23, 0x2c, 0xa1, 0x74, 0x08, 0x34, 0xd6, 0xa6, 0x7c,
+	0xb4, 0x21, 0xf9, 0xfd, 0x26, 0x01, 0xeb, 0xfd, 0x51, 0xbf, 0x30, 0xfd, 0x1d, 0xd6, 0x53, 0x62,
+	0x38, 0x3d, 0xdd, 0x85, 0xb9, 0x2e, 0x9d, 0x98, 0x76, 0x50, 0x71, 0x4c, 0x4e, 0x4b, 0xad, 0x66,
+	0xf6, 0x6c, 0x0f, 0x39, 0xf9, 0x66, 0x58, 0x43, 0x1d, 0x6a, 0x2a, 0xd9, 0xbc, 0xf8, 0x46, 0x60,
+	0x0f, 0xff, 0x51, 0x81, 0x95, 0x81, 0xfa, 0xeb, 0xa8, 0x97, 0xa1, 0x04, 0x78, 0x03, 0x52, 0x21,
+	0x74, 0x42, 0x86, 0x1d, 0x2c, 0x85, 0x61, 0x1d, 0xa7, 0x7d, 0x01, 0x8d, 0xc5, 0x02, 0xf4, 0x7d,
+	0x05, 0x70, 0x54, 0xd9, 0x4b, 0x05, 0xea, 0xbe, 0xd6, 0x4d, 0xbb, 0x5b, 0x80, 0x57, 0x07, 0x09,
+	0xf0, 0x54, 0x28, 0x71, 0x5f, 0x7f, 0x33, 0x32, 0x73, 0x29, 0xbf, 0x13, 0x30, 0xfb, 0x75, 0xcf,
+	0x62, 0x64, 0x06, 0x17, 0xec, 0x16, 0xa4, 0xdb, 0x43, 0x32, 0x8f, 0x55, 0x48, 0xda, 0x9e, 0xc5,
+	0xab, 0xc4, 0xed, 0xa8, 0x3c, 0x89, 0x30, 0x98, 0xc2, 0xda, 0x94, 0x2d, 0x5d, 0xf1, 0x75, 0x98,
+	0x66, 0x3f, 0x46, 0xd9, 0x11, 0xbc, 0x01, 0xc7, 0x85, 0xaf, 0x5c, 0x7e, 0x1d, 0xc6, 0xd9, 0x8c,
+	0xbc, 0xdf, 0x4f, 0xaa, 0xe2, 0xd1, 0xa0, 0xfa, 0x8f, 0x06, 0xb5, 0x60, 0x37, 0x8a, 0xc9, 0xcf,
+	0x7e, 0x9b, 0x9b, 0xe0, 0x65, 0xab, 0x71, 0x63, 0x06, 0xad, 0x50, 0xad, 0x76, 0x41, 0x2b, 0x41,
+	0xba, 0x3d, 0x24, 0x63, 0x5f, 0x81, 0x09, 0x1f, 0xd6, 0x58, 0x9c, 0xe0, 0xc2, 0x1a, 0x17, 0xe0,
+	0xf4, 0x6d, 0xd3, 0xa5, 0x3c, 0x56, 0xb1, 0xc1, 0xeb, 0xc0, 0x87, 0x7a, 0x1e, 0x26, 0x44, 0x19,
+	0x89, 0xad, 0x4a, 0xb7, 0x9a, 0xd9, 0xe3, 0x02, 0xa8, 0xac, 0x1e, 0x31, 0x8d, 0xdf, 0x81, 0xf9,
+	0xc3, 0x21, 0x8e, 0x96, 0xd5, 0x53, 0x05, 0xd2, 0x77, 0x6b, 0x0e, 0xdd, 0xae, 0x9b, 0x7b, 0x64,
+	0x24, 0x31, 0x6c, 0x41, 0x9a, 0xbd, 0x05, 0x75, 0xc3, 0x75, 0x09, 0xed, 0x92, 0xc3, 0x99, 0xf6,
+	0xb1, 0x1e, 0xb6, 0xc0, 0x5a, 0x8a, 0x0d, 0x15, 0xd8, 0x88, 0x90, 0xc4, 0x2d, 0x38, 0xf1, 0xc8,
+	0x73, 0x68, 0x77, 0x1c, 0x21, 0x8d, 0xb3, 0xad, 0x66, 0x76, 0x5e, 0xc4, 0x39, 0x64, 0x82, 0xb5,
+	0x59, 0x3e, 0xd6, 0x8e, 0x84, 0x4b, 0x70, 0xa2, 0x03, 0x91, 0xa4, 0xe7, 0x32, 0x80, 0x5b, 0x73,
+	0xa8, 0x5e, 0x63, 0xa3, 0x92, 0xe7, 0xb9, 0x56, 0x33, 0x7b, 0x42, 0xc4, 0x6d, 0xcf, 0x61, 0x2d,
+	0xe9, 0xfa, 0xde, 0xf8, 0x16, 0x2c, 0xec, 0x38, 0xd4, 0xe0, 0x05, 0x70, 0xdb, 0x7c, 0xe4, 0x99,
+	0x65, 0x93, 0x36, 0x46, 0x2a, 0xd0, 0x9f, 0x2a, 0x90, 0xe9, 0x15, 0x4a, 0xa6, 0xf7, 0x11, 0x24,
+	0xab, 0xfe, 0xa0, 0xdc, 0xc1, 0x05, 0x55, 0xbe, 0x7b, 0x19, 0x51, 0xc1, 0xd5, 0xb3, 0xe1, 0x98,
+	0x76, 0x71, 0x53, 0x5e, 0x36, 0x52, 0x4d, 0x81, 0x27, 0xfe, 0xe5, 0xdf, 0xb2, 0xcb, 0x15, 0x93,
+	0x3e, 0xf0, 0x76, 0xd5, 0x3d, 0xc7, 0x92, 0x0f, 0x67, 0xf9, 0x4f, 0xce, 0x2d, 0x3f, 0xcc, 0x53,
+	0x76, 0x37, 0xf0, 0x20, 0xae, 0xd6, 0x5e, 0x11, 0x9f, 0x86, 0x39, 0x9e, 0x5c, 0x18, 0x23, 0xfe,
+	0x54, 0x81, 0x53, 0xe1, 0x99, 0xff, 0x8f, 0x94, 0xfd, 0xad, 0x79, 0xcf, 0xa9, 0x7a, 0x16, 0xb9,
+	0xe9, 0xd4, 0x47, 0x3e, 0x3b, 0x7e, 0xe2, 0x6f, 0x4d, 0x28, 0x94, 0xc4, 0x49, 0x61, 0x72, 0x9f,
+	0x4f, 0x0c, 0x06, 0x59, 0xe8, 0x7e, 0x04, 0x08, 0xb7, 0xe1, 0x10, 0xca, 0xb5, 0xf0, 0x3e, 0x64,
+	0x76, 0xea, 0x46, 0xd9, 0xb4, 0x2b, 0xdb, 0x86, 0x59, 0xdf, 0x31, 0x1e, 0x92, 0xfa, 0x4d, 0xd2,
+	0x29, 0x50, 0x5e, 0xfd, 0xfa, 0x25, 0x59, 0xca, 0x1d, 0xf8, 0xe4, 0x04, 0xd6, 0x26, 0xf9, 0xaf,
+	0x4b, 0x6d, 0xe3, 0x55, 0xa9, 0xcb, 0x43, 0xc6, 0xab, 0xbe, 0xf1, 0x2a, 0xfe, 0x0e, 0x9c, 0xe9,
+	0xb9, 0xae, 0x24, 0xe3, 0xab, 0x90, 0xa4, 0x6c, 0x4c, 0xbf, 0x4f, 0x7c, 0x15, 0xa9, 0xf2, 0x62,
+	0x39, 0x1f, 0x03, 0xe3, 0x26, 0xd9, 0xd3, 0xa6, 0xa8, 0x0c, 0x8a, 0xff, 0x9c, 0x80, 0xf3, 0xfe,
+	0x95, 0xc6, 0x16, 0x25, 0x45, 0xc3, 0x25, 0xe5, 0x3b, 0x36, 0xd7, 0x5e, 0xc9, 0xaa, 0x19, 0x7b,
+	0xc1, 0xf5, 0xfc, 0x65, 0x48, 0xde, 0xaf, 0x3b, 0x96, 0xce, 0x1a, 0x51, 0x79, 0xa8, 0x47, 0xec,
+	0x83, 0x68, 0xd5, 0xa6, 0x98, 0x07, 0xfb, 0x1b, 0x61, 0x98, 0xa1, 0x0e, 0xf7, 0xed, 0x3c, 0x9f,
+	0xb4, 0x69, 0xea, 0xb0, 0x69, 0x71, 0xfe, 0x9c, 0x6e, 0x97, 0x0c, 0x3b, 0x75, 0xc6, 0x83, 0xf3,
+	0xed, 0x03, 0x48, 0x5b, 0xc6, 0x81, 0x38, 0x1c, 0x74, 0x93, 0x67, 0x25, 0xdf, 0x20, 0xc3, 0x22,
+	0x4f, 0x59, 0xc6, 0x41, 0x07, 0x36, 0xf4, 0x2e, 0xa4, 0xc8, 0x01, 0x25, 0x75, 0xdb, 0xa8, 0xca,
+	0x73, 0x69, 0x62, 0xa4, 0xb8, 0x33, 0x7e, 0x14, 0x71, 0x68, 0xfd, 0x4a, 0x81, 0xd7, 0x06, 0xd2,
+	0x2a, 0xf7, 0xf3, 0x4d, 0x00, 0xd3, 0xae, 0x79, 0x74, 0x28, 0x62, 0x93, 0xdc, 0x85, 0x33, 0xfb,
+	0x16, 0x4c, 0x3b, 0x1e, 0x0d, 0x02, 0x24, 0xe2, 0x05, 0x00, 0xe1, 0xc3, 0x46, 0xd6, 0x3e, 0x39,
+	0x0b, 0x13, 0xef, 0x78, 0xa4, 0xde, 0x40, 0x3f, 0x52, 0x60, 0x52, 0xf4, 0xda, 0xe8, 0x42, 0x8c,
+	0x86, 0x5c, 0x96, 0x46, 0x66, 0x25, 0x96, 0xad, 0xc0, 0x8b, 0x57, 0xbe, 0xf7, 0xa7, 0x7f, 0x7c,
+	0x92, 0xf8, 0x3c, 0x3a, 0x97, 0x8f, 0xfa, 0x28, 0x22, 0xb3, 0xf8, 0xa7, 0x02, 0x0b, 0x7d, 0x7b,
+	0x1e, 0xf4, 0x46, 0xe4, 0xba, 0x83, 0xbe, 0x0d, 0x64, 0xde, 0x1c, 0xd5, 0x5d, 0x22, 0xb9, 0xcd,
+	0x91, 0xdc, 0x44, 0x9b, 0x91, 0x48, 0xbe, 0x2b, 0x6b, 0xfa, 0xa3, 0x3c, 0x91, 0x11, 0xc5, 0x17,
+	0x1f, 0xc2, 0x62, 0xca, 0x27, 0x9e, 0x6e, 0xda, 0xe8, 0xe7, 0x89, 0x8e, 0xe7, 0xf2, 0xe0, 0xee,
+	0x1e, 0xdd, 0x19, 0x2d, 0xfb, 0xbe, 0x7d, 0xca, 0x91, 0xe9, 0x30, 0x38, 0x1d, 0xdf, 0x44, 0xdf,
+	0x78, 0x11, 0x74, 0xe8, 0x8f, 0x4d, 0xfa, 0x80, 0x49, 0x52, 0x24, 0xaa, 0x73, 0xa9, 0xa1, 0x1f,
+	0x26, 0xe0, 0x5c, 0x8c, 0x96, 0x1e, 0xbd, 0x1d, 0x0f, 0xca, 0xc0, 0x8f, 0x02, 0x47, 0xe6, 0xe4,
+	0x03, 0xce, 0x89, 0x86, 0xb6, 0x87, 0xe6, 0x84, 0xe7, 0x26, 0x5a, 0xbc, 0x9e, 0xe5, 0xf2, 0x6f,
+	0x05, 0x32, 0xfd, 0x9b, 0x11, 0x34, 0x52, 0xe2, 0xed, 0x66, 0x2c, 0x73, 0x63, 0x64, 0x7f, 0x89,
+	0xfc, 0x6b, 0x1c, 0xf9, 0xdb, 0x68, 0xeb, 0xe8, 0xd5, 0xe0, 0x78, 0x14, 0xfd, 0x22, 0x01, 0x17,
+	0x87, 0x69, 0xbe, 0xd1, 0xf6, 0x88, 0x00, 0xfa, 0xeb, 0xe3, 0xc8, 0x94, 0xec, 0x72, 0x4a, 0xbe,
+	0x85, 0x3e, 0x7c, 0x21, 0x94, 0xf4, 0x56, 0xc8, 0xc7, 0x09, 0x78, 0x35, 0x4e, 0xd3, 0x8d, 0x6e,
+	0x1d, 0x4d, 0x22, 0x2f, 0xb2, 0x54, 0xee, 0x71, 0x5e, 0xde, 0x47, 0xef, 0x0e, 0xc9, 0x0b, 0x63,
+	0x61, 0x80, 0x50, 0x58, 0xe9, 0x7c, 0xaa, 0xc0, 0x94, 0xdf, 0x1c, 0xa3, 0x8b, 0x91, 0xc9, 0x86,
+	0xda, 0xea, 0x4c, 0x2e, 0xa6, 0xb5, 0x04, 0xa2, 0x72, 0x20, 0xcb, 0xe8, 0x7c, 0x24, 0x90, 0xa0,
+	0xf3, 0x46, 0x3f, 0x56, 0x60, 0x9c, 0x45, 0x40, 0xcb, 0xd1, 0x17, 0x68, 0xfb, 0x59, 0x9d, 0x79,
+	0x3d, 0x86, 0xa5, 0xcc, 0xe6, 0x32, 0xcf, 0x46, 0x45, 0x17, 0x23, 0xb3, 0xe1, 0x99, 0xb4, 0xc9,
+	0xe5, 0x6c, 0xf9, 0xfd, 0xf6, 0x00, 0xb6, 0x42, 0x9d, 0xfa, 0x00, 0xb6, 0xc2, 0x4d, 0x7c, 0x4c,
+	0xb6, 0x8c, 0x6a, 0x35, 0x27, 0xd8, 0xfa, 0xbd, 0x02, 0xe9, 0x70, 0xef, 0x8d, 0x2e, 0x47, 0xae,
+	0xd9, 0xa7, 0xdb, 0xcf, 0x5c, 0x19, 0xd2, 0x4b, 0x66, 0x7c, 0x8d, 0x67, 0xbc, 0x86, 0x2e, 0x45,
+	0x66, 0x5c, 0x35, 0x5d, 0x2a, 0x52, 0xce, 0xed, 0x36, 0x72, 0xfc, 0xb5, 0x8b, 0x7e, 0xa6, 0x40,
+	0x32, 0xe8, 0x88, 0x51, 0x34, 0x51, 0xe1, 0x6f, 0x01, 0x19, 0x35, 0xae, 0xb9, 0x4c, 0x73, 0x9d,
+	0xa7, 0x99, 0x43, 0x2b, 0x3d, 0xd3, 0x0c, 0x6d, 0x78, 0x9e, 0x3f, 0x7b, 0x5d, 0xf4, 0x54, 0x01,
+	0x74, 0xb8, 0x3b, 0x46, 0x5f, 0x88, 0x5c, 0xbb, 0x6f, 0x67, 0x9e, 0xb9, 0x3a, 0xb4, 0x9f, 0x4c,
+	0xbe, 0xc4, 0x93, 0xdf, 0x40, 0x85, 0x61, 0xaa, 0x36, 0x4f, 0x59, 0x40, 0x71, 0x08, 0x04, 0xfd,
+	0x29, 0xfa, 0x9d, 0x02, 0xa9, 0xee, 0xce, 0x19, 0xad, 0x0d, 0x4e, 0xeb, 0x10, 0x94, 0xf5, 0xa1,
+	0x7c, 0x24, 0x8c, 0xeb, 0x1c, 0xc6, 0x65, 0xb4, 0x16, 0x03, 0x86, 0x48, 0xbe, 0x9d, 0xf7, 0x13,
+	0x7f, 0x2b, 0xba, 0xba, 0xe1, 0x38, 0x5b, 0xd1, 0xab, 0x13, 0x8f, 0xb3, 0x15, 0x3d, 0xdb, 0x6e,
+	0x5c, 0xe0, 0x18, 0xbe, 0x84, 0xbe, 0x38, 0xc2, 0x56, 0x88, 0x1e, 0x1a, 0x7d, 0xa6, 0xc0, 0xcb,
+	0x3d, 0x9a, 0x59, 0x34, 0x20, 0xa7, 0xbe, 0x6d, 0x77, 0xe6, 0xda, 0xf0, 0x8e, 0x12, 0xcd, 0x5b,
+	0x1c, 0xcd, 0x75, 0x74, 0x2d, 0xce, 0x8e, 0x88, 0x38, 0x7a, 0xcd, 0x30, 0xeb, 0x3a, 0x6f, 0x96,
+	0xef, 0x13, 0x82, 0xfe, 0xa5, 0x40, 0x76, 0x40, 0x57, 0x87, 0x36, 0x62, 0x5d, 0x86, 0xd1, 0xad,
+	0x76, 0x66, 0xf3, 0x68, 0x41, 0x24, 0xe0, 0x37, 0x38, 0xe0, 0xab, 0xe8, 0xca, 0xb0, 0xd7, 0x2a,
+	0xe5, 0x81, 0xef, 0x3d, 0x79, 0xb6, 0xa8, 0x3c, 0x7d, 0xb6, 0xa8, 0xfc, 0xfd, 0xd9, 0xa2, 0xf2,
+	0xf1, 0xf3, 0xc5, 0x63, 0x4f, 0x9f, 0x2f, 0x1e, 0xfb, 0xcb, 0xf3, 0xc5, 0x63, 0x1f, 0x6e, 0x74,
+	0x34, 0xc5, 0x32, 0x74, 0xae, 0x6a, 0xec, 0xba, 0xc1, 0x3a, 0xfb, 0x6b, 0x97, 0xf2, 0x07, 0x5d,
+	0xab, 0xed, 0x55, 0x4d, 0x62, 0x53, 0xf1, 0x9f, 0xd5, 0xe2, 0x73, 0xe8, 0x24, 0xff, 0x67, 0xfd,
+	0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x12, 0xa7, 0x1d, 0x71, 0xc8, 0x1f, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1633,6 +1732,8 @@ type QueryClient interface {
 	Pool(ctx context.Context, in *PoolRequest, opts ...grpc.CallOption) (*PoolResponse, error)
 	// AllPools returns all pools on the Osmosis chain sorted by IDs.
 	AllPools(ctx context.Context, in *AllPoolsRequest, opts ...grpc.CallOption) (*AllPoolsResponse, error)
+	// ListPoolsByDenom return all pools by denom
+	ListPoolsByDenom(ctx context.Context, in *ListPoolsByDenomRequest, opts ...grpc.CallOption) (*ListPoolsByDenomResponse, error)
 	// SpotPrice defines a gRPC query handler that returns the spot price given
 	// a base denomination and a quote denomination.
 	SpotPrice(ctx context.Context, in *SpotPriceRequest, opts ...grpc.CallOption) (*SpotPriceResponse, error)
@@ -1748,6 +1849,15 @@ func (c *queryClient) AllPools(ctx context.Context, in *AllPoolsRequest, opts ..
 	return out, nil
 }
 
+func (c *queryClient) ListPoolsByDenom(ctx context.Context, in *ListPoolsByDenomRequest, opts ...grpc.CallOption) (*ListPoolsByDenomResponse, error) {
+	out := new(ListPoolsByDenomResponse)
+	err := c.cc.Invoke(ctx, "/osmosis.poolmanager.v1beta1.Query/ListPoolsByDenom", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) SpotPrice(ctx context.Context, in *SpotPriceRequest, opts ...grpc.CallOption) (*SpotPriceResponse, error) {
 	out := new(SpotPriceResponse)
 	err := c.cc.Invoke(ctx, "/osmosis.poolmanager.v1beta1.Query/SpotPrice", in, out, opts...)
@@ -1830,6 +1940,8 @@ type QueryServer interface {
 	Pool(context.Context, *PoolRequest) (*PoolResponse, error)
 	// AllPools returns all pools on the Osmosis chain sorted by IDs.
 	AllPools(context.Context, *AllPoolsRequest) (*AllPoolsResponse, error)
+	// ListPoolsByDenom return all pools by denom
+	ListPoolsByDenom(context.Context, *ListPoolsByDenomRequest) (*ListPoolsByDenomResponse, error)
 	// SpotPrice defines a gRPC query handler that returns the spot price given
 	// a base denomination and a quote denomination.
 	SpotPrice(context.Context, *SpotPriceRequest) (*SpotPriceResponse, error)
@@ -1881,6 +1993,9 @@ func (*UnimplementedQueryServer) Pool(ctx context.Context, req *PoolRequest) (*P
 func (*UnimplementedQueryServer) AllPools(ctx context.Context, req *AllPoolsRequest) (*AllPoolsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AllPools not implemented")
 }
+func (*UnimplementedQueryServer) ListPoolsByDenom(ctx context.Context, req *ListPoolsByDenomRequest) (*ListPoolsByDenomResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListPoolsByDenom not implemented")
+}
 func (*UnimplementedQueryServer) SpotPrice(ctx context.Context, req *SpotPriceRequest) (*SpotPriceResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SpotPrice not implemented")
 }
@@ -2084,6 +2199,24 @@ func _Query_AllPools_Handler(srv interface{}, ctx context.Context, dec func(inte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_ListPoolsByDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListPoolsByDenomRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ListPoolsByDenom(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/osmosis.poolmanager.v1beta1.Query/ListPoolsByDenom",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ListPoolsByDenom(ctx, req.(*ListPoolsByDenomRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_SpotPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(SpotPriceRequest)
 	if err := dec(in); err != nil {
@@ -2236,6 +2369,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "AllPools",
 			Handler:    _Query_AllPools_Handler,
 		},
+		{
+			MethodName: "ListPoolsByDenom",
+			Handler:    _Query_ListPoolsByDenom_Handler,
+		},
 		{
 			MethodName: "SpotPrice",
 			Handler:    _Query_SpotPrice_Handler,
@@ -2867,6 +3004,73 @@ func (m *AllPoolsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ListPoolsByDenomRequest) 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 *ListPoolsByDenomRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListPoolsByDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Denom) > 0 {
+		i -= len(m.Denom)
+		copy(dAtA[i:], m.Denom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ListPoolsByDenomResponse) 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 *ListPoolsByDenomResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListPoolsByDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Pools) > 0 {
+		for iNdEx := len(m.Pools) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Pools[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 (m *SpotPriceRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3572,6 +3776,34 @@ func (m *AllPoolsResponse) Size() (n int) {
 	return n
 }
 
+func (m *ListPoolsByDenomRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Denom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *ListPoolsByDenomResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Pools) > 0 {
+		for _, e := range m.Pools {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
 func (m *SpotPriceRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -5415,6 +5647,172 @@ func (m *AllPoolsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ListPoolsByDenomRequest) 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: ListPoolsByDenomRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListPoolsByDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *ListPoolsByDenomResponse) 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: ListPoolsByDenomResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListPoolsByDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pools", 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.Pools = append(m.Pools, &types1.Any{})
+			if err := m.Pools[len(m.Pools)-1].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 *SpotPriceRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/poolmanager/client/queryproto/query.pb.gw.go b/x/poolmanager/client/queryproto/query.pb.gw.go
index a22f9280715..5053847b8d3 100644
--- a/x/poolmanager/client/queryproto/query.pb.gw.go
+++ b/x/poolmanager/client/queryproto/query.pb.gw.go
@@ -573,6 +573,42 @@ func local_request_Query_AllPools_0(ctx context.Context, marshaler runtime.Marsh
 
 }
 
+var (
+	filter_Query_ListPoolsByDenom_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Query_ListPoolsByDenom_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ListPoolsByDenomRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ListPoolsByDenom_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.ListPoolsByDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_ListPoolsByDenom_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ListPoolsByDenomRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ListPoolsByDenom_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.ListPoolsByDenom(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 var (
 	filter_Query_SpotPrice_0 = &utilities.DoubleArray{Encoding: map[string]int{"pool_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
 )
@@ -1115,6 +1151,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_ListPoolsByDenom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		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_ListPoolsByDenom_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_ListPoolsByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_SpotPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1494,6 +1553,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_ListPoolsByDenom_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_ListPoolsByDenom_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_ListPoolsByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_SpotPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1638,6 +1717,8 @@ var (
 
 	pattern_Query_AllPools_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"osmosis", "poolmanager", "v1beta1", "all-pools"}, "", runtime.AssumeColonVerbOpt(false)))
 
+	pattern_Query_ListPoolsByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"osmosis", "poolmanager", "v1beta1", "list-pools-by-denom"}, "", runtime.AssumeColonVerbOpt(false)))
+
 	pattern_Query_SpotPrice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"osmosis", "poolmanager", "pools", "pool_id", "prices"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_TotalPoolLiquidity_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"osmosis", "poolmanager", "v1beta1", "pools", "pool_id", "total_pool_liquidity"}, "", runtime.AssumeColonVerbOpt(false)))
@@ -1672,6 +1753,8 @@ var (
 
 	forward_Query_AllPools_0 = runtime.ForwardResponseMessage
 
+	forward_Query_ListPoolsByDenom_0 = runtime.ForwardResponseMessage
+
 	forward_Query_SpotPrice_0 = runtime.ForwardResponseMessage
 
 	forward_Query_TotalPoolLiquidity_0 = runtime.ForwardResponseMessage
diff --git a/x/poolmanager/router.go b/x/poolmanager/router.go
index e13eb8b049e..4da50c598bc 100644
--- a/x/poolmanager/router.go
+++ b/x/poolmanager/router.go
@@ -548,6 +548,38 @@ func (k Keeper) AllPools(
 	return sortedPools, nil
 }
 
+// ListPoolsByDenom returns all pools by denom sorted by their ids
+// from every pool module registered in the
+// pool manager keeper.
+func (k Keeper) ListPoolsByDenom(
+	ctx sdk.Context,
+	denom string,
+) ([]types.PoolI, error) {
+	less := func(i, j types.PoolI) bool {
+		return i.GetId() < j.GetId()
+	}
+	var sortedPools []types.PoolI
+	for _, poolModule := range k.poolModules {
+		currentModulePools, err := poolModule.GetPools(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		var poolsByDenom []types.PoolI
+		for _, pool := range currentModulePools {
+			coins, err := k.GetTotalPoolLiquidity(ctx, pool.GetId())
+			if err != nil {
+				return nil, err
+			}
+			if coins.AmountOf(denom).GT(osmomath.ZeroInt()) {
+				poolsByDenom = append(poolsByDenom, pool)
+			}
+		}
+		sortedPools = osmoutils.MergeSlices(sortedPools, poolsByDenom, less)
+	}
+	return sortedPools, nil
+}
+
 // createMultihopExpectedSwapOuts defines the output denom and output amount for the last pool in
 // the routeStep of pools the caller is intending to hop through in a fixed-output multihop tx. It estimates the input
 // amount for this last pool and then chains that input as the output of the previous pool in the routeStep, repeating
diff --git a/x/poolmanager/router_test.go b/x/poolmanager/router_test.go
index 8d89dcd1a03..064ccc80573 100644
--- a/x/poolmanager/router_test.go
+++ b/x/poolmanager/router_test.go
@@ -3785,3 +3785,82 @@ func (s *KeeperTestSuite) testSwapExactAmpountInVolumeTracked(noTakerFeeVariant
 	totalVolume = s.App.PoolManagerKeeper.GetTotalVolumeForPool(s.Ctx, concentratedPool.GetId())
 	s.Require().Equal(tokenIn.String(), totalVolume.String())
 }
+
+func (suite *KeeperTestSuite) TestListPoolsByDenom() {
+	suite.Setup()
+
+	tests := map[string]struct {
+		denom            string
+		poolCoins        []sdk.Coins
+		expectedNumPools int
+		expectedError    bool
+		poolType         []types.PoolType
+	}{
+		"Single pool, pool contain denom": {
+			poolType: []types.PoolType{types.Balancer},
+			poolCoins: []sdk.Coins{
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 1 bar-uosmo
+			},
+			denom:            BAR,
+			expectedNumPools: 1,
+		},
+		"Single pool, pool does not contain denom": {
+			poolType: []types.PoolType{types.Balancer},
+			poolCoins: []sdk.Coins{
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 1 bar-uosmo
+			},
+			denom:            FOO,
+			expectedNumPools: 0,
+		},
+		"Two pools, pools contains denom": {
+			poolType: []types.PoolType{types.Balancer, types.Balancer},
+			poolCoins: []sdk.Coins{
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 1 bar-uosmo
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(FOO, defaultInitPoolAmount)),   // pool 2. baz-foo
+			},
+			denom:            BAR,
+			expectedNumPools: 2,
+		},
+		"Two pools, pools does not contains denom": {
+			poolType: []types.PoolType{types.Balancer, types.Concentrated},
+			poolCoins: []sdk.Coins{
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 1 bar-uosmo
+				sdk.NewCoins(sdk.NewCoin(BAZ, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 2. baz-foo
+			},
+			denom:            FOO,
+			expectedNumPools: 0,
+		},
+		"Many pools": {
+			poolType: []types.PoolType{types.Concentrated, types.Balancer, types.Concentrated, types.Balancer},
+			poolCoins: []sdk.Coins{
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 1 bar-uosmo
+				sdk.NewCoins(sdk.NewCoin(BAZ, defaultInitPoolAmount), sdk.NewCoin(FOO, defaultInitPoolAmount)),   // pool 2. baz-foo
+				sdk.NewCoins(sdk.NewCoin(BAR, defaultInitPoolAmount), sdk.NewCoin(BAZ, defaultInitPoolAmount)),   // pool 3. bar-baz
+				sdk.NewCoins(sdk.NewCoin(BAZ, defaultInitPoolAmount), sdk.NewCoin(UOSMO, defaultInitPoolAmount)), // pool 4. baz-uosmo
+			},
+			denom:            BAR,
+			expectedNumPools: 2,
+		},
+	}
+
+	for name, tc := range tests {
+		suite.Run(name, func() {
+			suite.SetupTest()
+			ctx := suite.Ctx
+			poolManagerKeeper := suite.App.PoolManagerKeeper
+
+			for i := range tc.poolType {
+				suite.FundAcc(suite.TestAccs[0], tc.poolCoins[i])
+				suite.CreatePoolFromTypeWithCoins(tc.poolType[i], tc.poolCoins[i])
+			}
+
+			poolsResult, err := poolManagerKeeper.ListPoolsByDenom(ctx, tc.denom)
+			if tc.expectedError {
+				suite.Require().Error(err)
+			} else {
+				suite.Require().NoError(err)
+				suite.Require().Equal(tc.expectedNumPools, len(poolsResult))
+			}
+		})
+	}
+}