diff --git a/.fleet/settings.json b/.fleet/settings.json index 0015ba49..135024c7 100644 --- a/.fleet/settings.json +++ b/.fleet/settings.json @@ -1,3 +1,4 @@ { - "backend.maxHeapSizeMb": 2744 + "backend.maxHeapSizeMb": 2744, + "editor.formatOnSave": true } \ No newline at end of file diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index d21721e8..ebae0bb8 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -33208,7 +33208,7 @@ paths: additionalProperties: {} tags: - Query - /DecentralCardGame/Cardchain/cardchain/q_cards/{status}: + /DecentralCardGame/Cardchain/cardchain/q_cards: get: summary: Queries a list of QCards items. operationId: DecentralCardGameCardchainCardchainQCards @@ -33242,34 +33242,51 @@ paths: type: string additionalProperties: {} parameters: - - name: status - in: path - required: true - type: string - enum: - - scheme - - prototype - - trial - - permanent - - suspended - - banned - - bannedSoon - - bannedVerySoon - - none - - playable - - unplayable - name: owner in: query required: false type: string - - name: cardType + - name: statuses in: query required: false - type: string + type: array + items: + type: string + enum: + - scheme + - prototype + - trial + - permanent + - suspended + - banned + - bannedSoon + - bannedVerySoon + - none + collectionFormat: multi + - name: cardTypes + in: query + required: false + type: array + items: + type: string + enum: + - place + - action + - entity + - headquarter + collectionFormat: multi - name: classes in: query required: false - type: string + type: array + items: + type: string + enum: + - nature + - culture + - mysticism + - technology + collectionFormat: multi - name: sortBy in: query required: false @@ -33294,6 +33311,23 @@ paths: in: query required: false type: boolean + - name: rarities + in: query + required: false + type: array + items: + type: string + enum: + - common + - uncommon + - rare + - exceptional + - unique + collectionFormat: multi + - name: multiClassOnly + in: query + required: false + type: boolean tags: - Query /DecentralCardGame/Cardchain/cardchain/q_council/{councilId}: @@ -68732,6 +68766,14 @@ definitions: - active - archived default: design + DecentralCardGame.cardchain.cardchain.CardClass: + type: string + enum: + - nature + - culture + - mysticism + - technology + default: nature DecentralCardGame.cardchain.cardchain.CardRarity: type: string enum: @@ -68741,6 +68783,14 @@ definitions: - exceptional - unique default: common + DecentralCardGame.cardchain.cardchain.CardType: + type: string + enum: + - place + - action + - entity + - headquarter + default: place DecentralCardGame.cardchain.cardchain.CouncelingStatus: type: string enum: @@ -69407,21 +69457,6 @@ definitions: lastCardModified: type: string format: uint64 - DecentralCardGame.cardchain.cardchain.QueryQCardsRequest.Status: - type: string - enum: - - scheme - - prototype - - trial - - permanent - - suspended - - banned - - bannedSoon - - bannedVerySoon - - none - - playable - - unplayable - default: scheme DecentralCardGame.cardchain.cardchain.QueryQCardsResponse: type: object properties: diff --git a/proto/cardchain/cardchain/card.proto b/proto/cardchain/cardchain/card.proto index e5b3d97c..c2ffb123 100644 --- a/proto/cardchain/cardchain/card.proto +++ b/proto/cardchain/cardchain/card.proto @@ -68,6 +68,20 @@ enum CardRarity { unique = 4; } +enum CardClass { + nature = 0; + culture = 1; + mysticism = 2; + technology = 3; +} + +enum CardType { + place = 0; + action = 1; + entity = 2; + headquarter = 3; +} + message TimeStamp { uint64 timeStamp = 1; } diff --git a/proto/cardchain/cardchain/query.proto b/proto/cardchain/cardchain/query.proto index c7688c5e..d7ce30fd 100644 --- a/proto/cardchain/cardchain/query.proto +++ b/proto/cardchain/cardchain/query.proto @@ -61,7 +61,7 @@ service Query { // Queries a list of QCards items. rpc QCards (QueryQCardsRequest) returns (QueryQCardsResponse) { - option (google.api.http).get = "/DecentralCardGame/Cardchain/cardchain/q_cards/{status}"; + option (google.api.http).get = "/DecentralCardGame/Cardchain/cardchain/q_cards"; } @@ -173,29 +173,18 @@ message QueryQVotingResultsResponse { } message QueryQCardsRequest { - enum Status { - scheme = 0; - prototype = 1; - trial = 2; - permanent = 3; - suspended = 4; - banned = 5; - bannedSoon = 6; - bannedVerySoon = 7; - none = 8; - playable = 9; - unplayable = 10; - } string owner = 1; - Status status = 2; - string cardType = 3; - string classes = 4; + repeated Status statuses = 2; + repeated CardType cardTypes = 3; + repeated CardClass classes = 4; string sortBy = 5; string nameContains = 6; string keywordsContains = 7; string notesContains = 8; bool onlyStarterCard = 9; bool onlyBalanceAnchors = 10; + repeated CardRarity rarities = 11; + bool multiClassOnly = 12; } message QueryQCardsResponse { diff --git a/x/cardchain/client/cli/query_q_cards.go b/x/cardchain/client/cli/query_q_cards.go index 34d804f7..0b8ce68f 100644 --- a/x/cardchain/client/cli/query_q_cards.go +++ b/x/cardchain/client/cli/query_q_cards.go @@ -14,27 +14,83 @@ var _ = strconv.Itoa(0) func CmdQCards() *cobra.Command { cmd := &cobra.Command{ - Use: "q-cards [owner] [status] [card-type] [classes] [sort-by] [name-contains] [keywords-contains] [notes-contains] [startercards-only] [balance-achors-only]", + Use: "q-cards [owner] [statuses] [card-types] [classes] [rarities] [sort-by] [name-contains] [keywords-contains] [notes-contains] [startercards-only] [balance-achors-only]", Short: "Query qCards", - Args: cobra.ExactArgs(10), + Args: cobra.ExactArgs(11), RunE: func(cmd *cobra.Command, args []string) (err error) { reqOwner := args[0] var reqOnlyStarterCards bool var reqOnlyBalanceAnchors bool - var reqStatus types.QueryQCardsRequest_Status - if args[1] == "" { - reqStatus = types.QueryQCardsRequest_none - } else { - reqStatus = types.QueryQCardsRequest_Status(types.QueryQCardsRequest_Status_value[args[1]]) + var statuses []string + var reqStatuses []types.Status + + err = getJsonArg(args[1], &statuses) + if err != nil { + return err + } + + for _, status := range statuses { + s, ok := types.Status_value[status] + if !ok { + return fmt.Errorf("invalid status %s", status) + } + reqStatuses = append(reqStatuses, types.Status(s)) + } + + var cardTypes []string + var reqCardTypes []types.CardType + + err = getJsonArg(args[2], &cardTypes) + if err != nil { + return err + } + + for _, cardType := range cardTypes { + s, ok := types.CardType_value[cardType] + if !ok { + return fmt.Errorf("invalid class %s", cardType) + } + reqCardTypes = append(reqCardTypes, types.CardType(s)) + } + + var classes []string + var reqClasses []types.CardClass + + err = getJsonArg(args[3], &classes) + if err != nil { + return err + } + + for _, class := range classes { + s, ok := types.CardClass_value[class] + if !ok { + return fmt.Errorf("invalid class %s", class) + } + reqClasses = append(reqClasses, types.CardClass(s)) } - reqCardType := args[2] - reqClasses := args[3] - reqSortBy := args[4] - reqNameContains := args[5] - reqKeywordsContains := args[6] - reqNotesContains := args[7] - - switch args[8] { + + var rarities []string + var reqRarities []types.CardRarity + + err = getJsonArg(args[4], &rarities) + if err != nil { + return err + } + + for _, rarity := range rarities { + s, ok := types.CardRarity_value[rarity] + if !ok { + return fmt.Errorf("invalid rarity %s", rarity) + } + reqRarities = append(reqRarities, types.CardRarity(s)) + } + + reqSortBy := args[5] + reqNameContains := args[6] + reqKeywordsContains := args[7] + reqNotesContains := args[8] + + switch args[9] { case "yes": reqOnlyStarterCards = true case "no": @@ -43,7 +99,7 @@ func CmdQCards() *cobra.Command { return fmt.Errorf("arg 'only-startercard' has to be either yes or no but not %s", args[8]) } - switch args[9] { + switch args[10] { case "yes": reqOnlyBalanceAnchors = true case "no": @@ -62,9 +118,10 @@ func CmdQCards() *cobra.Command { params := &types.QueryQCardsRequest{ Owner: reqOwner, - Status: reqStatus, - CardType: reqCardType, + Statuses: reqStatuses, + CardTypes: reqCardTypes, Classes: reqClasses, + Rarities: reqRarities, SortBy: reqSortBy, NameContains: reqNameContains, KeywordsContains: reqKeywordsContains, diff --git a/x/cardchain/client/cli/util.go b/x/cardchain/client/cli/util.go new file mode 100644 index 00000000..e0834d34 --- /dev/null +++ b/x/cardchain/client/cli/util.go @@ -0,0 +1,7 @@ +package cli + +import "encoding/json" + +func getJsonArg[T any](from string, into *T) error { + return json.Unmarshal([]byte(from), into) +} diff --git a/x/cardchain/keeper/grpc_query_q_cards.go b/x/cardchain/keeper/grpc_query_q_cards.go index a70a1e53..67a587d6 100644 --- a/x/cardchain/keeper/grpc_query_q_cards.go +++ b/x/cardchain/keeper/grpc_query_q_cards.go @@ -26,7 +26,6 @@ type Result struct { func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*types.QueryQCardsResponse, error) { var ( - states []types.Status cardsList []uint64 results []Result ) @@ -37,29 +36,6 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t ctx := sdk.UnwrapSDKContext(goCtx) - // This one fixes escaping - for _, arg := range []*string{&req.Owner, &req.CardType, &req.Classes, &req.SortBy, &req.NameContains, &req.KeywordsContains, &req.NotesContains} { - if *arg == "\"\"" { - *arg = "" - } - } - - switch req.Status { - case types.QueryQCardsRequest_playable: - states = []types.Status{types.Status_trial, types.Status_permanent} - case types.QueryQCardsRequest_unplayable: - states = []types.Status{ - types.Status_scheme, - types.Status_prototype, - types.Status_suspended, - types.Status_banned, - types.Status_bannedSoon, - types.Status_bannedVerySoon, - } - default: - states = []types.Status{types.Status(types.Status_value[req.Status.String()])} - } - checkName := func(cardName cardobject.CardName) bool { if req.NameContains != "" && !strings.Contains(strings.ToLower(string(cardName)), strings.ToLower(req.NameContains)) { return false @@ -73,31 +49,34 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t return false } checkClasses := func(cardobjClass cardobject.Class) bool { - if strings.Contains(req.Classes, "OR") { - if bool(cardobjClass.Mysticism) && strings.Contains(req.Classes, "Mysticism") { + if len(req.Classes) == 0 { + return true + } + if !req.MultiClassOnly { + if bool(cardobjClass.Mysticism) && slices.Contains(req.Classes, types.CardClass_mysticism) { return true } - if bool(cardobjClass.Nature) == true && strings.Contains(req.Classes, "Nature") { + if bool(cardobjClass.Nature) && slices.Contains(req.Classes, types.CardClass_nature) { return true } - if bool(cardobjClass.Technology) && strings.Contains(req.Classes, "Technology") { + if bool(cardobjClass.Technology) && slices.Contains(req.Classes, types.CardClass_technology) { return true } - if bool(cardobjClass.Culture) && strings.Contains(req.Classes, "Culture") { + if bool(cardobjClass.Culture) && slices.Contains(req.Classes, types.CardClass_culture) { return true } return false } else { - if bool(cardobjClass.Mysticism) != strings.Contains(req.Classes, "Mysticism") { + if bool(cardobjClass.Mysticism) != slices.Contains(req.Classes, types.CardClass_mysticism) { return false } - if bool(cardobjClass.Nature) != strings.Contains(req.Classes, "Nature") { + if bool(cardobjClass.Nature) != slices.Contains(req.Classes, types.CardClass_nature) { return false } - if bool(cardobjClass.Technology) != strings.Contains(req.Classes, "Technology") { + if bool(cardobjClass.Technology) != slices.Contains(req.Classes, types.CardClass_technology) { return false } - if bool(cardobjClass.Culture) != strings.Contains(req.Classes, "Culture") { + if bool(cardobjClass.Culture) != slices.Contains(req.Classes, types.CardClass_culture) { return false } return true @@ -119,23 +98,30 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t continue } - // first skip all cards with irrelevant status - if gottenCard.Status == types.Status_none || gottenCard.Status == types.Status_scheme { - continue - } - // then check if a status constrain was given and skip the card if it has the wrong status - if req.Status != types.QueryQCardsRequest_none { - if !slices.Contains(states, gottenCard.Status) { + if len(req.Statuses) != 0 { + if !slices.Contains(req.Statuses, gottenCard.Status) { + continue + } + } else { + // first skip all cards with irrelevant status + if gottenCard.Status == types.Status_none || gottenCard.Status == types.Status_scheme { continue } } + + // rarity + if len(req.Rarities) != 0 && !slices.Contains(req.Rarities, gottenCard.Rarity) { + continue + } + // then check if an owner constrain was given and skip the card if it has the wrong owner if req.Owner != "" { if gottenCard.Owner != req.Owner { continue } } + // then check if the notes should contain something and skip the card if it does not if req.NotesContains != "" { if !strings.Contains(gottenCard.Notes, req.NotesContains) { @@ -144,17 +130,17 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t } // lastly check if this is a special request and skip the card if it does not meet it - if req.NameContains != "" || req.CardType != "" || req.SortBy != "" || req.Classes != "" || req.KeywordsContains != "" { + if req.NameContains != "" || len(req.CardTypes) != 0 || req.SortBy != "" || len(req.Classes) != 0 || req.KeywordsContains != "" { cardobj, err := keywords.Unmarshal(gottenCard.Content) if err != nil { return nil, sdkerrors.Wrap(errors.ErrJSONMarshal, err.Error()+"cardid="+strconv.FormatUint(idx, 10)) } if cardobj.Action != nil { - if req.CardType != "" && req.CardType != "Action" { + if len(req.CardTypes) != 0 && !slices.Contains(req.CardTypes, types.CardType_action) { continue } - if req.Classes != "" && !checkClasses(cardobj.Action.Class) { + if !checkClasses(cardobj.Action.Class) { continue } if !checkName(cardobj.Action.CardName) { @@ -175,10 +161,10 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t } } if cardobj.Entity != nil { - if req.CardType != "" && req.CardType != "Entity" { + if len(req.CardTypes) != 0 && !slices.Contains(req.CardTypes, types.CardType_entity) { continue } - if req.Classes != "" && !checkClasses(cardobj.Entity.Class) { + if !checkClasses(cardobj.Entity.Class) { continue } if !checkName(cardobj.Entity.CardName) { @@ -199,10 +185,10 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t } } if cardobj.Headquarter != nil { - if req.CardType != "" && req.CardType != "Headquarter" { + if len(req.CardTypes) != 0 && !slices.Contains(req.CardTypes, types.CardType_headquarter) { continue } - if req.Classes != "" && !checkClasses(cardobj.Headquarter.Class) { + if !checkClasses(cardobj.Headquarter.Class) { continue } if !checkName(cardobj.Headquarter.CardName) { @@ -223,13 +209,13 @@ func (k Keeper) QCards(goCtx context.Context, req *types.QueryQCardsRequest) (*t } } if cardobj.Place != nil { - if req.CardType != "" && req.CardType != "Place" { + if len(req.CardTypes) != 0 && !slices.Contains(req.CardTypes, types.CardType_place) { continue } if !checkName(cardobj.Place.CardName) { continue } - if req.Classes != "" && !checkClasses(cardobj.Place.Class) { + if !checkClasses(cardobj.Place.Class) { continue } if req.KeywordsContains != "" { diff --git a/x/cardchain/types/card.pb.go b/x/cardchain/types/card.pb.go index 7194106e..179e322d 100644 --- a/x/cardchain/types/card.pb.go +++ b/x/cardchain/types/card.pb.go @@ -104,6 +104,68 @@ func (CardRarity) EnumDescriptor() ([]byte, []int) { return fileDescriptor_a360ffd2377ddc30, []int{1} } +type CardClass int32 + +const ( + CardClass_nature CardClass = 0 + CardClass_culture CardClass = 1 + CardClass_mysticism CardClass = 2 + CardClass_technology CardClass = 3 +) + +var CardClass_name = map[int32]string{ + 0: "nature", + 1: "culture", + 2: "mysticism", + 3: "technology", +} + +var CardClass_value = map[string]int32{ + "nature": 0, + "culture": 1, + "mysticism": 2, + "technology": 3, +} + +func (x CardClass) String() string { + return proto.EnumName(CardClass_name, int32(x)) +} + +func (CardClass) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_a360ffd2377ddc30, []int{2} +} + +type CardType int32 + +const ( + CardType_place CardType = 0 + CardType_action CardType = 1 + CardType_entity CardType = 2 + CardType_headquarter CardType = 3 +) + +var CardType_name = map[int32]string{ + 0: "place", + 1: "action", + 2: "entity", + 3: "headquarter", +} + +var CardType_value = map[string]int32{ + "place": 0, + "action": 1, + "entity": 2, + "headquarter": 3, +} + +func (x CardType) String() string { + return proto.EnumName(CardType_name, int32(x)) +} + +func (CardType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_a360ffd2377ddc30, []int{3} +} + type Card struct { Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` Artist string `protobuf:"bytes,2,opt,name=artist,proto3" json:"artist,omitempty"` @@ -489,6 +551,8 @@ func (m *TimeStamp) GetTimeStamp() uint64 { func init() { proto.RegisterEnum("DecentralCardGame.cardchain.cardchain.Status", Status_name, Status_value) proto.RegisterEnum("DecentralCardGame.cardchain.cardchain.CardRarity", CardRarity_name, CardRarity_value) + proto.RegisterEnum("DecentralCardGame.cardchain.cardchain.CardClass", CardClass_name, CardClass_value) + proto.RegisterEnum("DecentralCardGame.cardchain.cardchain.CardType", CardType_name, CardType_value) proto.RegisterType((*Card)(nil), "DecentralCardGame.cardchain.cardchain.Card") proto.RegisterType((*OutpCard)(nil), "DecentralCardGame.cardchain.cardchain.OutpCard") proto.RegisterType((*TimeStamp)(nil), "DecentralCardGame.cardchain.cardchain.TimeStamp") @@ -497,51 +561,56 @@ func init() { func init() { proto.RegisterFile("cardchain/cardchain/card.proto", fileDescriptor_a360ffd2377ddc30) } var fileDescriptor_a360ffd2377ddc30 = []byte{ - // 692 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0x4d, 0x6f, 0xd3, 0x40, - 0x10, 0x8d, 0x1b, 0xc7, 0xb1, 0xa7, 0x6d, 0xea, 0xae, 0x2a, 0x64, 0x10, 0x4a, 0xad, 0x0a, 0x44, - 0xa8, 0x68, 0x22, 0xe0, 0xc2, 0xb5, 0x2d, 0x15, 0xaa, 0x10, 0x02, 0xb9, 0xa8, 0x07, 0x2e, 0x68, - 0x63, 0x4f, 0x63, 0x0b, 0x7b, 0xd7, 0xec, 0xae, 0xfb, 0xf1, 0x07, 0x38, 0xf3, 0x3b, 0xf8, 0x0f, - 0xdc, 0x7b, 0xec, 0x11, 0x71, 0xa8, 0x50, 0xfb, 0x47, 0xd0, 0xae, 0xd3, 0xa6, 0x1f, 0x08, 0x55, - 0xea, 0x0d, 0x71, 0xca, 0xbc, 0xb7, 0xef, 0x8d, 0x35, 0x3b, 0x4f, 0x59, 0xe8, 0xc6, 0x54, 0x24, - 0x71, 0x4a, 0x33, 0x36, 0xb8, 0x5c, 0xf5, 0x4b, 0xc1, 0x15, 0x27, 0x0f, 0x5f, 0x62, 0x8c, 0x4c, - 0x09, 0x9a, 0xaf, 0x53, 0x91, 0xbc, 0xa2, 0x05, 0xf6, 0xcf, 0x75, 0x93, 0xea, 0xde, 0xc2, 0x88, - 0x8f, 0xb8, 0x71, 0x0c, 0x74, 0x55, 0x9b, 0x97, 0xbe, 0xb5, 0xc0, 0xd6, 0x36, 0xb2, 0x00, 0x2d, - 0xbe, 0xc7, 0x50, 0x04, 0x56, 0x68, 0xf5, 0xbc, 0xa8, 0x06, 0xe4, 0x0e, 0x38, 0x54, 0xa8, 0x4c, - 0xaa, 0x60, 0xca, 0xd0, 0x63, 0x44, 0x02, 0x68, 0xc7, 0x9c, 0x29, 0x64, 0x2a, 0x68, 0x86, 0x56, - 0x6f, 0x26, 0x3a, 0x83, 0xe4, 0x2e, 0xb8, 0x59, 0x41, 0x47, 0xf8, 0x31, 0x4b, 0x02, 0x3b, 0xb4, - 0x7a, 0x76, 0xd4, 0x36, 0x78, 0x33, 0xd1, 0xa6, 0x9d, 0x2a, 0xcf, 0x57, 0x85, 0x0a, 0x5a, 0xa1, - 0xd5, 0x73, 0xa3, 0x33, 0xa8, 0x3f, 0xce, 0xb8, 0x42, 0x19, 0x38, 0xf5, 0xc7, 0x0d, 0x20, 0x1b, - 0xe0, 0x48, 0x45, 0x55, 0x25, 0x83, 0x76, 0x68, 0xf5, 0x3a, 0xcf, 0x56, 0xfa, 0x37, 0x9a, 0xb4, - 0xbf, 0x65, 0x4c, 0xd1, 0xd8, 0x4c, 0x5e, 0x83, 0xbb, 0xcb, 0x15, 0xbe, 0xe3, 0x3c, 0x0f, 0x5c, - 0xdd, 0x7f, 0x6d, 0x70, 0x78, 0xbc, 0xd8, 0xf8, 0x79, 0xbc, 0xf8, 0x68, 0x94, 0xa9, 0xb4, 0x1a, - 0xf6, 0x63, 0x5e, 0x0c, 0x62, 0x2e, 0x0b, 0x2e, 0xc7, 0x3f, 0x2b, 0x32, 0xf9, 0x34, 0x50, 0x07, - 0x25, 0xca, 0xfe, 0x3a, 0xcf, 0x58, 0x74, 0xde, 0x40, 0x5f, 0x88, 0xae, 0x85, 0x0c, 0x3a, 0x61, - 0x53, 0x5f, 0x48, 0x8d, 0x48, 0x0f, 0xe6, 0x76, 0x68, 0x26, 0x36, 0x18, 0xaf, 0x46, 0xe9, 0xb6, - 0x99, 0xc5, 0x33, 0xd3, 0x5f, 0xa5, 0xc9, 0x32, 0xf8, 0x7c, 0x17, 0x45, 0xc9, 0xf7, 0x50, 0x60, - 0x52, 0x4b, 0xc1, 0x48, 0xaf, 0xf1, 0xe4, 0x09, 0xcc, 0x57, 0x2c, 0xb9, 0x22, 0x9e, 0x36, 0xe2, - 0xeb, 0x07, 0xa4, 0x0f, 0x24, 0x63, 0xb4, 0x2c, 0x05, 0x2f, 0x45, 0x46, 0x15, 0xd6, 0xf2, 0x19, - 0x23, 0xff, 0xc3, 0x09, 0xb9, 0x0f, 0x1e, 0x43, 0xb1, 0x93, 0xe3, 0x2e, 0xe6, 0xc1, 0x6c, 0x68, - 0xf5, 0x9a, 0xd1, 0x84, 0x20, 0x0f, 0x60, 0x76, 0x48, 0x73, 0xca, 0x62, 0x5c, 0x65, 0x71, 0xca, - 0x45, 0x30, 0x67, 0x76, 0x76, 0x99, 0x24, 0x21, 0x4c, 0x4b, 0x45, 0x85, 0x42, 0xa1, 0x57, 0x12, - 0xf8, 0x46, 0x73, 0x91, 0x22, 0x9b, 0xe0, 0x08, 0x2a, 0x32, 0x75, 0x10, 0xcc, 0x9b, 0x2d, 0x3e, - 0xbd, 0xe1, 0x16, 0xf5, 0x61, 0x64, 0x8c, 0xd1, 0xb8, 0xc1, 0xd2, 0xf7, 0x16, 0xb8, 0x6f, 0x2b, - 0x55, 0xde, 0x3e, 0xb0, 0xde, 0x24, 0xb0, 0x0b, 0xd0, 0x32, 0x01, 0x35, 0x69, 0xf5, 0xa2, 0x1a, - 0xfc, 0xcf, 0xea, 0x3f, 0x98, 0x55, 0x02, 0x76, 0x4a, 0x65, 0x6a, 0x42, 0xea, 0x45, 0xa6, 0xbe, - 0x9a, 0xdf, 0xf9, 0xbf, 0xe5, 0x97, 0xdc, 0x36, 0xbf, 0x8f, 0xc1, 0x7b, 0x9f, 0x15, 0xb8, 0xa5, - 0x68, 0x51, 0xea, 0x89, 0xd4, 0x19, 0x30, 0x19, 0xb6, 0xa3, 0x09, 0xb1, 0xfc, 0xc5, 0x02, 0xa7, - 0xce, 0x06, 0x01, 0x70, 0x64, 0x9c, 0x62, 0x81, 0x7e, 0x83, 0xcc, 0x82, 0x67, 0xfe, 0xb7, 0xf5, - 0xbe, 0x7d, 0x8b, 0x78, 0xd0, 0x52, 0x22, 0xa3, 0xb9, 0x3f, 0x65, 0x4e, 0x50, 0x14, 0x94, 0x21, - 0x53, 0x7e, 0x53, 0x43, 0x59, 0xc9, 0x12, 0x59, 0x82, 0x89, 0x6f, 0xeb, 0x1e, 0x43, 0xca, 0x18, - 0x26, 0x7e, 0x8b, 0x74, 0x00, 0xea, 0x7a, 0x8b, 0x73, 0xe6, 0x3b, 0x84, 0x40, 0xa7, 0xc6, 0xdb, - 0x28, 0x0e, 0x0c, 0xd7, 0x26, 0x2e, 0xd8, 0x8c, 0x33, 0xf4, 0xdd, 0xe5, 0x37, 0x00, 0x93, 0x49, - 0x74, 0x9f, 0x98, 0x17, 0x05, 0x67, 0x7e, 0x83, 0xcc, 0x80, 0x5b, 0xb1, 0x31, 0xb2, 0xb4, 0x43, - 0x50, 0x81, 0xfe, 0x14, 0x99, 0x83, 0x69, 0xdc, 0x8f, 0xb1, 0x54, 0x19, 0x67, 0x34, 0xf7, 0x9b, - 0xda, 0x54, 0xb1, 0xec, 0x73, 0x85, 0xbe, 0xbd, 0x16, 0x1d, 0x9e, 0x74, 0xad, 0xa3, 0x93, 0xae, - 0xf5, 0xeb, 0xa4, 0x6b, 0x7d, 0x3d, 0xed, 0x36, 0x8e, 0x4e, 0xbb, 0x8d, 0x1f, 0xa7, 0xdd, 0xc6, - 0x87, 0x17, 0x17, 0x02, 0x7e, 0xed, 0x86, 0x07, 0xeb, 0xe7, 0x2f, 0xdf, 0xfe, 0x85, 0x57, 0xd0, - 0xc4, 0x7e, 0xe8, 0x98, 0x2b, 0x79, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x0c, 0xa7, 0xa5, 0x39, - 0x29, 0x07, 0x00, 0x00, + // 779 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0x41, 0x8f, 0x1b, 0x35, + 0x14, 0xce, 0x6c, 0x26, 0x93, 0x99, 0x97, 0xdd, 0xac, 0xd7, 0x5a, 0xa1, 0x01, 0xa1, 0x74, 0x54, + 0x81, 0x08, 0x11, 0x4d, 0x04, 0x5c, 0x38, 0x21, 0xb5, 0xa1, 0x42, 0x15, 0x42, 0xa0, 0xd9, 0xaa, + 0x07, 0x2e, 0xc8, 0xf1, 0xbc, 0xcd, 0x58, 0xcc, 0xd8, 0x53, 0xdb, 0xb3, 0x6d, 0xfe, 0x00, 0x67, + 0x7e, 0x07, 0xff, 0x81, 0x7b, 0x8f, 0x3d, 0x22, 0x0e, 0x15, 0xda, 0xfd, 0x23, 0xc8, 0x9e, 0xec, + 0x66, 0xbb, 0x8b, 0x50, 0xa5, 0xde, 0x50, 0x4f, 0x79, 0xdf, 0xf3, 0xfb, 0x9e, 0xfd, 0xfc, 0x7d, + 0x13, 0xc3, 0x84, 0x33, 0x5d, 0xf0, 0x92, 0x09, 0xb9, 0x78, 0x3d, 0x9a, 0x37, 0x5a, 0x59, 0x45, + 0x3f, 0xfe, 0x06, 0x39, 0x4a, 0xab, 0x59, 0xb5, 0x64, 0xba, 0xf8, 0x96, 0xd5, 0x38, 0xbf, 0xaa, + 0xdb, 0x45, 0x1f, 0x1c, 0xaf, 0xd5, 0x5a, 0x79, 0xc6, 0xc2, 0x45, 0x1d, 0xf9, 0xee, 0xef, 0x03, + 0x08, 0x1d, 0x8d, 0x1e, 0xc3, 0x40, 0x3d, 0x93, 0xa8, 0xd3, 0x20, 0x0b, 0xa6, 0x49, 0xde, 0x01, + 0xfa, 0x1e, 0x44, 0x4c, 0x5b, 0x61, 0x6c, 0xba, 0xe7, 0xd3, 0x5b, 0x44, 0x53, 0x18, 0x72, 0x25, + 0x2d, 0x4a, 0x9b, 0xf6, 0xb3, 0x60, 0xba, 0x9f, 0x5f, 0x42, 0xfa, 0x3e, 0xc4, 0xa2, 0x66, 0x6b, + 0xfc, 0x59, 0x14, 0x69, 0x98, 0x05, 0xd3, 0x30, 0x1f, 0x7a, 0xfc, 0xa8, 0x70, 0xa4, 0xd3, 0xb6, + 0xaa, 0xee, 0x6b, 0x9b, 0x0e, 0xb2, 0x60, 0x1a, 0xe7, 0x97, 0xd0, 0x6d, 0x2e, 0x95, 0x45, 0x93, + 0x46, 0xdd, 0xe6, 0x1e, 0xd0, 0x87, 0x10, 0x19, 0xcb, 0x6c, 0x6b, 0xd2, 0x61, 0x16, 0x4c, 0xc7, + 0x5f, 0xdc, 0x9b, 0xbf, 0xd1, 0xa4, 0xf3, 0x13, 0x4f, 0xca, 0xb7, 0x64, 0xfa, 0x1d, 0xc4, 0x67, + 0xca, 0xe2, 0x8f, 0x4a, 0x55, 0x69, 0xec, 0xfa, 0x3f, 0x58, 0xbc, 0x78, 0x75, 0xa7, 0xf7, 0xd7, + 0xab, 0x3b, 0x9f, 0xac, 0x85, 0x2d, 0xdb, 0xd5, 0x9c, 0xab, 0x7a, 0xc1, 0x95, 0xa9, 0x95, 0xd9, + 0xfe, 0xdc, 0x33, 0xc5, 0x2f, 0x0b, 0xbb, 0x69, 0xd0, 0xcc, 0x97, 0x4a, 0xc8, 0xfc, 0xaa, 0x81, + 0xbb, 0x10, 0x17, 0x6b, 0x93, 0x8e, 0xb3, 0xbe, 0xbb, 0x90, 0x0e, 0xd1, 0x29, 0x1c, 0x9e, 0x32, + 0xa1, 0x1f, 0x4a, 0xd5, 0xae, 0xcb, 0x27, 0x7e, 0x96, 0xc4, 0x4f, 0x7f, 0x33, 0x4d, 0x67, 0x40, + 0xd4, 0x19, 0xea, 0x46, 0x3d, 0x43, 0x8d, 0x45, 0x57, 0x0a, 0xbe, 0xf4, 0x56, 0x9e, 0x7e, 0x06, + 0x47, 0xad, 0x2c, 0x6e, 0x14, 0x8f, 0x7c, 0xf1, 0xed, 0x05, 0x3a, 0x07, 0x2a, 0x24, 0x6b, 0x1a, + 0xad, 0x1a, 0x2d, 0x98, 0xc5, 0xae, 0x7c, 0xdf, 0x97, 0xff, 0xcb, 0x0a, 0xfd, 0x10, 0x12, 0x89, + 0xfa, 0xb4, 0xc2, 0x33, 0xac, 0xd2, 0x83, 0x2c, 0x98, 0xf6, 0xf3, 0x5d, 0x82, 0x7e, 0x04, 0x07, + 0x2b, 0x56, 0x31, 0xc9, 0xf1, 0xbe, 0xe4, 0xa5, 0xd2, 0xe9, 0xa1, 0xd7, 0xec, 0xf5, 0x24, 0xcd, + 0x60, 0x64, 0x2c, 0xd3, 0x16, 0xb5, 0x93, 0x24, 0x25, 0xbe, 0xe6, 0x7a, 0x8a, 0x3e, 0x82, 0x48, + 0x33, 0x2d, 0xec, 0x26, 0x3d, 0xf2, 0x2a, 0x7e, 0xfe, 0x86, 0x2a, 0xba, 0xc5, 0xdc, 0x13, 0xf3, + 0x6d, 0x83, 0xbb, 0x7f, 0x0c, 0x20, 0xfe, 0xa1, 0xb5, 0xcd, 0xdb, 0x1b, 0x36, 0xd9, 0x19, 0xf6, + 0x18, 0x06, 0xde, 0xa0, 0xde, 0xad, 0x49, 0xde, 0x81, 0x77, 0x5e, 0xfd, 0x1f, 0x7a, 0x95, 0x42, + 0x58, 0x32, 0x53, 0x7a, 0x93, 0x26, 0xb9, 0x8f, 0x6f, 0xfa, 0xf7, 0xe8, 0xbf, 0xfc, 0x4b, 0xdf, + 0xd6, 0xbf, 0x9f, 0x42, 0xf2, 0x58, 0xd4, 0x78, 0x62, 0x59, 0xdd, 0xb8, 0x89, 0xec, 0x25, 0xf0, + 0x1e, 0x0e, 0xf3, 0x5d, 0x62, 0xf6, 0x6b, 0x00, 0x51, 0xe7, 0x0d, 0x0a, 0x10, 0x19, 0x5e, 0x62, + 0x8d, 0xa4, 0x47, 0x0f, 0x20, 0xf1, 0xff, 0xdb, 0x4e, 0x6f, 0x12, 0xd0, 0x04, 0x06, 0x56, 0x0b, + 0x56, 0x91, 0x3d, 0xbf, 0x82, 0xba, 0x66, 0x12, 0xa5, 0x25, 0x7d, 0x07, 0x4d, 0x6b, 0x1a, 0x94, + 0x05, 0x16, 0x24, 0x74, 0x3d, 0x56, 0x4c, 0x4a, 0x2c, 0xc8, 0x80, 0x8e, 0x01, 0xba, 0xf8, 0x44, + 0x29, 0x49, 0x22, 0x4a, 0x61, 0xdc, 0xe1, 0x27, 0xa8, 0x37, 0x3e, 0x37, 0xa4, 0x31, 0x84, 0x52, + 0x49, 0x24, 0xf1, 0xec, 0x7b, 0x80, 0xdd, 0x24, 0xae, 0x0f, 0x57, 0x75, 0xad, 0x24, 0xe9, 0xd1, + 0x7d, 0x88, 0x5b, 0xb9, 0x45, 0x81, 0x63, 0x68, 0xa6, 0x91, 0xec, 0xd1, 0x43, 0x18, 0xe1, 0x73, + 0x8e, 0x8d, 0x15, 0x4a, 0xb2, 0x8a, 0xf4, 0x1d, 0xa9, 0x95, 0xe2, 0x69, 0x8b, 0x24, 0x9c, 0x2d, + 0x21, 0x71, 0xed, 0x96, 0x15, 0x33, 0x7e, 0x32, 0xc9, 0x6c, 0xab, 0xdd, 0x64, 0x23, 0x18, 0xf2, + 0xb6, 0xf2, 0x20, 0x70, 0xa7, 0xaf, 0x37, 0xc6, 0x0a, 0x2e, 0x4c, 0x4d, 0xf6, 0xdc, 0x89, 0x2d, + 0xf2, 0x52, 0xaa, 0x4a, 0xad, 0x37, 0xa4, 0x3f, 0xfb, 0x1a, 0x62, 0xd7, 0xe4, 0xf1, 0xa6, 0x41, + 0x77, 0x05, 0x4d, 0xc5, 0xb8, 0x6b, 0x01, 0x10, 0x31, 0xee, 0x76, 0x25, 0x81, 0x8b, 0x51, 0x5a, + 0x61, 0x37, 0xdd, 0x81, 0x4a, 0x64, 0xc5, 0xd3, 0xd6, 0x8b, 0x4a, 0xfa, 0x0f, 0xf2, 0x17, 0xe7, + 0x93, 0xe0, 0xe5, 0xf9, 0x24, 0xf8, 0xfb, 0x7c, 0x12, 0xfc, 0x76, 0x31, 0xe9, 0xbd, 0xbc, 0x98, + 0xf4, 0xfe, 0xbc, 0x98, 0xf4, 0x7e, 0xfa, 0xea, 0xda, 0x57, 0x76, 0x4b, 0xe6, 0xc5, 0xf2, 0xea, + 0xf9, 0x7d, 0x7e, 0xed, 0x29, 0xf6, 0xdf, 0xde, 0x2a, 0xf2, 0xba, 0x7c, 0xf9, 0x4f, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x92, 0x69, 0x4e, 0x10, 0xae, 0x07, 0x00, 0x00, } func (m *Card) Marshal() (dAtA []byte, err error) { diff --git a/x/cardchain/types/query.pb.go b/x/cardchain/types/query.pb.go index 7efd7982..5ec13ef5 100644 --- a/x/cardchain/types/query.pb.go +++ b/x/cardchain/types/query.pb.go @@ -31,58 +31,6 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type QueryQCardsRequest_Status int32 - -const ( - QueryQCardsRequest_scheme QueryQCardsRequest_Status = 0 - QueryQCardsRequest_prototype QueryQCardsRequest_Status = 1 - QueryQCardsRequest_trial QueryQCardsRequest_Status = 2 - QueryQCardsRequest_permanent QueryQCardsRequest_Status = 3 - QueryQCardsRequest_suspended QueryQCardsRequest_Status = 4 - QueryQCardsRequest_banned QueryQCardsRequest_Status = 5 - QueryQCardsRequest_bannedSoon QueryQCardsRequest_Status = 6 - QueryQCardsRequest_bannedVerySoon QueryQCardsRequest_Status = 7 - QueryQCardsRequest_none QueryQCardsRequest_Status = 8 - QueryQCardsRequest_playable QueryQCardsRequest_Status = 9 - QueryQCardsRequest_unplayable QueryQCardsRequest_Status = 10 -) - -var QueryQCardsRequest_Status_name = map[int32]string{ - 0: "scheme", - 1: "prototype", - 2: "trial", - 3: "permanent", - 4: "suspended", - 5: "banned", - 6: "bannedSoon", - 7: "bannedVerySoon", - 8: "none", - 9: "playable", - 10: "unplayable", -} - -var QueryQCardsRequest_Status_value = map[string]int32{ - "scheme": 0, - "prototype": 1, - "trial": 2, - "permanent": 3, - "suspended": 4, - "banned": 5, - "bannedSoon": 6, - "bannedVerySoon": 7, - "none": 8, - "playable": 9, - "unplayable": 10, -} - -func (x QueryQCardsRequest_Status) String() string { - return proto.EnumName(QueryQCardsRequest_Status_name, int32(x)) -} - -func (QueryQCardsRequest_Status) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_e1bdbfeb9d7f6cfd, []int{10, 0} -} - // QueryParamsRequest is request type for the Query/Params RPC method. type QueryParamsRequest struct { } @@ -552,16 +500,18 @@ func (m *QueryQVotingResultsResponse) GetLastVotingResults() *VotingResults { } type QueryQCardsRequest struct { - Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` - Status QueryQCardsRequest_Status `protobuf:"varint,2,opt,name=status,proto3,enum=DecentralCardGame.cardchain.cardchain.QueryQCardsRequest_Status" json:"status,omitempty"` - CardType string `protobuf:"bytes,3,opt,name=cardType,proto3" json:"cardType,omitempty"` - Classes string `protobuf:"bytes,4,opt,name=classes,proto3" json:"classes,omitempty"` - SortBy string `protobuf:"bytes,5,opt,name=sortBy,proto3" json:"sortBy,omitempty"` - NameContains string `protobuf:"bytes,6,opt,name=nameContains,proto3" json:"nameContains,omitempty"` - KeywordsContains string `protobuf:"bytes,7,opt,name=keywordsContains,proto3" json:"keywordsContains,omitempty"` - NotesContains string `protobuf:"bytes,8,opt,name=notesContains,proto3" json:"notesContains,omitempty"` - OnlyStarterCard bool `protobuf:"varint,9,opt,name=onlyStarterCard,proto3" json:"onlyStarterCard,omitempty"` - OnlyBalanceAnchors bool `protobuf:"varint,10,opt,name=onlyBalanceAnchors,proto3" json:"onlyBalanceAnchors,omitempty"` + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + Statuses []Status `protobuf:"varint,2,rep,packed,name=statuses,proto3,enum=DecentralCardGame.cardchain.cardchain.Status" json:"statuses,omitempty"` + CardTypes []CardType `protobuf:"varint,3,rep,packed,name=cardTypes,proto3,enum=DecentralCardGame.cardchain.cardchain.CardType" json:"cardTypes,omitempty"` + Classes []CardClass `protobuf:"varint,4,rep,packed,name=classes,proto3,enum=DecentralCardGame.cardchain.cardchain.CardClass" json:"classes,omitempty"` + SortBy string `protobuf:"bytes,5,opt,name=sortBy,proto3" json:"sortBy,omitempty"` + NameContains string `protobuf:"bytes,6,opt,name=nameContains,proto3" json:"nameContains,omitempty"` + KeywordsContains string `protobuf:"bytes,7,opt,name=keywordsContains,proto3" json:"keywordsContains,omitempty"` + NotesContains string `protobuf:"bytes,8,opt,name=notesContains,proto3" json:"notesContains,omitempty"` + OnlyStarterCard bool `protobuf:"varint,9,opt,name=onlyStarterCard,proto3" json:"onlyStarterCard,omitempty"` + OnlyBalanceAnchors bool `protobuf:"varint,10,opt,name=onlyBalanceAnchors,proto3" json:"onlyBalanceAnchors,omitempty"` + Rarities []CardRarity `protobuf:"varint,11,rep,packed,name=rarities,proto3,enum=DecentralCardGame.cardchain.cardchain.CardRarity" json:"rarities,omitempty"` + MultiClassOnly bool `protobuf:"varint,12,opt,name=multiClassOnly,proto3" json:"multiClassOnly,omitempty"` } func (m *QueryQCardsRequest) Reset() { *m = QueryQCardsRequest{} } @@ -604,25 +554,25 @@ func (m *QueryQCardsRequest) GetOwner() string { return "" } -func (m *QueryQCardsRequest) GetStatus() QueryQCardsRequest_Status { +func (m *QueryQCardsRequest) GetStatuses() []Status { if m != nil { - return m.Status + return m.Statuses } - return QueryQCardsRequest_scheme + return nil } -func (m *QueryQCardsRequest) GetCardType() string { +func (m *QueryQCardsRequest) GetCardTypes() []CardType { if m != nil { - return m.CardType + return m.CardTypes } - return "" + return nil } -func (m *QueryQCardsRequest) GetClasses() string { +func (m *QueryQCardsRequest) GetClasses() []CardClass { if m != nil { return m.Classes } - return "" + return nil } func (m *QueryQCardsRequest) GetSortBy() string { @@ -667,6 +617,20 @@ func (m *QueryQCardsRequest) GetOnlyBalanceAnchors() bool { return false } +func (m *QueryQCardsRequest) GetRarities() []CardRarity { + if m != nil { + return m.Rarities + } + return nil +} + +func (m *QueryQCardsRequest) GetMultiClassOnly() bool { + if m != nil { + return m.MultiClassOnly + } + return false +} + type QueryQCardsResponse struct { CardsList []uint64 `protobuf:"varint,1,rep,packed,name=cardsList,proto3" json:"cardsList,omitempty"` } @@ -1668,7 +1632,6 @@ func (m *QueryQCardContentsResponse) GetCards() []*QueryQCardContentResponse { } func init() { - proto.RegisterEnum("DecentralCardGame.cardchain.cardchain.QueryQCardsRequest_Status", QueryQCardsRequest_Status_name, QueryQCardsRequest_Status_value) proto.RegisterType((*QueryParamsRequest)(nil), "DecentralCardGame.cardchain.cardchain.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "DecentralCardGame.cardchain.cardchain.QueryParamsResponse") proto.RegisterType((*QueryQCardRequest)(nil), "DecentralCardGame.cardchain.cardchain.QueryQCardRequest") @@ -1704,135 +1667,132 @@ func init() { func init() { proto.RegisterFile("cardchain/cardchain/query.proto", fileDescriptor_e1bdbfeb9d7f6cfd) } var fileDescriptor_e1bdbfeb9d7f6cfd = []byte{ - // 2047 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x19, 0x5d, 0x6f, 0x1b, 0xc7, - 0x51, 0x47, 0x51, 0x94, 0x38, 0xb2, 0x54, 0x66, 0xeb, 0xba, 0x2c, 0xeb, 0xca, 0xea, 0xc1, 0x69, - 0xd5, 0x24, 0xe2, 0x25, 0x8a, 0x63, 0xcb, 0x8e, 0x23, 0x5b, 0x1f, 0x76, 0xa2, 0x36, 0x8e, 0x9d, - 0x63, 0x63, 0x14, 0xed, 0x83, 0x70, 0xe4, 0xad, 0xa5, 0x43, 0xc8, 0x5b, 0xfa, 0x76, 0x69, 0x87, - 0x10, 0xf8, 0xd0, 0xfe, 0x82, 0xa2, 0xfd, 0x0b, 0x7d, 0x2d, 0x0a, 0xa4, 0x45, 0xdf, 0x8a, 0xf6, - 0xd1, 0x45, 0x5f, 0x02, 0x14, 0x05, 0xd2, 0x00, 0x75, 0x0b, 0xbb, 0xef, 0xfd, 0x0b, 0xc5, 0xce, - 0xee, 0xde, 0x07, 0x45, 0x0b, 0x77, 0xf4, 0x93, 0x6e, 0x66, 0x67, 0x66, 0xe7, 0x7b, 0x67, 0x28, - 0xb8, 0xd0, 0xf1, 0x22, 0xbf, 0x73, 0xe4, 0x05, 0xa1, 0x93, 0x7c, 0x3d, 0x1c, 0xd0, 0x68, 0xd8, - 0xec, 0x47, 0x4c, 0x30, 0xf2, 0xea, 0x1e, 0xed, 0xd0, 0x50, 0x44, 0x5e, 0x77, 0xd7, 0x8b, 0xfc, - 0xf7, 0xbd, 0x1e, 0x6d, 0xc6, 0x84, 0xc9, 0x57, 0xe3, 0xec, 0x21, 0x3b, 0x64, 0xc8, 0xe1, 0xc8, - 0x2f, 0xc5, 0xdc, 0x38, 0x7f, 0xc8, 0xd8, 0x61, 0x97, 0x3a, 0x5e, 0x3f, 0x70, 0xbc, 0x30, 0x64, - 0xc2, 0x13, 0x01, 0x0b, 0xb9, 0x3e, 0x7d, 0xad, 0xc3, 0x78, 0x8f, 0x71, 0xa7, 0xed, 0x71, 0xaa, - 0xee, 0x74, 0x1e, 0xbd, 0xd5, 0xa6, 0xc2, 0x7b, 0xcb, 0xe9, 0x7b, 0x87, 0x41, 0x88, 0xc4, 0x9a, - 0x76, 0x75, 0x92, 0x9e, 0x7d, 0x2f, 0xf2, 0x7a, 0xfc, 0x34, 0x8a, 0x47, 0x4c, 0x04, 0xe1, 0xa1, - 0xa6, 0x58, 0x99, 0x44, 0x21, 0xbf, 0x4e, 0x3b, 0x1f, 0x70, 0x1a, 0xe9, 0xf3, 0x89, 0xbe, 0xea, - 0x79, 0xa2, 0x73, 0xa4, 0x09, 0xbe, 0x33, 0x89, 0x80, 0x53, 0xa1, 0x8f, 0x2f, 0x4e, 0x3e, 0xee, - 0x76, 0x0f, 0xd8, 0x83, 0x07, 0xf1, 0x2d, 0xdf, 0x9d, 0xa8, 0x25, 0x1b, 0x84, 0x9d, 0xa0, 0x7b, - 0x9a, 0xa9, 0x9c, 0x46, 0x8f, 0x62, 0x21, 0xe7, 0x27, 0x51, 0x88, 0xcf, 0xd4, 0xa9, 0x7d, 0x16, - 0xc8, 0xc7, 0xd2, 0xdd, 0xf7, 0xd0, 0x7f, 0x2e, 0x7d, 0x38, 0xa0, 0x5c, 0xd8, 0x6d, 0xf8, 0x7a, - 0x06, 0xcb, 0xfb, 0x2c, 0xe4, 0x94, 0xfc, 0x08, 0x2a, 0xca, 0xcf, 0x75, 0x6b, 0xd5, 0x5a, 0x5b, - 0xdc, 0x58, 0x6f, 0xe6, 0xca, 0x88, 0xa6, 0x12, 0xb3, 0x53, 0x7e, 0xf2, 0xf4, 0xc2, 0x8c, 0xab, - 0x45, 0xd8, 0xaf, 0xc3, 0x2b, 0x78, 0xc7, 0xc7, 0x92, 0x55, 0x5f, 0x4c, 0xce, 0x41, 0x45, 0xb2, - 0xed, 0xfb, 0x78, 0x43, 0xd5, 0xd5, 0x90, 0xbd, 0x01, 0xf5, 0x84, 0x78, 0x97, 0x85, 0x82, 0x86, - 0x62, 0x32, 0x4f, 0x39, 0xe6, 0xd9, 0x87, 0x6f, 0x4d, 0xe0, 0xd1, 0xa6, 0xd4, 0x61, 0xbe, 0xa3, - 0x50, 0xfa, 0x26, 0x03, 0x12, 0x02, 0xe5, 0x23, 0x8f, 0x1f, 0xd5, 0x4b, 0x88, 0xc6, 0x6f, 0x7b, - 0xdd, 0xe8, 0xfa, 0x09, 0xa7, 0x91, 0xb9, 0xb7, 0x0e, 0xf3, 0x9e, 0xef, 0x47, 0x94, 0x73, 0x23, - 0x42, 0x83, 0xf6, 0x79, 0x68, 0x24, 0x37, 0xa3, 0x0b, 0xf6, 0xc3, 0x07, 0xcc, 0x38, 0xf7, 0x59, - 0x09, 0xbe, 0x3d, 0xf1, 0x58, 0xab, 0xf6, 0x33, 0xa8, 0x49, 0x0b, 0xb6, 0x07, 0x1d, 0x99, 0xf4, - 0xf7, 0xa2, 0xa0, 0x43, 0xd5, 0x05, 0x3b, 0x8e, 0x74, 0xe0, 0x57, 0x4f, 0x2f, 0x7c, 0xff, 0x30, - 0x10, 0x47, 0x83, 0x76, 0xb3, 0xc3, 0x7a, 0x8e, 0x2e, 0x1c, 0xf5, 0x67, 0x9d, 0xfb, 0x9f, 0x3a, - 0x62, 0xd8, 0xa7, 0xbc, 0xb9, 0xcb, 0x82, 0xd0, 0x3d, 0x21, 0x88, 0xac, 0x00, 0x78, 0x1d, 0x11, - 0x3c, 0xa2, 0x2d, 0x2a, 0x78, 0xbd, 0xb4, 0x3a, 0xbb, 0x56, 0x76, 0x53, 0x18, 0xb2, 0x0a, 0x8b, - 0x92, 0x87, 0x7f, 0x34, 0xe8, 0xb5, 0x69, 0x54, 0x9f, 0x45, 0x8f, 0xa6, 0x51, 0xe4, 0x22, 0x2c, - 0x61, 0xa2, 0x53, 0x43, 0x53, 0x46, 0x9a, 0x2c, 0x92, 0xbc, 0x06, 0x35, 0x99, 0xce, 0x77, 0x65, - 0x36, 0x1b, 0xc2, 0x39, 0x24, 0x3c, 0x81, 0x27, 0xdf, 0x83, 0x65, 0x9d, 0xd4, 0x86, 0xb2, 0x82, - 0x94, 0x63, 0x58, 0x29, 0xb3, 0xeb, 0x71, 0x21, 0xbd, 0x76, 0x87, 0xf9, 0xc1, 0x83, 0x80, 0xfa, - 0xf5, 0x79, 0x25, 0x73, 0x1c, 0x9f, 0x84, 0xe0, 0x3e, 0x96, 0xbd, 0x4b, 0xf9, 0xa0, 0x2b, 0xe2, - 0xfc, 0xfe, 0xb9, 0x65, 0x42, 0x30, 0x76, 0xac, 0x43, 0xd0, 0x86, 0x57, 0xa4, 0xc4, 0xcc, 0xa1, - 0xce, 0xf9, 0x4b, 0x39, 0x73, 0x3e, 0x2b, 0xf8, 0xa4, 0x38, 0xfb, 0xaf, 0x65, 0x5d, 0x7a, 0x98, - 0x06, 0x46, 0x35, 0x72, 0x16, 0xe6, 0xd8, 0xe3, 0x90, 0x46, 0x3a, 0xa7, 0x14, 0x40, 0x7e, 0x02, - 0x15, 0x2e, 0x3c, 0x31, 0xe0, 0x98, 0x96, 0xcb, 0x1b, 0x37, 0x73, 0x6a, 0x71, 0xf2, 0x82, 0x66, - 0x0b, 0xe5, 0xb8, 0x5a, 0x1e, 0x69, 0xc0, 0x82, 0x24, 0xff, 0xf1, 0xb0, 0x4f, 0x31, 0xda, 0x55, - 0x37, 0x86, 0xb1, 0x48, 0xba, 0x1e, 0xe7, 0x94, 0x63, 0x90, 0x65, 0x91, 0x28, 0x50, 0xd6, 0x1c, - 0x67, 0x91, 0xd8, 0x19, 0x62, 0x50, 0xab, 0xae, 0x86, 0x88, 0x0d, 0x67, 0x42, 0xaf, 0x47, 0x65, - 0xb5, 0x79, 0x41, 0xc8, 0x31, 0x90, 0x55, 0x37, 0x83, 0x93, 0x61, 0xfc, 0x94, 0x0e, 0x1f, 0xb3, - 0xc8, 0xe7, 0x31, 0xdd, 0x3c, 0xd2, 0x9d, 0xc0, 0xcb, 0x64, 0x0b, 0x99, 0xa0, 0x09, 0xe1, 0x02, - 0x12, 0x66, 0x91, 0x64, 0x0d, 0xbe, 0xc6, 0xc2, 0xee, 0xb0, 0x25, 0xbc, 0x48, 0xd0, 0x48, 0x5a, - 0x5b, 0xaf, 0xae, 0x5a, 0x6b, 0x0b, 0xee, 0x38, 0x9a, 0x34, 0x81, 0x48, 0xd4, 0x8e, 0xd7, 0xf5, - 0xc2, 0x0e, 0xdd, 0x0e, 0x3b, 0x47, 0x2c, 0xe2, 0x75, 0x40, 0xe2, 0x09, 0x27, 0xf6, 0x6f, 0x2c, - 0xa8, 0x28, 0x87, 0x11, 0x80, 0x0a, 0xef, 0x1c, 0xd1, 0x1e, 0xad, 0xcd, 0x90, 0x25, 0xa8, 0x62, - 0xfb, 0x94, 0xa5, 0x56, 0xb3, 0x48, 0x15, 0xe6, 0x44, 0x14, 0x78, 0xdd, 0x5a, 0x09, 0x4f, 0x68, - 0xd4, 0xf3, 0x42, 0x1a, 0x8a, 0xda, 0xac, 0x04, 0xf9, 0x80, 0xf7, 0x69, 0xe8, 0x53, 0xbf, 0x56, - 0x96, 0x32, 0xda, 0x5e, 0x18, 0x52, 0xbf, 0x36, 0x47, 0x96, 0x01, 0xd4, 0x77, 0x8b, 0xb1, 0xb0, - 0x56, 0x21, 0x04, 0x96, 0x15, 0x7c, 0x9f, 0x46, 0x43, 0xc4, 0xcd, 0x93, 0x05, 0x28, 0x87, 0x2c, - 0xa4, 0xb5, 0x05, 0x72, 0x06, 0x16, 0xfa, 0x5d, 0x6f, 0xe8, 0xb5, 0xbb, 0xb4, 0x56, 0x95, 0xbc, - 0x83, 0x30, 0x86, 0xc1, 0x7e, 0x5b, 0xf7, 0x6b, 0x13, 0x69, 0x9d, 0xc6, 0xe7, 0xa1, 0x8a, 0x95, - 0xfb, 0x61, 0xc0, 0x65, 0x9b, 0x93, 0xb5, 0x9e, 0x20, 0xec, 0xa6, 0xc9, 0xbf, 0x3b, 0xb2, 0x72, - 0x53, 0x5d, 0x0d, 0x2b, 0x39, 0x6e, 0xa7, 0x06, 0xb4, 0xd7, 0xa0, 0xa6, 0xe8, 0x5b, 0x54, 0xa4, - 0xb2, 0x95, 0x53, 0x11, 0xd3, 0x2a, 0xc0, 0xbe, 0x06, 0xe7, 0x0c, 0xa5, 0x2e, 0x75, 0x43, 0xbf, - 0x0a, 0x8b, 0x71, 0xf9, 0xc7, 0x5c, 0x69, 0x94, 0x7d, 0x09, 0xce, 0x6a, 0x53, 0x54, 0xf1, 0x1b, - 0x4e, 0x69, 0x8b, 0xc2, 0xc4, 0x7c, 0x09, 0xc2, 0xfe, 0xaa, 0x64, 0xd8, 0xee, 0xa8, 0x36, 0x64, - 0xd8, 0x2e, 0xc2, 0x92, 0x08, 0x7a, 0x94, 0x0b, 0xaf, 0xd7, 0xdf, 0x63, 0x8f, 0x43, 0xcd, 0x9a, - 0x45, 0x4a, 0xb5, 0x62, 0xc4, 0x27, 0x7d, 0xac, 0xb1, 0xb2, 0x9b, 0x46, 0x49, 0x39, 0x1d, 0x9d, - 0x6e, 0xf2, 0x0d, 0xe0, 0xf5, 0xd9, 0xd5, 0x59, 0x99, 0x88, 0x19, 0xa4, 0x2c, 0xa6, 0x88, 0xf6, - 0x99, 0x4c, 0x37, 0x5d, 0x31, 0x31, 0x4c, 0x3e, 0x80, 0x79, 0x36, 0x10, 0x1d, 0xd6, 0xa3, 0x58, - 0x33, 0xcb, 0x1b, 0xcd, 0x9c, 0x35, 0x7c, 0x57, 0x71, 0xb9, 0x86, 0x3d, 0xee, 0xd1, 0xf7, 0xba, - 0xde, 0x90, 0xfa, 0xf5, 0x0a, 0x06, 0x36, 0x8d, 0x22, 0x1f, 0x42, 0x25, 0x38, 0x0c, 0x59, 0x44, - 0xb1, 0xb0, 0xf2, 0x37, 0xad, 0x7d, 0x64, 0x32, 0x2e, 0xd4, 0x32, 0xec, 0x1f, 0xc0, 0x52, 0xe6, - 0x40, 0xe6, 0x88, 0x31, 0xc5, 0xc2, 0xd2, 0x31, 0xa0, 0x6c, 0xac, 0xdf, 0x18, 0x8b, 0x83, 0xce, - 0xc5, 0x55, 0x58, 0xd4, 0x2f, 0x44, 0x2a, 0x1b, 0xd3, 0x28, 0x72, 0x5b, 0x67, 0x1e, 0x55, 0xef, - 0xd2, 0xe2, 0xc6, 0x1b, 0x39, 0xb5, 0x56, 0xf9, 0x6b, 0x98, 0xed, 0x3f, 0x94, 0xe0, 0x9b, 0x63, - 0xe9, 0xc7, 0x53, 0x59, 0xd4, 0x97, 0xef, 0x60, 0x9c, 0x0a, 0x55, 0x37, 0x41, 0x48, 0xbb, 0x10, - 0xd0, 0x29, 0x50, 0x75, 0x0d, 0x88, 0xfd, 0x8e, 0x76, 0xbb, 0xfa, 0x45, 0x94, 0xfd, 0x0e, 0x21, - 0x99, 0xff, 0xed, 0xc1, 0x30, 0x8e, 0xb6, 0x02, 0xe4, 0x08, 0x21, 0xb5, 0xd3, 0x0f, 0x1e, 0x7e, - 0x93, 0x8f, 0xe2, 0x0e, 0x5e, 0xc1, 0xe8, 0x5f, 0xce, 0x69, 0x5c, 0x6c, 0xc3, 0x58, 0xdf, 0xbe, - 0x3b, 0x16, 0xe2, 0x2b, 0x85, 0x42, 0x9c, 0xf2, 0x8c, 0x89, 0xf2, 0x16, 0xd4, 0xc6, 0xcf, 0xd0, - 0x6c, 0xa5, 0xb4, 0x8a, 0xb3, 0xb9, 0xdc, 0x18, 0x58, 0x42, 0x2c, 0x7e, 0xdb, 0xbf, 0xb2, 0xcc, - 0x8c, 0x96, 0x76, 0xbb, 0x8e, 0xfe, 0x45, 0x58, 0x4a, 0x9e, 0xfd, 0x7d, 0x9f, 0xeb, 0xf8, 0x67, - 0x91, 0xe4, 0x1e, 0x40, 0x82, 0xd0, 0x49, 0xf0, 0x66, 0x51, 0x3f, 0xb9, 0x29, 0x19, 0xf6, 0xab, - 0xa6, 0x31, 0xb6, 0x70, 0x24, 0x36, 0x69, 0xb0, 0x0c, 0xa5, 0xc0, 0x74, 0x91, 0x52, 0xe0, 0xdb, - 0xe7, 0x4c, 0xf7, 0x30, 0x64, 0x4a, 0x6d, 0xfb, 0xdf, 0x96, 0x19, 0xfc, 0xe4, 0x70, 0x64, 0xb8, - 0x6f, 0x67, 0xbc, 0x92, 0xbf, 0x90, 0x77, 0xc7, 0x42, 0x68, 0xc3, 0x19, 0xe5, 0xfb, 0x56, 0xf2, - 0xb4, 0x2f, 0xb8, 0x19, 0x9c, 0xa4, 0x91, 0x2d, 0x26, 0x0a, 0xda, 0x03, 0xc1, 0xe2, 0xb6, 0x93, - 0xc1, 0xa5, 0x7b, 0x13, 0xf6, 0xff, 0x7a, 0x59, 0x39, 0x37, 0x83, 0x4c, 0x06, 0x8b, 0xb9, 0xd4, - 0x60, 0x61, 0xbf, 0x61, 0x1e, 0x01, 0x65, 0xa0, 0x0e, 0x17, 0xa6, 0xbb, 0x48, 0xe2, 0xa4, 0x21, - 0xfb, 0x32, 0xac, 0x20, 0xb5, 0xeb, 0x45, 0x81, 0x18, 0xee, 0x05, 0x5c, 0x29, 0x11, 0xb0, 0xf0, - 0xf4, 0x07, 0xa1, 0x05, 0x17, 0x5e, 0xc8, 0x97, 0x1a, 0xc8, 0x07, 0x51, 0xa4, 0x06, 0xf2, 0xd9, - 0xb5, 0x25, 0xd7, 0x80, 0x52, 0x99, 0xc7, 0x5e, 0x28, 0xa8, 0x8f, 0x19, 0xb1, 0xe4, 0x6a, 0xc8, - 0x7e, 0x67, 0xc2, 0x7c, 0xcf, 0x53, 0xcf, 0x98, 0x5a, 0x03, 0x8c, 0x09, 0x06, 0xb4, 0x45, 0x7a, - 0x38, 0x4f, 0xd8, 0xb4, 0x1a, 0xf7, 0x61, 0x0e, 0x1b, 0x29, 0x72, 0x2d, 0x4e, 0x31, 0x67, 0x8d, - 0x2d, 0x1a, 0xae, 0x12, 0xb7, 0xf1, 0xaf, 0x06, 0xcc, 0x21, 0x11, 0xf9, 0xa3, 0x05, 0x15, 0xb5, - 0x10, 0x91, 0xab, 0x45, 0xa4, 0x67, 0x36, 0xb4, 0xc6, 0xb5, 0x69, 0x58, 0x75, 0x56, 0xbf, 0xf3, - 0x8b, 0xbf, 0xff, 0xf7, 0xd7, 0x25, 0x87, 0xac, 0x3b, 0x27, 0x64, 0x38, 0xbb, 0x2f, 0xdc, 0xad, - 0xc9, 0xe7, 0x16, 0xcc, 0xa1, 0x89, 0x64, 0xb3, 0xb0, 0x57, 0x8c, 0xda, 0x4e, 0xfe, 0x37, 0xaf, - 0x2f, 0x09, 0xec, 0x2d, 0xd4, 0x75, 0x93, 0x5c, 0xce, 0xa9, 0xeb, 0xc3, 0x03, 0xf9, 0xed, 0x1c, - 0xab, 0x68, 0x8f, 0xc8, 0x3f, 0x2d, 0x38, 0x93, 0x8e, 0x0b, 0xb9, 0x31, 0x7d, 0x44, 0x95, 0x09, - 0x2f, 0x9d, 0x12, 0xf6, 0x6d, 0xb4, 0xe9, 0x26, 0xd9, 0x2a, 0x64, 0xd3, 0x81, 0x5e, 0x50, 0x13, - 0xdb, 0x7e, 0x27, 0x03, 0x22, 0x07, 0x8f, 0x82, 0x01, 0x49, 0x2d, 0xb1, 0x8d, 0xd7, 0x73, 0x72, - 0x4a, 0x1e, 0xfb, 0x06, 0x2a, 0x7e, 0x95, 0x5c, 0xc9, 0xad, 0xf8, 0x80, 0xd3, 0xc8, 0x39, 0xd6, - 0x7b, 0xf1, 0x88, 0x7c, 0x69, 0xc1, 0x72, 0x76, 0xeb, 0x25, 0xdb, 0x85, 0xdd, 0x39, 0xbe, 0x50, - 0x37, 0x76, 0x5e, 0x46, 0x84, 0x8e, 0x49, 0x71, 0xd3, 0xe2, 0xef, 0x83, 0x40, 0xda, 0x81, 0xa6, - 0x65, 0x36, 0xbc, 0x82, 0xa6, 0x4d, 0x5a, 0x54, 0x0b, 0x9a, 0x36, 0x71, 0x99, 0x9d, 0xc2, 0x34, - 0xf5, 0x53, 0xd9, 0x41, 0xa4, 0xed, 0xf8, 0x8b, 0x05, 0x15, 0xb5, 0x59, 0x14, 0xeb, 0x58, 0x99, - 0xbd, 0xb3, 0x58, 0xc7, 0xca, 0x2e, 0x32, 0x53, 0x46, 0x87, 0x3b, 0xc7, 0xea, 0xa5, 0x1d, 0x91, - 0xdf, 0x4b, 0x13, 0x70, 0x4e, 0x2c, 0x68, 0x42, 0x7a, 0x37, 0x6a, 0x14, 0x1a, 0x48, 0xed, 0x9b, - 0xa8, 0xf4, 0x35, 0xb2, 0x99, 0x5b, 0x69, 0x9c, 0x60, 0x9d, 0x63, 0xbd, 0x70, 0x8d, 0xc8, 0x6f, - 0x2d, 0x28, 0xcb, 0x87, 0x99, 0x5c, 0x29, 0xa4, 0x73, 0xb2, 0x9f, 0x35, 0x0a, 0xec, 0x18, 0xfd, - 0x16, 0x15, 0xf6, 0x75, 0xd4, 0xf9, 0x32, 0xb9, 0x94, 0x5b, 0x67, 0x4e, 0x85, 0x73, 0x8c, 0xaf, - 0xfc, 0x88, 0x3c, 0xb1, 0x00, 0x92, 0xe9, 0x8f, 0xbc, 0x57, 0x50, 0xeb, 0xec, 0xae, 0xd8, 0x28, - 0x3c, 0xf9, 0xd9, 0xfb, 0xa8, 0xfd, 0x2e, 0xd9, 0x2e, 0xa0, 0xbd, 0xf9, 0xc9, 0x55, 0x1a, 0x11, - 0x6f, 0xa1, 0x23, 0xf2, 0x27, 0x0b, 0x16, 0xcc, 0x0a, 0x4a, 0xde, 0x2d, 0x96, 0xba, 0x99, 0xc5, - 0x35, 0x77, 0x08, 0x34, 0x9b, 0xbd, 0x87, 0x46, 0x6c, 0x91, 0xeb, 0xf9, 0x73, 0x5d, 0x71, 0x3a, - 0xc7, 0xf1, 0x3e, 0x3c, 0x22, 0x7f, 0x96, 0xfa, 0x9b, 0x7d, 0xed, 0xdd, 0xe2, 0x29, 0x1f, 0x6f, - 0xd0, 0x8d, 0xeb, 0xd3, 0x31, 0xeb, 0xca, 0xdd, 0x44, 0x6b, 0x36, 0xc8, 0x9b, 0xc5, 0x8a, 0x80, - 0x72, 0xf2, 0x0f, 0x0b, 0x16, 0x53, 0xab, 0x04, 0xd9, 0x9a, 0x2e, 0x9b, 0x62, 0x3b, 0x6e, 0x4c, - 0xcd, 0xaf, 0x4d, 0xb9, 0x85, 0xa6, 0xdc, 0x20, 0xef, 0x4d, 0x91, 0x5d, 0xa9, 0x56, 0xf4, 0xb9, - 0x05, 0xf3, 0x7a, 0xcf, 0x20, 0xd7, 0x0a, 0xea, 0x94, 0xda, 0x61, 0x1a, 0xeb, 0xb9, 0xcb, 0x43, - 0x72, 0x4d, 0x55, 0xd9, 0x92, 0xd1, 0x39, 0x0e, 0xfc, 0x11, 0xf9, 0x9b, 0x1c, 0x35, 0xf0, 0x07, - 0xe2, 0xcd, 0xa2, 0xad, 0x28, 0x0e, 0xc0, 0xd5, 0x29, 0x38, 0xb5, 0xeb, 0xef, 0xa0, 0xf2, 0xef, - 0x93, 0x5b, 0x45, 0xda, 0x52, 0xe2, 0x73, 0xe7, 0x38, 0xbd, 0x53, 0x8d, 0xc8, 0xff, 0x2c, 0x20, - 0x27, 0x57, 0x11, 0x72, 0xab, 0x88, 0x82, 0x2f, 0x5c, 0x81, 0x1a, 0xb7, 0x5f, 0x56, 0x8c, 0x36, - 0xfa, 0x87, 0x68, 0xf4, 0x1e, 0xd9, 0xc9, 0x69, 0x74, 0x84, 0xa2, 0x0e, 0xfc, 0x94, 0xac, 0xb8, - 0x33, 0x3f, 0xb5, 0x60, 0x29, 0xb3, 0xf0, 0x90, 0xa9, 0xc7, 0xd8, 0x38, 0x9e, 0xdb, 0x2f, 0x21, - 0x41, 0x9b, 0xf8, 0x01, 0x9a, 0xb8, 0x43, 0x6e, 0x4e, 0x35, 0x09, 0x73, 0x33, 0x0a, 0xf3, 0xd1, - 0x8e, 0xfb, 0xe4, 0xd9, 0x8a, 0xf5, 0xc5, 0xb3, 0x15, 0xeb, 0x3f, 0xcf, 0x56, 0xac, 0x5f, 0x3e, - 0x5f, 0x99, 0xf9, 0xe2, 0xf9, 0xca, 0xcc, 0x97, 0xcf, 0x57, 0x66, 0x7e, 0xba, 0x99, 0xfa, 0x67, - 0xc9, 0x69, 0xb7, 0x7c, 0x96, 0xfe, 0xf7, 0xd8, 0xb0, 0x4f, 0x79, 0xbb, 0x82, 0xbf, 0xf1, 0xbe, - 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x31, 0x53, 0x56, 0x9c, 0x19, 0x1d, 0x00, 0x00, + // 1999 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x59, 0x5f, 0x6f, 0x1b, 0xc7, + 0x11, 0xf7, 0xd1, 0x14, 0x25, 0xae, 0x2c, 0xd5, 0x99, 0xba, 0x2e, 0xcb, 0xba, 0xb4, 0xba, 0x70, + 0x5a, 0x35, 0x89, 0x79, 0xb6, 0xe2, 0xc8, 0xb2, 0xe3, 0xc8, 0xd6, 0x1f, 0x3b, 0x51, 0x1a, 0xc5, + 0xce, 0xa9, 0xc9, 0x43, 0xfb, 0x20, 0x1c, 0xc9, 0xb5, 0x74, 0x08, 0x79, 0x4b, 0xdf, 0x2e, 0xed, + 0x10, 0x02, 0x1f, 0xda, 0x4f, 0x50, 0xb4, 0x9f, 0xa3, 0x28, 0xd0, 0x16, 0xed, 0x53, 0xd1, 0x57, + 0x03, 0x7d, 0x09, 0xd0, 0x16, 0x48, 0xf3, 0xe0, 0x16, 0x76, 0xdf, 0xf3, 0x15, 0x8a, 0x9d, 0xdd, + 0xbd, 0x3f, 0x14, 0x2d, 0xdc, 0xd1, 0x4f, 0xba, 0x9d, 0x9d, 0x99, 0x9d, 0x3f, 0xbf, 0x9d, 0x9d, + 0xa1, 0xc8, 0xc5, 0xb6, 0x1f, 0x75, 0xda, 0x87, 0x7e, 0x10, 0xba, 0xc9, 0xd7, 0xa3, 0x01, 0x8b, + 0x86, 0xcd, 0x7e, 0xc4, 0x25, 0x87, 0xd7, 0xb7, 0x59, 0x9b, 0x85, 0x32, 0xf2, 0xbb, 0x5b, 0x7e, + 0xd4, 0x79, 0xdf, 0xef, 0xb1, 0x66, 0xcc, 0x98, 0x7c, 0xd5, 0xcf, 0x1d, 0xf0, 0x03, 0x8e, 0x12, + 0xae, 0xfa, 0xd2, 0xc2, 0xf5, 0x0b, 0x07, 0x9c, 0x1f, 0x74, 0x99, 0xeb, 0xf7, 0x03, 0xd7, 0x0f, + 0x43, 0x2e, 0x7d, 0x19, 0xf0, 0x50, 0x98, 0xdd, 0x37, 0xda, 0x5c, 0xf4, 0xb8, 0x70, 0x5b, 0xbe, + 0x60, 0xfa, 0x4c, 0xf7, 0xf1, 0xd5, 0x16, 0x93, 0xfe, 0x55, 0xb7, 0xef, 0x1f, 0x04, 0x21, 0x32, + 0x1b, 0xde, 0xa5, 0x49, 0x76, 0xf6, 0xfd, 0xc8, 0xef, 0x89, 0x93, 0x38, 0x1e, 0x73, 0x19, 0x84, + 0x07, 0x86, 0xa3, 0x31, 0x89, 0x43, 0x7d, 0x9d, 0xb4, 0x3f, 0x10, 0x2c, 0x32, 0xfb, 0x13, 0x63, + 0xd5, 0xf3, 0x65, 0xfb, 0xd0, 0x30, 0xfc, 0x60, 0x12, 0x83, 0x60, 0xd2, 0x6c, 0x5f, 0x9a, 0xbc, + 0xdd, 0xed, 0xee, 0xf3, 0x87, 0x0f, 0xe3, 0x53, 0x7e, 0x38, 0xd1, 0x4a, 0x3e, 0x08, 0xdb, 0x41, + 0xf7, 0x24, 0x57, 0x05, 0x8b, 0x1e, 0xc7, 0x4a, 0x2e, 0x4c, 0xe2, 0x90, 0x5f, 0xe8, 0x5d, 0x7a, + 0x8e, 0xc0, 0x27, 0x2a, 0xdc, 0x0f, 0x30, 0x7e, 0x1e, 0x7b, 0x34, 0x60, 0x42, 0xd2, 0x16, 0xf9, + 0x76, 0x86, 0x2a, 0xfa, 0x3c, 0x14, 0x0c, 0x7e, 0x4a, 0x2a, 0x3a, 0xce, 0x35, 0x67, 0xc9, 0x59, + 0x9e, 0x5f, 0xb9, 0xdc, 0xcc, 0x85, 0x88, 0xa6, 0x56, 0xb3, 0x59, 0x7e, 0xfa, 0xec, 0xe2, 0x29, + 0xcf, 0xa8, 0xa0, 0x6f, 0x92, 0xd7, 0xf0, 0x8c, 0x4f, 0x94, 0xa8, 0x39, 0x18, 0xce, 0x93, 0x8a, + 0x12, 0xdb, 0xe9, 0xe0, 0x09, 0x55, 0xcf, 0xac, 0xe8, 0x0a, 0xa9, 0x25, 0xcc, 0x5b, 0x3c, 0x94, + 0x2c, 0x94, 0x93, 0x65, 0xca, 0xb1, 0xcc, 0x0e, 0xf9, 0xde, 0x04, 0x19, 0xe3, 0x4a, 0x8d, 0xcc, + 0xb6, 0x35, 0xc9, 0x9c, 0x64, 0x97, 0x00, 0xa4, 0x7c, 0xe8, 0x8b, 0xc3, 0x5a, 0x09, 0xc9, 0xf8, + 0x4d, 0x2f, 0x5b, 0x5b, 0x3f, 0x15, 0x2c, 0xb2, 0xe7, 0xd6, 0xc8, 0xac, 0xdf, 0xe9, 0x44, 0x4c, + 0x08, 0xab, 0xc2, 0x2c, 0xe9, 0x05, 0x52, 0x4f, 0x4e, 0xc6, 0x10, 0xec, 0x84, 0x0f, 0xb9, 0x0d, + 0xee, 0xf3, 0x12, 0xf9, 0xfe, 0xc4, 0x6d, 0x63, 0xda, 0x2f, 0xc8, 0x59, 0xe5, 0xc1, 0xc6, 0xa0, + 0xad, 0x40, 0xff, 0x20, 0x0a, 0xda, 0x4c, 0x1f, 0xb0, 0xe9, 0xaa, 0x00, 0x7e, 0xfd, 0xec, 0xe2, + 0x8f, 0x0f, 0x02, 0x79, 0x38, 0x68, 0x35, 0xdb, 0xbc, 0xe7, 0x9a, 0x8b, 0xa3, 0xff, 0x5c, 0x16, + 0x9d, 0xcf, 0x5d, 0x39, 0xec, 0x33, 0xd1, 0xdc, 0xe2, 0x41, 0xe8, 0x1d, 0x53, 0x04, 0x0d, 0x42, + 0xfc, 0xb6, 0x0c, 0x1e, 0xb3, 0x3d, 0x26, 0x45, 0xad, 0xb4, 0x74, 0x7a, 0xb9, 0xec, 0xa5, 0x28, + 0xb0, 0x44, 0xe6, 0x95, 0x8c, 0xf8, 0x78, 0xd0, 0x6b, 0xb1, 0xa8, 0x76, 0x1a, 0x23, 0x9a, 0x26, + 0xc1, 0x25, 0xb2, 0x80, 0x40, 0x67, 0x96, 0xa7, 0x8c, 0x3c, 0x59, 0x22, 0xbc, 0x41, 0xce, 0x2a, + 0x38, 0xdf, 0x57, 0x68, 0xb6, 0x8c, 0x33, 0xc8, 0x78, 0x8c, 0x0e, 0x3f, 0x22, 0x8b, 0x06, 0xd4, + 0x96, 0xb3, 0x82, 0x9c, 0x63, 0x54, 0xa5, 0xb3, 0xeb, 0x0b, 0xa9, 0xa2, 0xb6, 0xcb, 0x3b, 0xc1, + 0xc3, 0x80, 0x75, 0x6a, 0xb3, 0x5a, 0xe7, 0x38, 0x3d, 0x49, 0xc1, 0x67, 0x78, 0xed, 0x3d, 0x26, + 0x06, 0x5d, 0x19, 0xe3, 0xfb, 0x97, 0x8e, 0x4d, 0xc1, 0xd8, 0xb6, 0x49, 0x41, 0x8b, 0xbc, 0xa6, + 0x34, 0x66, 0x36, 0x0d, 0xe6, 0xaf, 0xe5, 0xc4, 0x7c, 0x56, 0xf1, 0x71, 0x75, 0xf4, 0x9b, 0xb2, + 0xb9, 0x7a, 0x08, 0x03, 0x6b, 0x1a, 0x9c, 0x23, 0x33, 0xfc, 0x49, 0xc8, 0x22, 0x83, 0x29, 0xbd, + 0x80, 0x1d, 0x32, 0x27, 0xa4, 0x2f, 0x07, 0x82, 0xe9, 0xa4, 0x2d, 0xe6, 0xbe, 0x7b, 0x7b, 0x28, + 0xe6, 0xc5, 0xe2, 0xb0, 0x4b, 0xaa, 0x6a, 0xf7, 0x67, 0x0a, 0x25, 0xb5, 0xd3, 0xa8, 0xcb, 0xcd, + 0xa9, 0x6b, 0xcb, 0xc8, 0x79, 0x89, 0x06, 0xf8, 0x90, 0xcc, 0xb6, 0xbb, 0xbe, 0x50, 0x86, 0x95, + 0x51, 0xd9, 0x95, 0x02, 0xca, 0xb6, 0x94, 0xa4, 0x67, 0x15, 0xa8, 0x9b, 0x2c, 0x78, 0x24, 0x37, + 0x87, 0x08, 0x95, 0xaa, 0x67, 0x56, 0x40, 0xc9, 0x99, 0xd0, 0xef, 0x31, 0x75, 0x87, 0xfd, 0x20, + 0x14, 0x08, 0x8f, 0xaa, 0x97, 0xa1, 0x29, 0x70, 0x7c, 0xce, 0x86, 0x4f, 0x78, 0xd4, 0x11, 0x31, + 0xdf, 0x2c, 0xf2, 0x1d, 0xa3, 0x2b, 0x08, 0x87, 0x5c, 0xb2, 0x84, 0x71, 0x0e, 0x19, 0xb3, 0x44, + 0x58, 0x26, 0xdf, 0xe2, 0x61, 0x77, 0xb8, 0x27, 0xfd, 0x48, 0xb2, 0x48, 0x99, 0x5b, 0xab, 0x2e, + 0x39, 0xcb, 0x73, 0xde, 0x38, 0x19, 0x9a, 0x04, 0x14, 0x69, 0xd3, 0xef, 0xfa, 0x61, 0x9b, 0x6d, + 0x84, 0xed, 0x43, 0x1e, 0x89, 0x1a, 0x41, 0xe6, 0x09, 0x3b, 0xb0, 0x4b, 0xe6, 0x22, 0x3f, 0x0a, + 0x64, 0xc0, 0x44, 0x6d, 0x1e, 0x83, 0x76, 0xb5, 0x40, 0xd0, 0x3c, 0x25, 0x3a, 0xf4, 0x62, 0x15, + 0xea, 0xfe, 0xf4, 0x06, 0x5d, 0x19, 0x60, 0x34, 0xef, 0x87, 0xdd, 0x61, 0xed, 0x0c, 0x1e, 0x3d, + 0x46, 0xa5, 0x6f, 0x9b, 0xaa, 0x6e, 0x01, 0x67, 0xc0, 0x7e, 0x41, 0x03, 0x42, 0x7c, 0x14, 0x08, + 0x55, 0x0c, 0x55, 0x45, 0x48, 0x08, 0xb4, 0x69, 0x51, 0xba, 0xab, 0xee, 0x77, 0xaa, 0xf6, 0xe1, + 0x7d, 0x8f, 0x8b, 0xae, 0x5d, 0xd2, 0x65, 0x72, 0x56, 0xf3, 0xef, 0x31, 0x99, 0xc2, 0xb4, 0x60, + 0x32, 0xe6, 0xd5, 0x0b, 0x7a, 0x93, 0x9c, 0xb7, 0x9c, 0xa6, 0x20, 0x58, 0xfe, 0x25, 0x32, 0x1f, + 0x17, 0x89, 0x58, 0x2a, 0x4d, 0xa2, 0xd7, 0xc8, 0x39, 0xe3, 0x8a, 0x2e, 0x11, 0x56, 0x52, 0xf9, + 0xa2, 0x29, 0xb1, 0x5c, 0x42, 0xa0, 0x5f, 0x97, 0xac, 0xd8, 0xae, 0x2e, 0x56, 0x56, 0xec, 0x12, + 0x59, 0x90, 0x41, 0x8f, 0x09, 0xe9, 0xf7, 0xfa, 0xdb, 0xfc, 0x49, 0x68, 0x44, 0xb3, 0x44, 0x65, + 0x56, 0x4c, 0xf8, 0xb4, 0x8f, 0x0f, 0x44, 0xd9, 0x4b, 0x93, 0x94, 0x9e, 0xb6, 0x81, 0x8f, 0x7a, + 0x29, 0xf4, 0xfd, 0xaa, 0x7a, 0x59, 0x22, 0xd4, 0xc9, 0x5c, 0xc4, 0xfa, 0x5c, 0xc1, 0x07, 0x8b, + 0x67, 0xd5, 0x8b, 0xd7, 0xf0, 0x01, 0x99, 0xe5, 0x03, 0xd9, 0xe6, 0x3d, 0x86, 0x77, 0x60, 0x71, + 0xa5, 0x99, 0x13, 0x19, 0xf7, 0xb5, 0x94, 0x67, 0xc5, 0xe3, 0x4a, 0xfe, 0xa0, 0xeb, 0x0f, 0x59, + 0xa7, 0x56, 0xc1, 0xc4, 0xa6, 0x49, 0xf0, 0x11, 0xa9, 0x04, 0x07, 0x21, 0x8f, 0x18, 0x5e, 0x94, + 0xfc, 0xa5, 0x6d, 0x07, 0x85, 0x6c, 0x08, 0x8d, 0x0e, 0xfa, 0x13, 0xb2, 0x90, 0xd9, 0x50, 0x18, + 0xb1, 0xae, 0x38, 0x88, 0x47, 0xbb, 0x54, 0xe5, 0xf7, 0x3b, 0x63, 0x79, 0x30, 0x58, 0x5c, 0x22, + 0xf3, 0xe6, 0x1d, 0x49, 0xa1, 0x31, 0x4d, 0x82, 0x7b, 0x06, 0x79, 0xa6, 0x10, 0xce, 0xaf, 0xbc, + 0x95, 0xd3, 0x6a, 0x8d, 0x5f, 0x2b, 0x4c, 0xff, 0x54, 0x22, 0xdf, 0x1d, 0x83, 0x9f, 0x48, 0xa1, + 0xa8, 0xaf, 0x5e, 0xcb, 0x18, 0x0a, 0x55, 0x2f, 0x21, 0x28, 0xbf, 0x70, 0x61, 0x20, 0x50, 0xf5, + 0xec, 0x12, 0xeb, 0x17, 0xeb, 0x76, 0xcd, 0xbb, 0xa9, 0xea, 0x17, 0xae, 0x14, 0xfe, 0x5b, 0x83, + 0x61, 0x9c, 0x6d, 0xbd, 0x50, 0x8d, 0x86, 0xb2, 0xce, 0x3c, 0x8b, 0xf8, 0x0d, 0x1f, 0x93, 0x8a, + 0x2e, 0xd4, 0x58, 0xe3, 0x16, 0x57, 0x56, 0xf3, 0x56, 0x79, 0xeb, 0x83, 0x29, 0xf7, 0x46, 0x0b, + 0xdc, 0x1f, 0x4b, 0xf1, 0xf5, 0x42, 0x29, 0x4e, 0x45, 0xc6, 0x66, 0x79, 0x9d, 0x9c, 0x1d, 0xdf, + 0x43, 0xb7, 0xb5, 0xd1, 0x3a, 0xcf, 0xf6, 0x70, 0xeb, 0x60, 0x09, 0xa9, 0xf8, 0x4d, 0x7f, 0xe3, + 0xd8, 0x4e, 0x2e, 0x1d, 0x76, 0x93, 0xfd, 0x4b, 0x64, 0x21, 0x69, 0x0e, 0x76, 0x3a, 0xc2, 0xe4, + 0x3f, 0x4b, 0x84, 0x07, 0x84, 0x24, 0x04, 0x03, 0x82, 0x2b, 0x45, 0xe3, 0xe4, 0xa5, 0x74, 0xd0, + 0xd7, 0x6d, 0x61, 0xdc, 0xc3, 0xc6, 0xd9, 0xc2, 0x60, 0x91, 0x94, 0x02, 0x5b, 0x45, 0x4a, 0x41, + 0x87, 0x9e, 0xb7, 0xd5, 0xc3, 0xb2, 0x69, 0xb3, 0xe9, 0x7f, 0x1c, 0xdb, 0x1e, 0xaa, 0x16, 0xca, + 0x4a, 0xdf, 0xcb, 0x44, 0x25, 0xff, 0x45, 0xde, 0x1a, 0x4b, 0x21, 0x25, 0x67, 0x74, 0xec, 0x35, + 0xdd, 0x44, 0x33, 0x43, 0x53, 0x3c, 0xaa, 0xc4, 0x44, 0x41, 0x6b, 0x20, 0x79, 0x5c, 0x76, 0x32, + 0xb4, 0x74, 0x6d, 0xc2, 0xfa, 0x8f, 0xcf, 0x75, 0xd9, 0xcb, 0x12, 0x93, 0xf6, 0x63, 0x26, 0xd5, + 0x7e, 0xd0, 0xb7, 0xec, 0x23, 0xa0, 0x1d, 0x34, 0xe9, 0x42, 0xb8, 0xcb, 0x24, 0x4f, 0x66, 0x45, + 0x57, 0x49, 0x03, 0xb9, 0xf5, 0x43, 0xb5, 0x1d, 0x08, 0x6d, 0x44, 0xc0, 0xc3, 0x93, 0x1f, 0x84, + 0x3d, 0x72, 0xf1, 0xa5, 0x72, 0xa9, 0xb6, 0x7d, 0x10, 0x45, 0xba, 0x6d, 0x3f, 0xbd, 0xbc, 0xe0, + 0xd9, 0xa5, 0x32, 0xe6, 0x89, 0x1f, 0x4a, 0xd6, 0x41, 0x44, 0x2c, 0x78, 0x66, 0x45, 0xdf, 0x99, + 0x30, 0x05, 0x88, 0xd4, 0x33, 0xa6, 0x87, 0x05, 0xeb, 0x82, 0x5d, 0x52, 0x99, 0x6e, 0xe1, 0x13, + 0x31, 0x63, 0xc6, 0x67, 0x64, 0x06, 0x0b, 0x29, 0x4a, 0xcd, 0xaf, 0xdc, 0xc9, 0x99, 0xda, 0x97, + 0x8e, 0x23, 0x9e, 0x56, 0xb7, 0xf2, 0xcf, 0x3a, 0x99, 0x41, 0x26, 0xf8, 0xb3, 0x43, 0x2a, 0x7a, + 0x6c, 0x82, 0x1b, 0x45, 0xb4, 0x67, 0xe6, 0xb8, 0xfa, 0xcd, 0x69, 0x44, 0x0d, 0xaa, 0xdf, 0xf9, + 0xd5, 0x3f, 0xfe, 0xf7, 0xdb, 0x92, 0x0b, 0x97, 0xdd, 0x63, 0x3a, 0xdc, 0xad, 0x97, 0x4e, 0xe0, + 0xf0, 0x07, 0x87, 0xcc, 0xa0, 0x8b, 0xb0, 0x56, 0x38, 0x2a, 0xd6, 0x6c, 0x37, 0xff, 0x9b, 0xd7, + 0x57, 0x0c, 0x74, 0x1d, 0x6d, 0x5d, 0x83, 0xd5, 0x9c, 0xb6, 0x3e, 0xda, 0x57, 0xdf, 0xee, 0x91, + 0xce, 0xf6, 0x08, 0xfe, 0xed, 0x90, 0x33, 0xe9, 0xbc, 0xc0, 0xed, 0xe9, 0x33, 0xaa, 0x5d, 0x78, + 0x65, 0x48, 0xd0, 0x7b, 0xe8, 0xd3, 0x1d, 0x58, 0x2f, 0xe4, 0xd3, 0xbe, 0x19, 0x63, 0x13, 0xdf, + 0x7e, 0xaf, 0x12, 0xa2, 0x1a, 0x8f, 0x82, 0x09, 0x49, 0x8d, 0xba, 0xf5, 0x37, 0x73, 0x4a, 0x2a, + 0x19, 0x7a, 0x1b, 0x0d, 0xbf, 0x01, 0xd7, 0x73, 0x1b, 0x3e, 0x10, 0x2c, 0x72, 0x8f, 0xcc, 0xf4, + 0x3c, 0x82, 0xaf, 0x1c, 0xb2, 0x98, 0x9d, 0x8d, 0x61, 0xa3, 0x70, 0x38, 0xc7, 0xc7, 0xee, 0xfa, + 0xe6, 0xab, 0xa8, 0x30, 0x39, 0x29, 0xee, 0x5a, 0xfc, 0xbd, 0x1f, 0x28, 0x3f, 0xd0, 0xb5, 0xcc, + 0x1c, 0x58, 0xd0, 0xb5, 0x49, 0xe3, 0x6c, 0x41, 0xd7, 0x26, 0x8e, 0xbc, 0x53, 0xb8, 0xa6, 0x7f, + 0x50, 0xdb, 0x8f, 0x8c, 0x1f, 0x7f, 0x71, 0x48, 0x45, 0x4f, 0x16, 0xc5, 0x2a, 0x56, 0x66, 0xfc, + 0x2d, 0x56, 0xb1, 0xb2, 0x83, 0x0c, 0x5d, 0x45, 0x17, 0xae, 0x40, 0xb3, 0x50, 0x76, 0x04, 0xfc, + 0x51, 0x59, 0x8e, 0xed, 0x61, 0x41, 0xcb, 0xd3, 0x23, 0x51, 0xbd, 0x50, 0x1f, 0x4a, 0xef, 0xa0, + 0xad, 0x37, 0x61, 0x2d, 0xb7, 0xad, 0xd8, 0xb8, 0xba, 0x47, 0x66, 0xce, 0x1a, 0xc1, 0xef, 0x1c, + 0x52, 0x56, 0xef, 0x31, 0x5c, 0x2f, 0x64, 0x73, 0x32, 0x96, 0xd5, 0x0b, 0x8c, 0x16, 0xfd, 0x3d, + 0x26, 0xe9, 0x2d, 0xb4, 0x79, 0x15, 0xae, 0xe5, 0xb6, 0x59, 0x30, 0xe9, 0x1e, 0xe1, 0xe3, 0x3e, + 0x82, 0xa7, 0x0e, 0x21, 0x49, 0xd3, 0x07, 0xef, 0x15, 0xb4, 0x3a, 0x3b, 0x22, 0xd6, 0x0b, 0x37, + 0x7c, 0x74, 0x07, 0xad, 0xdf, 0x82, 0x8d, 0x02, 0xd6, 0xdb, 0xdf, 0x63, 0x95, 0x13, 0xf1, 0xf0, + 0x39, 0x82, 0xbf, 0x3a, 0x64, 0xce, 0x4e, 0x9e, 0xf0, 0x6e, 0x31, 0xc4, 0x66, 0xe6, 0xd5, 0xdc, + 0x29, 0x30, 0x62, 0x74, 0x1b, 0x9d, 0x58, 0x87, 0x5b, 0xf9, 0x21, 0xae, 0x25, 0xdd, 0xa3, 0x78, + 0x0c, 0x1e, 0xc1, 0xdf, 0x94, 0xfd, 0x76, 0x4c, 0x7b, 0xb7, 0x38, 0xe4, 0xe3, 0xc1, 0xb9, 0x7e, + 0x6b, 0x3a, 0x61, 0x73, 0x61, 0xd7, 0xd0, 0x9b, 0x15, 0xb8, 0x52, 0xec, 0x12, 0x30, 0x01, 0xff, + 0x72, 0xc8, 0x7c, 0x6a, 0x82, 0x80, 0xf5, 0xe9, 0xd0, 0x14, 0xfb, 0x71, 0x7b, 0x6a, 0x79, 0xe3, + 0xca, 0x5d, 0x74, 0xe5, 0x36, 0xbc, 0x37, 0x05, 0xba, 0x84, 0x7b, 0xa4, 0x7b, 0xfd, 0x91, 0xea, + 0x9e, 0x66, 0xcd, 0x78, 0x01, 0x37, 0x0b, 0xda, 0x94, 0x1a, 0x5d, 0xea, 0xb9, 0x7f, 0x1d, 0x44, + 0xa9, 0xa9, 0x6e, 0xb6, 0x12, 0x74, 0x8f, 0x82, 0xce, 0x08, 0xfe, 0xae, 0x3a, 0x0c, 0xfc, 0xf5, + 0x78, 0xad, 0x68, 0x29, 0x8a, 0x13, 0x70, 0x63, 0x0a, 0x49, 0x13, 0xfa, 0x5d, 0x34, 0xfe, 0x7d, + 0xb8, 0x5b, 0xa4, 0x2c, 0x25, 0x31, 0x77, 0x8f, 0xd2, 0xa3, 0xd4, 0x08, 0xbe, 0x71, 0x08, 0x1c, + 0x9f, 0x40, 0xe0, 0x6e, 0x11, 0x03, 0x5f, 0x3a, 0xf9, 0xd4, 0xef, 0xbd, 0xaa, 0x1a, 0xe3, 0xf4, + 0x87, 0xe8, 0xf4, 0x36, 0x6c, 0xe6, 0x74, 0x1a, 0x7f, 0x2c, 0x1c, 0xee, 0x77, 0x52, 0xba, 0xe2, + 0xca, 0xfc, 0xcc, 0x21, 0x0b, 0x99, 0x39, 0x07, 0xa6, 0xee, 0x5e, 0xe3, 0x7c, 0x6e, 0xbc, 0x82, + 0x06, 0xe3, 0xe2, 0x07, 0xe8, 0xe2, 0x26, 0xdc, 0x99, 0xaa, 0x01, 0x16, 0xb6, 0x03, 0x16, 0xa3, + 0x4d, 0xef, 0xe9, 0xf3, 0x86, 0xf3, 0xe5, 0xf3, 0x86, 0xf3, 0xdf, 0xe7, 0x0d, 0xe7, 0xd7, 0x2f, + 0x1a, 0xa7, 0xbe, 0x7c, 0xd1, 0x38, 0xf5, 0xd5, 0x8b, 0xc6, 0xa9, 0x9f, 0xaf, 0xa5, 0xfe, 0x93, + 0x72, 0xd2, 0x29, 0x5f, 0xa4, 0xff, 0x77, 0x36, 0xec, 0x33, 0xd1, 0xaa, 0xe0, 0xff, 0xcf, 0xde, + 0xfe, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x67, 0x94, 0x1f, 0x36, 0x1d, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2883,6 +2843,34 @@ func (m *QueryQCardsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.MultiClassOnly { + i-- + if m.MultiClassOnly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + if len(m.Rarities) > 0 { + dAtA6 := make([]byte, len(m.Rarities)*10) + var j5 int + for _, num := range m.Rarities { + for num >= 1<<7 { + dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j5++ + } + dAtA6[j5] = uint8(num) + j5++ + } + i -= j5 + copy(dAtA[i:], dAtA6[:j5]) + i = encodeVarintQuery(dAtA, i, uint64(j5)) + i-- + dAtA[i] = 0x5a + } if m.OnlyBalanceAnchors { i-- if m.OnlyBalanceAnchors { @@ -2932,23 +2920,58 @@ func (m *QueryQCardsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x2a } if len(m.Classes) > 0 { - i -= len(m.Classes) - copy(dAtA[i:], m.Classes) - i = encodeVarintQuery(dAtA, i, uint64(len(m.Classes))) + dAtA8 := make([]byte, len(m.Classes)*10) + var j7 int + for _, num := range m.Classes { + for num >= 1<<7 { + dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j7++ + } + dAtA8[j7] = uint8(num) + j7++ + } + i -= j7 + copy(dAtA[i:], dAtA8[:j7]) + i = encodeVarintQuery(dAtA, i, uint64(j7)) i-- dAtA[i] = 0x22 } - if len(m.CardType) > 0 { - i -= len(m.CardType) - copy(dAtA[i:], m.CardType) - i = encodeVarintQuery(dAtA, i, uint64(len(m.CardType))) + if len(m.CardTypes) > 0 { + dAtA10 := make([]byte, len(m.CardTypes)*10) + var j9 int + for _, num := range m.CardTypes { + for num >= 1<<7 { + dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j9++ + } + dAtA10[j9] = uint8(num) + j9++ + } + i -= j9 + copy(dAtA[i:], dAtA10[:j9]) + i = encodeVarintQuery(dAtA, i, uint64(j9)) i-- dAtA[i] = 0x1a } - if m.Status != 0 { - i = encodeVarintQuery(dAtA, i, uint64(m.Status)) + if len(m.Statuses) > 0 { + dAtA12 := make([]byte, len(m.Statuses)*10) + var j11 int + for _, num := range m.Statuses { + for num >= 1<<7 { + dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + dAtA12[j11] = uint8(num) + j11++ + } + i -= j11 + copy(dAtA[i:], dAtA12[:j11]) + i = encodeVarintQuery(dAtA, i, uint64(j11)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } if len(m.Owner) > 0 { i -= len(m.Owner) @@ -2981,20 +3004,20 @@ func (m *QueryQCardsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.CardsList) > 0 { - dAtA6 := make([]byte, len(m.CardsList)*10) - var j5 int + dAtA14 := make([]byte, len(m.CardsList)*10) + var j13 int for _, num := range m.CardsList { for num >= 1<<7 { - dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) + dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j5++ + j13++ } - dAtA6[j5] = uint8(num) - j5++ + dAtA14[j13] = uint8(num) + j13++ } - i -= j5 - copy(dAtA[i:], dAtA6[:j5]) - i = encodeVarintQuery(dAtA, i, uint64(j5)) + i -= j13 + copy(dAtA[i:], dAtA14[:j13]) + i = encodeVarintQuery(dAtA, i, uint64(j13)) i-- dAtA[i] = 0xa } @@ -3146,20 +3169,20 @@ func (m *QueryQMatchesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x3a } if len(m.CardsPlayed) > 0 { - dAtA9 := make([]byte, len(m.CardsPlayed)*10) - var j8 int + dAtA17 := make([]byte, len(m.CardsPlayed)*10) + var j16 int for _, num := range m.CardsPlayed { for num >= 1<<7 { - dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80) + dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j8++ + j16++ } - dAtA9[j8] = uint8(num) - j8++ + dAtA17[j16] = uint8(num) + j16++ } - i -= j8 - copy(dAtA[i:], dAtA9[:j8]) - i = encodeVarintQuery(dAtA, i, uint64(j8)) + i -= j16 + copy(dAtA[i:], dAtA17[:j16]) + i = encodeVarintQuery(dAtA, i, uint64(j16)) i-- dAtA[i] = 0x32 } @@ -3265,20 +3288,20 @@ func (m *QueryQMatchesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.MatchesList) > 0 { - dAtA11 := make([]byte, len(m.MatchesList)*10) - var j10 int + dAtA19 := make([]byte, len(m.MatchesList)*10) + var j18 int for _, num := range m.MatchesList { for num >= 1<<7 { - dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80) + dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j10++ + j18++ } - dAtA11[j10] = uint8(num) - j10++ + dAtA19[j18] = uint8(num) + j18++ } - i -= j10 - copy(dAtA[i:], dAtA11[:j10]) - i = encodeVarintQuery(dAtA, i, uint64(j10)) + i -= j18 + copy(dAtA[i:], dAtA19[:j18]) + i = encodeVarintQuery(dAtA, i, uint64(j18)) i-- dAtA[i] = 0xa } @@ -3436,20 +3459,20 @@ func (m *QueryQSellOffersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error } } if len(m.SellOffersIds) > 0 { - dAtA14 := make([]byte, len(m.SellOffersIds)*10) - var j13 int + dAtA22 := make([]byte, len(m.SellOffersIds)*10) + var j21 int for _, num := range m.SellOffersIds { for num >= 1<<7 { - dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80) + dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j13++ + j21++ } - dAtA14[j13] = uint8(num) - j13++ + dAtA22[j21] = uint8(num) + j21++ } - i -= j13 - copy(dAtA[i:], dAtA14[:j13]) - i = encodeVarintQuery(dAtA, i, uint64(j13)) + i -= j21 + copy(dAtA[i:], dAtA22[:j21]) + i = encodeVarintQuery(dAtA, i, uint64(j21)) i-- dAtA[i] = 0xa } @@ -3535,20 +3558,20 @@ func (m *QueryQSetsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x2a } if len(m.ContainsCards) > 0 { - dAtA16 := make([]byte, len(m.ContainsCards)*10) - var j15 int + dAtA24 := make([]byte, len(m.ContainsCards)*10) + var j23 int for _, num := range m.ContainsCards { for num >= 1<<7 { - dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80) + dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j15++ + j23++ } - dAtA16[j15] = uint8(num) - j15++ + dAtA24[j23] = uint8(num) + j23++ } - i -= j15 - copy(dAtA[i:], dAtA16[:j15]) - i = encodeVarintQuery(dAtA, i, uint64(j15)) + i -= j23 + copy(dAtA[i:], dAtA24[:j23]) + i = encodeVarintQuery(dAtA, i, uint64(j23)) i-- dAtA[i] = 0x22 } @@ -3600,20 +3623,20 @@ func (m *QueryQSetsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.SetIds) > 0 { - dAtA18 := make([]byte, len(m.SetIds)*10) - var j17 int + dAtA26 := make([]byte, len(m.SetIds)*10) + var j25 int for _, num := range m.SetIds { for num >= 1<<7 { - dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80) + dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j17++ + j25++ } - dAtA18[j17] = uint8(num) - j17++ + dAtA26[j25] = uint8(num) + j25++ } - i -= j17 - copy(dAtA[i:], dAtA18[:j17]) - i = encodeVarintQuery(dAtA, i, uint64(j17)) + i -= j25 + copy(dAtA[i:], dAtA26[:j25]) + i = encodeVarintQuery(dAtA, i, uint64(j25)) i-- dAtA[i] = 0xa } @@ -3669,38 +3692,38 @@ func (m *QueryRarityDistributionResponse) MarshalToSizedBuffer(dAtA []byte) (int var l int _ = l if len(m.Wanted) > 0 { - dAtA20 := make([]byte, len(m.Wanted)*10) - var j19 int + dAtA28 := make([]byte, len(m.Wanted)*10) + var j27 int for _, num := range m.Wanted { for num >= 1<<7 { - dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80) + dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j19++ + j27++ } - dAtA20[j19] = uint8(num) - j19++ + dAtA28[j27] = uint8(num) + j27++ } - i -= j19 - copy(dAtA[i:], dAtA20[:j19]) - i = encodeVarintQuery(dAtA, i, uint64(j19)) + i -= j27 + copy(dAtA[i:], dAtA28[:j27]) + i = encodeVarintQuery(dAtA, i, uint64(j27)) i-- dAtA[i] = 0x12 } if len(m.Current) > 0 { - dAtA22 := make([]byte, len(m.Current)*10) - var j21 int + dAtA30 := make([]byte, len(m.Current)*10) + var j29 int for _, num := range m.Current { for num >= 1<<7 { - dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80) + dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j21++ + j29++ } - dAtA22[j21] = uint8(num) - j21++ + dAtA30[j29] = uint8(num) + j29++ } - i -= j21 - copy(dAtA[i:], dAtA22[:j21]) - i = encodeVarintQuery(dAtA, i, uint64(j21)) + i -= j29 + copy(dAtA[i:], dAtA30[:j29]) + i = encodeVarintQuery(dAtA, i, uint64(j29)) i-- dAtA[i] = 0xa } @@ -3728,20 +3751,20 @@ func (m *QueryQCardContentsRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro var l int _ = l if len(m.CardIds) > 0 { - dAtA24 := make([]byte, len(m.CardIds)*10) - var j23 int + dAtA32 := make([]byte, len(m.CardIds)*10) + var j31 int for _, num := range m.CardIds { for num >= 1<<7 { - dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) + dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j23++ + j31++ } - dAtA24[j23] = uint8(num) - j23++ + dAtA32[j31] = uint8(num) + j31++ } - i -= j23 - copy(dAtA[i:], dAtA24[:j23]) - i = encodeVarintQuery(dAtA, i, uint64(j23)) + i -= j31 + copy(dAtA[i:], dAtA32[:j31]) + i = encodeVarintQuery(dAtA, i, uint64(j31)) i-- dAtA[i] = 0xa } @@ -3945,16 +3968,26 @@ func (m *QueryQCardsRequest) Size() (n int) { if l > 0 { n += 1 + l + sovQuery(uint64(l)) } - if m.Status != 0 { - n += 1 + sovQuery(uint64(m.Status)) + if len(m.Statuses) > 0 { + l = 0 + for _, e := range m.Statuses { + l += sovQuery(uint64(e)) + } + n += 1 + sovQuery(uint64(l)) + l } - l = len(m.CardType) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) + if len(m.CardTypes) > 0 { + l = 0 + for _, e := range m.CardTypes { + l += sovQuery(uint64(e)) + } + n += 1 + sovQuery(uint64(l)) + l } - l = len(m.Classes) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) + if len(m.Classes) > 0 { + l = 0 + for _, e := range m.Classes { + l += sovQuery(uint64(e)) + } + n += 1 + sovQuery(uint64(l)) + l } l = len(m.SortBy) if l > 0 { @@ -3978,6 +4011,16 @@ func (m *QueryQCardsRequest) Size() (n int) { if m.OnlyBalanceAnchors { n += 2 } + if len(m.Rarities) > 0 { + l = 0 + for _, e := range m.Rarities { + l += sovQuery(uint64(e)) + } + n += 1 + sovQuery(uint64(l)) + l + } + if m.MultiClassOnly { + n += 2 + } return n } @@ -5314,88 +5357,212 @@ func (m *QueryQCardsRequest) Unmarshal(dAtA []byte) error { m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - 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 ErrIntOverflowQuery + if wireType == 0 { + var v Status + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= Status(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + m.Statuses = append(m.Statuses, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.Status |= QueryQCardsRequest_Status(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + if elementCount != 0 && len(m.Statuses) == 0 { + m.Statuses = make([]Status, 0, elementCount) } + for iNdEx < postIndex { + var v Status + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= Status(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Statuses = append(m.Statuses, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType) } case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CardType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery + if wireType == 0 { + var v CardType + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardType(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + m.CardTypes = append(m.CardTypes, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + if elementCount != 0 && len(m.CardTypes) == 0 { + m.CardTypes = make([]CardType, 0, elementCount) } + for iNdEx < postIndex { + var v CardType + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardType(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CardTypes = append(m.CardTypes, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field CardTypes", wireType) } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthQuery - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthQuery - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.CardType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Classes", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery + if wireType == 0 { + var v CardClass + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardClass(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + m.Classes = append(m.Classes, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + if elementCount != 0 && len(m.Classes) == 0 { + m.Classes = make([]CardClass, 0, elementCount) } + for iNdEx < postIndex { + var v CardClass + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardClass(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Classes = append(m.Classes, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Classes", wireType) } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthQuery - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthQuery - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Classes = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SortBy", wireType) @@ -5564,6 +5731,95 @@ func (m *QueryQCardsRequest) Unmarshal(dAtA []byte) error { } } m.OnlyBalanceAnchors = bool(v != 0) + case 11: + if wireType == 0 { + var v CardRarity + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardRarity(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Rarities = append(m.Rarities, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + if elementCount != 0 && len(m.Rarities) == 0 { + m.Rarities = make([]CardRarity, 0, elementCount) + } + for iNdEx < postIndex { + var v CardRarity + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= CardRarity(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Rarities = append(m.Rarities, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Rarities", wireType) + } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MultiClassOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MultiClassOnly = bool(v != 0) default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) diff --git a/x/cardchain/types/query.pb.gw.go b/x/cardchain/types/query.pb.gw.go index c6130f54..87affe52 100644 --- a/x/cardchain/types/query.pb.gw.go +++ b/x/cardchain/types/query.pb.gw.go @@ -250,34 +250,13 @@ func local_request_Query_QVotingResults_0(ctx context.Context, marshaler runtime } var ( - filter_Query_QCards_0 = &utilities.DoubleArray{Encoding: map[string]int{"status": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} + filter_Query_QCards_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) func request_Query_QCards_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryQCardsRequest var metadata runtime.ServerMetadata - var ( - val string - e int32 - ok bool - err error - _ = err - ) - - val, ok = pathParams["status"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "status") - } - - e, err = runtime.Enum(val, QueryQCardsRequest_Status_value) - - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "status", err) - } - - protoReq.Status = QueryQCardsRequest_Status(e) - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -294,27 +273,6 @@ func local_request_Query_QCards_0(ctx context.Context, marshaler runtime.Marshal var protoReq QueryQCardsRequest var metadata runtime.ServerMetadata - var ( - val string - e int32 - ok bool - err error - _ = err - ) - - val, ok = pathParams["status"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "status") - } - - e, err = runtime.Enum(val, QueryQCardsRequest_Status_value) - - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "status", err) - } - - protoReq.Status = QueryQCardsRequest_Status(e) - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1713,7 +1671,7 @@ var ( pattern_Query_QVotingResults_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"DecentralCardGame", "Cardchain", "cardchain", "q_voting_results"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_QCards_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"DecentralCardGame", "Cardchain", "cardchain", "q_cards", "status"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_QCards_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"DecentralCardGame", "Cardchain", "cardchain", "q_cards"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_QMatch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"DecentralCardGame", "Cardchain", "cardchain", "q_match", "matchId"}, "", runtime.AssumeColonVerbOpt(true)))