From 4c8273031b4f2084c27b8af4f50516375bfddd91 Mon Sep 17 00:00:00 2001 From: "DESKTOP-45ANQ2C\\unis" <121212121@qq.com> Date: Thu, 2 Jan 2025 11:10:47 +0800 Subject: [PATCH 1/4] =?UTF-8?q?=E5=AD=98=E9=92=B1=E7=BD=90=E9=A2=86?= =?UTF-8?q?=E5=8F=96=E9=92=BB=E7=9F=B3=E6=98=BE=E7=A4=BA=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- worldsrv/trascate_webapi.go | 6 +++--- worldsrv/welfmgr.go | 12 ++++++------ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/worldsrv/trascate_webapi.go b/worldsrv/trascate_webapi.go index cd7913b..4e22871 100644 --- a/worldsrv/trascate_webapi.go +++ b/worldsrv/trascate_webapi.go @@ -2945,7 +2945,7 @@ func init() { var msg *webapi.DebugTestReq err := json.Unmarshal(params, &msg) if err != nil { - logger.Logger.Error("Unmarshal webapi.PlatfromUpScoreReq error:", err) + logger.Logger.Error("Unmarshal webapi.DebugTestReq error:", err) return common.ResponseTag_ParamError, pack } @@ -2955,7 +2955,7 @@ func init() { Message: "未知错误", } - logger.Logger.Tracef("/api/platform/debug upScoreReqInfo%v", msg) + logger.Logger.Tracef("/api/platform/debug DebugTestReq%v", msg) player := PlayerMgrSington.GetPlayerBySnId(msg.Snid) //玩家在线 @@ -2967,7 +2967,7 @@ func init() { if msg.Rpc == 1 { addCoin, _ := strconv.ParseInt(msg.Count, 10, 64) - player.AddCoin(addCoin, 0, 5555, "platform", "debug加钻石") + player.AddCoin(addCoin, 0, 5555, "platform", "debug加金币") player.SendDiffData() jsonRet.Data.Count = player.Coin } else if msg.Rpc == 2 { diff --git a/worldsrv/welfmgr.go b/worldsrv/welfmgr.go index 502106a..fe42d65 100644 --- a/worldsrv/welfmgr.go +++ b/worldsrv/welfmgr.go @@ -1118,7 +1118,7 @@ func (this *WelfareMgr) BlindBoxInfo(p *Player, bid int32) { if cyc == 1 || blindBox.Cycle == model.WelfareOpen { p.WelfData.BlindBoxId = 0 } - } // == 1代表当日循环 + } // == 1代表当日循环 if p.WelfData.BlindBoxId == 0 { // 未领取过发随机Date idx := bid @@ -2064,15 +2064,15 @@ func (this *WelfareMgr) DiamondBankTakeCoin(p *Player) (retItemArr []*model.Item Num: 1, }) + retItemArr = append(retItemArr, &model.Item{ + ItemId: common.ItemIDDiamond, + ItemNum: addDiamond, + }) + // 发放奖励道具 if infoData.DiamondExc != nil { var items []*model.Item - retItemArr = append(retItemArr, &model.Item{ - ItemId: common.ItemIDDiamond, - ItemNum: addDiamond, - }) - for _, v := range infoData.DiamondExc { items = append(items, &model.Item{ ItemId: v.ItemId, From 9fd80b867d9426b1949d13b7335210c59ceca858 Mon Sep 17 00:00:00 2001 From: by <123456@qq.com> Date: Thu, 2 Jan 2025 11:18:58 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E5=B9=B4=E5=85=BD=E6=B4=BB=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- common/constant.go | 49 +- data/DB_GameItem.dat | Bin 20673 -> 20889 bytes data/DB_GameItem.json | 74 ++ data/DB_NewYearActivity.dat | 27 + data/DB_NewYearActivity.json | 124 ++++ data/DB_NewYearRankReward.dat | 84 +++ data/DB_NewYearRankReward.json | 730 +++++++++++++++++++ data/DB_Task.dat | Bin 5519 -> 6587 bytes data/DB_Task.json | 230 ++++++ etcd/keyconf.go | 1 + model/config.go | 18 +- model/player.go | 17 + protocol/activity/nian.pb.go | 1167 +++++++++++++++++++++++++++++++ protocol/activity/nian.proto | 93 +++ protocol/server/pbdata.proto | 32 + protocol/task/task.proto | 2 +- protocol/webapi/common.proto | 23 + srvdata/db_newyearactivity.go | 77 ++ srvdata/db_newyearrankreward.go | 77 ++ worldsrv/action_nian.go | 505 +++++++++++++ worldsrv/action_task.go | 20 +- worldsrv/etcd.go | 4 + worldsrv/player.go | 3 + worldsrv/taskmgr.go | 21 + worldsrv/welfmgr.go | 59 +- xlsx/DB_GameItem.xlsx | Bin 37714 -> 38013 bytes xlsx/DB_NewYearActivity.xlsx | Bin 0 -> 11837 bytes xlsx/DB_NewYearRankReward.xlsx | Bin 0 -> 13497 bytes xlsx/DB_Task.xlsx | Bin 22850 -> 23910 bytes 29 files changed, 3404 insertions(+), 33 deletions(-) create mode 100644 data/DB_NewYearActivity.dat create mode 100644 data/DB_NewYearActivity.json create mode 100644 data/DB_NewYearRankReward.dat create mode 100644 data/DB_NewYearRankReward.json create mode 100644 protocol/activity/nian.pb.go create mode 100644 protocol/activity/nian.proto create mode 100644 srvdata/db_newyearactivity.go create mode 100644 srvdata/db_newyearrankreward.go create mode 100644 worldsrv/action_nian.go create mode 100644 xlsx/DB_NewYearActivity.xlsx create mode 100644 xlsx/DB_NewYearRankReward.xlsx diff --git a/common/constant.go b/common/constant.go index 4112649..d257a6e 100644 --- a/common/constant.go +++ b/common/constant.go @@ -330,6 +330,8 @@ const ( GainWayCompoundGain = 119 // 道具合成获得 GainWayItem_PigBankTakeCoin = 120 // 购买金币存钱罐奖励道具 GainWayItem_PigBankTakeDiamond = 121 // 购买钻石存钱罐奖励道具 + GainWayNianCost = 122 //年兽活动消耗 + GainWayNianGain = 123 //年兽活动获得 ) // 后台选择 金币变化类型 的充值 类型id号起始 @@ -562,27 +564,29 @@ const ( // 道具ID const ( - ItemIDCoin = 100001 // 金币对应的itemId - ItemIDDiamond = 100002 // 钻石对应的itemId - ItemIDMoneyPond = 100003 // 玩家金币池对应物品Id - ItemIDVipExp = 100005 // VIP经验对应的物品Id - ItemIDPhoneScore = 100006 // 手机抽奖积分 - ItemIDWeekScore = 100004 // 周活跃积分 - ItemIDGiftBox = 50001 // 碎片礼盒 - ItemIDCollectBox = 50002 // 集卡礼盒 - ItemIDLike = 100007 // 点赞 - ItemIDCoffee = 100008 // 咖啡 - ItemIDBucket = 100009 // 水桶 - ItemIDSlippers = 100010 // 拖鞋 - ItemIDPermit = 100011 // 赛季通行证积分 - ItemIDLong = 50013 // 龙币 - ItemIDPetSkill = 11001 //宠物技能升级道具 - ItemIDVCard = 30001 // v卡 - ItemIDJCard = 30002 // 金券 - ItemDiamondScore = 100012 //钻石积分 - ItemIDClawdoll = 40003 // 娃娃卡 - ItemDollCard = 40004 // 娃娃卡积分 - ItemIDRoomCard = 40002 // 房卡 + ItemIDCoin = 100001 // 金币对应的itemId + ItemIDDiamond = 100002 // 钻石对应的itemId + ItemIDMoneyPond = 100003 // 玩家金币池对应物品Id + ItemIDVipExp = 100005 // VIP经验对应的物品Id + ItemIDPhoneScore = 100006 // 手机抽奖积分 + ItemIDWeekScore = 100004 // 周活跃积分 + ItemIDGiftBox = 50001 // 碎片礼盒 + ItemIDCollectBox = 50002 // 集卡礼盒 + ItemIDLike = 100007 // 点赞 + ItemIDCoffee = 100008 // 咖啡 + ItemIDBucket = 100009 // 水桶 + ItemIDSlippers = 100010 // 拖鞋 + ItemIDPermit = 100011 // 赛季通行证积分 + ItemIDLong = 50013 // 龙币 + ItemIDPetSkill = 11001 //宠物技能升级道具 + ItemIDVCard = 30001 // v卡 + ItemIDJCard = 30002 // 金券 + ItemDiamondScore = 100012 //钻石积分 + ItemIDClawdoll = 40003 // 娃娃卡 + ItemDollCard = 40004 // 娃娃卡积分 + ItemIDRoomCard = 40002 // 房卡 + ItemIDLittleGuaranteed = 50014 //小爆竹 + ItemIDBigGuaranteed = 50015 //大爆竹 ) func ToItemId(id int32) int32 { @@ -694,6 +698,7 @@ const ( TaskTypeTienlenWinCoin = 29 // Tienlen赢取金币数量 TaskTypeRankMatchWinTimes = 30 // 排位胜利次数 TaskTypeBuyPermit = 31 // 购买典藏通行证 + TaskTypeBuyRedBag = 32 // 参与红包雨活动 ) const ( @@ -711,6 +716,8 @@ const ( TaskActivityTypeAchieve = 5 // 成就任务 TaskActivityTypePermitEveryDay = 6 // 赛季通行证每日任务 TaskActivityTypePermit = 7 // 赛季通行证任务 + TaskActivityTypeNianEveryDay = 8 // 年兽每日任务 + TaskActivityTypeNian = 9 // 活动期间年兽任务 ) const HeadRange = 3 // 机器人头像id范围 diff --git a/data/DB_GameItem.dat b/data/DB_GameItem.dat index 4c9618617ceb54dfa32845adecc27cc88e1add2c..fb28f1078df546acd3fdaeaea40ef3d1ecd7d3a6 100644 GIT binary patch delta 227 zcmX@Oka6Z>#tjDp>bcT6?zJ%su|4l-d%k+76f*+@gA$0)kTGHdQb1q@r5zYOI@ALg zBl`Wa7!8UHp7yVQI%mbxom-x^?tQjp_tUNwPj;+*+P?c`Ljy$c{hpo|ecPYzoBnj^ ew5O9BxpFz~11;it-njbty0tLtB7qjr#y$WL0cCOk delta 9 QcmbQanDO93#tjDp02UeqVgLXD diff --git a/data/DB_GameItem.json b/data/DB_GameItem.json index c7bfc88..954355e 100644 --- a/data/DB_GameItem.json +++ b/data/DB_GameItem.json @@ -7226,6 +7226,80 @@ "CompositionMax": 1, "Location": "0", "Describe": "作用：用于报名特殊钻石赛事；\n产出途径：存钱罐" + }, + { + "Id": 50014, + "Name": "爆竹", + "ShowLocation": [ + 0, + 0, + 0 + ], + "Classify": [ + 0, + 0, + 0 + ], + "Type": 28, + "Effect0": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Effect": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "SaleType": 1, + "SaleGold": 5000, + "Composition": 1, + "CompositionMax": 9999, + "Location": "0", + "Describe": "可在年兽活动中击退年兽，获得奖品" + }, + { + "Id": 50015, + "Name": "火箭爆竹", + "ShowLocation": [ + 0, + 0, + 0 + ], + "Classify": [ + 0, + 0, + 0 + ], + "Type": 28, + "Effect0": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Effect": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "SaleType": 1, + "SaleGold": 5000, + "Composition": 1, + "CompositionMax": 9999, + "Location": "0", + "Describe": "可在年兽活动中击退年兽，获得奖品" } ] } \ No newline at end of file diff --git a/data/DB_NewYearActivity.dat b/data/DB_NewYearActivity.dat new file mode 100644 index 0000000..e1daacd --- /dev/null +++ b/data/DB_NewYearActivity.dat @@ -0,0 +1,27 @@ + +4 +SignReward50014,10;100001,100000" 签到奖励 +. SignExcReward50015,1"签到额外奖励 +=SignExcRewardMax2"$签到额外奖励赠送次数上限 +9SignExcRewardProp30"签到额外奖励赠送概率 + BossExp6000000" +BOSS血量 +9 +BossReward100001,100000;100002,10"BOSS击杀奖励 +0 LuckyRankNeed110000"幸运榜上榜条件 +0RankNeed80000000"总伤害榜上榜条件 +@ LittleHurtGold 80000,120000"小爆竹造成的伤害范围 +> + BigHurtGold 400000,600000"大爆竹造成的伤害范围 +4  +BigHurtExc30001"大爆竹额外掉落道具ID +> BigHurtExcNumber10,30"!大爆竹额外掉落数量范围 +5 LittleGuaranteed30"小爆竹保底掉落次数 +ALittleGuaranteedReward100002,5"小爆竹保底掉落物品 +2 BigGuaranteed10"大爆竹保底掉落次数 +?BigGuaranteedReward 30001,100"大爆竹保底掉落物品 +. +GiftShopID991001,991002,991003"礼包ID +@ GiftShopLimit3,0,0"&礼包每日限购次数,0为不限购 +4 BossExcLimit30"年兽死亡额外掉落要求 +" BuffCount1"Buff生效次数 \ No newline at end of file diff --git a/data/DB_NewYearActivity.json b/data/DB_NewYearActivity.json new file mode 100644 index 0000000..2268940 --- /dev/null +++ b/data/DB_NewYearActivity.json @@ -0,0 +1,124 @@ +{ + "Arr": [ + { + "Id": 1, + "PorpName": "SignReward", + "PropValue": "50014,10;100001,100000", + "PropDec": "签到奖励" + }, + { + "Id": 2, + "PorpName": "SignExcReward", + "PropValue": "50015,1", + "PropDec": "签到额外奖励" + }, + { + "Id": 3, + "PorpName": "SignExcRewardMax", + "PropValue": "2", + "PropDec": "签到额外奖励赠送次数上限" + }, + { + "Id": 4, + "PorpName": "SignExcRewardProp", + "PropValue": "30", + "PropDec": "签到额外奖励赠送概率" + }, + { + "Id": 5, + "PorpName": "BossExp", + "PropValue": "6000000", + "PropDec": "BOSS血量" + }, + { + "Id": 6, + "PorpName": "BossReward", + "PropValue": "100001,100000;100002,10", + "PropDec": "BOSS击杀奖励" + }, + { + "Id": 7, + "PorpName": "LuckyRankNeed", + "PropValue": "110000", + "PropDec": "幸运榜上榜条件" + }, + { + "Id": 8, + "PorpName": "RankNeed", + "PropValue": "80000000", + "PropDec": "总伤害榜上榜条件" + }, + { + "Id": 9, + "PorpName": "LittleHurtGold", + "PropValue": "80000,120000", + "PropDec": "小爆竹造成的伤害范围" + }, + { + "Id": 10, + "PorpName": "BigHurtGold", + "PropValue": "400000,600000", + "PropDec": "大爆竹造成的伤害范围" + }, + { + "Id": 11, + "PorpName": "BigHurtExc", + "PropValue": "30001", + "PropDec": "大爆竹额外掉落道具ID" + }, + { + "Id": 12, + "PorpName": "BigHurtExcNumber", + "PropValue": "10,30", + "PropDec": "大爆竹额外掉落数量范围" + }, + { + "Id": 13, + "PorpName": "LittleGuaranteed", + "PropValue": "30", + "PropDec": "小爆竹保底掉落次数" + }, + { + "Id": 14, + "PorpName": "LittleGuaranteedReward", + "PropValue": "100002,5", + "PropDec": "小爆竹保底掉落物品" + }, + { + "Id": 15, + "PorpName": "BigGuaranteed", + "PropValue": "10", + "PropDec": "大爆竹保底掉落次数" + }, + { + "Id": 16, + "PorpName": "BigGuaranteedReward", + "PropValue": "30001,100", + "PropDec": "大爆竹保底掉落物品" + }, + { + "Id": 17, + "PorpName": "GiftShopID", + "PropValue": "991001,991002,991003", + "PropDec": "礼包ID" + }, + { + "Id": 18, + "PorpName": "GiftShopLimit", + "PropValue": "3,0,0", + "PropDec": "礼包每日限购次数,0为不限购" + }, + { + "Id": 19, + "PorpName": "BossExcLimit", + "PropValue": "30", + "PropDec": "年兽死亡额外掉落要求" + }, + { + "Id": 20, + "PorpName": "BuffCount", + "PropValue": "1", + "PropDec": "Buff生效次数" + } + ] +} \ No newline at end of file diff --git a/data/DB_NewYearRankReward.dat b/data/DB_NewYearRankReward.dat new file mode 100644 index 0000000..0748d61 --- /dev/null +++ b/data/DB_NewYearRankReward.dat @@ -0,0 +1,84 @@ + +""d" +""d" +""d" +"d" +""c +""b +""a +""` +  ""_ + + +""^ +  ""] +  ""\ +  ""[ +""Z +""Y +""X +""W +""V +""U +""T +""S +""R +""Q +""P +""O +""N +""M +""L +""K +""J +""I +  ""H +!!""G +""""F +##""E +$$""D +%%""C +&&"B" +''""A +((""@ +)""d" +*"d"" ++""d" +,"d" +-""c +.""b +/""a +0""` +1 ""_ +2 +""^ +3 ""] +4 ""\ +5 ""[ +6""Z +7""Y +8""X +9""W +:""V +;""U +<""T +=""S +>""R +?""Q +@"P" +A"O" +B""N +C""M +D""L +E""K +F""J +G""I +H ""H +I!""G +J"""F +K#""E +L$""D +M%""C +N&""B +O'""A +P(""@ \ No newline at end of file diff --git a/data/DB_NewYearRankReward.json b/data/DB_NewYearRankReward.json new file mode 100644 index 0000000..0715204 --- /dev/null +++ b/data/DB_NewYearRankReward.json @@ -0,0 +1,730 @@ +{ + "Arr": [ + { + "Id": 1, + "RankType": 1, + "RankLevelId": 1, + "AwardMap": { + "100001": 30, + "100002": 100, + "30009": 2 + } + }, + { + "Id": 2, + "RankType": 1, + "RankLevelId": 2, + "AwardMap": { + "100001": 30, + "100002": 100, + "30008": 2 + } + }, + { + "Id": 3, + "RankType": 1, + "RankLevelId": 3, + "AwardMap": { + "100001": 30, + "100002": 100, + "30008": 1 + } + }, + { + "Id": 4, + "RankType": 1, + "RankLevelId": 4, + "AwardMap": { + "100001": 30, + "100002": 100 + } + }, + { + "Id": 5, + "RankType": 1, + "RankLevelId": 5, + "AwardMap": { + "100001": 30, + "100002": 99 + } + }, + { + "Id": 6, + "RankType": 1, + "RankLevelId": 6, + "AwardMap": { + "100001": 30, + "100002": 98 + } + }, + { + "Id": 7, + "RankType": 1, + "RankLevelId": 7, + "AwardMap": { + "100001": 30, + "100002": 97 + } + }, + { + "Id": 8, + "RankType": 1, + "RankLevelId": 8, + "AwardMap": { + "100001": 30, + "100002": 96 + } + }, + { + "Id": 9, + "RankType": 1, + "RankLevelId": 9, + "AwardMap": { + "100001": 30, + "100002": 95 + } + }, + { + "Id": 10, + "RankType": 1, + "RankLevelId": 10, + "AwardMap": { + "100001": 30, + "100002": 94 + } + }, + { + "Id": 11, + "RankType": 1, + "RankLevelId": 11, + "AwardMap": { + "100001": 30, + "100002": 93 + } + }, + { + "Id": 12, + "RankType": 1, + "RankLevelId": 12, + "AwardMap": { + "100001": 30, + "100002": 92 + } + }, + { + "Id": 13, + "RankType": 1, + "RankLevelId": 13, + "AwardMap": { + "100001": 30, + "100002": 91 + } + }, + { + "Id": 14, + "RankType": 1, + "RankLevelId": 14, + "AwardMap": { + "100001": 30, + "100002": 90 + } + }, + { + "Id": 15, + "RankType": 1, + "RankLevelId": 15, + "AwardMap": { + "100001": 30, + "100002": 89 + } + }, + { + "Id": 16, + "RankType": 1, + "RankLevelId": 16, + "AwardMap": { + "100001": 30, + "100002": 88 + } + }, + { + "Id": 17, + "RankType": 1, + "RankLevelId": 17, + "AwardMap": { + "100001": 30, + "100002": 87 + } + }, + { + "Id": 18, + "RankType": 1, + "RankLevelId": 18, + "AwardMap": { + "100001": 30, + "100002": 86 + } + }, + { + "Id": 19, + "RankType": 1, + "RankLevelId": 19, + "AwardMap": { + "100001": 30, + "100002": 85 + } + }, + { + "Id": 20, + "RankType": 1, + "RankLevelId": 20, + "AwardMap": { + "100001": 30, + "100002": 84 + } + }, + { + "Id": 21, + "RankType": 1, + "RankLevelId": 21, + "AwardMap": { + "100001": 30, + "100002": 83 + } + }, + { + "Id": 22, + "RankType": 1, + "RankLevelId": 22, + "AwardMap": { + "100001": 30, + "100002": 82 + } + }, + { + "Id": 23, + "RankType": 1, + "RankLevelId": 23, + "AwardMap": { + "100001": 30, + "100002": 81 + } + }, + { + "Id": 24, + "RankType": 1, + "RankLevelId": 24, + "AwardMap": { + "100001": 30, + "100002": 80 + } + }, + { + "Id": 25, + "RankType": 1, + "RankLevelId": 25, + "AwardMap": { + "100001": 30, + "100002": 79 + } + }, + { + "Id": 26, + "RankType": 1, + "RankLevelId": 26, + "AwardMap": { + "100001": 30, + "100002": 78 + } + }, + { + "Id": 27, + "RankType": 1, + "RankLevelId": 27, + "AwardMap": { + "100001": 30, + "100002": 77 + } + }, + { + "Id": 28, + "RankType": 1, + "RankLevelId": 28, + "AwardMap": { + "100001": 30, + "100002": 76 + } + }, + { + "Id": 29, + "RankType": 1, + "RankLevelId": 29, + "AwardMap": { + "100001": 30, + "100002": 75 + } + }, + { + "Id": 30, + "RankType": 1, + "RankLevelId": 30, + "AwardMap": { + "100001": 30, + "100002": 74 + } + }, + { + "Id": 31, + "RankType": 1, + "RankLevelId": 31, + "AwardMap": { + "100001": 30, + "100002": 73 + } + }, + { + "Id": 32, + "RankType": 1, + "RankLevelId": 32, + "AwardMap": { + "100001": 30, + "100002": 72 + } + }, + { + "Id": 33, + "RankType": 1, + "RankLevelId": 33, + "AwardMap": { + "100001": 30, + "100002": 71 + } + }, + { + "Id": 34, + "RankType": 1, + "RankLevelId": 34, + "AwardMap": { + "100001": 30, + "100002": 70 + } + }, + { + "Id": 35, + "RankType": 1, + "RankLevelId": 35, + "AwardMap": { + "100001": 30, + "100002": 69 + } + }, + { + "Id": 36, + "RankType": 1, + "RankLevelId": 36, + "AwardMap": { + "100001": 30, + "100002": 68 + } + }, + { + "Id": 37, + "RankType": 1, + "RankLevelId": 37, + "AwardMap": { + "100001": 30, + "100002": 67 + } + }, + { + "Id": 38, + "RankType": 1, + "RankLevelId": 38, + "AwardMap": { + "100001": 30, + "100002": 66 + } + }, + { + "Id": 39, + "RankType": 1, + "RankLevelId": 39, + "AwardMap": { + "100001": 30, + "100002": 65 + } + }, + { + "Id": 40, + "RankType": 1, + "RankLevelId": 40, + "AwardMap": { + "100001": 30, + "100002": 64 + } + }, + { + "Id": 41, + "RankType": 2, + "RankLevelId": 1, + "AwardMap": { + "100001": 30, + "100002": 100, + "30009": 2 + } + }, + { + "Id": 42, + "RankType": 2, + "RankLevelId": 2, + "AwardMap": { + "100001": 30, + "100002": 100, + "30008": 2 + } + }, + { + "Id": 43, + "RankType": 2, + "RankLevelId": 3, + "AwardMap": { + "100001": 30, + "100002": 100, + "30008": 1 + } + }, + { + "Id": 44, + "RankType": 2, + "RankLevelId": 4, + "AwardMap": { + "100001": 30, + "100002": 100 + } + }, + { + "Id": 45, + "RankType": 2, + "RankLevelId": 5, + "AwardMap": { + "100001": 30, + "100002": 99 + } + }, + { + "Id": 46, + "RankType": 2, + "RankLevelId": 6, + "AwardMap": { + "100001": 30, + "100002": 98 + } + }, + { + "Id": 47, + "RankType": 2, + "RankLevelId": 7, + "AwardMap": { + "100001": 30, + "100002": 97 + } + }, + { + "Id": 48, + "RankType": 2, + "RankLevelId": 8, + "AwardMap": { + "100001": 30, + "100002": 96 + } + }, + { + "Id": 49, + "RankType": 2, + "RankLevelId": 9, + "AwardMap": { + "100001": 30, + "100002": 95 + } + }, + { + "Id": 50, + "RankType": 2, + "RankLevelId": 10, + "AwardMap": { + "100001": 30, + "100002": 94 + } + }, + { + "Id": 51, + "RankType": 2, + "RankLevelId": 11, + "AwardMap": { + "100001": 30, + "100002": 93 + } + }, + { + "Id": 52, + "RankType": 2, + "RankLevelId": 12, + "AwardMap": { + "100001": 30, + "100002": 92 + } + }, + { + "Id": 53, + "RankType": 2, + "RankLevelId": 13, + "AwardMap": { + "100001": 30, + "100002": 91 + } + }, + { + "Id": 54, + "RankType": 2, + "RankLevelId": 14, + "AwardMap": { + "100001": 30, + "100002": 90 + } + }, + { + "Id": 55, + "RankType": 2, + "RankLevelId": 15, + "AwardMap": { + "100001": 30, + "100002": 89 + } + }, + { + "Id": 56, + "RankType": 2, + "RankLevelId": 16, + "AwardMap": { + "100001": 30, + "100002": 88 + } + }, + { + "Id": 57, + "RankType": 2, + "RankLevelId": 17, + "AwardMap": { + "100001": 30, + "100002": 87 + } + }, + { + "Id": 58, + "RankType": 2, + "RankLevelId": 18, + "AwardMap": { + "100001": 30, + "100002": 86 + } + }, + { + "Id": 59, + "RankType": 2, + "RankLevelId": 19, + "AwardMap": { + "100001": 30, + "100002": 85 + } + }, + { + "Id": 60, + "RankType": 2, + "RankLevelId": 20, + "AwardMap": { + "100001": 30, + "100002": 84 + } + }, + { + "Id": 61, + "RankType": 2, + "RankLevelId": 21, + "AwardMap": { + "100001": 30, + "100002": 83 + } + }, + { + "Id": 62, + "RankType": 2, + "RankLevelId": 22, + "AwardMap": { + "100001": 30, + "100002": 82 + } + }, + { + "Id": 63, + "RankType": 2, + "RankLevelId": 23, + "AwardMap": { + "100001": 30, + "100002": 81 + } + }, + { + "Id": 64, + "RankType": 2, + "RankLevelId": 24, + "AwardMap": { + "100001": 30, + "100002": 80 + } + }, + { + "Id": 65, + "RankType": 2, + "RankLevelId": 25, + "AwardMap": { + "100001": 30, + "100002": 79 + } + }, + { + "Id": 66, + "RankType": 2, + "RankLevelId": 26, + "AwardMap": { + "100001": 30, + "100002": 78 + } + }, + { + "Id": 67, + "RankType": 2, + "RankLevelId": 27, + "AwardMap": { + "100001": 30, + "100002": 77 + } + }, + { + "Id": 68, + "RankType": 2, + "RankLevelId": 28, + "AwardMap": { + "100001": 30, + "100002": 76 + } + }, + { + "Id": 69, + "RankType": 2, + "RankLevelId": 29, + "AwardMap": { + "100001": 30, + "100002": 75 + } + }, + { + "Id": 70, + "RankType": 2, + "RankLevelId": 30, + "AwardMap": { + "100001": 30, + "100002": 74 + } + }, + { + "Id": 71, + "RankType": 2, + "RankLevelId": 31, + "AwardMap": { + "100001": 30, + "100002": 73 + } + }, + { + "Id": 72, + "RankType": 2, + "RankLevelId": 32, + "AwardMap": { + "100001": 30, + "100002": 72 + } + }, + { + "Id": 73, + "RankType": 2, + "RankLevelId": 33, + "AwardMap": { + "100001": 30, + "100002": 71 + } + }, + { + "Id": 74, + "RankType": 2, + "RankLevelId": 34, + "AwardMap": { + "100001": 30, + "100002": 70 + } + }, + { + "Id": 75, + "RankType": 2, + "RankLevelId": 35, + "AwardMap": { + "100001": 30, + "100002": 69 + } + }, + { + "Id": 76, + "RankType": 2, + "RankLevelId": 36, + "AwardMap": { + "100001": 30, + "100002": 68 + } + }, + { + "Id": 77, + "RankType": 2, + "RankLevelId": 37, + "AwardMap": { + "100001": 30, + "100002": 67 + } + }, + { + "Id": 78, + "RankType": 2, + "RankLevelId": 38, + "AwardMap": { + "100001": 30, + "100002": 66 + } + }, + { + "Id": 79, + "RankType": 2, + "RankLevelId": 39, + "AwardMap": { + "100001": 30, + "100002": 65 + } + }, + { + "Id": 80, + "RankType": 2, + "RankLevelId": 40, + "AwardMap": { + "100001": 30, + "100002": 64 + } + } + ] +} \ No newline at end of file diff --git a/data/DB_Task.dat b/data/DB_Task.dat index 3f51acb68279faf7fb0d4dc69988478af86907d1..d93409f4aa96b2aa66f2e9ab90c0aa75bc93c1fe 100644 GIT binary patch delta 936 zcmZXSTWb?R7>1oq-2HZvG_z?ElQzT>sssetBIw528c-BMk=)vAr(pj?qcl~-8q>iO zo|@oA1htU_X&bd(daAXaZ>l%hP4@?Q?~)BocDz~`p67kPnf(d}8i%Syw<1D$UL+_3 zP_n*nX2)t}w}CpxLg#pKUSxN~^{5TwjBLXxFq^?Xap}o--F7CP58p*JC~Iari)qi*v)<^{361YO~QW zW(($}qP~1##CTG&Y{4o{>@-gbyAU3SkCeEb32ak|4TBnXj5z`8lVZM&Sn~eVnh@t@hxW1QT=Bf!Wsc_!OgNluQ1y=(#prfp>MV&hl@WO8x2 za7^?QV4NJlAvt*l`!hj^Fsl~_SmlC4a+CWx4njp4VWPckn-e*wFhPa6puz`QY&Wy< P{D27~nX#Flzkv+^)c7n7 diff --git a/data/DB_Task.json b/data/DB_Task.json index 6577f2f..1d61204 100644 --- a/data/DB_Task.json +++ b/data/DB_Task.json @@ -1234,6 +1234,236 @@ "Award": { "100011": 50 } + }, + { + "Id": 13001, + "Order": 1, + "Name": "年兽活动", + "Des": "领取转盘签到奖励", + "ActivityType": 8, + "TaskType": 17, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + } + }, + { + "Id": 13002, + "Order": 2, + "Name": "年兽活动", + "Des": "在线时长60分钟", + "ActivityType": 8, + "TaskType": 21, + "TargetTimes": 3600, + "FinishTimes": 1, + "Award": { + "50014": 10 + } + }, + { + "Id": 13003, + "Order": 3, + "Name": "年兽活动", + "Des": "购买任意金币1次", + "ActivityType": 8, + "TaskType": 2, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "Position": [ + 0, + 1 + ] + }, + { + "Id": 13004, + "Order": 4, + "Name": "年兽活动", + "Des": "购买任意存钱罐1次", + "ActivityType": 8, + "TaskType": 22, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + } + }, + { + "Id": 13005, + "Order": 5, + "Name": "年兽活动", + "Des": "参与大众场对局获得胜利3次", + "ActivityType": 8, + "TaskType": 23, + "TargetTimes": 3, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "GameType": 1 + }, + { + "Id": 13006, + "Order": 6, + "Name": "年兽活动", + "Des": "参与排位赛获得胜利3次", + "ActivityType": 8, + "TaskType": 30, + "TargetTimes": 3, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "GameType": 1 + }, + { + "Id": 13007, + "Order": 7, + "Name": "年兽活动", + "Des": "邀请好友进行私人桌对局1次", + "ActivityType": 8, + "TaskType": 24, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "GameType": 1 + }, + { + "Id": 13008, + "Order": 8, + "Name": "年兽活动", + "Des": "成功参与比赛场3次", + "ActivityType": 8, + "TaskType": 25, + "TargetTimes": 3, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "GameType": 1 + }, + { + "Id": 13009, + "Order": 9, + "Name": "年兽活动", + "Des": "比赛场获得前十名1次", + "ActivityType": 8, + "TaskType": 26, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "GameType": 1 + }, + { + "Id": 13010, + "Order": 10, + "Name": "年兽活动", + "Des": "今日累计消耗100钻石", + "ActivityType": 8, + "TaskType": 27, + "TargetTimes": 100, + "FinishTimes": 1, + "Award": { + "50014": 10 + } + }, + { + "Id": 13011, + "Order": 11, + "Name": "年兽活动", + "Des": "充值任意金额", + "ActivityType": 8, + "TaskType": 7, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50014": 10 + }, + "Position": [ + 1, + 1 + ] + }, + { + "Id": 13012, + "Order": 12, + "Name": "年兽活动", + "Des": "累计领取转盘签到奖励7天", + "ActivityType": 9, + "TaskType": 17, + "TargetTimes": 7, + "FinishTimes": 1, + "Award": { + "50014": 10 + } + }, + { + "Id": 13013, + "Order": 13, + "Name": "年兽活动", + "Des": "参与红包雨活动1次", + "ActivityType": 8, + "TaskType": 32, + "TargetTimes": 1, + "FinishTimes": 1, + "Award": { + "50015": 10 + } + }, + { + "Id": 13014, + "Order": 14, + "Name": "年兽活动", + "Des": "累计充值$9.99", + "ActivityType": 9, + "TaskType": 7, + "TargetTimes": 999, + "FinishTimes": 1, + "Award": { + "50015": 10 + }, + "Position": [ + 1, + 1 + ] + }, + { + "Id": 13015, + "Order": 15, + "Name": "年兽活动", + "Des": "累计充值$19.99", + "ActivityType": 9, + "TaskType": 7, + "TargetTimes": 1999, + "FinishTimes": 1, + "Award": { + "50015": 10 + }, + "Position": [ + 1, + 1 + ] + }, + { + "Id": 13016, + "Order": 16, + "Name": "年兽活动", + "Des": "累计赚取10B金币", + "ActivityType": 9, + "TaskType": 11, + "TargetTimes": 10000000000, + "FinishTimes": 1, + "Award": { + "50015": 10 + }, + "GameType": 1 } ] } \ No newline at end of file diff --git a/etcd/keyconf.go b/etcd/keyconf.go index 0e0d5dc..2208bc4 100644 --- a/etcd/keyconf.go +++ b/etcd/keyconf.go @@ -51,4 +51,5 @@ const ( ETCDKEY_LotteryUser = "/game/user_lottery" //抽奖用户必中配置 ETCDKEY_PigBankDiamond = "/game/pigbank_diamond" //存钱罐消耗获得 ETCDKEY_PigBankProp = "/game/pigbank_prop" //存钱罐属性 + ETCDKEY_NianConfig = "/game/activity_nian" //年兽活动配置 ) diff --git a/model/config.go b/model/config.go index 6c40140..bca39ca 100644 --- a/model/config.go +++ b/model/config.go @@ -17,14 +17,14 @@ import ( */ const ( - OpAll = 0 - OpTurnplate = 1 - OpBlindBox = 2 - OpFirstPay = 3 - OpContinuousPay = 4 - OpPhoneLottery = 5 - OpCollect = 6 - OpDiamondLottery = 7 + OpAll = 0 + OpTurnplate = 1 + OpBlindBox = 2 + OpFirstPay = 3 + OpContinuousPay = 4 + OpPhoneLottery = 5 + OpCollect = 6 + OpNian = 7 ) const ( @@ -167,6 +167,8 @@ type AllConfig struct { *webapi.GamePigBankDiamondConfig // 存钱罐属性 *webapi.GamePigBankPropConfig + //年兽配置 + *webapi.ActivityNianConfig } type GlobalConfig struct { diff --git a/model/player.go b/model/player.go index 638a06c..7895fea 100644 --- a/model/player.go +++ b/model/player.go @@ -564,6 +564,7 @@ type WelfareData struct { DiamondBank *DiamondBankData // 钻石储存罐 PermitAward map[int32]int64 // 赛季通行证奖励领取时间 PermitExchange map[int32][]int64 // 赛季通行证兑换次数, 多次的兑换时间 + NianData *NianData //年兽活动数据 } func NewWelfareData() *WelfareData { @@ -580,6 +581,9 @@ func NewWelfareData() *WelfareData { }, PermitAward: make(map[int32]int64), PermitExchange: make(map[int32][]int64), + NianData: &NianData{ + OtherAwardNum: make(map[int32]int32), + }, } } @@ -672,6 +676,19 @@ type WebPlayerDataParam struct { Long, PermitScore int64 } +type NianData struct { + ActivityStartTime int64 //活动开始时间 + ActivityEndTime int64 //活动结束时间 + BossHp int64 //Boss当前血量 + BuffStatus bool //Buff领取状态 + BuffCount int64 //Buff剩余生效次数 + SignAwardTime int64 //签到奖励领取时间 + BossDieCount int32 //BOSS死亡次数 + LittleHurt int32 //小爆竹次数 + BigHurt int32 //大爆竹次数 + OtherAwardNum map[int32]int32 //奖励掉落数量 +} + func ConvertPlayerDataToWebData(param *WebPlayerDataParam) *webapi.PlayerData { if param == nil || param.PlayerData == nil { return nil diff --git a/protocol/activity/nian.pb.go b/protocol/activity/nian.pb.go new file mode 100644 index 0000000..cc51864 --- /dev/null +++ b/protocol/activity/nian.pb.go @@ -0,0 +1,1167 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1-devel +// protoc v3.19.4 +// source: protocol/activity/nian.proto + +package activity + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type NianPacketID int32 + +const ( + NianPacketID_PACKET_Nian_ZERO NianPacketID = 0 // 弃用消息号 + NianPacketID_PACKET_CSNianData NianPacketID = 2660 // 获取年兽信息 + NianPacketID_PACKET_SCNianData NianPacketID = 2661 // 返回年兽信息 + NianPacketID_PACKET_CSNianBuff NianPacketID = 2662 // 请求领取BUFF + NianPacketID_PACKET_SCNianBuff NianPacketID = 2663 // 返回Buff信息 + NianPacketID_PACKET_CSNianRankData NianPacketID = 2664 // 请求排行榜信息 + NianPacketID_PACKET_SCNianRankData NianPacketID = 2665 // 返回排行榜信息 + NianPacketID_PACKET_CSNianAttack NianPacketID = 2666 //请求攻击年兽 + NianPacketID_PACKET_SCNianAttackData NianPacketID = 2667 //返回攻击年兽信息 + NianPacketID_PACKET_CSNianSignAward NianPacketID = 2668 //请求签到 + NianPacketID_PACKET_SCNianSignAward NianPacketID = 2669 //签到返回 +) + +// Enum value maps for NianPacketID. +var ( + NianPacketID_name = map[int32]string{ + 0: "PACKET_Nian_ZERO", + 2660: "PACKET_CSNianData", + 2661: "PACKET_SCNianData", + 2662: "PACKET_CSNianBuff", + 2663: "PACKET_SCNianBuff", + 2664: "PACKET_CSNianRankData", + 2665: "PACKET_SCNianRankData", + 2666: "PACKET_CSNianAttack", + 2667: "PACKET_SCNianAttackData", + 2668: "PACKET_CSNianSignAward", + 2669: "PACKET_SCNianSignAward", + } + NianPacketID_value = map[string]int32{ + "PACKET_Nian_ZERO": 0, + "PACKET_CSNianData": 2660, + "PACKET_SCNianData": 2661, + "PACKET_CSNianBuff": 2662, + "PACKET_SCNianBuff": 2663, + "PACKET_CSNianRankData": 2664, + "PACKET_SCNianRankData": 2665, + "PACKET_CSNianAttack": 2666, + "PACKET_SCNianAttackData": 2667, + "PACKET_CSNianSignAward": 2668, + "PACKET_SCNianSignAward": 2669, + } +) + +func (x NianPacketID) Enum() *NianPacketID { + p := new(NianPacketID) + *p = x + return p +} + +func (x NianPacketID) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NianPacketID) Descriptor() protoreflect.EnumDescriptor { + return file_protocol_activity_nian_proto_enumTypes[0].Descriptor() +} + +func (NianPacketID) Type() protoreflect.EnumType { + return &file_protocol_activity_nian_proto_enumTypes[0] +} + +func (x NianPacketID) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NianPacketID.Descriptor instead. +func (NianPacketID) EnumDescriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{0} +} + +//获取年兽活动信息 +//PACKET_CSNianData +type CSNianData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CSNianData) Reset() { + *x = CSNianData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CSNianData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CSNianData) ProtoMessage() {} + +func (x *CSNianData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CSNianData.ProtoReflect.Descriptor instead. +func (*CSNianData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{0} +} + +//PACKET_SCNianData +type SCNianData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ActivityStartTime int64 `protobuf:"varint,1,opt,name=ActivityStartTime,proto3" json:"ActivityStartTime,omitempty"` //活动开始时间 + ActivityEndTime int64 `protobuf:"varint,2,opt,name=ActivityEndTime,proto3" json:"ActivityEndTime,omitempty"` //活动结束时间 + BossMaxHp int64 `protobuf:"varint,3,opt,name=BossMaxHp,proto3" json:"BossMaxHp,omitempty"` //Boss最大血量 + BossHp int64 `protobuf:"varint,4,opt,name=BossHp,proto3" json:"BossHp,omitempty"` //Boss当前血量 + LuckData []*RankData `protobuf:"bytes,5,rep,name=LuckData,proto3" json:"LuckData,omitempty"` //幸运榜 + AwardTime int64 `protobuf:"varint,6,opt,name=AwardTime,proto3" json:"AwardTime,omitempty"` //每日签到领取时间 + BuffCount int64 `protobuf:"varint,7,opt,name=BuffCount,proto3" json:"BuffCount,omitempty"` //Buff剩余次数 + BuffStatus bool `protobuf:"varint,8,opt,name=BuffStatus,proto3" json:"BuffStatus,omitempty"` //Buff领取状态 + On int32 `protobuf:"varint,9,opt,name=On,proto3" json:"On,omitempty"` //活动开关 1开启 2关闭 + SignAwardTime int64 `protobuf:"varint,10,opt,name=SignAwardTime,proto3" json:"SignAwardTime,omitempty"` //签到领取时间 0-未领取 +} + +func (x *SCNianData) Reset() { + *x = SCNianData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SCNianData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCNianData) ProtoMessage() {} + +func (x *SCNianData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SCNianData.ProtoReflect.Descriptor instead. +func (*SCNianData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{1} +} + +func (x *SCNianData) GetActivityStartTime() int64 { + if x != nil { + return x.ActivityStartTime + } + return 0 +} + +func (x *SCNianData) GetActivityEndTime() int64 { + if x != nil { + return x.ActivityEndTime + } + return 0 +} + +func (x *SCNianData) GetBossMaxHp() int64 { + if x != nil { + return x.BossMaxHp + } + return 0 +} + +func (x *SCNianData) GetBossHp() int64 { + if x != nil { + return x.BossHp + } + return 0 +} + +func (x *SCNianData) GetLuckData() []*RankData { + if x != nil { + return x.LuckData + } + return nil +} + +func (x *SCNianData) GetAwardTime() int64 { + if x != nil { + return x.AwardTime + } + return 0 +} + +func (x *SCNianData) GetBuffCount() int64 { + if x != nil { + return x.BuffCount + } + return 0 +} + +func (x *SCNianData) GetBuffStatus() bool { + if x != nil { + return x.BuffStatus + } + return false +} + +func (x *SCNianData) GetOn() int32 { + if x != nil { + return x.On + } + return 0 +} + +func (x *SCNianData) GetSignAwardTime() int64 { + if x != nil { + return x.SignAwardTime + } + return 0 +} + +//贺春 +//请求领取BUFF +//PACKET_CSNianBuff +type CSNianBuff struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CSNianBuff) Reset() { + *x = CSNianBuff{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CSNianBuff) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CSNianBuff) ProtoMessage() {} + +func (x *CSNianBuff) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CSNianBuff.ProtoReflect.Descriptor instead. +func (*CSNianBuff) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{2} +} + +//PACKET_SCNianBuff +type SCNianBuff struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BuffCount int64 `protobuf:"varint,1,opt,name=BuffCount,proto3" json:"BuffCount,omitempty"` //BUFF剩余次数 +} + +func (x *SCNianBuff) Reset() { + *x = SCNianBuff{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SCNianBuff) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCNianBuff) ProtoMessage() {} + +func (x *SCNianBuff) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SCNianBuff.ProtoReflect.Descriptor instead. +func (*SCNianBuff) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{3} +} + +func (x *SCNianBuff) GetBuffCount() int64 { + if x != nil { + return x.BuffCount + } + return 0 +} + +//排行榜数据 +//PACKET_CSNianRankData +type CSNianRankData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` //1-幸运榜 2-总伤害榜 +} + +func (x *CSNianRankData) Reset() { + *x = CSNianRankData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CSNianRankData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CSNianRankData) ProtoMessage() {} + +func (x *CSNianRankData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CSNianRankData.ProtoReflect.Descriptor instead. +func (*CSNianRankData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{4} +} + +func (x *CSNianRankData) GetTypeId() int32 { + if x != nil { + return x.TypeId + } + return 0 +} + +//PACKET_SCNianRankData +type SCNianRankData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` + Data []*RankData `protobuf:"bytes,2,rep,name=Data,proto3" json:"Data,omitempty"` +} + +func (x *SCNianRankData) Reset() { + *x = SCNianRankData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SCNianRankData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCNianRankData) ProtoMessage() {} + +func (x *SCNianRankData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SCNianRankData.ProtoReflect.Descriptor instead. +func (*SCNianRankData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{5} +} + +func (x *SCNianRankData) GetTypeId() int32 { + if x != nil { + return x.TypeId + } + return 0 +} + +func (x *SCNianRankData) GetData() []*RankData { + if x != nil { + return x.Data + } + return nil +} + +type RankData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RankId int32 `protobuf:"varint,1,opt,name=RankId,proto3" json:"RankId,omitempty"` + Name string `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"` + Icon int32 `protobuf:"varint,3,opt,name=Icon,proto3" json:"Icon,omitempty"` + Score int64 `protobuf:"varint,4,opt,name=Score,proto3" json:"Score,omitempty"` + Award []*RankAwardData `protobuf:"bytes,5,rep,name=Award,proto3" json:"Award,omitempty"` +} + +func (x *RankData) Reset() { + *x = RankData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RankData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RankData) ProtoMessage() {} + +func (x *RankData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RankData.ProtoReflect.Descriptor instead. +func (*RankData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{6} +} + +func (x *RankData) GetRankId() int32 { + if x != nil { + return x.RankId + } + return 0 +} + +func (x *RankData) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *RankData) GetIcon() int32 { + if x != nil { + return x.Icon + } + return 0 +} + +func (x *RankData) GetScore() int64 { + if x != nil { + return x.Score + } + return 0 +} + +func (x *RankData) GetAward() []*RankAwardData { + if x != nil { + return x.Award + } + return nil +} + +type RankAwardData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ItemId int32 `protobuf:"varint,1,opt,name=ItemId,proto3" json:"ItemId,omitempty"` + ItemNum int64 `protobuf:"varint,2,opt,name=ItemNum,proto3" json:"ItemNum,omitempty"` +} + +func (x *RankAwardData) Reset() { + *x = RankAwardData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RankAwardData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RankAwardData) ProtoMessage() {} + +func (x *RankAwardData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RankAwardData.ProtoReflect.Descriptor instead. +func (*RankAwardData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{7} +} + +func (x *RankAwardData) GetItemId() int32 { + if x != nil { + return x.ItemId + } + return 0 +} + +func (x *RankAwardData) GetItemNum() int64 { + if x != nil { + return x.ItemNum + } + return 0 +} + +//攻击年兽 +//PACKET_CSNianAttack +type CSNianAttack struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` //1-小爆竹 2-小爆竹*10 3-大爆竹 +} + +func (x *CSNianAttack) Reset() { + *x = CSNianAttack{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CSNianAttack) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CSNianAttack) ProtoMessage() {} + +func (x *CSNianAttack) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CSNianAttack.ProtoReflect.Descriptor instead. +func (*CSNianAttack) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{8} +} + +func (x *CSNianAttack) GetTypeId() int32 { + if x != nil { + return x.TypeId + } + return 0 +} + +//PACKET_SCNianAttackData +type SCNianAttackData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TypeId int32 `protobuf:"varint,1,opt,name=TypeId,proto3" json:"TypeId,omitempty"` //1-小爆竹 2-小爆竹*10 3-大爆竹 + BossHp int64 `protobuf:"varint,2,opt,name=BossHp,proto3" json:"BossHp,omitempty"` //BOSS当前血量 + Award []*RankAwardData `protobuf:"bytes,3,rep,name=Award,proto3" json:"Award,omitempty"` //获得道具 + AttackHp int64 `protobuf:"varint,4,opt,name=AttackHp,proto3" json:"AttackHp,omitempty"` // 攻击伤害 + IsDie bool `protobuf:"varint,5,opt,name=IsDie,proto3" json:"IsDie,omitempty"` //BOSS是否死亡 + DieAward []*RankAwardData `protobuf:"bytes,6,rep,name=DieAward,proto3" json:"DieAward,omitempty"` //BOSS死亡奖励 + BuffCount int64 `protobuf:"varint,7,opt,name=BuffCount,proto3" json:"BuffCount,omitempty"` //BUFF剩余次数 + ExtraDrop []*RankAwardData `protobuf:"bytes,8,rep,name=ExtraDrop,proto3" json:"ExtraDrop,omitempty"` //大爆竹额外掉落 + FloorReward []*RankAwardData `protobuf:"bytes,9,rep,name=FloorReward,proto3" json:"FloorReward,omitempty"` //保底奖励 +} + +func (x *SCNianAttackData) Reset() { + *x = SCNianAttackData{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SCNianAttackData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCNianAttackData) ProtoMessage() {} + +func (x *SCNianAttackData) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SCNianAttackData.ProtoReflect.Descriptor instead. +func (*SCNianAttackData) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{9} +} + +func (x *SCNianAttackData) GetTypeId() int32 { + if x != nil { + return x.TypeId + } + return 0 +} + +func (x *SCNianAttackData) GetBossHp() int64 { + if x != nil { + return x.BossHp + } + return 0 +} + +func (x *SCNianAttackData) GetAward() []*RankAwardData { + if x != nil { + return x.Award + } + return nil +} + +func (x *SCNianAttackData) GetAttackHp() int64 { + if x != nil { + return x.AttackHp + } + return 0 +} + +func (x *SCNianAttackData) GetIsDie() bool { + if x != nil { + return x.IsDie + } + return false +} + +func (x *SCNianAttackData) GetDieAward() []*RankAwardData { + if x != nil { + return x.DieAward + } + return nil +} + +func (x *SCNianAttackData) GetBuffCount() int64 { + if x != nil { + return x.BuffCount + } + return 0 +} + +func (x *SCNianAttackData) GetExtraDrop() []*RankAwardData { + if x != nil { + return x.ExtraDrop + } + return nil +} + +func (x *SCNianAttackData) GetFloorReward() []*RankAwardData { + if x != nil { + return x.FloorReward + } + return nil +} + +//领取签到奖励 +//PACKET_CSNianSignAward +type CSNianSignAward struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CSNianSignAward) Reset() { + *x = CSNianSignAward{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CSNianSignAward) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CSNianSignAward) ProtoMessage() {} + +func (x *CSNianSignAward) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CSNianSignAward.ProtoReflect.Descriptor instead. +func (*CSNianSignAward) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{10} +} + +//PACKET_SCNianSignAward +type SCNianSignAward struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SignAwardTime int64 `protobuf:"varint,1,opt,name=SignAwardTime,proto3" json:"SignAwardTime,omitempty"` + SignAward []*RankAwardData `protobuf:"bytes,2,rep,name=SignAward,proto3" json:"SignAward,omitempty"` //签到奖励 +} + +func (x *SCNianSignAward) Reset() { + *x = SCNianSignAward{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_activity_nian_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SCNianSignAward) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCNianSignAward) ProtoMessage() {} + +func (x *SCNianSignAward) ProtoReflect() protoreflect.Message { + mi := &file_protocol_activity_nian_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SCNianSignAward.ProtoReflect.Descriptor instead. +func (*SCNianSignAward) Descriptor() ([]byte, []int) { + return file_protocol_activity_nian_proto_rawDescGZIP(), []int{11} +} + +func (x *SCNianSignAward) GetSignAwardTime() int64 { + if x != nil { + return x.SignAwardTime + } + return 0 +} + +func (x *SCNianSignAward) GetSignAward() []*RankAwardData { + if x != nil { + return x.SignAward + } + return nil +} + +var File_protocol_activity_nian_proto protoreflect.FileDescriptor + +var file_protocol_activity_nian_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x61, 0x63, 0x74, 0x69, 0x76, + 0x69, 0x74, 0x79, 0x2f, 0x6e, 0x69, 0x61, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x22, 0x0c, 0x0a, 0x0a, 0x43, 0x53, 0x4e, 0x69, + 0x61, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x22, 0xdc, 0x02, 0x0a, 0x0a, 0x53, 0x43, 0x4e, 0x69, 0x61, + 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x11, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x11, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x28, 0x0a, 0x0f, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x45, + 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x41, 0x63, + 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x42, 0x6f, 0x73, 0x73, 0x4d, 0x61, 0x78, 0x48, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x09, 0x42, 0x6f, 0x73, 0x73, 0x4d, 0x61, 0x78, 0x48, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x42, + 0x6f, 0x73, 0x73, 0x48, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x42, 0x6f, 0x73, + 0x73, 0x48, 0x70, 0x12, 0x2e, 0x0a, 0x08, 0x4c, 0x75, 0x63, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, + 0x2e, 0x52, 0x61, 0x6e, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x52, 0x08, 0x4c, 0x75, 0x63, 0x6b, 0x44, + 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x1e, 0x0a, 0x0a, 0x42, 0x75, 0x66, 0x66, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x42, 0x75, 0x66, 0x66, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x0e, 0x0a, 0x02, 0x4f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x4f, 0x6e, 0x12, + 0x24, 0x0a, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, + 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x42, + 0x75, 0x66, 0x66, 0x22, 0x2a, 0x0a, 0x0a, 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, 0x42, 0x75, 0x66, + 0x66, 0x12, 0x1c, 0x0a, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, + 0x28, 0x0a, 0x0e, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x52, 0x61, 0x6e, 0x6b, 0x44, 0x61, 0x74, + 0x61, 0x12, 0x16, 0x0a, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x22, 0x50, 0x0a, 0x0e, 0x53, 0x43, 0x4e, + 0x69, 0x61, 0x6e, 0x52, 0x61, 0x6e, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x54, + 0x79, 0x70, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x54, 0x79, 0x70, + 0x65, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, 0x6e, + 0x6b, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x44, 0x61, 0x74, 0x61, 0x22, 0x8f, 0x01, 0x0a, 0x08, + 0x52, 0x61, 0x6e, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x52, 0x61, 0x6e, 0x6b, + 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x52, 0x61, 0x6e, 0x6b, 0x49, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x49, 0x63, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x04, 0x49, 0x63, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x53, 0x63, 0x6f, 0x72, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x2d, + 0x0a, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, 0x6e, 0x6b, 0x41, 0x77, 0x61, + 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x22, 0x41, 0x0a, + 0x0d, 0x52, 0x61, 0x6e, 0x6b, 0x41, 0x77, 0x61, 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x12, 0x16, + 0x0a, 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, + 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x49, 0x74, 0x65, 0x6d, 0x4e, 0x75, + 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x49, 0x74, 0x65, 0x6d, 0x4e, 0x75, 0x6d, + 0x22, 0x26, 0x0a, 0x0c, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, + 0x12, 0x16, 0x0a, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x22, 0xe8, 0x02, 0x0a, 0x10, 0x53, 0x43, 0x4e, + 0x69, 0x61, 0x6e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, + 0x06, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x54, + 0x79, 0x70, 0x65, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x42, 0x6f, 0x73, 0x73, 0x48, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x42, 0x6f, 0x73, 0x73, 0x48, 0x70, 0x12, 0x2d, 0x0a, + 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, + 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, 0x6e, 0x6b, 0x41, 0x77, 0x61, 0x72, + 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x12, 0x1a, 0x0a, 0x08, + 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x48, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, + 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x48, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x73, 0x44, 0x69, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x49, 0x73, 0x44, 0x69, 0x65, 0x12, 0x33, + 0x0a, 0x08, 0x44, 0x69, 0x65, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, 0x6e, 0x6b, + 0x41, 0x77, 0x61, 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x08, 0x44, 0x69, 0x65, 0x41, 0x77, + 0x61, 0x72, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x42, 0x75, 0x66, 0x66, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x12, 0x35, 0x0a, 0x09, 0x45, 0x78, 0x74, 0x72, 0x61, 0x44, 0x72, 0x6f, 0x70, 0x18, 0x08, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, + 0x52, 0x61, 0x6e, 0x6b, 0x41, 0x77, 0x61, 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x09, 0x45, + 0x78, 0x74, 0x72, 0x61, 0x44, 0x72, 0x6f, 0x70, 0x12, 0x39, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x6f, + 0x72, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, 0x6e, 0x6b, 0x41, 0x77, 0x61, + 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x46, 0x6c, 0x6f, 0x6f, 0x72, 0x52, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x22, 0x11, 0x0a, 0x0f, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x53, 0x69, 0x67, + 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x22, 0x6e, 0x0a, 0x0f, 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, + 0x53, 0x69, 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x69, 0x67, + 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, + 0x35, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2e, 0x52, 0x61, + 0x6e, 0x6b, 0x41, 0x77, 0x61, 0x72, 0x64, 0x44, 0x61, 0x74, 0x61, 0x52, 0x09, 0x53, 0x69, 0x67, + 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x2a, 0xae, 0x02, 0x0a, 0x0c, 0x4e, 0x69, 0x61, 0x6e, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x44, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x41, 0x43, 0x4b, 0x45, + 0x54, 0x5f, 0x4e, 0x69, 0x61, 0x6e, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x16, 0x0a, + 0x11, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x44, 0x61, + 0x74, 0x61, 0x10, 0xe4, 0x14, 0x12, 0x16, 0x0a, 0x11, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, + 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x10, 0xe5, 0x14, 0x12, 0x16, 0x0a, + 0x11, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x42, 0x75, + 0x66, 0x66, 0x10, 0xe6, 0x14, 0x12, 0x16, 0x0a, 0x11, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, + 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, 0x42, 0x75, 0x66, 0x66, 0x10, 0xe7, 0x14, 0x12, 0x1a, 0x0a, + 0x15, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x52, 0x61, + 0x6e, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x10, 0xe8, 0x14, 0x12, 0x1a, 0x0a, 0x15, 0x50, 0x41, 0x43, + 0x4b, 0x45, 0x54, 0x5f, 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, 0x52, 0x61, 0x6e, 0x6b, 0x44, 0x61, + 0x74, 0x61, 0x10, 0xe9, 0x14, 0x12, 0x18, 0x0a, 0x13, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, + 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x10, 0xea, 0x14, 0x12, + 0x1c, 0x0a, 0x17, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, + 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x10, 0xeb, 0x14, 0x12, 0x1b, 0x0a, + 0x16, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x43, 0x53, 0x4e, 0x69, 0x61, 0x6e, 0x53, 0x69, + 0x67, 0x6e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x10, 0xec, 0x14, 0x12, 0x1b, 0x0a, 0x16, 0x50, 0x41, + 0x43, 0x4b, 0x45, 0x54, 0x5f, 0x53, 0x43, 0x4e, 0x69, 0x61, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x41, + 0x77, 0x61, 0x72, 0x64, 0x10, 0xed, 0x14, 0x42, 0x28, 0x5a, 0x26, 0x6d, 0x6f, 0x6e, 0x67, 0x6f, + 0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x6d, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_protocol_activity_nian_proto_rawDescOnce sync.Once + file_protocol_activity_nian_proto_rawDescData = file_protocol_activity_nian_proto_rawDesc +) + +func file_protocol_activity_nian_proto_rawDescGZIP() []byte { + file_protocol_activity_nian_proto_rawDescOnce.Do(func() { + file_protocol_activity_nian_proto_rawDescData = protoimpl.X.CompressGZIP(file_protocol_activity_nian_proto_rawDescData) + }) + return file_protocol_activity_nian_proto_rawDescData +} + +var file_protocol_activity_nian_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_protocol_activity_nian_proto_msgTypes = make([]protoimpl.MessageInfo, 12) +var file_protocol_activity_nian_proto_goTypes = []interface{}{ + (NianPacketID)(0), // 0: activity.NianPacketID + (*CSNianData)(nil), // 1: activity.CSNianData + (*SCNianData)(nil), // 2: activity.SCNianData + (*CSNianBuff)(nil), // 3: activity.CSNianBuff + (*SCNianBuff)(nil), // 4: activity.SCNianBuff + (*CSNianRankData)(nil), // 5: activity.CSNianRankData + (*SCNianRankData)(nil), // 6: activity.SCNianRankData + (*RankData)(nil), // 7: activity.RankData + (*RankAwardData)(nil), // 8: activity.RankAwardData + (*CSNianAttack)(nil), // 9: activity.CSNianAttack + (*SCNianAttackData)(nil), // 10: activity.SCNianAttackData + (*CSNianSignAward)(nil), // 11: activity.CSNianSignAward + (*SCNianSignAward)(nil), // 12: activity.SCNianSignAward +} +var file_protocol_activity_nian_proto_depIdxs = []int32{ + 7, // 0: activity.SCNianData.LuckData:type_name -> activity.RankData + 7, // 1: activity.SCNianRankData.Data:type_name -> activity.RankData + 8, // 2: activity.RankData.Award:type_name -> activity.RankAwardData + 8, // 3: activity.SCNianAttackData.Award:type_name -> activity.RankAwardData + 8, // 4: activity.SCNianAttackData.DieAward:type_name -> activity.RankAwardData + 8, // 5: activity.SCNianAttackData.ExtraDrop:type_name -> activity.RankAwardData + 8, // 6: activity.SCNianAttackData.FloorReward:type_name -> activity.RankAwardData + 8, // 7: activity.SCNianSignAward.SignAward:type_name -> activity.RankAwardData + 8, // [8:8] is the sub-list for method output_type + 8, // [8:8] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name +} + +func init() { file_protocol_activity_nian_proto_init() } +func file_protocol_activity_nian_proto_init() { + if File_protocol_activity_nian_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_protocol_activity_nian_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CSNianData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SCNianData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CSNianBuff); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SCNianBuff); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CSNianRankData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SCNianRankData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RankData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RankAwardData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CSNianAttack); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SCNianAttackData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CSNianSignAward); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_activity_nian_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SCNianSignAward); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_protocol_activity_nian_proto_rawDesc, + NumEnums: 1, + NumMessages: 12, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_protocol_activity_nian_proto_goTypes, + DependencyIndexes: file_protocol_activity_nian_proto_depIdxs, + EnumInfos: file_protocol_activity_nian_proto_enumTypes, + MessageInfos: file_protocol_activity_nian_proto_msgTypes, + }.Build() + File_protocol_activity_nian_proto = out.File + file_protocol_activity_nian_proto_rawDesc = nil + file_protocol_activity_nian_proto_goTypes = nil + file_protocol_activity_nian_proto_depIdxs = nil +} diff --git a/protocol/activity/nian.proto b/protocol/activity/nian.proto new file mode 100644 index 0000000..12f2b76 --- /dev/null +++ b/protocol/activity/nian.proto @@ -0,0 +1,93 @@ +syntax = "proto3"; +package activity; +option go_package = "mongo.games.com/game/protocol/activity"; + +enum NianPacketID { + PACKET_Nian_ZERO = 0; // 弃用消息号 + PACKET_CSNianData = 2660; // 获取年兽信息 + PACKET_SCNianData = 2661; // 返回年兽信息 + PACKET_CSNianBuff = 2662; // 请求领取BUFF + PACKET_SCNianBuff = 2663; // 返回Buff信息 + PACKET_CSNianRankData = 2664; // 请求排行榜信息 + PACKET_SCNianRankData = 2665; // 返回排行榜信息 + PACKET_CSNianAttack = 2666; //请求攻击年兽 + PACKET_SCNianAttackData = 2667; //返回攻击年兽信息 + PACKET_CSNianSignAward = 2668; //请求签到 + PACKET_SCNianSignAward = 2669; //签到返回 +} + +//获取年兽活动信息 +//PACKET_CSNianData +message CSNianData{ +} +//PACKET_SCNianData +message SCNianData{ + int64 ActivityStartTime = 1; //活动开始时间 + int64 ActivityEndTime = 2; //活动结束时间 + int64 BossMaxHp = 3; //Boss最大血量 + int64 BossHp = 4; //Boss当前血量 + repeated RankData LuckData = 5;//幸运榜 + int64 AwardTime = 6;//每日签到领取时间 + int64 BuffCount = 7;//Buff剩余次数 + bool BuffStatus = 8;//Buff领取状态 + int32 On = 9;//活动开关 1开启 2关闭 + int64 SignAwardTime = 10;//签到领取时间 0-未领取 +} + +//贺春 +//请求领取BUFF +//PACKET_CSNianBuff +message CSNianBuff{ +} +//PACKET_SCNianBuff +message SCNianBuff{ + int64 BuffCount = 1; //BUFF剩余次数 +} +//排行榜数据 +//PACKET_CSNianRankData +message CSNianRankData{ + int32 TypeId = 1;//1-幸运榜 2-总伤害榜 +} +//PACKET_SCNianRankData +message SCNianRankData{ + int32 TypeId = 1; + repeated RankData Data = 2; +} +message RankData{ + int32 RankId =1; + string Name = 2; + int32 Icon = 3; + int64 Score = 4; + repeated RankAwardData Award = 5; +} + +message RankAwardData{ + int32 ItemId =1; + int64 ItemNum = 2; +} +//攻击年兽 +//PACKET_CSNianAttack +message CSNianAttack{ + int32 TypeId = 1; //1-小爆竹 2-小爆竹*10 3-大爆竹 +} +//PACKET_SCNianAttackData +message SCNianAttackData{ + int32 TypeId = 1; //1-小爆竹 2-小爆竹*10 3-大爆竹 + int64 BossHp = 2; //BOSS当前血量 + repeated RankAwardData Award = 3; //获得道具 + int64 AttackHp = 4; // 攻击伤害 + bool IsDie = 5; //BOSS是否死亡 + repeated RankAwardData DieAward = 6;//BOSS死亡奖励 + int64 BuffCount = 7; //BUFF剩余次数 + repeated RankAwardData ExtraDrop = 8;//大爆竹额外掉落 + repeated RankAwardData FloorReward = 9;//保底奖励 +} +//领取签到奖励 +//PACKET_CSNianSignAward +message CSNianSignAward{ +} +//PACKET_SCNianSignAward +message SCNianSignAward{ + int64 SignAwardTime = 1; + repeated RankAwardData SignAward = 2;//签到奖励 +} \ No newline at end of file diff --git a/protocol/server/pbdata.proto b/protocol/server/pbdata.proto index bd35af5..531f3fd 100644 --- a/protocol/server/pbdata.proto +++ b/protocol/server/pbdata.proto @@ -1263,6 +1263,38 @@ message DB_NewPlayerArray { repeated DB_NewPlayer Arr = 1; } +message DB_NewYearActivity { + + int32 Id = 1; + + string PorpName = 2; + + string PropValue = 3; + + string PropDec = 4; + +} + +message DB_NewYearActivityArray { + repeated DB_NewYearActivity Arr = 1; +} + +message DB_NewYearRankReward { + + int32 Id = 1; + + int32 RankType = 2; + + int32 RankLevelId = 3; + + map AwardMap = 4; + +} + +message DB_NewYearRankRewardArray { + repeated DB_NewYearRankReward Arr = 1; +} + message DB_PassShow { int32 Id = 1; diff --git a/protocol/task/task.proto b/protocol/task/task.proto index 2f7f359..88b4474 100644 --- a/protocol/task/task.proto +++ b/protocol/task/task.proto @@ -44,7 +44,7 @@ message SCTaskList{ // 领取任务奖励 // PACKET_CSTaskReward message CSTaskReward{ - int32 Tp = 1; // 任务类型 1:日常任务 2:周活跃任务 3:新手任务 4:邀请任务 5:成就系统 6:赛季通行证任务 + int32 Tp = 1; // 任务类型 1:日常任务 2:周活跃任务 3:新手任务 4:邀请任务 5:成就系统 6:赛季通行证任务 8: 年兽每日任务 9：年兽活动任务 int32 Id = 2; // 任务id; 0 表示一键领取 } // PACKET_SCTaskReward diff --git a/protocol/webapi/common.proto b/protocol/webapi/common.proto index 7f20107..69bb367 100644 --- a/protocol/webapi/common.proto +++ b/protocol/webapi/common.proto @@ -1096,4 +1096,27 @@ message PigBankPropInfo { message GamePigBankPropConfig{ string Platform = 1; // 平台 repeated PigBankPropInfo PropInfo = 2; // 存钱罐属性 +} +//etcd /game/activity_nian +message ActivityNianConfig { + string Platform = 1; // 平台 + repeated NianInfo List = 2; + int32 Switch = 3; // 活动开关 1.开启 2.关闭 +} + +message NianInfo{ + string ActivityStart = 1; // 活动开始时间 + string ActivityEnd = 2; // 活动结束时间 + int64 BuffStartTime = 3; //Buff领取开始时间 18 + int64 BuffEndTime = 4; //Buff领取结束时间 21 + repeated ItemInfo SignReward = 5; // 签到奖励 + repeated ItemInfo BossDieReward = 6; // 击杀BOSS奖励 + repeated NianDropInfo BossDieOtherReward = 7; // 击杀Boss额外奖励 +} +message NianDropInfo{ + int32 Id = 1; + int32 ItemId = 2; // 物品ID + int64 ItemNum = 3; // 物品数量 + int32 DropRate = 4;//掉落概率 + int32 DropUp = 5;//掉落上限 } \ No newline at end of file diff --git a/srvdata/db_newyearactivity.go b/srvdata/db_newyearactivity.go new file mode 100644 index 0000000..b7224d7 --- /dev/null +++ b/srvdata/db_newyearactivity.go @@ -0,0 +1,77 @@ + +// Code generated by xlsx2proto. +// DO NOT EDIT! + +package srvdata + +import ( + "google.golang.org/protobuf/proto" + + "mongo.games.com/game/protocol/server" +) + +var PBDB_NewYearActivityMgr = &DB_NewYearActivityMgr{ + Datas: &server.DB_NewYearActivityArray{}, + pool: make(map[int32]*server.DB_NewYearActivity), + +} + +type DB_NewYearActivityMgr struct { + Datas *server.DB_NewYearActivityArray + pool map[int32]*server.DB_NewYearActivity + +} + +func (this *DB_NewYearActivityMgr) unmarshal(data []byte) error { + err := proto.Unmarshal(data, this.Datas) + if err == nil { + this.arrangeData() + } + return err +} + +func (this *DB_NewYearActivityMgr) reunmarshal(data []byte) error { + newDatas := &server.DB_NewYearActivityArray{} + err := proto.Unmarshal(data, newDatas) + if err == nil { + for _, item := range newDatas.Arr { + existItem := this.GetData(item.GetId()) + if existItem == nil { + this.pool[item.GetId()] = item + this.Datas.Arr = append(this.Datas.Arr, item) + + } else { + *existItem = *item + } + } + } + return err +} + +func (this *DB_NewYearActivityMgr) arrangeData() { + if this.Datas == nil { + return + } + + dataArr := this.Datas.GetArr() + if dataArr == nil { + return + } + + for _, data := range dataArr { + this.pool[data.GetId()] = data + + } +} + +func (this *DB_NewYearActivityMgr) GetData(id int32) *server.DB_NewYearActivity { + if data, ok := this.pool[id]; ok { + return data + } + return nil +} + + +func init() { + DataMgr.register("DB_NewYearActivity.dat", &ProtobufDataLoader{dh: PBDB_NewYearActivityMgr}) +} diff --git a/srvdata/db_newyearrankreward.go b/srvdata/db_newyearrankreward.go new file mode 100644 index 0000000..38c579f --- /dev/null +++ b/srvdata/db_newyearrankreward.go @@ -0,0 +1,77 @@ + +// Code generated by xlsx2proto. +// DO NOT EDIT! + +package srvdata + +import ( + "google.golang.org/protobuf/proto" + + "mongo.games.com/game/protocol/server" +) + +var PBDB_NewYearRankRewardMgr = &DB_NewYearRankRewardMgr{ + Datas: &server.DB_NewYearRankRewardArray{}, + pool: make(map[int32]*server.DB_NewYearRankReward), + +} + +type DB_NewYearRankRewardMgr struct { + Datas *server.DB_NewYearRankRewardArray + pool map[int32]*server.DB_NewYearRankReward + +} + +func (this *DB_NewYearRankRewardMgr) unmarshal(data []byte) error { + err := proto.Unmarshal(data, this.Datas) + if err == nil { + this.arrangeData() + } + return err +} + +func (this *DB_NewYearRankRewardMgr) reunmarshal(data []byte) error { + newDatas := &server.DB_NewYearRankRewardArray{} + err := proto.Unmarshal(data, newDatas) + if err == nil { + for _, item := range newDatas.Arr { + existItem := this.GetData(item.GetId()) + if existItem == nil { + this.pool[item.GetId()] = item + this.Datas.Arr = append(this.Datas.Arr, item) + + } else { + *existItem = *item + } + } + } + return err +} + +func (this *DB_NewYearRankRewardMgr) arrangeData() { + if this.Datas == nil { + return + } + + dataArr := this.Datas.GetArr() + if dataArr == nil { + return + } + + for _, data := range dataArr { + this.pool[data.GetId()] = data + + } +} + +func (this *DB_NewYearRankRewardMgr) GetData(id int32) *server.DB_NewYearRankReward { + if data, ok := this.pool[id]; ok { + return data + } + return nil +} + + +func init() { + DataMgr.register("DB_NewYearRankReward.dat", &ProtobufDataLoader{dh: PBDB_NewYearRankRewardMgr}) +} diff --git a/worldsrv/action_nian.go b/worldsrv/action_nian.go new file mode 100644 index 0000000..ca15794 --- /dev/null +++ b/worldsrv/action_nian.go @@ -0,0 +1,505 @@ +package main + +import ( + "math/rand" + "mongo.games.com/game/common" + "mongo.games.com/game/model" + "mongo.games.com/game/protocol/activity" + "mongo.games.com/game/srvdata" + "mongo.games.com/goserver/core/logger" + "mongo.games.com/goserver/core/netlib" + "strconv" + "strings" + "time" +) + +// 请求年兽信息 +func CSNianData(s *netlib.Session, packetid int, data interface{}, sid int64) error { + if _, ok := data.(*activity.CSNianData); ok { + p := PlayerMgrSington.GetOnlinePlayer(sid) + sData := srvdata.PBDB_NewYearActivityMgr.Datas.GetArr() + BossMaxHp := int64(0) + for _, value := range sData { + if value.Id == 5 { + BossMaxHp, _ = strconv.ParseInt(value.PropValue, 10, 64) + break + } + } + logger.Logger.Trace("请求年兽信息！snid = ", p.SnId) + if p == nil { + logger.Logger.Warn("CSNianData p == nil") + return nil + } + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil || pool.Switch == model.WelfareClose { + return nil + } + startTime := pool.List[0].ActivityStart + endTime := pool.List[0].ActivityEnd + start, _ := time.Parse(time.DateTime, startTime) + // 转换为时间戳（以秒为单位） + timestamp := start.Unix() + end, _ := time.Parse(time.DateTime, endTime) + endTimestamp := end.Unix() + + if p.WelfData.NianData != nil && (p.WelfData.NianData.ActivityStartTime != timestamp || p.WelfData.NianData.ActivityEndTime != endTimestamp) { + logger.Logger.Infof("CSNianData 年兽活动时间变更 清除之前数据 snid= %d", p.SnId) + WelfareMgrSington.ClearActivityNianData(p) + } + + if p.WelfData.NianData == nil { + p.WelfData.NianData = &model.NianData{ + ActivityStartTime: timestamp, + ActivityEndTime: endTimestamp, + } + + } + + if p.WelfData.NianData.BossHp == 0 { + p.WelfData.NianData.BossHp = BossMaxHp + } + pack := &activity.SCNianData{} + pack.BossHp = p.WelfData.NianData.BossHp + pack.BossMaxHp = BossMaxHp + // pack.ActivityStartTime = timestamp + //pack.ActivityEndTime = endTimestamp + pack.ActivityStartTime = 0 + pack.ActivityEndTime = 0 + pack.AwardTime = p.WelfData.NianData.SignAwardTime + pack.BuffCount = p.WelfData.NianData.BuffCount + pack.BuffStatus = p.WelfData.NianData.BuffStatus + pack.LuckData = nil + pack.SignAwardTime = p.WelfData.NianData.SignAwardTime + logger.Logger.Trace("请求年兽活动信息 ", pack) + p.SendToClient(int(activity.NianPacketID_PACKET_SCNianData), pack) + } + return nil +} + +// 攻击年兽 +func CSNianAttack(s *netlib.Session, packetid int, data interface{}, sid int64) error { + if msg, ok := data.(*activity.CSNianAttack); ok { + typeId := msg.TypeId + p := PlayerMgrSington.GetOnlinePlayer(sid) + sData := srvdata.PBDB_NewYearActivityMgr.Datas.GetArr() + BossMaxHp := int64(0) + for _, value := range sData { + if value.Id == 5 { + BossMaxHp, _ = strconv.ParseInt(value.PropValue, 10, 64) + break + } + } + if p.WelfData.NianData == nil { + p.WelfData.NianData = &model.NianData{} + } + if p.WelfData.NianData.BossHp <= 0 { + p.WelfData.NianData.BossHp = BossMaxHp + } + logger.Logger.Trace("客户端请求攻击年兽！snid = ", p.SnId) + if p == nil { + logger.Logger.Warn("CSNianAttack p == nil") + return nil + } + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil { + return nil + } + if pool.Switch == model.WelfareClose { + logger.Logger.Trace("CSNianAttack 活动关闭！") + return nil + } + //判断活动时间 + startTime := pool.List[0].ActivityStart + endTime := pool.List[0].ActivityEnd + t, _ := time.Parse(time.DateTime, startTime) + // 转换为时间戳（以秒为单位） + timestamp := t.Unix() + end, _ := time.Parse(time.DateTime, endTime) + endTimestamp := end.Unix() + nowTime := time.Now().Unix() + if nowTime < timestamp || nowTime > endTimestamp { + return nil + } + + pack := &activity.SCNianAttackData{} + itemId := 0 + itemNum := 1 + count := 1 + if typeId == 1 { + itemId = common.ItemIDLittleGuaranteed + } else if typeId == 2 { + itemId = common.ItemIDLittleGuaranteed + itemNum = 10 + count = 10 + } else if typeId == 3 { + itemId = common.ItemIDBigGuaranteed + } else { + return nil + } + var items []*model.Item + items = append(items, &model.Item{ + ItemId: int32(itemId), + ItemNum: int64(itemNum), + }) + _, _, result := BagMgrSingleton.AddItems(&model.AddItemParam{ + Platform: p.Platform, + SnId: p.SnId, + Change: items, + GainWay: common.GainWayNianCost, + Operator: "system", + Remark: "年兽活动消耗", + }) + if !result { + return nil + } + //本次攻击总血量 + AttackHp := int64(0) + //伤害范围 + var intSlice []int + if typeId == 1 || typeId == 2 { + for _, value := range sData { + if value.Id == 9 { + str := value.PropValue + strSlice := strings.Split(str, ",") + // 转换每个字符串为 int + for _, s := range strSlice { + num, err := strconv.Atoi(s) + if err != nil { + return nil + } + intSlice = append(intSlice, num) + } + break + } + } + } + //保底奖励次数 + floorCount := 0 + for _, value := range sData { + if typeId == 1 || typeId == 2 { + if value.Id == 13 { + floorCount, _ = strconv.Atoi(value.PropValue) + break + } + } else { + if value.Id == 15 { + floorCount, _ = strconv.Atoi(value.PropValue) + break + } + } + } + if typeId == 3 { + for _, value := range sData { + if value.Id == 10 { + str := value.PropValue + strSlice := strings.Split(str, ",") + // 转换每个字符串为 int + for _, s := range strSlice { + num, err := strconv.Atoi(s) + if err != nil { + return nil + } + intSlice = append(intSlice, num) + } + break + } + } + } + awardInfo := &activity.RankAwardData{} + + for i := 0; i < count; i++ { + //随机伤害值 + randomValue := int64(rand.Intn(intSlice[1]-intSlice[0]+1) + intSlice[0]) + logger.Logger.Tracef("随机到的伤害值是：%d", randomValue) + //计算BUFF + if p.WelfData.NianData.BuffCount > 0 { + randomValue = randomValue + randomValue/2 + p.WelfData.NianData.BuffCount -= 1 + } + AttackHp += randomValue + if typeId == 3 { + p.WelfData.NianData.BigHurt += 1 + //判断是否掉落保底奖励 + if p.WelfData.NianData.BigHurt%int32(floorCount) == 0 { + floorReward := &activity.RankAwardData{} + for _, value := range sData { + if value.Id == 16 { + strSlice := strings.Split(value.PropValue, ",") + FloorItemId, _ := strconv.Atoi(strSlice[0]) + FloorItemNum, _ := strconv.Atoi(strSlice[1]) + items = append(items, &model.Item{ + ItemId: int32(FloorItemId), + ItemNum: int64(FloorItemNum), + }) + floorReward.ItemId = int32(FloorItemId) + floorReward.ItemNum = int64(FloorItemNum) + pack.FloorReward = append(pack.FloorReward, floorReward) + break + } + } + } + //额外掉落 + extraItemId := 0 + extraItemNum := 0 + var intSlice1 []int + for _, value := range sData { + if value.Id == 11 { + extraItemId, _ = strconv.Atoi(value.PropValue) + break + } + } + for _, value := range sData { + if value.Id == 12 { + str := value.PropValue + strSlice := strings.Split(str, ",") + // 转换每个字符串为 int + for _, s := range strSlice { + num, err := strconv.Atoi(s) + if err != nil { + return nil + } + intSlice1 = append(intSlice1, num) + } + break + } + } + //随机个数 + extraItemNum = rand.Intn(intSlice1[1]-intSlice1[0]+1) + intSlice1[0] + items = append(items, &model.Item{ + ItemId: int32(extraItemId), + ItemNum: int64(extraItemNum), + }) + extraDrop := &activity.RankAwardData{} + extraDrop.ItemId = int32(extraItemId) + extraDrop.ItemNum = int64(extraItemNum) + pack.ExtraDrop = append(pack.ExtraDrop, extraDrop) + } else { + p.WelfData.NianData.LittleHurt += 1 + //判断是否掉落保底奖励 + if p.WelfData.NianData.LittleHurt%int32(floorCount) == 0 { + floorReward := &activity.RankAwardData{} + for _, value := range sData { + if value.Id == 14 { + strSlice := strings.Split(value.PropValue, ",") + FloorItemId, _ := strconv.Atoi(strSlice[0]) + FloorItemNum, _ := strconv.Atoi(strSlice[1]) + items = append(items, &model.Item{ + ItemId: int32(FloorItemId), + ItemNum: int64(FloorItemNum), + }) + floorReward.ItemId = int32(FloorItemId) + floorReward.ItemNum = int64(FloorItemNum) + pack.FloorReward = append(pack.FloorReward, floorReward) + break + } + } + } + } + //上榜 幸运榜 总榜 + + } + p.WelfData.NianData.BossHp -= AttackHp + isDie := false //是否死亡 + //判断Boss是否死亡 + var bossDieAward []*model.Item + if p.WelfData.NianData.BossHp <= 0 { + isDie = true + p.WelfData.NianData.BossHp = BossMaxHp + p.WelfData.NianData.BossDieCount += 1 + //获取死亡奖励 + for _, value := range sData { + if value.Id == 6 { + str := value.PropValue + strSlice := strings.Split(str, ";") + for _, s := range strSlice { + strSlice1 := strings.Split(s, ",") + bossDieItemId, err := strconv.Atoi(strSlice1[0]) + if err != nil { + return nil + } + bossDieItemNum, err := strconv.ParseInt(strSlice1[1], 10, 64) + if err != nil { + return nil + } + bossDieAward = append(bossDieAward, &model.Item{ + ItemId: int32(bossDieItemId), + ItemNum: bossDieItemNum, + }) + items = append(items, &model.Item{ + ItemId: int32(bossDieItemId), + ItemNum: bossDieItemNum, + }) + } + break + } + } + //年兽死亡额外掉落 + BigHurtCount := 0 + for _, value := range sData { + if value.Id == 19 { + BigHurtCount, _ = strconv.Atoi(value.PropValue) + break + } + } + logger.Logger.Trace("年兽死亡额外掉落 当前已使用BigHurt ：", p.WelfData.NianData.BigHurt, "BigHurtCount = ", BigHurtCount) + if p.WelfData.NianData.BigHurt >= int32(BigHurtCount) { + //后台配置额外掉落 + for _, info := range pool.List[0].BossDieOtherReward { + //value.BossDieOtherReward + if p.WelfData.NianData.OtherAwardNum[info.Id] >= info.DropUp { + logger.Logger.Trace("BOSS死亡 额外掉落达到上限 id = ", info.Id, "数量：", p.WelfData.NianData.OtherAwardNum[info.Id]) + continue + } + //随机 + if rand.Intn(100) < int(info.DropRate) { + otherItemId := info.ItemId + otherItemNum := info.ItemNum + if int32(otherItemNum)+p.WelfData.NianData.OtherAwardNum[info.Id] > info.DropUp { + otherItemNum = int64(info.DropUp - p.WelfData.NianData.OtherAwardNum[info.Id]) + } + p.WelfData.NianData.OtherAwardNum[info.Id] += int32(otherItemNum) + items = append(items, &model.Item{ + ItemId: otherItemId, + ItemNum: otherItemNum, + }) + bossDieAward = append(bossDieAward, &model.Item{ + ItemId: otherItemId, + ItemNum: otherItemNum, + }) + } + } + } + } + + items = append(items, &model.Item{ + ItemId: common.ItemIDCoin, + ItemNum: AttackHp, + }) + BagMgrSingleton.AddItems(&model.AddItemParam{ + Platform: p.Platform, + SnId: p.SnId, + Change: items, + GainWay: common.GainWayNianGain, + Operator: "system", + Remark: "年兽活动-攻击年兽获得", + }) + awardInfo.ItemId = common.ItemIDCoin + awardInfo.ItemNum = AttackHp + pack.Award = append(pack.Award, awardInfo) + pack.AttackHp = AttackHp + pack.TypeId = typeId + pack.BossHp = p.WelfData.NianData.BossHp + pack.IsDie = isDie + for _, item := range bossDieAward { + dieInfo := &activity.RankAwardData{} + dieInfo.ItemId = item.ItemId + dieInfo.ItemNum = item.ItemNum + pack.DieAward = append(pack.DieAward, dieInfo) + } + pack.BuffCount = p.WelfData.NianData.BuffCount + p.SendToClient(int(activity.NianPacketID_PACKET_SCNianAttackData), pack) + } + return nil +} + +// 请求领取BUFF +func CSNianBuff(s *netlib.Session, packetid int, data interface{}, sid int64) error { + if _, ok := data.(*activity.CSNianBuff); ok { + p := PlayerMgrSington.GetOnlinePlayer(sid) + //yearActivity := &server.DB_NewYearActivity{} + logger.Logger.Trace("客户端请求请求领取BUFF snid = ", p.SnId) + if p == nil { + return nil + } + if p.WelfData.NianData == nil { + p.WelfData.NianData = &model.NianData{} + } + if p.WelfData.NianData.BuffStatus { + return nil + } + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil { + return nil + } + if pool.Switch == model.WelfareClose { + logger.Logger.Trace("CSNianSignAward 活动关闭！") + return nil + } + //判断领取时间 + if time.Now().Hour() >= int(pool.List[0].BuffStartTime) && time.Now().Hour() <= int(pool.List[0].BuffEndTime) { + sData := srvdata.PBDB_NewYearActivityMgr.Datas.GetArr() + count := int64(0) + for _, value := range sData { + if value.Id == 20 { + count, _ = strconv.ParseInt(value.PropValue, 10, 64) + break + } + } + p.WelfData.NianData.BuffCount = count + p.WelfData.NianData.BuffStatus = true + pack := &activity.SCNianBuff{ + BuffCount: p.WelfData.NianData.BuffCount, + } + p.SendToClient(int(activity.NianPacketID_PACKET_SCNianBuff), pack) + } + } + return nil +} + +// 领取签到奖励 +func CSNianSignAward(s *netlib.Session, packetid int, data interface{}, sid int64) error { + if _, ok := data.(*activity.CSNianBuff); ok { + p := PlayerMgrSington.GetOnlinePlayer(sid) + logger.Logger.Trace("客户端请求请求领取BUFF snid = ", p.SnId) + if p == nil { + return nil + } + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil { + return nil + } + if pool.Switch == model.WelfareClose { + logger.Logger.Trace("CSNianSignAward 活动关闭！") + return nil + } + if p.WelfData.NianData == nil { + p.WelfData.NianData = &model.NianData{} + } + if p.WelfData.NianData.SignAwardTime > 0 { + return nil + } + p.WelfData.NianData.SignAwardTime = time.Now().Unix() + //奖励 + pack := &activity.SCNianSignAward{} + pack.SignAwardTime = p.WelfData.NianData.SignAwardTime + var items []*model.Item + for _, info := range pool.List[0].SignReward { + items = append(items, &model.Item{ + ItemId: info.ItemId, + ItemNum: info.ItemNum, + }) + award := &activity.RankAwardData{} + award.ItemId = info.ItemId + award.ItemNum = info.ItemNum + pack.SignAward = append(pack.SignAward, award) + } + + BagMgrSingleton.AddItems(&model.AddItemParam{ + Platform: p.Platform, + SnId: p.SnId, + Change: items, + GainWay: common.GainWayNianGain, + Operator: "system", + Remark: "年兽活动-领取签到奖励获得", + }) + p.SendToClient(int(activity.NianPacketID_PACKET_SCNianSignAward), pack) + } + return nil +} + +func init() { + common.Register(int(activity.NianPacketID_PACKET_CSNianData), activity.CSNianData{}, CSNianData) + common.Register(int(activity.NianPacketID_PACKET_CSNianAttack), activity.CSNianAttack{}, CSNianAttack) + common.Register(int(activity.NianPacketID_PACKET_CSNianBuff), activity.CSNianBuff{}, CSNianBuff) + common.Register(int(activity.NianPacketID_PACKET_CSNianSignAward), activity.CSNianSignAward{}, CSNianSignAward) +} diff --git a/worldsrv/action_task.go b/worldsrv/action_task.go index a88863d..877bea5 100644 --- a/worldsrv/action_task.go +++ b/worldsrv/action_task.go @@ -53,7 +53,7 @@ func IsTaskReward(p *Player, id int32) bool { if data := p.WelfData.Task[id]; data != nil && data.Ts > 0 { t := srvdata.PBDB_TaskMgr.GetData(id) switch t.ActivityType { - case common.TaskActivityTypeEveryDay, common.TaskActivityTypePermitEveryDay: + case common.TaskActivityTypeEveryDay, common.TaskActivityTypePermitEveryDay, common.TaskActivityTypeNianEveryDay: if common.TsInSameDay(time.Now().Unix(), data.Ts) { return true } @@ -74,6 +74,24 @@ func IsTaskReward(p *Player, id int32) bool { return data.Ts >= startTs && data.Ts < endTs } return true + case common.TaskActivityTypeNian: + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil { + return false + } + if pool.Switch == model.WelfareClose { + return false + } + startTime := pool.List[0].ActivityStart + endTime := pool.List[0].ActivityEnd + start, _ := time.Parse(time.DateTime, startTime) + timestamp := start.Unix() + end, _ := time.Parse(time.DateTime, endTime) + endTimestamp := end.Unix() + if timestamp > 0 { + return data.Ts >= timestamp && data.Ts < endTimestamp + } + return true } } } diff --git a/worldsrv/etcd.go b/worldsrv/etcd.go index c637fbe..e6ad23f 100644 --- a/worldsrv/etcd.go +++ b/worldsrv/etcd.go @@ -110,6 +110,8 @@ func init() { etcd.Register(etcd.ETCDKEY_PigBankDiamond, webapi.GamePigBankDiamondConfig{}, platformConfigEvent) // 存钱罐属性值 etcd.Register(etcd.ETCDKEY_PigBankProp, webapi.GamePigBankPropConfig{}, platformConfigEvent) + //年兽配置 + etcd.Register(etcd.ETCDKEY_NianConfig, webapi.ActivityNianConfig{}, platformConfigEvent) } @@ -356,6 +358,8 @@ func platformConfigEvent(ctx context.Context, completeKey string, isInit bool, e PlatformMgrSingleton.GetConfig(config.Platform).GamePigBankDiamondConfig = config case *webapi.GamePigBankPropConfig: PlatformMgrSingleton.GetConfig(config.Platform).GamePigBankPropConfig = config + case *webapi.ActivityNianConfig: + WelfareMgrSington.UpdateActivityNianStatus(config) default: logger.Logger.Errorf("etcd completeKey:%s, Not processed", completeKey) } diff --git a/worldsrv/player.go b/worldsrv/player.go index 7839929..bc7eaad 100644 --- a/worldsrv/player.go +++ b/worldsrv/player.go @@ -1681,6 +1681,9 @@ func (this *Player) OnDayTimer(login, continuous bool, t int) { for _, v := range srvdata.TaskMgr.GetActivityType(common.TaskActivityTypePermitEveryDay) { this.WelfData.Task[v.GetId()] = &model.TaskData{} } + for _, v := range srvdata.TaskMgr.GetActivityType(common.TaskActivityTypeNianEveryDay) { + this.WelfData.Task[v.GetId()] = &model.TaskData{} + } } } //周卡数据更新 diff --git a/worldsrv/taskmgr.go b/worldsrv/taskmgr.go index ee42382..356aac8 100644 --- a/worldsrv/taskmgr.go +++ b/worldsrv/taskmgr.go @@ -4,6 +4,7 @@ import ( "container/list" "math" "mongo.games.com/goserver/core/logger" + "time" "mongo.games.com/game/common" "mongo.games.com/game/model" @@ -191,6 +192,25 @@ func (t *TaskHandle) AllTask(id int, data any) { } } } + if v.ActivityType == common.TaskActivityTypeNianEveryDay || v.ActivityType == common.TaskActivityTypeNian { + //判断是否在开启时间段内 + pool := PlatformMgrSingleton.GetConfig(p.Platform).ActivityNianConfig + if pool == nil || pool.List == nil { + continue + } + if pool.Switch == model.WelfareClose { + continue + } + startTime := pool.List[0].ActivityStart + endTime := pool.List[0].ActivityEnd + start, _ := time.Parse(time.DateTime, startTime) + timestamp := start.Unix() + end, _ := time.Parse(time.DateTime, endTime) + endTimestamp := end.Unix() + if time.Now().Unix() < timestamp || time.Now().Unix() > endTimestamp { + continue + } + } if p.WelfData.Task[v.Id] == nil { p.WelfData.Task[v.Id] = &model.TaskData{N: 0} // 初始化任务数据 @@ -292,4 +312,5 @@ func init() { TaskSubjectSingleton.Attach(common.TaskTypeTienlenWinCoin, taskHandle) TaskSubjectSingleton.Attach(common.TaskTypeRankMatchWinTimes, taskHandle) TaskSubjectSingleton.Attach(common.TaskTypeBuyPermit, taskHandle) + TaskSubjectSingleton.Attach(common.TaskTypeBuyRedBag, taskHandle) } diff --git a/worldsrv/welfmgr.go b/worldsrv/welfmgr.go index 352855b..84bb667 100644 --- a/worldsrv/welfmgr.go +++ b/worldsrv/welfmgr.go @@ -291,6 +291,8 @@ func (this *WelfareMgr) OnDayChanged(player *Player) error { // 重置存钱罐 this.DayResetPigBank(player) + //重置年兽 + this.DayReserNian(player) return nil } @@ -305,8 +307,9 @@ func (this *WelfareMgr) MonitorWelfData(player *Player) { player.WelfData.PigBank = &model.PigBankData{} } else if player.WelfData.DiamondBank == nil { player.WelfData.DiamondBank = &model.DiamondBankData{} + } else if player.WelfData.NianData == nil { + player.WelfData.NianData = &model.NianData{} } - } // GetTurnplate 获取转盘奖励 @@ -1004,6 +1007,13 @@ func (this *WelfareMgr) WelfareSwitch(p *Player, platform string, op int) { } else { pack.WelfareSwitch = append(pack.WelfareSwitch, model.WelfareClose) } + //年兽活动 + nianConfig := info.ActivityNianConfig + if nianConfig != nil { + pack.WelfareSwitch = append(pack.WelfareSwitch, nianConfig.Switch) //年兽活动开关 + } else { + pack.WelfareSwitch = append(pack.WelfareSwitch, model.WelfareClose) + } if model.GameParamData.TestActSwitch { for k := range pack.WelfareSwitch { @@ -1118,7 +1128,7 @@ func (this *WelfareMgr) BlindBoxInfo(p *Player, bid int32) { if cyc == 1 || blindBox.Cycle == model.WelfareOpen { p.WelfData.BlindBoxId = 0 } - } // == 1代表当日循环 + } // == 1代表当日循环 if p.WelfData.BlindBoxId == 0 { // 未领取过发随机Date idx := bid @@ -2155,6 +2165,51 @@ func (this *WelfareMgr) UpdateDiamondBankData(p *Player, coinNum int64, isWin bo logger.Logger.Tracef("玩家更新钻石存储罐数据 snid = %d,coinNum = %d,isWin = %s,当前钻石存储罐钻石数量：%f，本次增加钻石数量:%f", p.SnId, coinNum, isWin, p.WelfData.DiamondBank.BankDiamond, addDiamond) } +// 年兽活动 +func (this *WelfareMgr) UpdateActivityNianStatus(cfg *webapi_proto.ActivityNianConfig) { + if model.GameParamData.TestActSwitch { + cfg.Switch = model.WelfareOpen + } + s := int32(0) + info := this.GetConfig(cfg.Platform) + if info.ActivityNianConfig != nil { + s = info.ActivityNianConfig.Switch + } + info.ActivityNianConfig = cfg + //更新活动时间 + // 打开关闭要广播给客户端 + if s != 0 && s != cfg.Switch { + this.WelfareSwitch(nil, cfg.Platform, model.OpNian) + } +} + +// 每日重置年兽 +func (this *WelfareMgr) DayReserNian(p *Player) { + if time.Now().Unix() > p.WelfData.NianData.ActivityEndTime { + this.ClearActivityNianData(p) + } + if p != nil && p.WelfData != nil && p.WelfData.NianData != nil { + p.WelfData.NianData.BuffStatus = false + p.WelfData.NianData.BuffCount = 0 + p.WelfData.NianData.SignAwardTime = 0 + p.WelfData.NianData.OtherAwardNum = make(map[int32]int32) + } + +} + +// 年兽活动结束清除数据 +func (this *WelfareMgr) ClearActivityNianData(p *Player) { + if p != nil && p.WelfData != nil && p.WelfData.NianData != nil { + p.WelfData.NianData = nil + //清除任务数据 + for id, _ := range p.WelfData.Task { + data := srvdata.PBDB_TaskMgr.GetData(id) + if data.ActivityType == common.TaskActivityTypeNianEveryDay || data.ActivityType == common.TaskActivityTypeNian { + p.WelfData.Task[id] = nil + } + } + } +} func (this *WelfareMgr) Update() { } diff --git a/xlsx/DB_GameItem.xlsx b/xlsx/DB_GameItem.xlsx index 6df38f19cf37c13c45b0a3d1e86c380e0cc99427..adf11e3b8a894c94487260a9fadfa0499e73b630 100644 GIT binary patch delta 26720 zcmb@ubySsW*F8)~Nq2XHbR*p@AtEgx(%pH3l%&X}QxrA=0!pV!H!7X#CIzGfNrB(J zv5r3HoacSt?;GP9j&uIl_qx`)=9+V^>)z~PDAMT@q-Pa~fW);0|67O%2v$f42>1vH z2)A9VwB21?J$S5K+^xBNog9Ob2G!bSh$0T|ZsFa@8(?}ajb(S4!_*Kjj%_nCV@5b# zqiw);I_HCYJ;7}KSQ+JerI;5Hkm`7@nEtCPv-dr?39(oFmS^t{+tH)-9H6_)e3mP4 z7nfP-?b%>drUY0}`Y&T3S0ltn?wpx*sP|!_6qT^aW)M|dsp{&P;k+40PqKV^gyjyE zTu;1_O~hf-m0%yE-c>P0qbFSu!Q8NSX~Mr(!=lZ0C_ zzSR$ncgLrpW@RKoV?s9>_6XCG6R#dA3^y6W@ZMj)R~i+VvjEJ8uA@1>QCG=3Hl>I( z?!cyVcHcq|jy9QbSHg#GE%Ap|H7$fS@Ud1i`&U20=uz0xZ591mU~! ze@=Vg=E4Md`L!F^-;A;Wjt_T6W)7r-zXX2nj9qz61AJXRt#bjs4jR1nnVC4>{&ZAz z?V3yQ*Zo1aY8;EVYg>C3N2r`^(Ld#4KvBLaKd3q=*V!1>-DjMO~% zXfVb0ehhn}Gvs4lb#_U7pva-A9{QZ@BR@p8B{*o$Xws zJ);*t3qdR^{;79i^U?C^MxGS(tNrmj5yDyTi{?|{VJ%Og=*gDu z$8||JAKJX2lf${JJRsON^W{10rT@vs$bq?}G+QpDz z=d@jg9?caxK*;uW0spNQ|jw zYoXrDNoD_Z_MjiQnz29lHEs1vlR0^#^`^nguZL$VHolmz?wzC^ouPbQZO_^)v;T~_ z7fl+la!!G$@&qromGud5TnZxd^R?%dfe^x~^z_kaKMjrbj?#3|5<*fwHxpK~?he(Q z`nc#cFH3yFBCmN4mZ7x{FOBSp=&bbgdezfRh1sXvsvVlZdW^zs^Sh*bS(8@@+yt7m z96{_GrX-xCEPf?=lSJuEVdS03gn;DJK4;V$7%pv!( z=9r`Ffhp5Mm4hy(*9#A_-WjL5?FMx7JKvqSvT)}x*Ls%7Y{u_w-L-OIPTRVe-^*-TZVC7bcqkU1;3m7~6Dq?Mbm~AW^ zWfJB#vTC#LhmV)0k2hQAZr+!%b(+{1_P@Pv(Ay0u!)vTLtW~%q$MdwsHSZFpg?6p% zly#xe73#~lVpgR6gh2zuPwJiL!eYL7jb@2|CVrCez;MT_L~E8%=>7vMQa?oo=ZCQb z77t0T#ft7fya*>#Lt}WQY=Z`viT{FLG(NuKc#hf(ZlO2}qW_tzh?U#jn4zthblj}| z+TA5VwwZ^YDlNsnFi9+GbQVkL5Eo5)(sZzYCN7%Z2u)6+zAb3e z#XFs&QpjZ|-khu#` z=L*vZ_Pl7Lea1w}Dqdr;hMdb%lSLYrN6O&kTS4ZUl!(2FX^T1OC|h3In^l&63B$r_ zO$-^FXAGU{XPer4xQoP+*PF#J-I>EX32E(U!5lDT*;YGt%fMWX`m84I+G(bS2ECbP zs1gZ$HbSLe_8Q~gwm0TCE2H&wN-vdg%$gW&-8t*3GuGNHKwhfph;`2sAg*A)UErj# z5p&yb5F4Z7X85^`*<1O}(txF*Mvvgvr88bbhF#AO?G={g_>&EE?^*5WirelO9n-6r zsiJi>mk+!u-ALWBKYiuUZn9)C(+tHSsMur&njtusbJicu+H}5Zh`va}&`gg{IozP( z;qj+a8F2*_R^7S6RO72QbF3N?6^&us-I~_=mh`X3vYyV z9B4_G^Q3jZiFMVW1BK+ynzWo7t0dbqX7l8e?BWnjdPXNJdjlo_)6rQar1SA1GU?5| zH#?I-M0gX6bmL{YRh#Xa>=rk;4m=0!dUg)&H9pG8o608iOsr*EntXKEu+7hRrc!>R zKhnbOEbdd@+gz+sJG^`}E8@MtUD`EdVokWQl=xxP+L>8Tr5UqNobAAn&(`@-b^LI- zO6vID;pFES`LM7}0K=0uafT-~fT$;)6C<76jk7oVcAHZuegT1HfAaoo6BX&X zU2(5BEhGk<(YLyE0`JhDdOj9KDCdCOHB|a&)I|DGb1XB|jyhLUf*3!IhpO#uK#|7yn0)XtsNP!EN(&NFQJUcimXdr{ZyM*TPOiNTQ9L%z~-p6&xL??`Xx-Bq*5s?Eo1G#Yh;IS`FY0{eumS285i zan2`hC+qn{c#APqC2EMo81I4!&8}1gP8>q{0rIr{9TaZLWsU+)J--mPjB6!^rnq)+ z+%l$ZvBRyl&NgS$J5OHdlSN{Tk1ju;ZXbyBnrI)!xD5&?D*>VV$)=r7zK0`l_>no1mwMqxfUjyxh+|5bc66l z>YnEC?U2P5*5;S@F-&dm5gPT4xiRFoX8?-icX01oeJbH6&-V+Vk>gCmH(GlfEcF<9Tk5;nlwYrj;(1Lp*l| z)hi^hC(I1E$VT^UFD1IdBeZx>9yT zk!f6up_w1^hOTT^l*KErFy_tZ82IM-5NMRxC?FOD6aagj;zzJsBVpmGILGLN z!LKQd8sfBPTC#er_0t6mIvoi!8$~|NEqN>b=Z=X0vV2=@{Iz$lz{+eL`y6>3yb$Hd z7tU`ey75siU_Lz6-T2pT?`!+folu;9e}0&&A@TBnJ{jNJ&=+|TK1ZW1tvlRx0>k2J z7bg$|!6#$@>;W@5u0ylO19#-+H!Lw9^*lp%5{-9!W%Kq{4i=T1|@6cNT&%|tCMFKJVmS6+Fj+; z(SpK(KIEy1j}veDtiz`_sl)qAcx}pKrdR~MaFvq5%3j3yqq0PnvBG&RK{AryNdsXpaAV!%fk}bw3bE1(hut^d{f4G+evk-k0`ZSF?0fyajiKsjJJaL5TexCrPUtC6y)zIFK zN+Y@i*tNRcOV2%J2G)m%Ki`}%+5PNg_iW`YfDmBVfK#K-hZdsIZXkndmvh2jd~yY* z+|UfX|9SQy9XhQRGSiP^aeB5<&5%e`lsBmIw8&BU?=U2aji52DG9ZX$8>%#fH^4oG z2Ig(kDzwVv5p1uuWhcW%tERz==OdGiZo11emOb{&V}4d31AP(qgXcmNzCsb~GE4IFoJ=Zo%toNqEe4U;}vJspugZaP0CeR=-=JnH3%!TH+3`H?i!5^b~J z0gQGq!8LZVsa%Ef@Z|jX<>>}+Z1bgb=|%ug?4oJ%xK88!;U8q7I>wsZ#A8DPSc*}j zd`OdTLTf&6p*-LgT=!p1HF5Dc7swMk44_caOUIHBUcn7<#*WtzwL3lO#MJ#NAD@w>Z9NMe6>|xxJc3BhA}l zX(q%ABwLEB(QY7p(4-cgmn-;8dFa()UspES+tn>y+;by*4@GL%`Z zNvZwlXJ&nkwY0b8aw-7LzpOTukd2zqC>f7&z9c<+7#g70lsi0M37-S> zHLiBUGU~^!%YMFSA!R$l3rY8XQjn=Tds6g1a^#Uu?2+AGdH=+E{(Pb`voWFf{?UZCxH?SL8DPy2wSS zFj=iZ(WrYgC|Ou%TFH*IFiNe2T{BAB7YnT_^M1V6fk55+m`1C?spkqr3B4UoH&>V= z;!{lm6>oSLl)Z`AueKR8U23^8gSE)pOa&(OM(pu&NxjWLi*ut$4dt!DDw%H6)Y?%~ z;)$UTx94eqvoh##R+9An#*vUV&exg`Hm&S`rbzM5b8}m4ds%=8xnd@MD1rG=HF(1@ z!pp;cwG{u|HyFA38q#h~HH}JD-+4*Fqjt~IU4NFwxA1b~@D1k>ktWYsYx1w4)^^Uf6VNzf>sj`X!HfVYwrBP{L z@IO%F8zqObu^4o2gc_he-2R(12z{BgpP4wkR{U%C2{nsC#eD0s?tAa`4VZfjCNNt* z_nL|EQ?-zyXfhR3S;GYr2ymQ}sTdOuy5u+|!(GiL`5f5zq|X;nK2QLtIW3{uSM^7l zrdnh)a6oewdOO}P4PS?S4>Qc-!XU2jlNSU!$1EeRJX}Ra=`Y1;@EhOY1#vy&rdm#$j!322Qd-Of z*dPYeD1L<|B6C^O*cB1u_5H)CH)=SXw;br-;;O9UPJZ1y|9bH9Wb1rk>wFD3oqPE; z_IRkH%)8jOpNiCuTJJz-`ny(e6w943QRfArPB#=P&Tu^yh-YIZJb%07rz-T8h7gP` zZ){rDr57N^Qq4wx`K`X&5&wI@)5U(`v8jppX60&mOaR+7aFBL>>~cPGemDc1(Vm_0 zoKNSMnUW;@N2YJP=ton)@o6)teA8v|g|WU=yY-txb(@&5eU`R>-)-1%u8uuJ;# z!Fwg%LBhM%WcV)X>O;-yj` zd^Dqv@h*o_us)PzsAgNxzIPEGOXh9)Y>2n_YJERHx0gYu+Ti`ORmSC`rqhumkrheX z^EvZ#7vSLi*OQm0S?61Iz!w+EX#f<5VQ#O_K5?Dd2>-o?J$R)BvWIqWeii(i}@(5d%}KQ z1;Xf4y5N4@KA#7UBB!f05Ef_93d&%mQ@UW5I z$yB-9OM|+-=h4Gj%*OYP$!P^6UfA2aQSS2EzeQl8w4b|GMF^-)Ce2>H%2O;{)4)l| zFsc@#$5~s}ExD2QH22lMoL;gKd361RmvPj9<_5pL$BN`=?X3PP73Y&H_z*^TKyn2T zXg8vDv(|Wn9IIs!{fd&xxEXl);dE3On!$4T! zNeWTX4M*c^z(a2h`+R*u?uyJ!uMP3r&h}|KS(u;lYnRH^R**-bQdn+24fzkoIdtsh zX(^o^j;i%ZF^3wdqS(73BtJQQ6p-?aOIDnLBX&L65rfIX0o{kiy^ny5kD2~%ae*k* za>gGCYNZ=XsH&r3yy-P3e9NfDI(=CN7s}W|ryQTI0ycQE3~;a*I@4CBc2&2yL;UdbE+fO|x%Q98%bz`S;_6wKbTn^O8b}3&58`1U`?a z)4egOL^|!)ymJIJCn;t-Pnrud(<`+*uImv2dNodxIM4faiX)(8P|brzZ%Js4`i&8S z59z{lDUIHjO)%=jtkaug!L3IY|EP|?1T^z<`n=K{0#s!*z0q{#Qz4TEb~jF}pK1-? zpy?D|>vdf!z2};eFmK{gRy zeXjbQa^bTQx6a%N4{Xgxv=|zOql>4DNTx|Gc1u>l%bcwHS<}{webq_%X@z1-{)Od1 zuI1q~+5GA66z$4%4Wec)y#q>(dFSACoTCO+!0iZwwq?c|EFmDT$0mE4^UzGPx5q4p>~0$3*a!~)ncjKgM*LFXd3iW&4RsrQ+j zwZ+{P&@@lBJR{qf4;~lDO61h{mK1RJ2&rtilB4&t>&Z1PnlLG=L=bGk&?HLTtC|@E zl6bh8mmRn_n{g72a|*I82fZ|g%+%V(KX|u;I&76FKx+OG;3Q#KTt+k@VkKs2(e$mh@=dK=M9SMu6B}bm3rBBAT3hDdBxg*9q(MD^C|W^;E}FUA(Ie2^R_ zQULo*YokBg9-=N6Zldbu-YNV=!M(eH#7KzQ;Fu0<^zm=coE5Y7FwFc_DE&pKY<%@N z5wnQkq-_||uCUtG6piQyCNn`TuRB-U5gJwl+nzR9F}bYQW!yxUravLzC`>;o*YVgyORyG!kA6>(CqlyM3`zo5?^g*`!8OGISQ+ z>y7!dr8_^Hgn2O)!P;ZW^JfvSaPM%KcKWlUkB&)dP)uv_xUIrj}itEFNcB}C|g5* zs}dzqdY#U6@olxZ#pz84cQj00z&+3(L9&`E>E+4`8XK^DIww_N!4trL zYkn-Q1Dyw16mVWsbB6O8$}*hSG6)zOYES$JQ5caI87%f2=qAdbU}hjG=UT!kt$umA z{AUqqUS^tA`Xjx^)Wi=ghsz_XdtqO>jgm8tHUL86FFhHy`Zqmk$uuGSw6_!1h0rjj zqg7|@%6a_hIzcU}&ow_YT{cDV1@i1{3O2qwb7wEu{FgPrSaP7jP%Dp9m|bryYhMO$ z!W$Yq`j#sNi#F9vucBOV=ja^Bodf{0h`!zNq%AVDNP&0e1*NrTnox~mB^pyNc`h~v zy}Aem5a@tOsW@-;MS=wI4dNFhQ_A9KCN#G`?KL?&%FQT3sxoDgx;$!H>`?S7#WhPW zvayM+O#jg$ltU9P`iqgHT6)k9m2#(>aQq>Q*2_G;yOvi~)gzfC1u z2hL=Cmm3bPUN|G&DFVCo@TIdfXke_FM0~6P`9EmqhvL-0bzm8Z{eQ${FFcv0Y%kAE zEY8QlnIXoa2m62oG%>ElM|N6W*|3Oy-AtOkyH*O+|ZHc8LD5O>~e!f6ihaEDXo z|D4_wH>W<38>R6ckUU#H4#3O=Rc-X|c;SNGzEO{Q4;LbM_^Use{~OBq+{d`mfr}Sr zTFiQubOw6CgOcs!iUETg1VRmG@9wfVVsi_@1=EigE|@V8P{>%5uCmm;DPeCIMsurJ zul**M%R>P@P7S5QVw;hD@!7tSsd~f>#m0r&Q%Y@vA20egXj}- zx;pVbvCho(EiNEi71S|ZaD>&4oJ0D?1U9zS5S4OI%aZ-#h<(M$X8Xp88p@uOou*v! z2L7_!AFWsag9@VmP)x8nEi}2!Qjiy+dRSGjy|VVEGMIj(^Gp9Dy8xxjKK4Ayg(R5_ zhbF&(YyeHcYPm8P(34WT%#LAW+kpE+Ek{)TqL$w}^BV_vV;1eaYlBBQV|r9@CE0Bd z?w{xlbhAxB{}e3La{J4r7oxSohpGoO1zWJfxE}c2m6i<=xYv78ki$i30L)~U^k|0tJ-ua`eD5Bt zhRyQUPZ|W!Nbr5rxSuK<(%-814HV@KR=SvFncqqKn_`>L{jS)5Z*72YCpE-|+M`)S z7HQ%$am$+pL$AF!3;Lg7e#f4()c@Spe5X*^K{$mDv3q0w$Oq7?D@spGj^I!FE)Aj$ zmRbG`|C4;yHsSNq-vaM@I@W`dj0U!Ff6yq|`SnWCmE;E|1iyC@@E@)8_ly(fnWla4 z7ZHDZURZ>tnST;9yW1*I&26#C6=G7CIV1>j4(IOwf)9WTE2!=aIzf;Rh}|E9x4Pfi z0Ca&m)f2P3Af1hWfA;o)hkA*oGtIy+75H0z-lcIj-YoG5J zspBpm7B9@k>+-l-uQ!>jw`LBQaNz!4t%%v(dSlVF@Uqsq!z}obd?LAdFEI=4lbHPD z90m76LcN-6T-7{n7jyHROnKbMP0XDUJKB4REu0%O7qwPvq9k<(duZ zZZ*Q+d%(S6k+Z<(hsDp9=k>+l{lmK$Id_-I5%izIn|@j~z0BWzfsL(WfoswJ#fX0Q z^~H!DHTcVfG)I}(Ipij}My8%T>4Cp@{aXvVj8uT={($$y1hk-abRe8FUgibl>K)R% z+;SVdhy=oHT_t>$4=9efp}F1ggW?Wk5a#@aP8tP4ub%Zwt1spp0%j3OtpD_)-xX)v z1du*3A%LQuE9-&x54seKzYK^t0sU{PbKytFXJ^3y2LQ)s@$MLAh~|DnF`VR_Z3}AD zz%l1PJns)>gOkn*9McVwoz4Hrb7%p*YZ!q%g1>m1<3J`+NCeFvE)o2D2w)gce}04k ze#Y@jWw;>iA+{Gst0N;PJ{9kQzynksZIc1)huH~2m-|FBUF-1Su@!R~G`qmqh4@Qw zuZN4+#?c3G-d9-qF+y{Rp@{kBG*%ubAGisgfKUV!5e)*JG~MpsQ97)>qHP z*SsyV&aMx(XHn*Feys$AuLSZIC5fM5Q2Iw<^Iu}Hkn6Qkf zDqkD(xP1K~ltu0^oeVvVjJ4T1Y`f2U1g(uTiy)UUD7?-QkGnSKvH_%3f|N6bppBUX zqnjgu7iOzh0o!z@Mo+uP{%OGJj*M>tHlCJloNM$KJnk38(Rh$hbs9u#h>i@2s2)4L ziRA;=S6=W>5pFuqhq^|mw++qRK@DFa3+|yun2LfBF`8IPhR0TfMPv=9RYUQRVZ)RV zL=`fd|B{-N2QO?@LwO59Yqmuaj~icavLQR#9q1 zeu#`J30HA49`|zqf-nM0pJylX2U_04_{3fcbQR zCd&lYja!*|Q_**G%GLq$IJ}#Ma-=}}CG+%k?Gi7hKTmHqH9h|*!PeoiTib{&loAiDE4;Ls7j>zR zT;Tn9t8D}^X;T;K>?~8SpaEE{I13=Rc{ql+CRv87KaFw)J2`xtj}MQVPYaHTlnp4Z zgRiw-o5!R3+o{-Xo$zJ`kL=EyOE6hu%6LMW%#c62Y)1*i_bNg!-sbmIzHW(!{(1I+ z8d%}#afFcDDx^BUox!I{Mnsq_GJHMCP{V)`#D*i6hhZpZ`KQfaJkQo*g!E$1Skkwp zRlM1mI?>Z^;=<DIdi3 zlU*iSksANnaq94n!;-$7IazoKJ3O`vgS5#rObFzb3wrt9B2=i1fe*l-uaqVRvV))7=0_;bc4w{ev z1zJQ-NVyy-$G7_YI92*z$z8(@`>o<-kOwk!-&lzApLagS^T*C1`4Y5<7mNp7Fdlkd za975i3FwP7f+0bnM-iH*B1!|S%;PNCh2Pqt0%U0AP7{;JvFh7?$3A-b*YcHZst1 zJzUwzv{62RfF{dP10r|&&Dk)*#_+ymEaQV6ZQ9->Obo!fHw`H7q?f_Thwx7wH6pz8 zEI2>p8}Z)V)}KLz>94E&$-DJj&oj42N58w9h&%sG?+J6WA+8`yMxuY{uG0_UEsMsN zVnJmHBtk9Ft%hA%V|G{OYoFWj9!`B$A4Y&BTaC$xnO z7InV1!Ya_{81;H)^r&EEnn_1h#8JhTQLR}aJ<_--1)ub%A7D|0>nJzMp5oJASqzNRo# zH9uIrItR4R54P>^9c%28Maf2$!%VYcwh4WB0rWO_&x6rG12IrZxkXY5npbhSx%+`J zCA=5*Gjz@N8*h;Qoi_iCowMs35HBQK@As}ju0J$_#LLnBu7yAN_Lmm6>;7gK|5|wN z?}c}z))1W@Z6dlbnQ&IPCI&i|cHAl4B-6`3Mgws&h=~d<`EPFJuZ9)UDnd*Gepa3Q zPuqR*LAihY;5Vm>B@Q~>klW}!b%?U{AO)^I_|dvQJNJJe;(I-Rjv(U@m^$4zH^lk7 z8~S07;V#1y=^x4d${%F^v$D$n!1lnuu{}!LHK_%SDhIvya4Dkz$q;;uKwk1qkbxP( z9pVVfUyLiD(-Iq}53|FjF`rkMIz)}fSCPXC&uQAS_SKHNC50Q>SZy*J(qgusl&Sml z=(Jfu;_Y;wyeDw75!AC|Y6d7CNsUPSwA5d%MMp-##+7u>0#7D@;@1rFCrqg^{$#>B z<{N~$nH1mc-y5v9FjV+b6u2O#3D@uTZ`ia?T|}g+H~Qk-fd4qS|KBP1TQ0xpBj3-_ z7{Vb&@=YnZzbPe7Jq`<%)0$~a6ZW^B{bmW^`0f(WOa+a<&Be(1OJcA5F0ps8acweL zFKqJ#ZRfur`DsYkZ~gKde`82HD7f)KfEn2QqnsmhK(^$Gi7~Tin*N235mO*K3dF<_ zn)ffp<$o|H|A^J@{~K1#fB0Q+_84M;qZNG6|DIeS0)w;aioT=cg;y8ZV9$HI1ldPj zqH6^*ivd9bGi;qayB8flCcv+P-<-*}YDgM-pMLqsnfc?4guWj$dYge0cm-0%_$RL} z)OOgn>FGTNZ#_g|mZX`ozfIKh6hB;3qq>-vN0<;PT%7hM|C2QI)ad1~@Nz99m#;nw zb?tR)>l6-0!-lWeJKw<}Qu5P(9qInVV}5cE&v)+mAfE18UF^dSnul??L-~u5y`3ia z(@~K<5J=KZ1mR|?q9+9k62*+2Q0|_8*hQPM}Kjt;D`>ItN*ld5Mvd(|25J7 z^k{!W^uW()O{eVuh}&<^qIFXhJL>d|2{?K$adJ4eYktiPy1>|8*Mx!oLa*TDEO^T7 z+O^pmsDUfFsD~`mVw~Kk4v=M3uEEKaz`{0@Si>(t-YPO%GSCI)A!+O zr~QjC)E9~ifw4}9I27uCp_&e0NrJpbCuR-@-`v^>%Y)8$l7lu zI(6_&TUmKtek|9TqIg$R44_M6vR=ppt1~C)Gp?o1`Bo(Un0FjBVSby(#hHbnpP-+05D- zCqF68Y4bZ&ExtQ#PD-x=RBcoA&QA$nNkY*#+QDzi+ud)RIemF!CUxOmB)4)Qf`4(8 z$2-?hzjlY*Z1m6fh-A3gaopQcdaz09j79D`&Y{Eqr#Fk5m zklP3-J+jE~WmqaRM1f3>b`@X)dX5~Qgh;sUUIs%X5juN8l5O^g*ZZOn+{r7@7ApRrF%!!uWoyf`T%W>2vihJeCauwA1XLopyJ7d3A@!)1$l_4Q zfNRJI#eJNtNA%^9yzG#&3{qv5SBMEgYPPTPRj9;c1V7PBiRw>)ix><&jJgO71)}gL zikO5rnu-)o8r>ARJL`(*?j9w>U3|*aNH6359J|*HsaLf`6^B9vTth~RV1QoH;;F3= z$^+=Gg%&;W%m@GeOV`yqDq+G!lPKNE=iY=5)#MWR9~#NcT{(Gq`@X5`b0;z9^#maw zh09M;i2&sq7?S?FI9X_k*J@!dcD-14<&3MWgS&\A!lmc$`?SDVLTHcwVuB~)8EQ`?P@D3<4wAnFhV#*7_yODFr~my z%iFz>UC1z1!1+?w9Q^YYR9_di^((53GF z=y-2o^GvbxIVAyA+P%91lGtfJOp2ljruYf!Pofqq9mK*HV0fb3^h3|R*t>=C#A>;h zCIM8c;t%z(y9>`JhC*$*9*5I za9@|+CuSaPcY9t#1-X7*0?-RmcB5hx?%-qi@V@V+YLYcZ)ZD@~MJ4$zN85{R6l}RfW1`k>Se_Jk)FaqFT?_@UvG_ z$KB#QAYh!gF|eB=?ADUp_$W61%igpfM4{;2Op7!OqTKm339)5McnMMRz=!&9(eK$z zHYQt9-lGyRam}8ML27eTB~NI%1YeNr9#n#^;L5Jaw2H#~9_Yp^x9kMX?eo3xf*tyg zRl}75F|R+))hB6ZLv5V7(B}AvrG)lk3cnT=hx)AA->;)wt(mT+ImqldtshopM0uqi zgY0YyoToLrT^*WExHg+mRUUQ@eo@KE4Y$44i+fUwTWa^oeXhWAK+h6AOT@D-2qoT{ zEo*pVJvah6j?Y@zlNSoX6%-@u8m@fxF;&WuT&*oRVDk<-Zx>M*9~3=~c@)_S{APy@ zeiuIbtDCx1O6vqf1L- zJL`m2hiuMuyV^uqP|29bmqBJ#uiC{qd;7dNpJ^MAvBj`b~v> zy-;8whNx7^jaD@B&)(dU$lzQih6kH;~$ z8?xKttzS6g)AGL)*t(UgDQML{LERgyyF%a~U@l(8-qzeDy1O=$iM0FJ5>rpy+AM&6 zzs7+&y~0>vS^chDOY&K93xBN^iiH%eE*~vW1;_DV>fyNNd)1+}hNgqC5 zo)-Kk71P4$6-LU-oLT&Nghckd?<-rIC&h{5j)+P#a4FJB;{|xUVUz=C*aNXpea+WE z`<`q{nsD4Eb=UpV7a)*<_tT3pK z;6ra{f)72UuZ!&Qjwm2oBv=nM38apb1+NQxn7im*rb3!485dJD>A~x7co0(KqPw!W zmO_iN;I7?zI)xL_uoJ;jQMb4@U6RqV#Bz^T>~Z54xJ2hC-u#@iVa5^Jy?4@o?k;YR z2iBKrI#zbnh7Nx^QgbxOqyZnVzB11&(&Zl2I9cxJ=wb;@k#yHsuada?xFPf~TdjLl zp!|_BB>N`cr4q*Tb;#SBgn&VEhzWnK87cCjm@tBvDqj!tIC8_G5n&kkrYTW9P9Chf zpS5xiXOf#QHC1?R+vPmeNPzpmFtDXSSLF8VQ7|$e}4Jk*Df;PyU;;(H%F&S ziz}Ou%m@KrKK|OdgXQ<413#)>zy0*@k2zkRyEgRuA=nb|NPN#z>j4-6O_Rj^;0hwV zItvjt3D`1Px?u6X$Z)?H@1O%;Kr9k0z_)A$b|-?LwO)_MBizra*gc)&#kUfRZeshr zL4ceZU;+Bd5MP)oyzYKIMLdfV)mu$;2M>-nV}P1L4e)$xk3R8s5P9llDtyLN+Nnkl^gLHwP zC86&Y)2U0MwNQpg`3P;xrme;XR#r>HB!MpFbE-bN7fg;DXAH@OZF3zLf6%J8Npg2$ z&0dJd6#O9$^z5|mPQE(l1I)g&o5)WL9vr_}fUX9EX7bf-&`kPLOmK546Z-6axS@wK z*u;joJ#3&lN7@_wG{rVVTu7)P$9DNDouzX~ zq(b!a=bW@i<;)#!T;(_9U8!*pCkW>2jq1=QI0#&w>R*jD;!i|knn13GJE#)lg_fp; zfXg8XE0XdN;zS~HxnZg6AVoW|jmSpO=RHNKcT>C3_uEf$unwN&AfLjv!=9CuA!lWT&h=O!5R3`(ka#RxfN1 zdX13!Helz+pnEsjRbIWma25Rf9CEjbJQ<-PRBh@9NF_;Y=nPM~VieI!+UY?fNTt87 zd)?z9?pPo6$uvGg2{!4IJ3i=RM5Q{|6x!g@G>W%>6Y_nHW0jZ(AD`{)td3#Dq5PC?e6FEm?peI8s@4^=fJ_p32p!} z&vR*i@W%wX2yurCN{0Hucz#kVx zM~Kpzmq8|fgQSd%fWU!)fB?a}MGEl4e`hfMhOtW)FIiAt^?ArwGZi|`OpXHk;u6iZ z0{gk8DHPV{m(!=TY!B9b90>`~b3V6qN=Zq*KcF@z5phx6+(^G}lFUbb!Z`n&pO~Cy zg74^P0X84wt2V;_xPi@3<6Q=WNdN0RlA6Q{`}XwxSK1}%j@9MmVKRl3H?)DJ*qD@$ zh8Tw0@#YOU*O|!&KRsl?ZF_4=L6n@$m=~87LQ7o6Ye#hIG{p=qBcHo zJGN}dua{;jVd-OB@6#F7r1bDRpRX^bV_d8F(DkK*^J7-fgmdc7XkO$)4X5eM;_g9h z5jICu*c{enHQ6$hs&&6QPx z>>FL)x)|My>R_whOw}Rdx=Rgw&K6E@q8})TRgL6L<6;TPyg}f8i%IjjUwvFn1o?Gz zQKEUj0@rE&8Sob;d8@ct+{hL`-&-l^^dv&MO*DizDs~xBx);`L?R^=I_wAEdRVq}@ zrH8x}b?FImA#rWJwr8@Yh#wtd+EV-NDBAYy^F*<7l{0Z_wruaV#zDnMfVq&jai{)D zu{fx1cO!XQbZ5#CLwzn$tIgpHIwgh6uV(Wj1wY!pg;%sqM7Yn9BdTKX0dWNX9#{A6 zEBq1CrkNi%)-(35c=*I%;PyUCB1BvLm=XAagQ@Rhg97>r(*V_eOOnP!dFgC#HLj)*USBio2jgou@VSqb=2xwW?ZPGYKas4@hPIF&RoK-qO^BK&87Kr z((j$2QMSN>?)V$~5tpS0E(2~6p;-}&^^%k7@){iUH3cSF8*>jNZ<2VZ)zoD#{n2oC zPdB2~AQ-p!ftOA<`&uJmNL&<5LD_b8*7)Er2NXOlFn?coo88+{P%L^L$L3B0GWS*< zrfkAP>@;fyd7g)t`V^qev&wrb_Xp?V2&@b<`03T}eZ(a5rv=WcpB74`Q@tX%&8Df~ z;V{;ApqV7!8pleUe6zQJJH6Aq}On%ZR~^`Vaesc69=m_EU<=9V%{gsrNx*t1vGYNlofoKfN+Oz)!)G zg&|=pZ3YFXT;9g#+V(IsVzhS(Q|UYvOgE>p_o!uY{&!$M(-27*F^6|5H*A#5xw{548rIm zVVE(9UL&IpQKCejC=sGZ^iD|h-v8`cd@R%^{%UR^ISad>Y}7-@CbKoqDeRA z{rS+dY)yat&uyA!UXgo#3EKBV>~$O*3B{I$K&nfT@%o{Am?=n^;i3yL&HBNRI_&-MW6E<-;U>1 zerzE3igZ%?W#n_7$BBob-Bg;^J|J=d9T({KjE24?hE&J`Lu*khA|nNWhPR%9Gns;) zU|xEA!LIQUWB_`|GaY}HL?_P@w?H42p9-!IFXpY2C@7aY@hPqb-`CGmY>Xc$M^@1q z>P3dHKo8om``SYXWv*5k@q%SlPIE0e4G!6HJ?o#L)T>YgYaPmNlIUI!*9V6$e{HcQ z3MgOK3#bm|+)m(a-K^m^)%72T)U#pvyGVTc>wh;hBqp9f^^$O{2TMa|ah~ zMC!V*zs5&J&p;Ku?WFnNY2=ul`m5L9^R4KxjqTgMS|vYjj#0%!UV_p|#R<0Ne{z$G za+qot#s%^{s`@6^59AsIv^V|WP^UYM^56=ZKTsZ)?8dag3<^-YboG&Da|z35%S3y} zSX*+dp9-JX?YHN`(RXRa$Ue^+8*!d(+r~Mc>Ca?#l6C%{XG^pioIwBsHWf-4U=n;} zD2z(SNp$O_d^S^I=KFYTVR*nr25Zi0EC*Fz$y^LJIzh*J<3=NXS8vq&*Nw)D?_36& z)X-U9c|}Aojdrte(lfy0$+TdkN_^i(a*$(RD>5n(EOiw7_b2fvq<}yr7ePXTR)z{ZqVhl?zYO3uk+w-|qYR z+Vcyk(1n8ERN@^;0dG#-BtWrI`8tH zN$dn#^OeXqpCPDfem80S%FLDLi3~^ft4G^hlSfl2u_Ge9n%lbknm>Fpecy}AKBnK0 zjcwA}UKjRwKvixoy#LsY)$}yvaKkP(`r-0^ed?4J`7i<|xop(@cP}_j@W0BgSm2QV*U!HChJdYDJn+b`!M-AUtd3XY7 zBo!0X&_!0;y_F6GOhDAANX`u9S5@Wy0!?V#pn>LQEdx_)4Oh}rj2%1Zls+?=$r}wj zwxC#qIK>H`OC& z8S?L^1UGr8m|7*jT}|!e$boC{XFkDtN^3h*ixq9JaCi_?k@Ja%ctiQ0 z8_AKZ7>j{Ur!8}q)xDzexo0)FzImh5+cG%9bW0W1&B8fKN)+kbHUBP0 z#A=qn@9kr!WZE&}_ZU&Us8$6UP3TCIElouiJ_&~+pMVdxjzeX+bB*WQY2}6)Ip;Iy znupxU?&JX!F2k&~E$VP@@x*A7oPl`a-IJ7^;WT!4)mHZmGOJlrXW)U(qud-CCS})< znV2P_)Q9@ti}}(+>BpbFYg2oV{YblzkDKh}8uD`dJZR#uzP`2fGEb`)pO|{9Kwf#xQ}6nFhh6-AXVlA_%zgj*QF;-cvq1-w99Vj~ldhdZre_DdE(# z@nHr%l*~3EwQ4uo9o14`(!KiFG7mGhE4micIjJU4TR;zJwP?Ijj~qIM%C-I)tq2rz zS&dDs{sQ>9+iDR77Sb+R41vy#NGyA(4d=Y#GrH9Ge*M(Isy9Ar9ATgaf#Oy62@xL6 zZ^w#gWwb|e`m24X3fA#OdT`^MsOE&RRbQME`NN*vf_lKRc0+( zWtl$GhAehfC_vcBoM|VS@S!Fc0C!KZ)MQ)tG-2Eg?YFh)>30dA3c}nep*Gq!((>!Yd{rg9&jJ$Wo|vUDXB*SQyACZg2E~d)lKW~* z3jP#?CG@XDw*E*%D9=fRO6*j{C50sf96~etFopibVcBy%P(+Dp4xM>SEY1E)#~#Ks z%|h%O*Q>;_vLh*QYoq;)i7a`E$~d}XGnO{-I0Xz77`Ir?n@U15%Etc zMA_2?Rn_#_p=!?%^*)CLY>XQeQ~veNnzdSx9dav$vAS5F-`KCXhdz#zXXkF3lU!-S}_SG@CEUMH#HPE0QU`Qsl5eZ!@&qY`-c6TW|rb4`P6Emc=6 zR6LovTlOwypyQGn?4L>cb|Lo?IJB&2Y<`-tVLa^nH8Q-Y*$9AtT(zN;n z5FsB4pknSPrYMbZ)AyX?x|N5Zd{}g1>)Zz~zNK;oH$87)>F9x0jHp4;k3H5Rn3U-= z$5k~XkIa4N%I_Ef(l@VnI8#1BI?)}@%AVpkJDDb-M9=!nTElhtxQdEAUvVsO zW9*#=Gi~3g)MgEqmguM69t(Z0_$@{;Iu6@7gns@IIw|&7i;EXh;>8$6Ev~K*ZmbHe z7SB{Sz07H-EJ-X`l7w9utn+l9_({W~g}zxWT_{WsQ3N(Zn!kUzd?6BE4^UDYFtNyu z#86L@PM^>O8p1L8H3=!Sina_ThDoNsF7YfF#^I$d-E)3QdgkhuD&ww77MIye+1xpQ zpt_`Hhe9s{Gse7I3lsE#Y8z>blj(JE=ZhITM1QldbdmH7Pf#nZ6?6n}X$aXfD{R?c z3R1c*o)pRXU8VjGS%K3}BgyY@G%EjVTg^83^Yk~9rj5h0d!#KB(_t`hS z*lD}8_asasX=^SZ_r?7x`B`!=K!m=EQ015MyHL%f#^rS4y)$SWUaW`mOThjU*EP(ENRiW=~O=D$sB zb{7A-wols0X)n0!e(%kz>#?$aMudG@;%N2zlB!{o8X#TD!;9Y^SBivFY%hL4ZSvK)MgyE9{e%~WmJw}jTsFH|a zTHNJU(sI*a9`OeCIhjsXVtN2|CA7nC$%33fmXdQgU=eN%o0`1P!ZRX&A{48cG=M8#puU zOa3j(wIRRA=JY;-csy+yWSbA^PyLulwc_dYde5(!m@Y8KXBpg=EvlI=1t!GLaTrF| zTbsr-DY$e9F2DQqq`}&R7>U#ll-zyNZDtg0!u7?-^pJaTq%d+XaxIGYdA}#~Pmf0z z7&2f4i%^w$#9eJccQ^@92&&n-3HJ&DR)8H|Ws72tti5eB-Pu+mbRP7a^l^YpON3IZ zH{_a_*RQyLy<%*yif|%6Ei;HTI>Tr;t=~%@vl}D-0!U5w^*hKT1`558n|5nZgcXh% z5o{y+LofkRxww*T!t}W*)f-YuVv)fD-wkkc+Cl3w3V?_=^}R;7&~N3%%{qED`c@<3 zLjqlaSyQy-mL;<&A*>zZG?$F+Df}LmijDV`_3c46@p}EW1=q?kBTk;t1Ks%}-2TuC zDMFkKzn~qiQc%sKWZW4tKX3(*>;wytl(Q)TPVn*w8tsSW#@kr|y@HroHddx5h_7kO zeDhD=cuTi*PS!I*3oo*?`rCbIY$@S3cpB|zW8Se!8I)elRTns*`)ew}GDaIcDZHCR)Dl7%^uM452j?Gv{?Fjzu>U=uxuN)xV7!`elp9hG@0C5O1Sy4= zW{;Xfs^DqAM%_@6q5Jll2ARyf!-Gb7kl1i7- z@$UnAuh;k9`+nd5|6}ao;9l8#JlCB)mo-ak%WtyzFNWc|Tu#@t8t)k*fORXIxztOsPRx3Aat znx}@aj<2%sv0TA1sa+ZhKUEGn!5i?*yA;;WzkVoPyMFD(d*;5h+uBlmiV=R%j93?V zytx+yrBb7&{O7E%0vOqbOpMBE{nqg-Yl`Y2ueF_D;No;;KEI?!Ds@*#*`Te1*rK<9 zF?+m((5%%k!_{`>)xs@ZPmM2u=n9w;SXU)Q$qnQT$`wnMU5AE{JiR%SB|YH zY$R4pdU6^Wq_SU?DuoRyx?hQr`7RjZ9^HB3_pt$xZt$y}%BMFqAkrc^aVTo3mJ7yM z8@+C(cjsl=E@3pnBK`s^HdM$x_$2;Y^9dvCT(Rn#GE*gc`Yn&B(@@_6hQStGs)J@i z7xe2(lM|nq_c2QZ(2G$CMe^B`91T!VfGcPy)F|*q_(eD_h6#|fw0<}<36E`vh^URd zd%VSPI#$Dwe!Mu_uI2RUbZ=<8lZroG*7s;Lb@x;K@us+`^d|??)8>*deKOK@`dV2ld!f_41p53NSI&j}a`kmJ&m;&G3;*WLvd+oCRdyhDeP>I%} zKb~ytEcWdZRfv4s%k&61+5f^HaI&!&?iA2t43EbY2GpN5k6F=wlsP%-JUSj5NR=JG za(zuz1@Yr9pEHQSxd9tTe3Cy=$>ps)f_94MsWX90P#sra8z`?ghRAsm&JxvRsUjt z^6V8%AW@KilhY`_ajGIjwwu^}%$t{g8|BCl6G-zH+}P9Fram%k!`Hg#J?b^=5^Htf z{Z+x6eHVNHjhm3jy$4wivab%+XhglULIVRE;&rS{)iLjx>uP^J(GAfENgq)O%0T}0 zm0)<&)!n2kD|@X}R_JpYxMWkNT|@6e9#IIfABboPW)UQ^&r7B+v1)Rlw`g{gdjg%n z>QnW@dneuB4yFq6r-XL%OauH*w}oplK8GD9?Vn(5EjFjF<=bxI4Yq{WZ3B@gtnQCn zKa&m09uI|^2JC0wGOX_mHB?t$YPrIW@R+%&PB#=9o-9#7R%kJksR?as>6R*b96BK7 zLP2KbF(bwPZn;H6U41e$K!e#)KZ$h)KzJxIJDNDDv}mkc3axx%oZUg*fyYiJUa`wN zd(W#`$T6S-{J}d(*y?ciS=206o*&NMJVjuV)*(e8iV5m1wfPKsFAv84L?wvbOXbz?C_vDd-6YF zshu2{NLiuW)MZ*{>hN;nIrNI|45#9s%(7}7v04}v6yP8+n5PJpz=Wt~`qH{Jn^N_O zOm9@uMe(Y_pwnGG9LXUv2gcLm;{{c;%TH&4@BM}Ot6h-%YwSRRpMB(S8dw$>JTfJq;U;@_XSYIJAI)XW^1$XeBqebvGks*o%=?VGVE1 zM=ar_Oa_(3^wWdmYeiGHqMdCWc55N|?GhR?C#KIlE1(|}A3HBSETdY3-;pHf6636S zof%zmxT>VTBaX$5xfw7Z=*`Q3iaD%0_fUQk9T%VSlX|f4wPg5X-*l7M$5w9?r4-V3 ztGxjPPTyzeyE@Df^2;9hQbq;&>-3Y6-?3rCo|Z|&EF}%9GU@gY`}12X*qDiZ&USGN zJGhvj3&JyGzNqcpK~r-p{i{WRTw4ge*RmFlB1fU z#P_Cgyj_(yX_%I@@y7bR+3B!HX*m)@9Jw>(sqca%lia3pwX6aQf}|2` zB;wOlY)uk;>0%@jmyoq`v905}t>f?(ZY!;jTPB?|ynNkbpg}c2DR*sQrw{0N2*u7Z zx#c@8gOfP;+&;LtTU9C7Vw%Z{TeoaF?8c~^|A;Q}9C6k69UxTjE|261UZ?w=Dynun zK@FBQzOSx|_n4lnF-N`3OT2IVgfJtui}jm+ea%X-WkIna>g)A98x}^It+-mUlFxO7 zUH`P1$wJ{6oi2I5myp(69X3XLQmG&p@X22kgBdEhwT(xx^*YNn)x|RT+Tu^lla55 z9B&OK76%Jk1J-Uk`s?1U%tz-z))Fo+zuT8CbR3biqG_Kw+YA_kC8|}8tAD0!km))Y z5R7o|^H8E?t&!};xPZZav4e?TP)nXKF0h^{m*I9P{_r)mg!uU`y6tQi9&d0nypr*i zjUgoY5PD-*r#t^?$r>$ty1|tE`lrahY$oXKvhzJ1kRt0=W22h252Ad9UZ;;9~knPVib;<+#cP zVUt!XO5N<5F!ay4LR`u7xKq}))xysZNM^@T9=1@mrTa zy(Q<*?Iq_(-4<|RccxBWB$jV<@1Jf*Y1-KyTy6ity8U73zLLh4TBbCxF%JV8`Vcj?)c2hMCZO$|A9ih zd-T`!)#)zKVcwIH)E1cPb{_V>Ipq(L^0@q7vQtsO;wkpM&Xq>@y#{szNsnj!kZX4- z;}#2MhHLY>Sast77 zq*av6W#OQXF4pjR2(PI@tGeC{{gTIOb@-=2$jgcz_NpzQIN}~dy8c+&%<&CQ3AfuN zw+Xl!7Q?6wGCkC%tQNms*G=Vgcv%|$;cDy-|C6wHYaBj=FG^?`pT$Z^O`)f&yj2hL z6;4l5hrbidz#~{qlJ?3NX)W)IVVOgU2n|~2O+m@@vSmnsUd@F*(mNL*x7h>2Tu;@9 zysJmn^Fwffa4#LBYl|{!lznG$NCPN6J}r_olELUgI52N`OEKRYpnIdX`@~l(JxM#Y z51Kj7MRL z@UDr1x7^l8vX7tIVGxlP9KO{h59W;KCrVX4^cUJkZ(0f|Y-9Lf=R=jP7o$l*P013R z?2fgOajV&$pc9h#sAO{~>yVd*?o3puvK}#$D7aic6;K#B2G|DqqDyQD?<~0My90-* znhC0}G^`5-agD9nG_7q6QbS>cR+RHXY5ls-?Se?SiSB-~s6+b{|G`F;CZoJ|;xnY% zx;|tf)0oWxq@C>ONg1>x1Pj5z$#vU zUzm~5ja@c>3D%t}XjKpvigpk{`Eg$FK4I{zF}+o$NBmmJ4U!aFI29Q)FmO@}Guo)T zNLJlX%u!mJ*W2Q?4@wX;gvx@f5@G84hhhN25SHw7nPh^>w#jx5G}H!d(0 ze_d?FE)k2!Q!LI5$8gEz0F7%EA^NatqN8n6Te1|MG6gE5P%@)&2NJ0?!}xAz1+^d< z1zn2Rj|nnHr`C& z$Gu@Xm7?MHoO#gy^Rpyvy!taP&cG5qZ~s}-=>C=6*MCjN7`sS<_{!A0i!#UsKt>I- zT_e6+XIyD9<2p>6?h>8yE9t4P*dDig#ze5V6{fIGz*^$;CKzSl0+~?b1$YL&7jYx9NIv1d z7ALQev>dJZv9A?}KlUYIZskoKMa{Tu`N+ciDnDwg%S^+ZNc+pJ9%Xt9_N`=L|0{8% zLG9B$3gcN<646>}AuN2+9(|(xrb(#2^v6_hk`k7+Z&SFTbhz*1c7Vv`1CdL5!pX2M z4j^sFnPM=y+;FCj+4=ecU8puFDG=j>&gJ$By^x@YC)ju2eM41Iy}8YvU0z8a($Q&a%fW^u+eNe}m4+F^^f@TO&=vfx}fM&S65>z_G z&OdeHWVqzQynXA4DVu&y`f?V2fLB%S54CXmQ!Pjl# zCK;E5eBUOQ^;ZmC5BN@WGMBxpb^3MvWY+ZP1UO|lSu;J(`*ix{G$tO{SeSYQh+J;s zi(9W|clf-1x_r7*ak}_ys4($%z6oV#4QKvKcZRH=M2pLH;`C}ryZ?9|a3>FBAY7&2 zIQil@S=0YI?*m`et>fPAaX~Tu9I@`I8$9kA3Dt>{tGOdfw&L^y-GUiPID)SV!tOUs zE+c&PYJ%pkV7=Zb# z+%TVnQj|Qh%=uLIRc2>$&;q^tJ}>Ax&qD9$XdJ=)s6`EQ^ZOs_FQq$=^xAoprFO8^ zMCFxoBGY@bhn_u4#ctt*XoVvlFp2%B=lwP1;Lhk4h{;IVs5iM_GQZ%fYc9pt;CK@2ffmKSD;(?SjmW ze9#S@b_Ex$nk92vZMkR-)ekU+dX8CkLn#I{Keas5`eduhmEaj(8kKX%`ID;&H}p~n zfemWHd!h`qPuHv*8z?;5Q;^Z<;Gq+5-l^fz^6hU>81`l%<+Rjl$iK@szq~4@dBauR zT1VkaL`vRFy5Mg0;>SV9K+!(5y0zknthL-qPfQN7U0}mWG~r|X(fz@vnB*q+9mCui z^!}{s2Ey%8Uy%5-3~KKwM|V$Nk}OLhm(-B^Dr1I`8w+P;nb|15xHeWZcyYYMG?I!< zQLu{Jk*M|qhOrHg_}f%tpDD{Kh=)OIneg?``GwJ`iQfqVFZ1bLHwG;e5>o2l2^h`V-dLWCo1@TTd>jwKOe@0aV*@ z#U&S~&y&|OZ7GUY%c2nO$`sal)5Z650-m<_-|R!{bAnu>Ykorbul%$1c2RfRa1>`) z{mLPH`os=QS9tz}evcaN_WRM*E_q$xs{+qzkq4Deet8bb8%rwJ45b{PrM$$Tb!Go9 z`**Ig1lm`<5D@*)M9{#DOQx$I8ACKEPS#$OMt$&)7yBWrs<~XPoh^;=3j_F9a}J3` zE+;-V7u-DkuwI+Fg5TD9^POgCJdv?=Rul@5F=Cr~k?`#~!I=xf#;)dEAy&1S$5bup zhScyTSuOy%$(~UhdIqQZda5}hH;|_Jn#~XKdzG1@Tg!ikB`|5J@iiiLZ&l`S9#7WK zbxsD_8^!j*SsfAe^}fn%k2U~Q;O~%a9;Ze}f06-qHaBYu(^+=HZ|<%S`S~0Uxm_t) zbz-8MmF7vCJlQclP5pE_02~|w+kF9teaHLxJKAp>&RUz!_}O3>PtTnbz?Uf;*LR;U zGj^wpc3H{aa~JsD07~?Ul0T>kYTV;O?Mg=NgTI!h zUq+?f>RFH{z0G@1yk&KkuFe*~S8;*}l+rNxd)k_z;YGGSzU{aJu7kGUIi+fBN0J`>IYUsP}kDf7$1IO)TMOCAQhI zm=34DzE&KhI-2Zy6%J35Zlr%Z4jBQI&jx;`FwZqawWgdeNZEp`Ox2(?jJu+SdCp^& z{-7)X!eIZstbfZDpaL-3TByYW_rH9)x_*)hoK^tar^h>mC;8WIr||WET)Y|f8xh`X zUXy+n?0FGP_A^eaLm~lF>1!=7R?GRe<8ou%XwN6f7uH`w@|G`@UV~B2OOe0Go7s8J zNA=v=z)|jU%{QRB+tqjpK?L`P5Goz6pKhHVtTyZ|Hyo!nfIl32(L30bJNp^<^fNFU z{*bI6ie){kZFQQU7Ua9Rw3B+Mp%h-TRzJ zy@r!)(}cFVM%|}|J3ptay7z>MGDUp~s2jr5@Zj4IZXdB-PGG;brr$pQYEVJ%LQfvT z*SN-U*wHrWh}8!tGt_I9KXpyj_%cSp!-=#eS;ov)2&;+fb{eZzHEqWxQ@R#pSx;5V z87hQitZ~b1ZCz-$1#AUTSZQsiTJLehz2U2(@HEkNuyy02Wgb)w)8i>$ZI@n60$x9R zyQ82NZ&XFDv3Ap9+4wKOF*i>!N5en)BJCw@ zxsN$_4_z3gt+}6d^ zyQX>Yw5P!MQIE!|kgZ!VG6-;!OGeHi*X(gkH#m>zhw9SW+Peqp@^Br-U$AAPc-4xk z{bDD4?PgQ?g~i9OcnkE3*5O)lDA~cOHs|g$(p>=OR9+8NFYO`0ofNI^ z5B5*d^hOp}6iLe;ZRqf3k0-|wH{Q^t(<^e2MI8{#QMzxxh^1#7c~%=#y{dp+Mrwp) zf3Qurae^ArofKPY_Vq0}mi(J9l0%Sb>X-t9#0BQ$-&}{fyb}tvkqOmNZ%(aewI`ZJ z*Vil)WCNHU$vpwDwfl1nsz?R)b^?6hH~L4sf#KJ-kjK( zC9a`MFtQFa8+R|X8?i8|xhu+t8U@%480Xk!zb$i4)eAv-oSWv!xwn(Slbh_g)pm>A zoIozeL4rGBijg@J9`8(4o4z@(yh%>FK|6pf?|JeMa4Pa{$!-QWAUF}OY%?Y!7MEDW z%en=6TYUu_s`7Me>rxhOJhb7q%Pa$b!|bgx7P)K1S^l%+fC4_#Rdkb?7K^}1KlZp? z)N7l1Hw{>d9DF1^`vz+>dE=+`DDX&Jw=uT)#a*IzMEOWN6POWp&y1}3nikIBB+dW^ z>qxL+OEO8Ej$clw-f66&bad;w<3p8IrfSUKNakJW*yw)N)VQBeN)r>M;Mze<642+E z&4wAFG0U>nb@8y(M(GyNsdn~e**}iq$#H}+Q(nx4pn^rd^HCX0mW^PXUH6C`gqnttDl`S!KDUwuR@rg+GCvnymeaTM zJsb{0i!@{dMC&q>wsIaKuw@K1cB?(nt3Fs7Jc&(3kMFhQ(ws`D_QZwafn%FMUHAth zHdV(Z;KShPR}?n!OwSY{J|9MU5sG2xML~{(9I6e4h>8p{Ye=&!EXhcR5 zYP(*w&E^_-fi)wq7X(e?xsD%`s!89q*eE#mMHPgW=d)?sh%4QL`FZ1T&`hlcJ zy`V6;Zf9}*vgAL26hAqbl~eQ{Rn_tOs)(gg#N2q0Xq7|^HKX_?Lu%J4+BUG@>O>sV z0gjqwooq}B1(_06=BWY9RTjG8TcdkSj%U)>s{w!^+=9VU)BIBESKx$xR_b3Xt?at` zHf(aB5xoRrw#Ij-;ke-3*UFL~z>Ih%pQfEJ_I4cm;IHQlu#@3YkR zwri}Cx~c^hSK0qaJh%&OFC-lzpnwM+;>_Xeb(T_h43T$@%*{l+s9Q)!=;4IaPu)ii;sx2U5HPNpU)_tMkg5M_cxq zH|G$=e_sxGcyJ1;YaZ}2ZD5VzQhr0B%;f~w;&clVx0V^-#N|zjh?&Gq-+U>c{u`3p z{X5Cm2zE`T9xR>>dN+jl(kq{S4MsGjgd5DGR4tOfd|kyjl8-3SQyHbFp1hitbR%^V zsb6RCousfZz}>BZzy*28e`Wf+e%HvbNs)fA$LhE?2SyTd3OKziMP{wDY<^jkDgr+y z95(jl0kk6JohF-^ud{F1eHBB_*_2eZF=8eI-LxNEzk7V4o+^cT4=OsfJWepDnq+LL z>`16BmXsyoVX!pL<;*v^5a0L>qH34G2~_2%=~=u)kDrVgx9LJgLbr2usT7oR^oSo= zrJM{y=4`cbN-sT$+$c8RfK@!H_y^RM6VTvEub;($5+BE7z`W)mJ$z09rs3h5B@l=SXrhW)L zvZ!}N1LFut?*UT*Cc2be*Bv32SAP>3v+dkPlM#x7)H2Wk%`IU5ssZP+RqxIRTB~`m z9?D=nq*?{$LVWSS)mIK4iDdJ}$NnZOf3AHuZE_I8B2JZU59xMZDi|!&`)pL%n-eza zuEUZqs?f_KB5gn0VjE~a;&5jAn67iN*Ok1 z8y1%b3Rlc!?y`RJ^FmQ;uC7S$H1*G9R z@FkHvooLKQ31rF7kS1IL_d5@8z@2ec{V-lXRQXr*I=baDiyIIAt&IHw=IR>E5@8ik z`lq}Mk%AmCx1cMg*pWcaVPHR?1qIG*gy=7bqp7Nr|Ba5x;9H}Ar(+1zYvc}Cr-A02 zR0L8kS*ohy2}oSoT01EwzL9laf*VX;+ zG@oW(@p7u}8UQ-FhQ zY;cup!AcUDwzxmUKXy_u=b@)YXTrsnx`K8odvKPEO%2x*OS1e$`7_p#%3qDOD5Efy zcUxczd5{4*7^PEwX=zYycwGCi`ueM3Kve~b>y)k30LZ2Mp6xi>xNe15DA<{X#Evhx zUdy6P`9UL(QBZA|DlUM&3-O2M^Hzb=TT91HgO11#=R6I9YG8m$_TI#;Z-6Vr(Cx>g zKlSnDh*j;I|56H(fzvaKE|JNLu|>O587it*Q( z4BAq%S<^D+|7!Dr-+aE@MMf%|lD^gyT2DN%wWRGIR(+9tC_6{MTTsRNgEn=fOlQd> z^E)5tT;~sb83P^bQv8iWKon?rWfeR{8)=$sq`WLX)(`{1|)-0+9#a^ zTWmainX?_Iz(eq>5`@NpPWI21gKU?@qT*EROcnD5sxGf@360%-mTF7Aw01t8&LPLs zzqbDKB84!GASFi)obwiT$icHw?KaUfj{*GfvqywGfARU^F+9d=L5y~egx_K&Tn*+w zpwA&LVh$i**nobfDx*yqi?fQUY#{!ABJ+>FT))3KFmUKq_zCda#pKuaOQw~Ryktin z?;Bt^QDlpI_S_N)q&jdOdagysxEd@PSbsrubMCD z%EHpt6veObx(^O!+#W<9{7D-ODx7OV&(PjeLLS8~@^DMEOQKYQeBS+?nYL&2Jx>VE zz~GY!j~=xy-HST!z`5@^FIQAC=yV@%A)PM!oAb8B*$uWOd|>|XBI(3m1?MGB_cLR7 zMUBMrcD*vqHOWUWpifWSvD((|wXZ-)5jnyY1W%IUvqWB`f!0voP?ydU90N(_&(uLD z@k|{sX9giH!wt1D}SKs1V9tnTNDye0#Skp$ix2xlGj~P)YTtW6kttalH zGa{#>Bvj{lq>~S>Vstp4dW5#`P7g8AZSC<{q=+1P@9z=2W>g;C<0>_P?k#lDQOcMB~H89 z`$m`nmilOn`s8Gwb7*qgyUBVC*q2e1Y1UTkq+3MOGpXs=(-!88Q1i5nM1m%s2@MA9 zLVHzj&2JUAMCH6DymW<-&2#S_$NNijJI z6~QL9;j5K<2o41}!)1EZGWc^LD)DTXbEr}i>Im{Cjmnx(tR^<|i6U~0UiQQJ>~akQ+Ye6XBn z)>ebgb}~i&V1w=|z}KV_Mgl3KZ)zP0$8eY5OQyz7qUNZz4BqJS+(v8SNhM7u`)hLe zek4coT_Y^JgyCvs&HS(HLWjZ0S)k_9uy7|I=9+l8#+6HocIdF|TN>W|a+TI;&P4>% z^61Fx#S=}OY0_}m?1iN}O?mLbH8`S%0Q;9M{^e2dQ#l6Ivt;uANM^PS7FoJxSkJ{Z zNAw5hd%B1Ddv)Mu^7N=@MdkTf)P8W?=&azn|0ltKvtW#VTQpWFQ^^M=VKoF2sn#tb zo@-*lZlPs3{H^w3#07$yl?RCI>wB+8n@TltMz~w*JzpZBbq|(wAPo~=O&DyK7Tbq0 zG;|o5Q%qMCzaM75h7)~N?B4Z^0JYMm@71$oH$*jdMY_=BjWP%nyVWQn7Hzyv`;@pVp0p zr;Adfj>CbgRAPDxl`YKE68KWd8}5O3hn>A>iD7Drw5bOG0t?;l^Eo8_$El%NeZj8JAtC-36u>Q96mwF>7t1cbZ4{SB2VvH>xsHi^+M14Z*Mo zVBu{zR1?JXBFGDpvIu`JK|$eQzjV5228zI+3@Ma`%UxqUXFbmk);B)~S&wx+`8{?Gk@1HPB_)9i1bSksRo`$=&p_95NsC z64uT{E1ap_z&8HQ8ZmI)+avTq-7T#7`PGpPM|GvjhMX&@)?jVwodKk*@%$pyJ1y7@ zWa!hREZC-H4#XyrQ7{8BwksS5*r0Ml?JrXlL{5ir{E=*H%s(rI6c#%P!eB!7 zE0-7-A+4uUio_5SFmFJ^1?;{e)IU`(o%)A>-#%CHjEADN#az>p@2`1xV@{h-`v<0g|K{_*a0y3)LA>9pC~Y zl#nw5#yY?C5SXUcTi0!RvT%cWe01>i1J0SK?*wnE!++BJyE$C#3IokQ$|t<~@ zjbr|&DAST5Cq{orZy^<2P>bE83xWQCNxt#TpzlRX_ZxGsW zMo1<+7883~*^B>M{@^6C4F9OGkA1n2?ESZlaR0~%9p)c-?9EXuEm~}Gxc4{A0RD*? z@x+iKxxM#RX*Qk~OTJvw>Uu0^c@34^Q%x9$m5|f>9BZ{hlg-ndjoKLWjZ=iieY}}? z)gwp?s91K&Xjl8IUBp;w2iKWuZ3;7G)`~hg{9F-F@@~McIT&{_{nTsVSHXU=KmuaS zxVc7@BPVoOhJLHS|r9lRt@qGihEwOW`<&h z2&)uc(C;97`mezH*@u4stLGy9JCSJC7yk{9KfTZ&cw7@>9Ci)`_mcCUd-;Pme}@v5 z|8^7a@6f852)xzI1}-t%Q5gLnm5}=%wEABc2%N`n)ql_9_P?2hCkujq zV2@+%j=_14(>!bA$(G_D`R;NlSCS*W;c6(!ndem|uD6|Fti8C}k2am4fzuZ%({x)5 zn`%PyAyQ$IGxnoE=(&Op4X^i4zW{eopdxQW==}$z;mHb&{~}HA6)3>lPP%m&ue4)g zbAW4U@xi7t^@X3v{SYR|4`Fh?q%P4mSVR6tn|6`}`zsQ7tTp66JJq=q{x>IyBnZe4 z!{#XmxpTdj1zYfMHurzfDCw*IcQOaMRuELtXCCF3>A+6w-}M{x6UZF>OS_=@8w7)s z!#LbUkqq_BDf|~b?EI@9e(P|!_y4z@17JVj{?oQ5o$D?#j+}Ra$e)wVI2ntdIzCJ- zg3)iNT;5w$iqvE*ek1KG3pi^y7p>l?6mwJq9U+0}MQo}_GKgme4buG}4bZ)_UR3bY z&}G)dCpkLagOefI&r$*WHbMOnhYXy+ye(@Mn=k$z2((r-DeI5HDX{%7-U_L**Cjr_ zIx`J4O+PW@Gbbke8;H$e(V^fNL*I^<@c&WXc>YP=EdGPz zWN_1~4Ck(z`>(DV+p7Xqz7pA{i~dEm|89Xu_>O)X{l97M-M?!q@-YjbIW-9zBWHqI zq&a^t<52i-Q<&B}5x0b}jaT_XwC9;SHS|3G^4>t?XET%*Y-(?jt8Bq;GH{@U8N6iqT~=qyTWp&Kv|oY)fW)*p zRf;?~1D}n-2xK;AE=K*Z=+$bH9&W*+P|ANujfpA~Xzc@4sebx0@!WH35Bjow-G8_V z93zzf%`9D)_$-y|9FgP2^|J%(ovLwwmTQ`5j3~|+_ve{}kKms}0^eV;^LiS*6+7ww z4yorr_D9X-DQ#t#wCE z>HbGc`-L3*1Dmna6H^y1eB%0Wd=fBbqNO#dkLmYC72OX`K6~3-+Aq9NTCl#oyB0yf@_rUmmYP=i% z2Q(bWlLpPO8XWMX0UV9eEAxAx<_=A2f~m|fy9ly^`W;1V28!Fs!(7uw4@XBFORp}s zjYVweHayxu)WscCHnZaqOTPct5lnHL{F=Nw#8tDTOF^O(-GSV&&i4Y`B&s} z{KwAkXdwblmCq-u3G2ZRr}*O=i5YJ^Bhk6GPC{YK^jryg}W7BP&(MmtRR!999(Fw zyz^I4s$f2Hka7o(2UnOeV${NdC!JAUn=v|uBN=atKS2J6>mxZx&RT5M7-~l=9}Mj- zKk6JSjU1|LKML|1=8h?8lWS{y$AAmC%FuE%YE9On&BeW$gWaBDou~0{Roy3+gN!Vr zR*jZl+Pz_>L?4UR!PYA8Scy_KjdpigIVOLZosI_?vhxyJRc7_Ig>>FPC=|Uo3B@(e zHYOMod6nn~rHNt+y>mLzj@c%O30%2%i7^Sr#_{oe6jvXo96cfG9O)8(jPVqE>oK_; zgo_aQL;@|tuTpRpC{U>dQ1u1QG8N~4ahsibJI zn$x;nd1uHSr=hx^Z~&sF(-ZmG?DAQs0x0+iT|lJN^wkp8x0|c!FoPqHOU@;pdNueC zPw=*KjfR^q?d8qv=)5`AZ^=jCT7oaAuPxSJrx>p?e(9j%$YIo5N|=uXq`ds91U+HUEa?p0?Ic%w^jM2! z-6+7}Z7gmSEkr`oQK_-}jiOqYGZd2&ht3y=j-ykchUuaNp`>$~=#km5#Unfk&7vie zw57EvmxzHxrl{?ph=TTm7o!cY!FZ!>O^D?G7R`atb<(-f#gzvayPfUk^H!e~fX#V@ z%{eVIW%hXx@_Ic)cNzNDCG2MO=NlD;Q5KWZ^fM9+HJt5hS?Ez}ij7awtNFNhCA@^W!|0NCy7$&xY^_b{eRfcnhIt+m%j7^ z;i(T&Q7(=`EiO_{3*A3C^K+1rVOX zm53TB!Z~@C9wSnJ!Czn5Q)`o^4*aLiVFTZK^5>slMl@A~m=wjIiivJOvUa>{c=cUdExUSXcxl$u-bGQ#R5#=LHZJWYe1X~` ztdUypLL2E)P!agjtOR@ZG5H-{F2a`{I1$61WN6g+v}UCRw0P9CkUQ#Yj1gInpJrpT zs64IlM72;Cz0^J&+mT#FL6r zDGs;N+%SHWUI~k4SZUKit9pB^A-+f;Dil>Y)Wg6{`}6A;mKHXz!RGe1sCdyA(ER2% zTTK33?0NiqDGJKi;~SqVnOk$6pvnZaD4nqe>|*HVNe&k%KRq`SW=!!EmG*Kvx)rNp zKXXdpT8qmXk~fUEQI*ydX<1JTWS9zl6kflRt|4MEF>x;RzCFL_PxA|y$!t?bSleLOc_MZpce=o6ZPF3IN z*Z;QGdVJ{H6?@NH5rX_fGg8qk@j*3IUl!wA9q&!j5;7)5td96&qRdH(p-8F-cCZbj zSM8N^T;pd14~pkVXMvasdpVOalC3U84EUO2j*m758HQ1-=;GFMRM+=A!lnSu{KrvD zR~lUrIY^4js{G@aXQ@W!DeJ0 zqxKrhb+at{jUxJ%pr9N?knnyt=3K(+!hG8p`4;p!(N>}+K}YLw&YhU-TLky}QL3!z zT#NAfZ*>M^b|?)LM441R6=dWP#H?yzp8M>8?W#EG+3N5TrRuJIgX7SJImr;&xnbh5 zf*A5(@by^?@~BPmmY|TqHU3EmY7Cqj{J$iwX+8Mz>4Z)zs%v5sfl#4x(~8gNTXa`t z`8rg>_A{z3-ugnc+9N5750|9`CTTjXPl_WMM5zDnh6ff{bXv!B1P`kj^^RXi`Eqsc~N3B2qU)789}Do3AH%)wt%>Tn4Yxo}^~x;UoB3MWRb zZHHFYdtnr1j$t^*WmSDq8my{z+$*xajERIbeq8` zT^A$xsrvPktDI^NYeLVyKmakxccE}-$kC*_e?FO5fn|?6Rm+d7=8roz;(3qaanaWG^8223IbyyO zLf9f69sZ@qb~37@7SO41?8-zKnybhr1BYSQ=Zk9l#Lj$7QFbn6v=5e@!M`JJAF7tF z)Q=6cYsM%Tj;s`eeomQWf~w^PVngdLATRh`fk|S5$`Cr|UZaP0!}tZJ0S70Wn~OuK z+2VUcr*H`<10F#7`P&gy!&-e=B-|Xz1Ng=fF?^~&-2=bds=+6q_7vmpH?-gp>1K}_ z@sPeMN1x1R9>%qmHOp(K8n9r7^?>1qqu0wbxqJRReF8(-Q+~5f160@cCc&dnO$1IGn~kl!^Iso&{1AwXVB^;MQwu^^VWQ_cPs zp*f8*Ua4HadyNpOC0VRuLS}xZ>8ESDiTP{~`HecJoj>|ETi!oSvHE)b;oVy7qAw8w zFO+)7^j8#)W)F9E2w8Hj$HqiZiL^M~m^mD3C+ZFhr>e@n!E}f7?&Dq61iX=i&GZFD zK&mzq<69yxADA$_#F-{yHKp<6d31^bM7@)_nQpH|HD%+kM?D|Tfz zA)MzUP9mNZ?oRd*o=(4@?8)Mmy571?pmU)x5rG!nWXwl~ zX*ig5?E!)*V1x4gr4Y~Hy-sU3{`%ONd8(A$$MFa(GaDQWgl3hC~8!q{^asG1ILy8mo5r0F65W z`8I^%j&H5U11`P9unN8GV%hb7zwPb#UJ&Dw|q=N-bX3wtBIsYL#DlT6$CUD4v0 z^0y_lMrdZ;?`iPdrw`T0e0+VR5)F3+1F%R9uix&wT<}2AMw$$JIt8{U+;IDYrr0og zvdf4C<$$ilnomzUil-e2dAlucsE~xsXGIrARkI4OZ33$p8;pu8ZWvbMi%vua zc(}9-EA`Y_X?X)g_TN%=Lvyc&s_N=)wwyF+U{3a61gpWSF2gG46mXj2KYrvJ8-DXu zFSlyt^~rA(d_0^OrUFMb69OhS@#0+Hm{rP!V`?y185tSExMJD3cos*zxD3OLX*D!o zR5m{`Tnl{P?8enWQaW86X7d#zUM`_4!r(CZWUsy|RnMF^Pl)|4hM+&{Rff1|h8N09 z!CWZ3@*!O zLy70qe3L2kn<2tLQ5=$Y_dq-EGOPaRWE7sG>A0uw)jOv5QxKaMEo)1qsw8TjJ1+zq z54Cl<_VT_|8Pxo&bEpyzxYR0%`@CR^US!8lns8Pq`d}X5YTYxIQkk)yd8M)`n->ve zfsUF}6VSBb2BW|x87O>7g89WuZF%_mB2n6x<#b>Gb6y9I@2Zbi6E{QEXHPPKvASE| zc@NLe^p^V4Xic`_u>Jd^fYWO;N)f+{@wh12X8!g*+2+I zyAv1lXH^%en5X1ULHE$V>bh(tGNToce?cEp*`%}<43uhxT%J;=m}sU#?A8h?%0;2$ z)zYw4<0;pa>z36>tjIhqO+Gp)e2azc{5j~6|AOxL3D)+a_p`UdVVnp#*-hEKk7j$B z3wwj5{OalngZjdb#_yzxHM(cEq_2c_n#RzVL|6=A;;u+v*@y$bHMCO-ZfCm>;KmHB zdY+U_=yc1^>+6NC*7w=etXD`oHq8E?uFfhd3bxzh^hiiE2#j?2(g;I$HzSR-($XPF z4c#>iA>C3+45CPf!hjd1HlJTG4k3eOM^k#>DA2aBwz6F!OpYM0QiJJ^^iR?I%&LzZ-frIJO~1 z!!R)Rt%2`cSMAv_iP_doQ|2r9$BJj#b(J zos;$%J4QL*JFv=bF~V#TLqk!Sny8w|Q&zxr;kB#?3iq$vo=-z@=`~mCJS<$9 zEH~^Tt6T(wLvJ7sBmu}k>Uu#XxQy1k^h@heW?U7 zrnJ-^^EPTA$op9Jry^=XidZJ3EL)YJrK@SXoNLflQG(9U-yuvQmMWPb^&xyP#E*HX zaRtQOhlXfI^|qUW?z~U?dYH?F)RTvf)9JS;&V*KNiV$M;paQS9F%H~#L$imM;cp%U z+d~<$_H>>Mcu8mX?;13ymcGs+d*yg57(e^lmY$N4wHSZNpx?f2F^C?&GD~-B3q;0= zv?1VRA11gEK;Ma@ObT>I&!WOQjS$R{yAYZUI{OKw1~vP@Wha42$n2@liDZqgYgz?% z+IPxkV|P!2IdKJI20}}^$0x?E;Ye3*MW{cJ*|wVDwnYv(;VASFJYtmcy2D0}=oE}x{7r6ib>_-2z(UrSxLiyAh=BDG7V>KUg=ySPxO&jQZ z7$t?{qmi>8npZiosuJ4b9Cl(B8Nd{{5ULviSDHn&s7~8nT!AEiT3Gei%-u#s8nouS zr~WwtCqfs>pcfKdqqy_ulQV0*WdmBQhsIa-+Q0pDm6xU?#&QPR!Mqw&+ycVc&NwpI zc3ZS1^yxrs#6J0o7VKx~(}{80gN zM1vEa#WRE&+$xICmdjMqrJh!nV`N>R?6vD=HD)@cpxbrN=EkOS5O24Jm|C6 zMTjk5|M2!o$ur_Eom5$X)(XPTV1CxO^$Gn-xc3|v*{vPfr+!JY)P{PSS&!1t<4Xyd z)SCI2WNahedagD7Vy9In#@ynM%ZRnfj~Ch!R^(iS8kPmJ5lQ(vsS0mOd6m3C)bU3@ zsS7QDC3g35yhV?Sl?-Z*6QJ>#-fgws-zIU$);L$Oa}1hVWm*ArYk5d&mnhOC+FF}vI5+V2=Owe7#9R)^R10(13xNprDS3_=*Q|GD1^$I z1)Eu_gQkOsE)HwGI_U3KeV;ijjehVwca5{!&JKm<^Ly57_Dan*X+fpC`el|=CsdM) z6u%-1e<;NW?X1KaU>aLHwIXBmlW6)K#-OLM)~m;bnNBiPzmGs%Cdh@jQ0fVHqxEJk z^%xR9&Ek+Ya>P*$i`_pam9r?yavwjiV$wx}czW0qjUWJ;o3UPxr#9wNoeRi<*QWu| z7aPUc+rKfIj0Wl8LNoFox%Nfu+!U%0<2H~8G4}4Nv4@6p%}f@ToB+rL4QJqXF2-vb zaDX69?qVMm^#sLQ@$x=w9rZ;RpOtYnUSrFlsIR>@tk@OgM#|JCe=#Kr|2 zT=Z6zvcRWLk%aVx-%1Rg3HZG103&i$+l*fH_GDf50>C11WjlDCN1}+7di-w#FhSBZ$|=m^85Hj zrk#YmqWdwm#T;@!afEbG+Ts%vPrceVFU@80;eOT()H}2&1G_>p^9mx{ggvXD_L<)? zxoA{e3>BS>I5dN&Iv>xghL-etkAK*+^m7k(`hF?QzQy3X6)LThV{j^`71#%3Zi^4U zN7gx|cx`kC)W3)ndyw0?f=GNi^Enm9mlH&+rRZ=`j7VRc|B3V^Pr=qcMYWW-_YG>b zJcMoGM|L+YA7~8&>)j$GRM?u-h@A2CO=z(d77OCppiT=7@l(s;QRId2j2854T9K#C zNxFTI@#%X4SheuaN9hC2F|B})j$~$*rK;j|{XKZP_R4q{frICpnrY3mvZWo9O#^iqQ{PNoX4+B|m)i<(aLSz!VRm3JRGcvTLTYjY7zbNSDb(b2o z(uP1&HH!?4PT0c7V1Hs`fNUq%tI^3;!E%%v?N!FFXX5Nndm^>GQ$lS9NyN3Pn-3}N zcDU{WS^eHJYNP#ltk`d|g6ryU#jjADSw8L|19jiZ@%&WcsQa1fpAar_*(xr9m&!fP z$V!%WIqd1x%m|FTpOUki&pv!}!=)BI)mE|H)(`mLr;`fN+3(ZmL9p6yVI5W!OR`-b znSOrg)uc|uL^gJuyoX_LKU|)AEKMFGOysid+dAr#IU^(;q`;EM`U_vCkR7A=WcVJG=A{r5}l{s-}*1;Jlr0wyABB#S{2BJkPRc zA}!9Xd8ajTDKe%JeR;rDj6+sM7?P+K`n(uV_&}!c(dfP8FM;HFQQ8M-6Te7}@z?E0 zv6?%}4FgZylwj|ldT9ss&4fCG^S-N?k9LCN>QVGrKl5qGsGGi%WC!bCRtgC(!`e1&=Ydwxt6k_H1v<8F~#1 z(}LIu3T`eV047d2&phd7y6Hfm=WL9ddMu>N#}=uT0a@PK4w1)$XxS7;n^F-f+)DgTN z=~$e!S2jsBUQ$|v#6_B(yYX8((wNmGn%fKne~5U#S7-A2Vuax7*7JmsQItr#?UXrc z{QfyE(9Su+*7HAGXb5{3d0jPeIkned05f=M*uRQyeh46~L~T z&Gl^8pKPp;zP1{1T!Ku`OA$79oXLn*?tD$5VJ^Kqu_Rn1nsaxKs_A&MMX#X+byq6i zoDIifEKIkAAS6y88Jd}lJ#ahTNS(u7`R{+c?=j@{Z;^1(nYCpva$9q9G2JI2LG z6bR``AIsGgcbVj9v+{%tKcCj`*Z0iryRAH-T)vXX>+i|57dW~p*xLZKnYUXw8ic$D z%FRUq=C+!#SA(jD0ZH#wgJHX*H9OxwNkjXuy>)I2AB-XXB&Kmm z0eku6m?()f?Np3BVY&Q*u2!DtXK*`dj)ZYW@^Ekpjszo=iSO}67u&$Rr&iR(wVYD8 zqA1e`+)GZ-MN>81)^fKDS1Ei$v5Gy{Fl@vm*wXz7BdxZW$>NPFaCrY^B1yei*Fz~G zgDeX#L$9yN4Vs@nA9Ufh^yf#Fx2guE|?a5w*o>@lIrePJz+91 zvggj$SpN*wQ|Vt2&av~p#J7P7WgdZ}mBm804edyfjhg*iCgbDNo7|?cM1yZ{&P=_Y z0S6my{GM1yQqvJq!3igIb*>DQVX!nN`==Ol-$qfP#@a0ZsAFB*J4qrok1gW)g7B9t zAWjm}cO8Ym%%SHm(+5_Vt)${0_J?sOWo0My3_p}r*Ml%OvNF>xKy?$$dOxbbUg5En zi(ZXwyJ5ip`OcFIwcU(EI|_`Mo|m-0^zLqod;3a&r<|fT|* z=FZJIvQgaEa+2daf;UZsX1y|o_5sq9CwY1oz z_6&LZY6BgnDfsQIk{)DS!IM${L866zy$uT7a(~q68#ax1j@Aj+zo^q_StrUGe=+{> zDge{RCxBX*qXD5>7VX?;z7G#d&wz|k%y+vjUT4QfjJwKQJv6S86DCyrl7DF5vL z!uKdP;>*_EL;1y#_uKg0`3A3;7}vvSS}R|jBC$V63Qm$SeOL?2l!Vj-_K3Narl7LX z9ojGZKoWWM;YF-Q2R@P%!>Y9689+jjR7%2Ge|uJv7o^(7NHJsjx`soFQtr=Srm(We z8?Hl}O@~oghDe|lDem1Pek)GOE<^kc`H>}@Q+k?(^qw|%7J;ptunpEuReCp&lZsnG zXzVWFHM7Y5a?Bx%hy3SVrV|Z~akck> zQ=~Ef1^K;zkEVlh@?XFkU()=6bK@`u!PVhX*yZpjI19u74G;O3`@iH-csHB}^#8s4 ufBU``f1*bI5Hn~%f6d^Z2pALm|B>_m9XhxEJH%v*4|mKUC#X*OxAh;aRSwQ7^(efDfP@Eo89=!Wp_k8p4mi*sMz)3u4z_jxMg@=<2IvdeUt)I% zZqK~0z`$(5!N5@eT}fvJbVx!fhHzh`dUbPjDzCL3 z1zgiy?v=*(MpRFT5ABiu(fTIfPBhK-E^z=ZPfD`%ii0qA)CsQii^;AS*6Kyfeg=Sd zEf*0!Ah^IPm&TN27f(na{=s8`j|;^QkvJUl4WOO$T$x0nDo4!~)fz8zDo9h2FSyXo z*qkkc$LnJNIWr-0G-NrP)vLZvTLd?Y435jysqXzG6k9AjB0pp24KL%myhbHmTmt;& zxcLQ5(Zta9R2^T7f$>B*s@mWpBr^xUT(^*mfsAG9zy^-pNceXeVOQ341Ux!!1;m27 z*{iFBg4wz(XpfF_L*8{&qq!N5epJo@*1{Vh{S52f3Q(@9W2!kHeJQ=xqDa;$G7d1o zBJVx5rp9oet;wgJN{=&1S5ZjM9+kJS{+{RxLd%b0phR1O5{>rni8i!#Fn-CjSKLSW z9%78XRoS1&NGJ3YxS0h<8`+0L

9Oo^S2Gpdna;9bF$49;ubF3UqVd3~+O9U1V0~ z$ydwG774MDP=UX-C>bdd8ZQ&)6OFz2E~z^U4POTX+}Xa2!x;fG68b zF@vwWYS+i+t$`ZVLC2>EIastf?wPc)>*?cN1(Sno>c!!pIxdu$THzN%qh zal1vi%oo~MpGFGxy1{Si>1_+t-f`QuC`VCBf9VV3?Lb8MNE`FzVRc7Yl=wy*ns1Ow z%uqBo|2%Gax$4a)#C;RyrYLHiN!p~Mh?pIINDmjB)u?p{Cy7-#=wdHv*=*kXf#7} zRD+@H8&nkdvE}#aHbETJQal73&o=!T8(raqM5_b4UMn68=T3WF!WwfpnWE^1unCp2 z)B8He*_7|^S+ozxKwcpHrSjcD3|J<&O3>oOm{oO;50oCD37b!7Zv|Mxw zmsdp~!5JvC-2TA|xp&00EU9_02JjbbJ z3~|4P^?19{N>63NM#_fF86lOXmzI0NB#H&}StP?s=WTyv&Y~pG^-LNemp6@wRsBj% zqQn%NphR}giRZ{Odl%aW^RklvJF-B4(&}pU3se5P0P=4E7h4BQfSIweb)jRYUZPEk>q#m`ZfG6aDg+%lTqy}T@c>?K}{_APqJn1plXSr0|2KD0(ZKOH;` zTjL|OnnjC`YBoo&?xXtf|GXbQ{(7IhE<+vNDaw1e$-29|>?x37x`@#e;Zz4T9C{_& zwQl&#N7S74MuNGdWOvA*CY4iswtuQe=NX6S(6LlHt@eCsBI!LPe+2^a&z`0q&__o{ zx70oZ?TsSkX#*l7g~pc>YOmXiXgoNoUuP$lr@pTFP%oKqKUP2Y=3GxN)*`Bx_b zavLGF$GrS!5#QM9sw49Awq|L)z!n6&4e+Zc7@8w`CQ3{N&1kWEmB4^}_g;Zd%b`=b z+Qjk=Yx{y|NbSIq3+6WuZBYlhm%E}w1p6h8Gkk_u9ka37H_Tj0hCZJUZ0pvqr8x@8uPT`;Pi@Hyg@Y(y)N8&Ff-_$PQr3jqf;2QXDCFIdr z2{ek+XlyTjI_HZIj`!z@eu$L{LTa+dyi>7frNNi{ zWDmNFh7Q;>rkdr5&t00Vhb4}O$Fn`4IWO@~QR4Pg7zHDWvJj{eC~3eE*a(V|3PqCS zV{{Wb7f$Vx^+lCn&rPL5D7Su-I|q@PU?uj-lg+xeC>`29?h9Pr`lojn-(>4Y&yVWW zD9F*R%}XgnhU+KOo`pA;As6gaYEyHJ7VAK_U9u7+8%9Nbx@8t)CcU1{kUKy9FzOiH zrHHg=Ofk!`$$NGlF9l~bWW}fp*m)JY4+cba8Kx$QvJi>)NENZJO}a^AjYm%v5n&3_ zg|6>B*KZzNe|!3#8H_5JJ@-SGBb(-N+q=PpcPuMkSsoJd`_B!3Y#VGu35>p-1VY*P z7fBeAO5|^^ymu~QldEa7yNKy82i?yi?3@`0nlEc(D-hE{Dt^u!P3YgzzL&+B@|;M7 ztIdnUuVmtyvdH~uZvEX|Goi{;jsI`G&@vrR!56oZdy$w z9<9Wlt8Haa6n7erf%5p~m7G^th^Kp#bZCQSMo|^U?j^B?+haVfpfeq#0F%mia zZ>!E5v$W)k7F-{6$5;#Pv0Gh#h3Bw=hB{a*perUIJN~KJvaE04oP~v7OHJ2yizIR% zDfu;uKPW!qm-s-+_G#@(PT5&Zv{jrA+XG{FiohZT=~AcWGw`N8NOxVK{K~j+rv>Ab z1!jkL`zu|Gd@vpXv&f1_E^u~e%u7~ZhWj+1{mOI&I$`MSMEzJ#_tjP;_T)_)EAmbc zn^L;YoDCulP);wyECrOj_t!-7@*fSaAhPyyKWcpJYD;L0S{xuaaQmo&PjpyV>#+`% z?LF{N+av$?8b;oJ@%9Y#LLCLc{{H}LmS12UFKfHRgcy7RaZLo7JEu8zPS8so2HE9| ztx*2ZOv3@fY8hFBAC4XEaXO|rQ=(qg;%M%-aqexcyf~v-oo+!+{V-Brab~#Rl&+Zm z9Jo0;ieQ!h%uvve%kqSnwOS$ItdR;T6qT3mzTW%ugm z03`O)#$&Brd(zp8O`_4{Ty z6M}NnY*L0^adTBP4A5*T@HtnLuhSyQhCU2mLlb7G(<5LOVOM2wQ?YsruIbmxKC4XJ zhO>v?w2AWd_9l~VnnU^p^T}lmox1t6n=LD)JWqq$9>avEuP%)e6O8sxOBIB(J~=EW zFE%*4*_Hb$5wce(J}W_~;$&ZVpWtz13m?(KduNhu!j3A!h`6%m=S6a}o?}e+EQHkV z$edo52ZSzhh`W4Bd=2xON$q&O%+W*DqbL^;r^4iVa1f#8xK)rhZwa&1kboL? z5#8wi>hH^BC;V)n5422z|MxOs{f}j`Y{_jMKNfUkAc<-PeAU++U28DifGRaZR%CN? zK)K|UM#4XX6`pr>>m^0g;lYx|?~ej+-Gv2OCiC!?#!LRsKWo}DuZA@j6SlPIj$yQ7p@I@lW z#ATM^bx9396wEH-foM~td;9pb#y~nR4&W`sXg`Tx2`c!^NFxVd*N7%` zAWF=JCl!}`H}B`c__bB7CQS4o6-2W8A`QOL!Xh%2rkR!)e60$7;>SeDNWkq!Ihhpc9|L{&#Ko zvg-uZhK^>&*2aJAIspVYDFA3NFaf;ZmHEHKehL37_>MGWZSlmh+uxoMz4NfOrgX-Y za4Maz!84nFSEDtv>B_&7>F#XG&MNl<&mvkmE!|HlpA}0aiIQqs2VbN2v@m0#shv{!f0bMl z&B3erDqY{K7RnUKkFg0mxPl*DB0q6KgYh3m2Tx)q~mMl_t$T(uSO`BlWnkN)ez;; z5CKK?x@~Ueyv4R)GV~kG%QnSY!}~a3*IpAdUzG|pPAcXWaYn%hy>$wfOE^lMus-H= zG!p}Amu)!HO6Zb4y;`Wcg8J$1RMB3)v4%9bfroJG?ol?a0XT&=Iwj z%!fgVI`*+O=f-of!^hxkzrT-P?YKpKyxtoAfFejcFiiTCd?MifbWyx5G?>#Q#wg(P z^I&>_k_0e(U>AEDvuB_2>fDku}(!oKn=jfgk`?*%SuZ&lzsN5}sf! z634{2k;6XHMN8<63PLw?#mVRhXi#bfw`-}t1?IwSYRw>xWG8z;qwdNS8Q`#EpxJw5 z=&8`(5@0w`zibY!%8DR8aGe>$WpK=lPm3RuLRGMO21i1^xSTsvbHH!~mF!tQK@hf> zl9Xm71e7Bl`7NpOLRLEXB|X<8Zm_%Rk82%{aP0yGN2PZcJUgu+ z-*@8WLh=g`mx}Gxd)p}~QS-2m>{X#xw{3#=Oiv-AlA9km$fH{186dxyt%b0mpgx+= z)G_8N@LqA|on>PhzRSg3!gke)&{}y@SM)hyo?Fd7dHpFU$OTV+lOMdMecpBD+wvEu zxrgz&W#cB#MGIcWY6Xw0Q@vdSR&t5=z%6Fu@+y-E?PL?VqzSrr{OU6gBXF@>z#_81 zDsy`mJHJj76m)GbA=P;ldvI3g(P=U8)Hq}^>Bhj?Obv#@iZiBSS`QYhJ=TB<81yn7 zfzQKb?%ce%TShX&a3goDhIOTI8A%I23KOV4JyMKVXns-#l;KRulmHsHX#!BNR0I0H zr!fT)r|5KkwX}OTSH5oLkAq|0vIL#c)aSa+r$Z*nM_LkHw-PQ;ibH8!W557G>@4kB zFz!aFUeQ@mGV}yxQ*5sktK$XNGUDOW_g({XyshBkTAk-}V@d|yJ0N}4g1Wiu;DFRH zUQf-N_IGfuIzPHlYQY$Qp5#{Z*(oCw!@Db1CSgrd3IXZxmN!sAnLIJDB@H!*)@CUm z%wen50iVyS*gDI13wjQH;=vF1nv)_1dOwJpVyV>~9U5v%->INYqDTPE z28#@c0v?<``3ti@ zQ5NQ#s8Dgv|GuEgOzk6AiqUiHQxtYgX{S@oGevm1PV+&p;G%xpK34=;l?tw8^)(Y$ z%Hpd@@VS~(Tz`0mgi#-1VdB>Sq|^A+c4sUJLV+&tw|X zgJPiVQL1_kaLc#auhP%5`HKftpaSPC89fBF3*XcCUABN=KSGDFyPcVs)|*BA+ZIZq z^pTtdE#Rn7{DL4>O+ne>qlw2ikMOWPtPAF{EMq7p+B$!ev};?cZXB(O3UvhBDmIq& z&hT*D9s>bXa=ZP2OQJm=mD`9Erf*12oj17+q_-8quLG+6KDFz?pcEh!=-_v+8DUv7 znJay(+utjwNMb(#WH|!b2O=uSc_TZ<%?>@e01Mnru37zZ^oR3{mGtcFuGg+%-BVn= zgV+Np+4W(9d}r%Ac9$I5XY#3WNe!>8pZ=&~7%}T|p+Oal6f79nOTQHKjslqJI~W@& zJ35%#m;zoZn8c(LWprWefmP1w=g#l6=}oP?3K9r*!EAv3k=P%PPzc`#mnWBX*LkZE z9aU18o$iID0yLEiqLN_Ko)KGMp2ZQ0i##O0wdv_+dkKu!j$bVEw+2XYAG<@d=_p|m zy>+~ZK%gRFr=wORy4YJ^PJfJe56nYp&q)u8&5gzk%CNCpv!Wa9SA(#;NSd&|ObiBBfzBb9MLQeGl1rvj4Y!>d? z*nVL8nTONRNzl`zU2;Juo-Xozo3`cGv@C`C-bShb1_BG`{2~g%aQpmPC)hxIenobm z1B@e6-NUQm1_f`l#5taMB?%5u>VO-8Ir%WIHrXYAC6!djadCPXEq6EFJ$gqs%-QoLh)&4!DE1g{xt% z#>Kj+w(UdH0?90y#QgbK^V2**He)I8aonARX0O%@kkDOG5jnz2Oel7@*0hV>_kGb^ zr>LlY1&eEJ(HP^vu$Y3DmX?K)SYi)mmH7^s*e^wB+fLa>lHI6KKIc7!#>2g-QsJ#4 zvU*c_N)%5V5#SLFEiuzbAM}*epzen++0r{9H#XAF(m}|fe882?x!PU_&hbV!$K}B> z>lO7PwWNIbSgqHQ-?eCA#dEaCj4XgJ&_?-+$W?3J)x0uR(55JP@~~?URhDb{m3}nd z`RklXXFpSZj#pgoh}|g-0G08x(P*MGVo*FG-6XvlL_a8@RCH=M^fPIA#BrantXmdz z7av;Ju^>_bA155rbfqn3-4Lz~9drxBjdtm^NqKiyZJZ8t3u+w@H(UMCsKEo6+4YmV zI>AT~tUTe%ke_OD33gAKUi+4j~aywnx?G{#7o`qCZYTXv2uQT+;kP47%=)l>WKe@$8~Vl`2N1c2ZPSp6(##t3cGuH|2TmRF)Ka zNYWf;n{Y50HdJ97nrgBMx$Nb=3@2fY{X``Ne^PP+#1hr>RQX?2wh#;JXL_oD1d!E zxNKf#v77 z0^Nd&pR=}%mf~Fj9gF4e4ktZphQ?jkx zrc08|5#q#(5HhRx$OTdyd*kGmO=S2VcuxG<&xfFVLjNPSxAB}Ca=gLaiE=Zs-XmG0{O{T#Q=U-gmDt2b@lqWrM_J&_{0t31^$ zYCg-nbsl!bn|C_2zRErw6M~o4Wy_ReI$v@y!xKg39NcL(t0%1s^{488W+NicY3klg zz-RCeIQbiXeXrVF5jl6`k!5?-l=CC@V>DOKI^;p+^m$wR9NafQ)vg1_j3oYC{Su|q zBVOb)Ii2OjL!@RC&OKUs+X)2RQnZgs^Oz*#+KIGE31GE$oVyQ+x;O!2FJl)J1I{Ws?eD7AGwE2usk}xrl2wPZ* zHE_6z1$jJICC@p9y(^eYcct6wwP9msy75T;6{CC4#@e}+5an}`Xu?op#pu)0SAyXn z8zoXS3%AN$+E+OQc`{X(<&~qF-#;U_R*Gv8sCyIfz`dP8a;WH>k7TAFGvM*GcfbA_ ze<8Rk_`J~;UXxXFLaLGdw6lEyl)9g?LgT485L(SV9S6gw0JL^=%qhs$!amEyE7+f) zY?GD*RMAyKgIgxdwnEC)L@jX2A6!@SS_ano8uBNWqxYOyedJNc7176TEtPsw3YEd( z>uNpE8+~1%I7dH~>d&?{!UQ$S?Wn9!lHROQfx0_ZhCr73W+M=G1`GIlYgi%2Ex%bg z!;&&vKUeB`bh=P^;|t%x*6f+Zom-ebQy$$Yr^*}2X#Yh_8n5dFhv``$`vd0CXaQb;<<)ss}x?9`BPNt47DaPjZu@fb~24L zIG^EIr+k^Gq_<@n3+(AF!?93NS@q-VY~#guZiXQ>!w|d1pVVkXiQ;=4{rXNsVEaJ-==b1NH02xKv~IC8oD`sew2{ z<76X_6ScQ1+Cy9;lHL^h@6K7_08U-(j54^h5j_!GrsyVQg7Hk#K%wxH(dw8ObL$rg z*0^k`lw>wYU-o2~e+WH?=@-Szq>ZwIo=s{9~yK2iXnZlgN zMtqcd>y#-eNB!@^LLOR$i*(-2QmI9LR?`=dx70NPf(=Y)c@`2|!=i~dqmue3kceSi zRL2T#%UQn7lQexxDrx>Uukll)wJjLJ88cyzBx!KmB}=@?)L1GR`g_x`q85IIEeODn#18nH@RJIi43e|zY;~Kc{)V9vhvUdv{^hrN|1|J;WG;>h6 zPTzpHU``-079?pZzW$6tVW(*n)B%OTp%pIhBce?DhN?WUlnFajB-W*PN{5wpT_wP# zR|8H}@dH^-=C_h|&b{M>b}1LjvtvVs763`)I`v$bdBi=oUSKgVS8fSS*MJC*mQc5d zK#+tq?T)f5&u0VN9x7a$|2xlqgrw zsq?B>er>FrDsEx$AtQz1?L2;CxMA_C~P-*B+pVnVC_U~l^QxNc5F zP+ZHT7m3xrN^KBt2FdC6aA6_dMPcg(Itt;zY}1=Z_;hV$co!wO<9_?@p(A{-Q$(y^ zS0dW^FwkM_>B8vta2M^>kc~F7mxP7(SealO7)ido0f|w@u=yT>;3k`B!4gWiU{pbD z4P|k`Nlb(?%M~gT4x9t-y+}9YsLx5ZpeOVF(WWFaPO?4jb!Y%HC!*lP<>6)7g+y`H ziqEc9Mpi@$7ymK`KLg2=a zf&?vxnhc#;DK40v%)f{v7B)JL&4vVx4JlO2vwH43h4%Bt`l)wBR2(cyO382@6d7gq zfRdP4XPw47hx@q?#nA@nXs?-oi7^oZ?Y#HHo9h9qC?~6UUbn_Fv>V{Q|pD$W*8G7S&KL`ixcs{?<~8EMmb* z?B|}+PZg6|G-fD6}%?jGr8nF%&~VP63rMc zp}Ol-Z3<-MUW--(%GHdrTVGa^GYbix+Is_ZyO9h|5gUbl5GgbcD53?}N4 zkCiuvXxx5U5U&P(ml9MFkIwO8Mr^CwL?13)tg6?l6Nzgkn2lGu6`WcBD%f)g$!|2q zfCKH9RndQ1Mfz>k*QZ)hX$vHZiqHmL&ICbi^2=8W{d?y0moUX_G{V0Bj$;_3$&&+F z^ugEDB*q39J#g(?)v#OxZDU8X!mQyD&K{gJRCyI`53X^ck*=8TX>KC48LPP|gOt!u~ z|EgO5JDma4vj+RD9)zhd2Z<$z^xhSgD-$~J5$ac`V zUGdb@RejlCvb=2;!cE1l8?xocxxqtVzz$!+A_G~hj;GQD3y_yO-h6UjML{T=mtDM= zThQ=r07sjRg3Z_Scm3If3bK5CD>NY@7vlP_H?NO+Hyo;lW>oE|`FoB{P;a6zA- z-pg;X7aqw!cap!d+ZNwt(erZD7|17{hW1PU#79m`vbqz+LxG~X-oYcT>D;O`F zE;7WBi`B!p{`^e0zWg*(zk$ckK1L&%hYh*dofuhx>A7PY%}5+lPw#XXphy9rZ8rgEiN27Xv_x%f9F1)pKdQLd83S})w%+v#!#3SasNy$?_b9Pn zFqsufN@>8u1(N8M_F)>Y1I2n#+z^90PI`sNQK6*G z6?wkSO;?&YvZ)AG>64aP4o?(W7ZBZ>kI4A_K`ysvx}wf<3fF+16JSTThvjPq+($Kh zgmvLI7HPXJ z{a?;rPV;_`7nVJ~{{!)hkfyrO$|Dpi?Uk?q^_{Vs8XiZQ@3xq`fm%`t(ltl4w(Di4ae`4H=qu*I- z`**efK)gTg{Mo1e%Z@PSFZch^wf@t>pKY1HEF^%y_oeUsuO`j^|7UjwG5rsKZ!JdSy2J~)c+CwKlqZrK7P?^{Qo2(_;631-{+{Rgy!*#; z*q!{&oY`~DH7hR#1`Z4Id<4sG3OxV)^MC<&@~5i(=#YdIbiw{e_3D=B6dr3m3Yg}F zoNJAhCS*@AwT?)?XnhkMb^M~e0bi^0i67^>Q!LIg7h-yFA)%fa+j>VO9J-AGt5jj(HLy4T#=Zuvy~I$3LL z1pHY#EGQ373&Y-ZRpUA7PQFww{?>wJ@OC$l?jz>-4B#r>ruoT6zPW;Adx>j zHD@MppRCDe9!pO$NY;=@&L5PvvHlJ8`%M!%MIg}PK%i0n3ACZDgYh%cUa^8wy-e6a zr+!a4+g~ZHIXHxteMe*w!D+)9V?5LP+36+gmSxVw0jO<&`7*4hNcaaV6Kyrhu)#Av zw+nCG-08NV3_N*mTH^@MXd);wMo|h=W^S3m6J)L>CTew^cOlcDthnT@JSbIEj2QT3 zpFoXSrlQy+W!y0Gqzq}oYIc(3nT|Dtmh9e_`r&veztLj$?l<`WCUj%>DhS2|TL)&f z^i8fRHK3@xQspZ&_+X6is~NK+557kegkqs5w;aiaA(A)YBNKCYXcVg)VzpF`mP z5FFzn9Z{c}`w^Em;$Er_I;>@YC zW#~T$dYJ)aCthSsYRX8=Vqn6x&MQ9Kse%l$Q_`RA@-eGOV7i&5H z+3`5J?=W>UE;6udVKG>u5<(&i5u{n)xeQ)~BZtD|aD5}!tXLz)p3sN&EzK|U9(0Xz zt_$}DFuROFn?_7-#fUR!ovZYjkds4<`?Hu%TVV3tvv#kYgX^+AQlo1Ho)8jhO`4Qi z^ErFfqHQ7ZzY_}cJZLU*=Yt!nV*l=0G0Iqr^qkuNxzvCGkp)=2K>wc!5PuQ4+B#S| zni(5A{a%nja@2O);Xy!jMLZb*6s z?QR7O?L7!5!=wj=$fPK#T^u?ecfx1q-;#2#1lNxr;HuiUcq}QFM|VCgT2of7p4WZp zT#*ScJKWFr&^RUJVAMS=eEPAwyJk}uKkIgV(X@1;+tRu}dBXbe@L1(@_q~DNo9C_T zs+)l-fNNDIYjU?Y_{&k9_lZl{?EK?YJNCA@&q~F_&fwOpvWwu z`>w;>a%~$m2ycrXX74Q8*T&oG=Dr;teY{(#h!12zvTWq`zW4q(XO+Wt?G@(pKtc%RCh)#7o3)lSC!QY zhSQ!}RE}>=hBdU%I!_m#jxM&Nx3+6M-g~WOraj#7rwv|Su3ot;>D~`M9^0<&9A17Q zvv97j4zIk`to6HlGHR^3&7tSi4fcW^T4FJ`U^o1 zrRD9EUxeRunE;0_SbKS8*oE5u<;!OVv8i$EbiidjmTvOyx#i5E0K-s=TiyvdN#B%~sVgZcpb;K55AYY-z6CJH} zm04r+3-^c7wQBJ~hsZfIA%5bl<|4zSPPhvFAt}>XqDytMqDy63+q^Rw2#I2J0FijH z5H{f5LAGRxT5E;;FD;J>OQWtz_m_w501*oiOGu_w!}zARqs7Bqwq5~Ms;zlQcD^O- zIPpr>jJKuz4b*)Bd63NAvv0*pZ38R_YnUbv_8+^g`r^IJc7{-gZw2f@O+H&$-)Mm0 z88F^{rdsptA)=@trU0}I4lPww?~tamVO_OxyF@GbfYya09k1+s8F0RZiqB6JZMiz4z6HT(qDm=+8@5aGaS-DL} z8dp^M%qiMeLD1G~NFq-Jm&F3AN19=Iv|YhMiZ2NT?HyhpxZEu^Hb&ygj~L>-%Q~~r zEB8sghP<1V5$yUTkG$Lk>b`u1KZu-Hf5gO!g|ZseF$w!jl(c@;#6VDFmUlPK);oaq z(^MF>4#6?UQup^hHqZLfFdlR*MGoa1J%L3*{(hyTuu-A~&k7CGOCa%= zUy(HqK7eoEsMjf|Fe#rf|DjDg7lGOE_5J;iasoRm%2=Sj3;QThS``T40z*jH(kNvI zt+4mD!ei=#j~%Dn4WyD2_WYn+gSjcCemOIL3UQteN+uo*EHOOKCir0D{b2B_E$-MU z?s7#=c%s&s?tovDvu=eTg@aW;?yNeoC*{7;hhUnE7q7)>i;hzFV?0?nZUU}CHR@yYaMPhS2OI6SHyohhoMf}faae?FTHh1p2#+)afftbgQQceMaM+cK{BByU+ZVgQktQrCsxr#VCZ+I#Y z7_&)EzjKlGdn>3UEt@SOm9T-*mCUXQkndg~ItB(c@9h>od)=gq%dp#kekppS zN@55_CQ5?x>ymYiy6|TJTn4L(L!s6Ka{@@zUDU8Bm|fdXl?u!%!g6NVUL4d44*~{u zy3+SH>JYA0JrGQVIpTQz;mXx@a)<3#fT~*(ztii$FXcV2%1~ug znOW`MiU6~_Qgqo&cnq-cIPsC=$lY6?-Em>djXt&9px9}=>zzC>_3F*=fM4BXT)=5l z2UFU(eb+`jVplyT*TvVcP`VK$s^)XuW>~ zS6^q`hoi|ln?jb!Csv0pje_%M9T8)o_kpCV9%bxX#Sn&AWU59kj-rytbK0J{DCz>$ zyz_&l;$;)*AIB4;2Nn?Yd<8xS^E*d9-*Hbt4D@{BR0-i~WaZab6y|3qL`fg{p)t$T zlwcstLnvmD>A+P60|jxvkpi#7U@lHzDGLeW=7zF@!wJsY>&J-E+L_h2_{YcoF_rm~O@u5bY>B<6F?o}nUaW?jy>Z_a#gv&vz8%R`hX z9}{Fog3!G!^VGy7k>~krw_qfF`^TbJ!f56afd`J2PWgVUBjP|mapx9iENODi=70b& z%gZ}!VgGVxHhW+;8`D+oxwr}X0-qs&k)Qq|$KbHVR_REpcs3xhx$dXAyrEQ8Nq`@# z2%0%O`XBCt1KmWhu-a$)Wm2TCU+Gp4QRGFe)MyqYTfBuLIEFse_%hW7fRn=hzdLNyA#0c zUet16K@>AFu=BfGFL93s#+_B&KuT8;2Kd-}!3m-587Ji(AWq$=a{dKPtp>#)c#tC; zdrmLNKYOu~b$4T2osSADXT8U&r+mkd`kWIl*mk38{)l_=#LWVFq_M?GD>=XWFz0VQ zzha+oD!%^@J%94V2I*Z)$N_PmhW*9S3A7Bz@#4NpM{V8aVF`{O#0?Q#?1i#M^NA&r6<26>ZxzCUmc?x~C66 zbvokMtSsGoD0CK+QVtrQdrVR2cI4 zVqJ_jg}2L=E||I$=Hc}>?ucZ3O^jf=tXX?yobf`TTKCe*zVYl87Zgo6^BOfU(@-WV z${k0kaAY>sO$dz5-nHLu`~;qM&6hvh;(e=aQL@*QuY(pS;wccl7GNVkOkDM)#3@(9 z5yu+;?16d_up&C@Bx|=y;_YZQ-@Q2NbO}$+gn-ikdoB%U6#!uFs%k>VwSi-bNHFgR zMjv4zHg^iOzFMGQHk3wz=RzFx>JVRMmzxOlre^G;O|x>`lf%0H~uY+aHApLDAdDg3> zW8r;ruX+BR>D!(+`7OX6j5)AP@Lv}9Z(cGze$-}}30d?O;s+A=Ey}k-^8*1z`9-EB zQQz!+Lm4U3P^Mx1VTFXNLn(#WtsZTo0=E#TTg2f06J4Jdsg@Ie z4&JWzi%)<`E=xpWzIz1sT~oDPLnr+qy!R?Z)DMCDG;}2rIp?H%C?*FCkB8o!l)A73 zt=la|hTEtPkhDt}5Ib^_Vz;H++tr}LW>rG~ubxUwP?ulKe>D;qc(d3RwgBJ~s|wFV z3tet@+^+bVwg0B{2D`eTT#VGje3xOt;2~O0Da-fq4ISx&z8x0IQEqelOju^zswnal zoGJdGl@oE`m_njR2yCRI}{<+5zJ$Opy zv=fhLKr*gwYTPawH0#{#c1lDR)Z&NFp*=mPXxW^oWt-$Wd#!cEu9<98BZ9M#*NpS> zx)*G^7Hf7t;Y$yxEBB0DoRzt7!oo6+*2}IkKKYuPZRxtXjHhJDj-;%Oa6s23+A6A{#kX|fj(C{W#0d`t}_ zp;CN;$UGkIlf}=)49K>SeUrK7;Z4|i`!kkSjgX9$vtJAOBYV$GKNY+kw-ITaEbhj! z_ic|2HgxC=N-kZ0q+OIK!1?Lnwle!I&K5WnQC8U7IcP)b+V+gs%mMmj44>eO&aB4( zeq?PI!xJHSZ>G|wG91w7T~I}4m?RWHElxA9dL9BN5Fz?Y&@J>N+~myrXuGEC^7+D> z%@hdINtU1mZ$mP!&%tmY(P3Z+arN_kHYOeuU)LqUDKrayjypWiWk`aHC^UXcnFSvv zNti8SHo7uKq(CN#JLDELXa-$p zP5cfr9bDW9Rf-L2sdwmyO;C`5wS){-2r*@fRREz0G^~Ef_59_j&RZYcHuuNvpBuH8 z!Tg#0?oN+qP=9xk3dWao2^l}8S7k2p0v2sp=0l}z}qe4`+A z{DF`d=RV?S{BCN%IUqn%ZiG$8P7cx8LND)H)Yitnd6f8k}HsDor7Uxs)HGu{`I zS=ETRvEbua)`l9w5NdgJ2ukT6>w{wz$k&K&0{a6_Ys8C^w>M&Tc-%$SGjT)*qY)ks zZU}FJJKMQlla{x_J2@BWQj)DMwT;7{F1e8MuJ>v32Gfqaqn-FH<}RCk%+xCmyCy%- z4)$Ki>22%~wk`eU)4|B7$?RlakHflb-F_$g)8mvmr;c(Loe-w|0kir?L<>`Kz?C2x z7E}#gkhsb~_G-5bCyfyW$pR~i-~c#2Qg3AG92B>dP1N8HK%-PG&y3lZFRmxRy(N^d zghBb^Sg2#3j$v-xD=9dCJyPVZn;evnhhhY>P$8SKEX+yO57k+^vqgX)xGaW*GCTCA z=%xa*nmD`ErTrpvJ4jb_8X9u0Lgy_D5 zk&X@}#?5?27zk&Pkg+MKpF+Y1-@_rS9jj6Qw4`)(|Iqia*0|hEKIUfCw?pTR}FvEik%sDMFI@iZ;F`%eLv#L+`V0i{~6WlxO*CmV4Xt28=|hlh)JiNSB`o2 zO0)E!5wl9WuVny2pU+$*LiHMBf9|u5rus$&iIRo1ZbgUeerO>fn`aD4CadU46U2d=jpdeP?@xC5Iz)o zn|_wClWb1`7iTg(Cv=s4SAE;gEz)?D=(-)^s85igrb4KMX&NVu-`q`GbZ@Ti_QvC_ zY&{lvVyZYEGd{LzUfA1m7kN*93KRQMDlJAX{FcTT!!cr}MB}Hf)j8{>U&K}ybPx(S zDSL#LU#tc;buV-q1!DO^O_vyUL%4qHe>y=ogzL5brxUx?LeTM2wKiUZWv|QemJ8gM zBA3r!68V4R^_m{2^ZQhqsk{p;caA}H*&eK-VQu%HH;yHI?1Wr};qyKds`S=vve@=N z`nG%i-h<)T2ivt{_&WGvI%(s+y{?mgY0p^Ga!J8*nbV>@HDM&fX2~aM;Ty#MWbej~ zX1_A}n-iN6!NXIi_haA>Pf2hP5Tw6%l?-fcEnj|bDzDitF(G>c zS61B@Je)A{&?L(F$Q6nuH1GCrSeu6f)n$%`*aOX%o;svJ>o8^$idyeaE_d%Yj2yhE z94;W2pvl1wTwcEu7@$FMz?&*^p2JZvpi6?8Obqz&2r67vq}wTd^RBal>iV6$K%@k8wpx2yvI}N(Jzv5_Wewro8?(FTRa&qrj*cZ2%+i&fdh3PHxHf4%- z_s`+!)PT?BFA5~2>Ax~K3=FAfp{ZY0$0*nM-oI=wUe1TGa>B|tyq~Xtr)K6PGO4!& zGFao?qSuzHR)H_~6#YFUO9YXAc)F1Me8;<4r(ydm{b&BHyoT*BEa{U=m!@U&M}zL? z4^9yGy8<{T_=G3smq%Av$&V2K&J2{dYBP?&t;%ji5DcULL^k zW}JEwm@*>_vmn=TT9$BVUm`~)LI7QafUOJcPNbq&2vepSS(QQVirlh^>w$o6bjAZW zOYL$dJg`o~jEo(a$g0_1EqV;hOd;laGb5kh*dnjfwRybK={OPd#%Sx{yerm5<8kO_ zrLg=c!D!flM`yw1Ugi#pBSJ{#qnPi$i_D;7MWLrb})M`6% znL8@zpw|A)Vn-u{vFRv|IxWuG%b&hDU6pH$Q9&KXF5)3(>*(`}C5rgT4YX*8t^Tr@ z6kxMY`vCPlfPW6oVsL{Y6lHP}9Rhc2)s6Nf2hwZ#>%}VZbbZID>#mdUUxyAMc)CjW zuH9V*Q)lH%(7g^nMz$#>X(G7tGC_7r8~_YC%tqWjB}hzlj(Y?}KZZ4V7NpJ4n%xgVxSTHAMzyaeg5Gtjd7c)MVUa4(={kR8B>r)_fHVwAYjT24>wH4S z6(b2_tr{wSAZtFr=l)^K`})9u^jhQ5am3(MbY*uU$b}+PH(Q!H!lrEcQVZ8e#g{6N zv|?b7e*fdXKq?iL(Cf)_Pil}l;e>OP1$_1Gu;DL^S^VwMRopBOC}c3ib52h1MG}B- zU65V5{-PwLDvB`LZM>3(`O#eroj!{R2zlU7@TBn)Q27QEpyk9gAyuj{af znXUMSHSfLPgpADPXh0-0eIE>JaRnmfC1|AO{KJf5JTEmMClKK2%E=&ICJUq3NvNkMcB6@TjiMUoa{g8cNFlHiAhF)NK9 zX$2&FFW9In!eVUCF&?EbHd?dY;0MJ@iAt&FmeVxKurQBz?0&Jki`x03o#Rn`rJv9j z&75?Wy7#!?<(6$0xEu67=yV%aljOOmVxW=rB(ueZ@I1njvwSOG73Mg4p2 zg@o%-M*p8Js%2`*@_BU@#S_a_zTYjHwPqt-8u#j(Y}=BJMf{8mXl~ie#KJ@{8EcHS`sB}L~ zn5cu?Rjyt(T|eHjn~G?KNgB3?rO>lYGzP~0Z5?{&JU4iChx4q5I+mn`YCF@N{`0G{ z7 z3ZNX_pfG=HR5Z`@y7d&14$EYLp1+#M%%%gZ6*EPi|75&+{`?@2wIhxTpPLeLXmDnj zpjhDc#*U}peu3oeUJi#RV>S0H9ToqUW2v$*EFr7FQYI})Bvroju%sQUKqcq4B~w~u z<2VdzdRbM}r-ea(;ZcsWIHpwEftL92X>65%y#d=&?9!!zRME{Xgvb4g~myX;x(!o!EZ9-K}rUUXlv*=frr8okFWb>*6mGbbnp z*-?^8+{c1d?xUYVeP_g1A0SF@pXLw2zMM_YAu^;yylFRFzq?{Fe0|7kKD@!wSrI&* zxpG5*nPkS3l^8P1(%2r{Uy!=|wbwiacoO9W{{M0@9AM*tRAdZ1VVwi%Wk-Q0_RaTy zUc|Gf|BLebfQMXcMgpbM)!32eH^unN8T->uwO27kes@NQ_Az8AJ{Q$tyj=dh->2tw zzJpUOnP$%CCf$vjwdinPc;3?|;}~Kh8fm?Y;UF)_y4yJma)!6W94d`z?ng3+Gz}*? z{anu#H9Dsyij{yO+x%e*pc@N8IvR*SAw48&vI^g6K{25P(@yg>fl@9ro!>oL;n>cK zr#kuLHc2^aDruAJ?%k|M{H>4u`LrzwOSLaC>FKKYsEZKS?vp#K+r?!F$Tx~af8B)C z#LG>jNr9m&+Ztqa`*;3pKT--(m|7l+ui_;Fs|ds#rZ_*&#Mp9;HR)gU@9vuF>hf}WoKJh~)?S$fNba96?Q5jW`aFKyyy}%8 z!aY&|1<2BdEZlAJ%XvR+T)7s_MnBbUk?@cQUXCf~H>8+eGTSeKo2M8x8%vIwEBINRDxWppT4~Vm(t=faT%n z<|-PA^46QD*~9e5uo^RcG@J@H73dw;d)5d8;7Eg``;X|^{o^N*%`W^Xk&u$%-lFqs z&w2U4m}F0TOx?*mL5$pu&70QAEZ!(d09~;Vopi^Ki=U^iAY1W+NDO=r-+%f~Qd?~} zJ55j!GtA92=KIyfAVgy{p`nN<$eH$TiKA^6#Z3eaqDOp#Sb`o4y;S_>TL9ymxR;oW z&_SHX=IeQB(jY|P9{6d)9*U3xIXQk0V+67RyU)^qbHb3Efp;A;$`?5+R42y@FlHe% z_Cgt31{0eGqze+SWDuzYp|v-j2aNR$PJ>TNUcnmo8e*!7!!D9N%Z!CP^o6iOZAYzr z#ZjH}IdEQK9U}y0pJNZt9)8h@*aWRz=*wC1d|KU&v<%_HRA4J>$6szG^cp~It2bl!`4YnuI|ZwXn}i;Y{xmY)H#Ni>voqK z=EKyY{N3S|x{`@Y$PX&v@ND)wLOcch{w?r%@~3Dv=IzVN{!+vx1+1?T|}{!kH&PebrB*ynPFMX5>O_Ad5g=hPVGKO^8P; zq&;U~+nud#>EXos+mt-v$v3py%CQ;FRxub6{+@Y@oygaskdR!H4$gd|r>^gU%PUOi z5k$2Dla<0&zG-#Z)1?e*$r6T){RPV2ax9;K9R8u_HBQ3<73m6 zaJZl^bN%mF{?Uy7PjHF?LY(h`FwOz@C~$#)fjx#_WX~gue=Znb&~1@zSNT#S%KlXV;jv#6jD#`d`L%w9ix|3LEv(_Xn~kC#QHXL-9XY;|D;h-QNMZ? zy_vvzPkF*M)&Hvg$k~35ZG<(7V@B>RQR@YIu%a)20v__+RPgpwyS54&L`TbJ8Snv1 zLUukC1QnunkE_w06$MHW2(VWNw`EiDo*m(Pw&`x*K(T*=!LOuKBuWu3_nFKzz6hsbT+AV?g6tLxXm6n*aB zYYN-iI2qeG=_Asfu}IML#V%qysjg8bjN!b7O4f{afDlP+G;8wf*Q0o$d5n*voj?3$9cX~*;p@*c^EdBY6x_0;9GsgB|U zOoqH=^~O4k19O$oMO*%wB_#ok(eReL{`g3;T_sHc^mYPc#8RFUdq4us7B1bpU=Aby zbN>MM9oMeHlgQlj0zV@R(P!ZL}VT9muC8W*@fP&tBrH-0#pUDB{z^j=DEFBLVPSRbSpTJkD2 zU%Rf1ZRw<1nG%2M@%=eJc1S|%k;mLJ%3w&9nZ?1kAJ+)@Na#; zzt8YY{7WC@KiU3xyWw|;ejn2Rn>z-W-hV0mb7cQ__TNX$|7J%47L&i({~9>|Urs+y zQvW)howfuvu7H*3e=+-mKe*FV|*PsRIP&hP!$zvay1|L5-P z?-G7*zx*wMiujj=znU@s|Go!ezOeqe)%foW`F*qTZ;j>uWcz#T@pqGd?}MtUq(NV!v8v+BOLK7!v7kK|F`A8kH$aq{)$@D|Ka_6Q2uxGf1ft_TS^)5y%b=M v{lkJ6DKE1pzf1XjC;x9LiNNQ=e~|LBuP-kJ@lrU@fRBlIpv}lk&wT$6(&G*# literal 0 HcmV?d00001 diff --git a/xlsx/DB_Task.xlsx b/xlsx/DB_Task.xlsx index 6d465cc14e556f126c3200ae9d462e46a395b94e..d7d8acfc13a375c7770360c0fdd4e2b3166149b9 100644 GIT binary patch delta 14040 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 z z^0>9OX>*wjN(&$8T%=rmg5S-tvEe6}6o*I3j0^3dxAxB#Zvy<{f=$tN*Or~5Jo%Ze zAv~Fj&#lS%RQ18Z4L2_1Md2@oPAjd@uyV2byhmE`8MA;aC$*{$L>;C`F!t;#WsM;#MBa-etpC8KzG#2s zX|X+mek?Jze3Aj{>Bh{x8gf&SuK6@lPO1%h3gOomEmu!Kb3jRqUr+0>0~LOzeXF^N z9BE2x=Fwh{v?4%R3&7TQh+pEvUF#+tYZ4^=&}Ml?qy+<$6t7E|gsnpYC!&?arjz*R zYhGPCA_#xHf0P8LtA_+UgMsm~<4l6+lO_4+V!~N!Cq?PUj(jEC+U|4VbV(j7P#%-Kk1Wl46sT6eu)PLhWIxs^z$b$VbYKR cE7{+>=l|`GWltJnCP`v5#73;v|2^#g0LnJkCIA2c delta 12954 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

ricx$k`5eR#I4NIm9vpT zO#+%nIzFtq=XBhz5mc+%WT9P_^y(&X0Vj9gX$<2HcJ#sY(M}jECXHmfFdL!!d zP@WYSXykK55njUs>9zvN16lsm&_^axsO0v)#qUmGfP`$QD>re zxb@YgC8FvET>~jK65ri%$7v6MA2^V&R~28vv$*$DZ&*WYk}hu68vRUx+u{E4a`u_E z=||uvdP91GYh@0L^6nowCERSBkQEHrjoKdgJVIzMlc-99CfAqhBsvDP)=a-h`He4I zMJ{{F+H-eU-t|@|cah&Tpjy-xSDEn#zJAkK3Ux7O&*^Hh_^*89%ibNV30dCgGB7(VKRCHH6OFD`#!e{O}!@kU(b#nFE`wW4( z4SStkc7Ct%bHgzmXO|xYD{MDJB5d-TNe4YmQ%$Sve zt5R9KWt;k~G9Gqwx1f`%4}NT~(J>5_Inp#G7>pkg>@kjAu-p)eV#ih@%Xn*khP}mj zJW{oNi8FX#e1bYVSD}3)=k*o7BnW%I;YUZD?tWP2#y9B?Wp?us6u{vyB)2(B{4h6b zTDq|v19@0`MT(CR#4}@^P&nOE>ERU0=U{3pP#YBS!X( z!`myz9(QmvPiQzvtGq_Ayh6|G^WFERC-(`kzvdDcYVLTiuT`Y97 zlg#KB)bDl>)S-i42PwLU2{o$>TKOOdbtMlX)MSCeQ2;4v#{d0-#=a&m>|bvVfGD*z zApJo;TJNC*6+u;6>`-QkpnWX~$XpPEHb3MKkhL~9Bq69ko00I}S^xs#_xlIGKadb4 z;J+&zpbKpws7)advko^D+Ix_V4m%X*dyp_27N|*w7OGPKw5!7lc?u%Y<%Nn@0%hr9 zgUB_}K(}gWDF0gN{XM`=@b44&5D>V(N5P-Jm%#;H=+Y7X+vEQ4cohxkyDk>E>xBg= M>7l_zs{Wq(e* Date: Thu, 2 Jan 2025 11:31:01 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E9=85=8D=E7=BD=AE=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- data/DB_NewYearRankReward.dat | 38 +- data/DB_PigBank_Diamond.dat | 4 +- data/DB_PropExchange.dat | Bin 384 -> 384 bytes data/DB_Task.dat | Bin 6587 -> 6587 bytes protocol/server/pbdata.pb.go | 1832 +++++++++++++++++++-------------- protocol/task/task.pb.go | 2 +- protocol/webapi/common.pb.go | 477 +++++++-- 7 files changed, 1497 insertions(+), 856 deletions(-) diff --git a/data/DB_NewYearRankReward.dat b/data/DB_NewYearRankReward.dat index 0748d61..2b3cb98 100644 --- a/data/DB_NewYearRankReward.dat +++ b/data/DB_NewYearRankReward.dat @@ -1,8 +1,8 @@ -""d" -""d" +"""d +"d"" ""d" -"d" +""d ""c ""b ""a @@ -20,20 +20,20 @@ ""W ""V ""U -""T +"T" ""S ""R ""Q ""P ""O ""N -""M +"M" ""L ""K ""J ""I   ""H -!!""G +!!"G" """"F ##""E $$""D @@ -41,10 +41,10 @@ &&"B" ''""A ((""@ -)""d" -*"d"" -+""d" -,"d" +)"""d +*""d" ++"""d +,""d -""c .""b /""a @@ -55,25 +55,25 @@ 3 ""] 4 ""\ 5 ""[ -6""Z +6"Z" 7""Y 8""X -9""W +9"W" :""V ;""U <""T =""S >""R -?""Q -@"P" -A"O" +?"Q" +@""P +A""O B""N -C""M +C"M" D""L -E""K +E"K" F""J G""I -H ""H +H "H" I!""G J"""F K#""E @@ -81,4 +81,4 @@ M%""C N&""B O'""A -P(""@ \ No newline at end of file +P("@" \ No newline at end of file diff --git a/data/DB_PigBank_Diamond.dat b/data/DB_PigBank_Diamond.dat index c40b846..3a06af9 100644 --- a/data/DB_PigBank_Diamond.dat +++ b/data/DB_PigBank_Diamond.dat @@ -1,4 +1,4 @@  (8@;PdX`c -< ((2Ÿ28@;JJƸPdX` -?/ 2(22Ÿ8@;JƸJPdX` \ No newline at end of file +< ((22Ÿ8@;JƸJPdX` +?/ 2(2Ÿ28@;JƸJPdX` \ No newline at end of file diff --git a/data/DB_PropExchange.dat b/data/DB_PropExchange.dat index e8c943cb7ae426c3fa4ddbe697bff5b345560b0f..cc7f1961579ffb3a487a7ae7441980a203308cf4 100644 GIT binary patch literal 384 zcmd-w<6snElw#w!(#8y?uR`f-Q2IKQz6_$3I5-yevI!h$vE|a^U;?YZ0hPZArEfv$ z+i2>;IUweP%|WscWx~fEfU@0PHZJ17Hq;IRIwC T9k9dMITisu`h}T`fwm9;VzN9n literal 384 zcmd-w<6snElw#w!(#8y?uR`f-Q2IKQz6_$3I5-yevI!h$vE|a^U;?YZ36;MErEf#& z8))joIUweP%|WscMLkd)-8`)BQQ`!m-D$hdhC%UnhwHjayJ%mN}_oM2NIoSwlrIgrhKatn_DBh%!WY-c4Q5(lPjWCEJ8 z2xK3Z3&%u10mjJz9Fm)7us1OYLd03UATC>QNN%$>mm?!om>DYkV7budT5fijFe6NL YFWcs+JTG9vOiMJ#g}g*d?`E;v1d(Tk1aVjHu7$mBpabEs-2sOkm1Y?EiQot1=` z!Q}CN39_iGBi%lLI&;H_u>iVw#-BE3#RS%Z_pKHBPb3P25b3lb>;kY@WgM PlyUN8PQlH6e7f8Kj&3|# diff --git a/protocol/server/pbdata.pb.go b/protocol/server/pbdata.pb.go index ba450cf..712979b 100644 --- a/protocol/server/pbdata.pb.go +++ b/protocol/server/pbdata.pb.go @@ -7701,6 +7701,242 @@ func (x *DB_NewPlayerArray) GetArr() []*DB_NewPlayer { return nil } +type DB_NewYearActivity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"` + PorpName string `protobuf:"bytes,2,opt,name=PorpName,proto3" json:"PorpName,omitempty"` + PropValue string `protobuf:"bytes,3,opt,name=PropValue,proto3" json:"PropValue,omitempty"` + PropDec string `protobuf:"bytes,4,opt,name=PropDec,proto3" json:"PropDec,omitempty"` +} + +func (x *DB_NewYearActivity) Reset() { + *x = DB_NewYearActivity{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_server_pbdata_proto_msgTypes[98] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DB_NewYearActivity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DB_NewYearActivity) ProtoMessage() {} + +func (x *DB_NewYearActivity) ProtoReflect() protoreflect.Message { + mi := &file_protocol_server_pbdata_proto_msgTypes[98] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DB_NewYearActivity.ProtoReflect.Descriptor instead. +func (*DB_NewYearActivity) Descriptor() ([]byte, []int) { + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{98} +} + +func (x *DB_NewYearActivity) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *DB_NewYearActivity) GetPorpName() string { + if x != nil { + return x.PorpName + } + return "" +} + +func (x *DB_NewYearActivity) GetPropValue() string { + if x != nil { + return x.PropValue + } + return "" +} + +func (x *DB_NewYearActivity) GetPropDec() string { + if x != nil { + return x.PropDec + } + return "" +} + +type DB_NewYearActivityArray struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Arr []*DB_NewYearActivity `protobuf:"bytes,1,rep,name=Arr,proto3" json:"Arr,omitempty"` +} + +func (x *DB_NewYearActivityArray) Reset() { + *x = DB_NewYearActivityArray{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_server_pbdata_proto_msgTypes[99] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DB_NewYearActivityArray) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DB_NewYearActivityArray) ProtoMessage() {} + +func (x *DB_NewYearActivityArray) ProtoReflect() protoreflect.Message { + mi := &file_protocol_server_pbdata_proto_msgTypes[99] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DB_NewYearActivityArray.ProtoReflect.Descriptor instead. +func (*DB_NewYearActivityArray) Descriptor() ([]byte, []int) { + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{99} +} + +func (x *DB_NewYearActivityArray) GetArr() []*DB_NewYearActivity { + if x != nil { + return x.Arr + } + return nil +} + +type DB_NewYearRankReward struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"` + RankType int32 `protobuf:"varint,2,opt,name=RankType,proto3" json:"RankType,omitempty"` + RankLevelId int32 `protobuf:"varint,3,opt,name=RankLevelId,proto3" json:"RankLevelId,omitempty"` + AwardMap map[int64]int64 `protobuf:"bytes,4,rep,name=AwardMap,proto3" json:"AwardMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` +} + +func (x *DB_NewYearRankReward) Reset() { + *x = DB_NewYearRankReward{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_server_pbdata_proto_msgTypes[100] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DB_NewYearRankReward) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DB_NewYearRankReward) ProtoMessage() {} + +func (x *DB_NewYearRankReward) ProtoReflect() protoreflect.Message { + mi := &file_protocol_server_pbdata_proto_msgTypes[100] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DB_NewYearRankReward.ProtoReflect.Descriptor instead. +func (*DB_NewYearRankReward) Descriptor() ([]byte, []int) { + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{100} +} + +func (x *DB_NewYearRankReward) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *DB_NewYearRankReward) GetRankType() int32 { + if x != nil { + return x.RankType + } + return 0 +} + +func (x *DB_NewYearRankReward) GetRankLevelId() int32 { + if x != nil { + return x.RankLevelId + } + return 0 +} + +func (x *DB_NewYearRankReward) GetAwardMap() map[int64]int64 { + if x != nil { + return x.AwardMap + } + return nil +} + +type DB_NewYearRankRewardArray struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Arr []*DB_NewYearRankReward `protobuf:"bytes,1,rep,name=Arr,proto3" json:"Arr,omitempty"` +} + +func (x *DB_NewYearRankRewardArray) Reset() { + *x = DB_NewYearRankRewardArray{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_server_pbdata_proto_msgTypes[101] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DB_NewYearRankRewardArray) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DB_NewYearRankRewardArray) ProtoMessage() {} + +func (x *DB_NewYearRankRewardArray) ProtoReflect() protoreflect.Message { + mi := &file_protocol_server_pbdata_proto_msgTypes[101] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DB_NewYearRankRewardArray.ProtoReflect.Descriptor instead. +func (*DB_NewYearRankRewardArray) Descriptor() ([]byte, []int) { + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{101} +} + +func (x *DB_NewYearRankRewardArray) GetArr() []*DB_NewYearRankReward { + if x != nil { + return x.Arr + } + return nil +} + type DB_PassShow struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -7715,7 +7951,7 @@ type DB_PassShow struct { func (x *DB_PassShow) Reset() { *x = DB_PassShow{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[98] + mi := &file_protocol_server_pbdata_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7728,7 +7964,7 @@ func (x *DB_PassShow) String() string { func (*DB_PassShow) ProtoMessage() {} func (x *DB_PassShow) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[98] + mi := &file_protocol_server_pbdata_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7741,7 +7977,7 @@ func (x *DB_PassShow) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PassShow.ProtoReflect.Descriptor instead. func (*DB_PassShow) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{98} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{102} } func (x *DB_PassShow) GetId() int32 { @@ -7783,7 +8019,7 @@ type DB_PassShowArray struct { func (x *DB_PassShowArray) Reset() { *x = DB_PassShowArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[99] + mi := &file_protocol_server_pbdata_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7796,7 +8032,7 @@ func (x *DB_PassShowArray) String() string { func (*DB_PassShowArray) ProtoMessage() {} func (x *DB_PassShowArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[99] + mi := &file_protocol_server_pbdata_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7809,7 +8045,7 @@ func (x *DB_PassShowArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PassShowArray.ProtoReflect.Descriptor instead. func (*DB_PassShowArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{99} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{103} } func (x *DB_PassShowArray) GetArr() []*DB_PassShow { @@ -7838,7 +8074,7 @@ type DB_PetSkill struct { func (x *DB_PetSkill) Reset() { *x = DB_PetSkill{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[100] + mi := &file_protocol_server_pbdata_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7851,7 +8087,7 @@ func (x *DB_PetSkill) String() string { func (*DB_PetSkill) ProtoMessage() {} func (x *DB_PetSkill) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[100] + mi := &file_protocol_server_pbdata_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7864,7 +8100,7 @@ func (x *DB_PetSkill) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PetSkill.ProtoReflect.Descriptor instead. func (*DB_PetSkill) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{100} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{104} } func (x *DB_PetSkill) GetId() int32 { @@ -7941,7 +8177,7 @@ type DB_PetSkillArray struct { func (x *DB_PetSkillArray) Reset() { *x = DB_PetSkillArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[101] + mi := &file_protocol_server_pbdata_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7954,7 +8190,7 @@ func (x *DB_PetSkillArray) String() string { func (*DB_PetSkillArray) ProtoMessage() {} func (x *DB_PetSkillArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[101] + mi := &file_protocol_server_pbdata_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7967,7 +8203,7 @@ func (x *DB_PetSkillArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PetSkillArray.ProtoReflect.Descriptor instead. func (*DB_PetSkillArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{101} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{105} } func (x *DB_PetSkillArray) GetArr() []*DB_PetSkill { @@ -7999,7 +8235,7 @@ type DB_PhoneLottery struct { func (x *DB_PhoneLottery) Reset() { *x = DB_PhoneLottery{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[102] + mi := &file_protocol_server_pbdata_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8012,7 +8248,7 @@ func (x *DB_PhoneLottery) String() string { func (*DB_PhoneLottery) ProtoMessage() {} func (x *DB_PhoneLottery) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[102] + mi := &file_protocol_server_pbdata_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8025,7 +8261,7 @@ func (x *DB_PhoneLottery) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PhoneLottery.ProtoReflect.Descriptor instead. func (*DB_PhoneLottery) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{102} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{106} } func (x *DB_PhoneLottery) GetId() int32 { @@ -8123,7 +8359,7 @@ type DB_PhoneLotteryArray struct { func (x *DB_PhoneLotteryArray) Reset() { *x = DB_PhoneLotteryArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[103] + mi := &file_protocol_server_pbdata_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8136,7 +8372,7 @@ func (x *DB_PhoneLotteryArray) String() string { func (*DB_PhoneLotteryArray) ProtoMessage() {} func (x *DB_PhoneLotteryArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[103] + mi := &file_protocol_server_pbdata_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8149,7 +8385,7 @@ func (x *DB_PhoneLotteryArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PhoneLotteryArray.ProtoReflect.Descriptor instead. func (*DB_PhoneLotteryArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{103} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{107} } func (x *DB_PhoneLotteryArray) GetArr() []*DB_PhoneLottery { @@ -8181,7 +8417,7 @@ type DB_PigBank_Diamond struct { func (x *DB_PigBank_Diamond) Reset() { *x = DB_PigBank_Diamond{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[104] + mi := &file_protocol_server_pbdata_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8194,7 +8430,7 @@ func (x *DB_PigBank_Diamond) String() string { func (*DB_PigBank_Diamond) ProtoMessage() {} func (x *DB_PigBank_Diamond) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[104] + mi := &file_protocol_server_pbdata_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8207,7 +8443,7 @@ func (x *DB_PigBank_Diamond) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PigBank_Diamond.ProtoReflect.Descriptor instead. func (*DB_PigBank_Diamond) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{104} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{108} } func (x *DB_PigBank_Diamond) GetId() int32 { @@ -8305,7 +8541,7 @@ type DB_PigBank_DiamondArray struct { func (x *DB_PigBank_DiamondArray) Reset() { *x = DB_PigBank_DiamondArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[105] + mi := &file_protocol_server_pbdata_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8318,7 +8554,7 @@ func (x *DB_PigBank_DiamondArray) String() string { func (*DB_PigBank_DiamondArray) ProtoMessage() {} func (x *DB_PigBank_DiamondArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[105] + mi := &file_protocol_server_pbdata_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8331,7 +8567,7 @@ func (x *DB_PigBank_DiamondArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PigBank_DiamondArray.ProtoReflect.Descriptor instead. func (*DB_PigBank_DiamondArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{105} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{109} } func (x *DB_PigBank_DiamondArray) GetArr() []*DB_PigBank_Diamond { @@ -8354,7 +8590,7 @@ type DB_Pigbank_Prop struct { func (x *DB_Pigbank_Prop) Reset() { *x = DB_Pigbank_Prop{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[106] + mi := &file_protocol_server_pbdata_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8367,7 +8603,7 @@ func (x *DB_Pigbank_Prop) String() string { func (*DB_Pigbank_Prop) ProtoMessage() {} func (x *DB_Pigbank_Prop) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[106] + mi := &file_protocol_server_pbdata_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8380,7 +8616,7 @@ func (x *DB_Pigbank_Prop) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Pigbank_Prop.ProtoReflect.Descriptor instead. func (*DB_Pigbank_Prop) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{106} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{110} } func (x *DB_Pigbank_Prop) GetId() int32 { @@ -8415,7 +8651,7 @@ type DB_Pigbank_PropArray struct { func (x *DB_Pigbank_PropArray) Reset() { *x = DB_Pigbank_PropArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[107] + mi := &file_protocol_server_pbdata_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8428,7 +8664,7 @@ func (x *DB_Pigbank_PropArray) String() string { func (*DB_Pigbank_PropArray) ProtoMessage() {} func (x *DB_Pigbank_PropArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[107] + mi := &file_protocol_server_pbdata_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8441,7 +8677,7 @@ func (x *DB_Pigbank_PropArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Pigbank_PropArray.ProtoReflect.Descriptor instead. func (*DB_Pigbank_PropArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{107} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{111} } func (x *DB_Pigbank_PropArray) GetArr() []*DB_Pigbank_Prop { @@ -8463,7 +8699,7 @@ type DB_PlayerExp struct { func (x *DB_PlayerExp) Reset() { *x = DB_PlayerExp{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[108] + mi := &file_protocol_server_pbdata_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8476,7 +8712,7 @@ func (x *DB_PlayerExp) String() string { func (*DB_PlayerExp) ProtoMessage() {} func (x *DB_PlayerExp) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[108] + mi := &file_protocol_server_pbdata_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8489,7 +8725,7 @@ func (x *DB_PlayerExp) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PlayerExp.ProtoReflect.Descriptor instead. func (*DB_PlayerExp) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{108} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{112} } func (x *DB_PlayerExp) GetId() int32 { @@ -8517,7 +8753,7 @@ type DB_PlayerExpArray struct { func (x *DB_PlayerExpArray) Reset() { *x = DB_PlayerExpArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[109] + mi := &file_protocol_server_pbdata_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8530,7 +8766,7 @@ func (x *DB_PlayerExpArray) String() string { func (*DB_PlayerExpArray) ProtoMessage() {} func (x *DB_PlayerExpArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[109] + mi := &file_protocol_server_pbdata_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8543,7 +8779,7 @@ func (x *DB_PlayerExpArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PlayerExpArray.ProtoReflect.Descriptor instead. func (*DB_PlayerExpArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{109} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{113} } func (x *DB_PlayerExpArray) GetArr() []*DB_PlayerExp { @@ -8581,7 +8817,7 @@ type DB_PlayerType struct { func (x *DB_PlayerType) Reset() { *x = DB_PlayerType{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[110] + mi := &file_protocol_server_pbdata_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8594,7 +8830,7 @@ func (x *DB_PlayerType) String() string { func (*DB_PlayerType) ProtoMessage() {} func (x *DB_PlayerType) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[110] + mi := &file_protocol_server_pbdata_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8607,7 +8843,7 @@ func (x *DB_PlayerType) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PlayerType.ProtoReflect.Descriptor instead. func (*DB_PlayerType) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{110} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{114} } func (x *DB_PlayerType) GetId() int32 { @@ -8747,7 +8983,7 @@ type DB_PlayerTypeArray struct { func (x *DB_PlayerTypeArray) Reset() { *x = DB_PlayerTypeArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[111] + mi := &file_protocol_server_pbdata_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8760,7 +8996,7 @@ func (x *DB_PlayerTypeArray) String() string { func (*DB_PlayerTypeArray) ProtoMessage() {} func (x *DB_PlayerTypeArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[111] + mi := &file_protocol_server_pbdata_proto_msgTypes[115] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8773,7 +9009,7 @@ func (x *DB_PlayerTypeArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PlayerTypeArray.ProtoReflect.Descriptor instead. func (*DB_PlayerTypeArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{111} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{115} } func (x *DB_PlayerTypeArray) GetArr() []*DB_PlayerType { @@ -8797,7 +9033,7 @@ type DB_PotOdd struct { func (x *DB_PotOdd) Reset() { *x = DB_PotOdd{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[112] + mi := &file_protocol_server_pbdata_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8810,7 +9046,7 @@ func (x *DB_PotOdd) String() string { func (*DB_PotOdd) ProtoMessage() {} func (x *DB_PotOdd) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[112] + mi := &file_protocol_server_pbdata_proto_msgTypes[116] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8823,7 +9059,7 @@ func (x *DB_PotOdd) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PotOdd.ProtoReflect.Descriptor instead. func (*DB_PotOdd) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{112} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{116} } func (x *DB_PotOdd) GetId() int32 { @@ -8865,7 +9101,7 @@ type DB_PotOddArray struct { func (x *DB_PotOddArray) Reset() { *x = DB_PotOddArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[113] + mi := &file_protocol_server_pbdata_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8878,7 +9114,7 @@ func (x *DB_PotOddArray) String() string { func (*DB_PotOddArray) ProtoMessage() {} func (x *DB_PotOddArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[113] + mi := &file_protocol_server_pbdata_proto_msgTypes[117] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8891,7 +9127,7 @@ func (x *DB_PotOddArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PotOddArray.ProtoReflect.Descriptor instead. func (*DB_PotOddArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{113} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{117} } func (x *DB_PotOddArray) GetArr() []*DB_PotOdd { @@ -8915,7 +9151,7 @@ type DB_PropExchange struct { func (x *DB_PropExchange) Reset() { *x = DB_PropExchange{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[114] + mi := &file_protocol_server_pbdata_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8928,7 +9164,7 @@ func (x *DB_PropExchange) String() string { func (*DB_PropExchange) ProtoMessage() {} func (x *DB_PropExchange) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[114] + mi := &file_protocol_server_pbdata_proto_msgTypes[118] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8941,7 +9177,7 @@ func (x *DB_PropExchange) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PropExchange.ProtoReflect.Descriptor instead. func (*DB_PropExchange) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{114} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{118} } func (x *DB_PropExchange) GetId() int32 { @@ -8983,7 +9219,7 @@ type DB_PropExchangeArray struct { func (x *DB_PropExchangeArray) Reset() { *x = DB_PropExchangeArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[115] + mi := &file_protocol_server_pbdata_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8996,7 +9232,7 @@ func (x *DB_PropExchangeArray) String() string { func (*DB_PropExchangeArray) ProtoMessage() {} func (x *DB_PropExchangeArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[115] + mi := &file_protocol_server_pbdata_proto_msgTypes[119] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9009,7 +9245,7 @@ func (x *DB_PropExchangeArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_PropExchangeArray.ProtoReflect.Descriptor instead. func (*DB_PropExchangeArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{115} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{119} } func (x *DB_PropExchangeArray) GetArr() []*DB_PropExchange { @@ -9032,7 +9268,7 @@ type DB_RankCycle struct { func (x *DB_RankCycle) Reset() { *x = DB_RankCycle{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[116] + mi := &file_protocol_server_pbdata_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9045,7 +9281,7 @@ func (x *DB_RankCycle) String() string { func (*DB_RankCycle) ProtoMessage() {} func (x *DB_RankCycle) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[116] + mi := &file_protocol_server_pbdata_proto_msgTypes[120] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9058,7 +9294,7 @@ func (x *DB_RankCycle) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankCycle.ProtoReflect.Descriptor instead. func (*DB_RankCycle) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{116} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{120} } func (x *DB_RankCycle) GetId() int32 { @@ -9093,7 +9329,7 @@ type DB_RankCycleArray struct { func (x *DB_RankCycleArray) Reset() { *x = DB_RankCycleArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[117] + mi := &file_protocol_server_pbdata_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9106,7 +9342,7 @@ func (x *DB_RankCycleArray) String() string { func (*DB_RankCycleArray) ProtoMessage() {} func (x *DB_RankCycleArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[117] + mi := &file_protocol_server_pbdata_proto_msgTypes[121] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9119,7 +9355,7 @@ func (x *DB_RankCycleArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankCycleArray.ProtoReflect.Descriptor instead. func (*DB_RankCycleArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{117} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{121} } func (x *DB_RankCycleArray) GetArr() []*DB_RankCycle { @@ -9144,7 +9380,7 @@ type DB_RankLevel struct { func (x *DB_RankLevel) Reset() { *x = DB_RankLevel{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[118] + mi := &file_protocol_server_pbdata_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9157,7 +9393,7 @@ func (x *DB_RankLevel) String() string { func (*DB_RankLevel) ProtoMessage() {} func (x *DB_RankLevel) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[118] + mi := &file_protocol_server_pbdata_proto_msgTypes[122] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9170,7 +9406,7 @@ func (x *DB_RankLevel) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankLevel.ProtoReflect.Descriptor instead. func (*DB_RankLevel) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{118} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{122} } func (x *DB_RankLevel) GetId() int32 { @@ -9219,7 +9455,7 @@ type DB_RankLevelArray struct { func (x *DB_RankLevelArray) Reset() { *x = DB_RankLevelArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[119] + mi := &file_protocol_server_pbdata_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9232,7 +9468,7 @@ func (x *DB_RankLevelArray) String() string { func (*DB_RankLevelArray) ProtoMessage() {} func (x *DB_RankLevelArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[119] + mi := &file_protocol_server_pbdata_proto_msgTypes[123] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9245,7 +9481,7 @@ func (x *DB_RankLevelArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankLevelArray.ProtoReflect.Descriptor instead. func (*DB_RankLevelArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{119} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{123} } func (x *DB_RankLevelArray) GetArr() []*DB_RankLevel { @@ -9274,7 +9510,7 @@ type DB_RankReward struct { func (x *DB_RankReward) Reset() { *x = DB_RankReward{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[120] + mi := &file_protocol_server_pbdata_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9287,7 +9523,7 @@ func (x *DB_RankReward) String() string { func (*DB_RankReward) ProtoMessage() {} func (x *DB_RankReward) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[120] + mi := &file_protocol_server_pbdata_proto_msgTypes[124] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9300,7 +9536,7 @@ func (x *DB_RankReward) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankReward.ProtoReflect.Descriptor instead. func (*DB_RankReward) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{120} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{124} } func (x *DB_RankReward) GetId() int32 { @@ -9377,7 +9613,7 @@ type DB_RankRewardArray struct { func (x *DB_RankRewardArray) Reset() { *x = DB_RankRewardArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[121] + mi := &file_protocol_server_pbdata_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9390,7 +9626,7 @@ func (x *DB_RankRewardArray) String() string { func (*DB_RankRewardArray) ProtoMessage() {} func (x *DB_RankRewardArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[121] + mi := &file_protocol_server_pbdata_proto_msgTypes[125] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9403,7 +9639,7 @@ func (x *DB_RankRewardArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_RankRewardArray.ProtoReflect.Descriptor instead. func (*DB_RankRewardArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{121} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{125} } func (x *DB_RankRewardArray) GetArr() []*DB_RankReward { @@ -9425,7 +9661,7 @@ type DB_Sensitive_Words struct { func (x *DB_Sensitive_Words) Reset() { *x = DB_Sensitive_Words{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[122] + mi := &file_protocol_server_pbdata_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9438,7 +9674,7 @@ func (x *DB_Sensitive_Words) String() string { func (*DB_Sensitive_Words) ProtoMessage() {} func (x *DB_Sensitive_Words) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[122] + mi := &file_protocol_server_pbdata_proto_msgTypes[126] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9451,7 +9687,7 @@ func (x *DB_Sensitive_Words) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Sensitive_Words.ProtoReflect.Descriptor instead. func (*DB_Sensitive_Words) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{122} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{126} } func (x *DB_Sensitive_Words) GetId() int32 { @@ -9479,7 +9715,7 @@ type DB_Sensitive_WordsArray struct { func (x *DB_Sensitive_WordsArray) Reset() { *x = DB_Sensitive_WordsArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[123] + mi := &file_protocol_server_pbdata_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9492,7 +9728,7 @@ func (x *DB_Sensitive_WordsArray) String() string { func (*DB_Sensitive_WordsArray) ProtoMessage() {} func (x *DB_Sensitive_WordsArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[123] + mi := &file_protocol_server_pbdata_proto_msgTypes[127] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9505,7 +9741,7 @@ func (x *DB_Sensitive_WordsArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Sensitive_WordsArray.ProtoReflect.Descriptor instead. func (*DB_Sensitive_WordsArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{123} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{127} } func (x *DB_Sensitive_WordsArray) GetArr() []*DB_Sensitive_Words { @@ -9539,7 +9775,7 @@ type DB_Skin struct { func (x *DB_Skin) Reset() { *x = DB_Skin{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[124] + mi := &file_protocol_server_pbdata_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9552,7 +9788,7 @@ func (x *DB_Skin) String() string { func (*DB_Skin) ProtoMessage() {} func (x *DB_Skin) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[124] + mi := &file_protocol_server_pbdata_proto_msgTypes[128] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9565,7 +9801,7 @@ func (x *DB_Skin) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Skin.ProtoReflect.Descriptor instead. func (*DB_Skin) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{124} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{128} } func (x *DB_Skin) GetId() int32 { @@ -9677,7 +9913,7 @@ type DB_SkinArray struct { func (x *DB_SkinArray) Reset() { *x = DB_SkinArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[125] + mi := &file_protocol_server_pbdata_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9690,7 +9926,7 @@ func (x *DB_SkinArray) String() string { func (*DB_SkinArray) ProtoMessage() {} func (x *DB_SkinArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[125] + mi := &file_protocol_server_pbdata_proto_msgTypes[129] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9703,7 +9939,7 @@ func (x *DB_SkinArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SkinArray.ProtoReflect.Descriptor instead. func (*DB_SkinArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{125} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{129} } func (x *DB_SkinArray) GetArr() []*DB_Skin { @@ -9731,7 +9967,7 @@ type DB_SkinLevel struct { func (x *DB_SkinLevel) Reset() { *x = DB_SkinLevel{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[126] + mi := &file_protocol_server_pbdata_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9744,7 +9980,7 @@ func (x *DB_SkinLevel) String() string { func (*DB_SkinLevel) ProtoMessage() {} func (x *DB_SkinLevel) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[126] + mi := &file_protocol_server_pbdata_proto_msgTypes[130] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9757,7 +9993,7 @@ func (x *DB_SkinLevel) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SkinLevel.ProtoReflect.Descriptor instead. func (*DB_SkinLevel) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{126} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{130} } func (x *DB_SkinLevel) GetId() int32 { @@ -9827,7 +10063,7 @@ type DB_SkinLevelArray struct { func (x *DB_SkinLevelArray) Reset() { *x = DB_SkinLevelArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[127] + mi := &file_protocol_server_pbdata_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9840,7 +10076,7 @@ func (x *DB_SkinLevelArray) String() string { func (*DB_SkinLevelArray) ProtoMessage() {} func (x *DB_SkinLevelArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[127] + mi := &file_protocol_server_pbdata_proto_msgTypes[131] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9853,7 +10089,7 @@ func (x *DB_SkinLevelArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SkinLevelArray.ProtoReflect.Descriptor instead. func (*DB_SkinLevelArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{127} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{131} } func (x *DB_SkinLevelArray) GetArr() []*DB_SkinLevel { @@ -9889,7 +10125,7 @@ type DB_SlotRateWeight struct { func (x *DB_SlotRateWeight) Reset() { *x = DB_SlotRateWeight{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[128] + mi := &file_protocol_server_pbdata_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9902,7 +10138,7 @@ func (x *DB_SlotRateWeight) String() string { func (*DB_SlotRateWeight) ProtoMessage() {} func (x *DB_SlotRateWeight) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[128] + mi := &file_protocol_server_pbdata_proto_msgTypes[132] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9915,7 +10151,7 @@ func (x *DB_SlotRateWeight) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SlotRateWeight.ProtoReflect.Descriptor instead. func (*DB_SlotRateWeight) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{128} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{132} } func (x *DB_SlotRateWeight) GetId() int32 { @@ -10041,7 +10277,7 @@ type DB_SlotRateWeightArray struct { func (x *DB_SlotRateWeightArray) Reset() { *x = DB_SlotRateWeightArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[129] + mi := &file_protocol_server_pbdata_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10054,7 +10290,7 @@ func (x *DB_SlotRateWeightArray) String() string { func (*DB_SlotRateWeightArray) ProtoMessage() {} func (x *DB_SlotRateWeightArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[129] + mi := &file_protocol_server_pbdata_proto_msgTypes[133] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10067,7 +10303,7 @@ func (x *DB_SlotRateWeightArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SlotRateWeightArray.ProtoReflect.Descriptor instead. func (*DB_SlotRateWeightArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{129} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{133} } func (x *DB_SlotRateWeightArray) GetArr() []*DB_SlotRateWeight { @@ -10092,7 +10328,7 @@ type DB_SystemChance struct { func (x *DB_SystemChance) Reset() { *x = DB_SystemChance{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[130] + mi := &file_protocol_server_pbdata_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10105,7 +10341,7 @@ func (x *DB_SystemChance) String() string { func (*DB_SystemChance) ProtoMessage() {} func (x *DB_SystemChance) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[130] + mi := &file_protocol_server_pbdata_proto_msgTypes[134] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10118,7 +10354,7 @@ func (x *DB_SystemChance) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SystemChance.ProtoReflect.Descriptor instead. func (*DB_SystemChance) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{130} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{134} } func (x *DB_SystemChance) GetId() int32 { @@ -10167,7 +10403,7 @@ type DB_SystemChanceArray struct { func (x *DB_SystemChanceArray) Reset() { *x = DB_SystemChanceArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[131] + mi := &file_protocol_server_pbdata_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10180,7 +10416,7 @@ func (x *DB_SystemChanceArray) String() string { func (*DB_SystemChanceArray) ProtoMessage() {} func (x *DB_SystemChanceArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[131] + mi := &file_protocol_server_pbdata_proto_msgTypes[135] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10193,7 +10429,7 @@ func (x *DB_SystemChanceArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_SystemChanceArray.ProtoReflect.Descriptor instead. func (*DB_SystemChanceArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{131} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{135} } func (x *DB_SystemChanceArray) GetArr() []*DB_SystemChance { @@ -10224,7 +10460,7 @@ type DB_Task struct { func (x *DB_Task) Reset() { *x = DB_Task{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[132] + mi := &file_protocol_server_pbdata_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10237,7 +10473,7 @@ func (x *DB_Task) String() string { func (*DB_Task) ProtoMessage() {} func (x *DB_Task) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[132] + mi := &file_protocol_server_pbdata_proto_msgTypes[136] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10250,7 +10486,7 @@ func (x *DB_Task) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Task.ProtoReflect.Descriptor instead. func (*DB_Task) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{132} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{136} } func (x *DB_Task) GetId() int32 { @@ -10341,7 +10577,7 @@ type DB_TaskArray struct { func (x *DB_TaskArray) Reset() { *x = DB_TaskArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[133] + mi := &file_protocol_server_pbdata_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10354,7 +10590,7 @@ func (x *DB_TaskArray) String() string { func (*DB_TaskArray) ProtoMessage() {} func (x *DB_TaskArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[133] + mi := &file_protocol_server_pbdata_proto_msgTypes[137] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10367,7 +10603,7 @@ func (x *DB_TaskArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_TaskArray.ProtoReflect.Descriptor instead. func (*DB_TaskArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{133} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{137} } func (x *DB_TaskArray) GetArr() []*DB_Task { @@ -10394,7 +10630,7 @@ type DB_ThirdPlatformGameMapping struct { func (x *DB_ThirdPlatformGameMapping) Reset() { *x = DB_ThirdPlatformGameMapping{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[134] + mi := &file_protocol_server_pbdata_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10407,7 +10643,7 @@ func (x *DB_ThirdPlatformGameMapping) String() string { func (*DB_ThirdPlatformGameMapping) ProtoMessage() {} func (x *DB_ThirdPlatformGameMapping) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[134] + mi := &file_protocol_server_pbdata_proto_msgTypes[138] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10420,7 +10656,7 @@ func (x *DB_ThirdPlatformGameMapping) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_ThirdPlatformGameMapping.ProtoReflect.Descriptor instead. func (*DB_ThirdPlatformGameMapping) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{134} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{138} } func (x *DB_ThirdPlatformGameMapping) GetId() int32 { @@ -10483,7 +10719,7 @@ type DB_ThirdPlatformGameMappingArray struct { func (x *DB_ThirdPlatformGameMappingArray) Reset() { *x = DB_ThirdPlatformGameMappingArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[135] + mi := &file_protocol_server_pbdata_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10496,7 +10732,7 @@ func (x *DB_ThirdPlatformGameMappingArray) String() string { func (*DB_ThirdPlatformGameMappingArray) ProtoMessage() {} func (x *DB_ThirdPlatformGameMappingArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[135] + mi := &file_protocol_server_pbdata_proto_msgTypes[139] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10509,7 +10745,7 @@ func (x *DB_ThirdPlatformGameMappingArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_ThirdPlatformGameMappingArray.ProtoReflect.Descriptor instead. func (*DB_ThirdPlatformGameMappingArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{135} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{139} } func (x *DB_ThirdPlatformGameMappingArray) GetArr() []*DB_ThirdPlatformGameMapping { @@ -10532,7 +10768,7 @@ type DB_Tips struct { func (x *DB_Tips) Reset() { *x = DB_Tips{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[136] + mi := &file_protocol_server_pbdata_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10545,7 +10781,7 @@ func (x *DB_Tips) String() string { func (*DB_Tips) ProtoMessage() {} func (x *DB_Tips) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[136] + mi := &file_protocol_server_pbdata_proto_msgTypes[140] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10558,7 +10794,7 @@ func (x *DB_Tips) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_Tips.ProtoReflect.Descriptor instead. func (*DB_Tips) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{136} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{140} } func (x *DB_Tips) GetId() int32 { @@ -10593,7 +10829,7 @@ type DB_TipsArray struct { func (x *DB_TipsArray) Reset() { *x = DB_TipsArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[137] + mi := &file_protocol_server_pbdata_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10606,7 +10842,7 @@ func (x *DB_TipsArray) String() string { func (*DB_TipsArray) ProtoMessage() {} func (x *DB_TipsArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[137] + mi := &file_protocol_server_pbdata_proto_msgTypes[141] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10619,7 +10855,7 @@ func (x *DB_TipsArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_TipsArray.ProtoReflect.Descriptor instead. func (*DB_TipsArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{137} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{141} } func (x *DB_TipsArray) GetArr() []*DB_Tips { @@ -10661,7 +10897,7 @@ type DB_VIP struct { func (x *DB_VIP) Reset() { *x = DB_VIP{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[138] + mi := &file_protocol_server_pbdata_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10674,7 +10910,7 @@ func (x *DB_VIP) String() string { func (*DB_VIP) ProtoMessage() {} func (x *DB_VIP) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[138] + mi := &file_protocol_server_pbdata_proto_msgTypes[142] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10687,7 +10923,7 @@ func (x *DB_VIP) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_VIP.ProtoReflect.Descriptor instead. func (*DB_VIP) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{138} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{142} } func (x *DB_VIP) GetId() int32 { @@ -10855,7 +11091,7 @@ type DB_VIPArray struct { func (x *DB_VIPArray) Reset() { *x = DB_VIPArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[139] + mi := &file_protocol_server_pbdata_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10868,7 +11104,7 @@ func (x *DB_VIPArray) String() string { func (*DB_VIPArray) ProtoMessage() {} func (x *DB_VIPArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[139] + mi := &file_protocol_server_pbdata_proto_msgTypes[143] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10881,7 +11117,7 @@ func (x *DB_VIPArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_VIPArray.ProtoReflect.Descriptor instead. func (*DB_VIPArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{139} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{143} } func (x *DB_VIPArray) GetArr() []*DB_VIP { @@ -10906,7 +11142,7 @@ type DB_VIPShow struct { func (x *DB_VIPShow) Reset() { *x = DB_VIPShow{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[140] + mi := &file_protocol_server_pbdata_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10919,7 +11155,7 @@ func (x *DB_VIPShow) String() string { func (*DB_VIPShow) ProtoMessage() {} func (x *DB_VIPShow) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[140] + mi := &file_protocol_server_pbdata_proto_msgTypes[144] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10932,7 +11168,7 @@ func (x *DB_VIPShow) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_VIPShow.ProtoReflect.Descriptor instead. func (*DB_VIPShow) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{140} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{144} } func (x *DB_VIPShow) GetId() int32 { @@ -10981,7 +11217,7 @@ type DB_VIPShowArray struct { func (x *DB_VIPShowArray) Reset() { *x = DB_VIPShowArray{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_server_pbdata_proto_msgTypes[141] + mi := &file_protocol_server_pbdata_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10994,7 +11230,7 @@ func (x *DB_VIPShowArray) String() string { func (*DB_VIPShowArray) ProtoMessage() {} func (x *DB_VIPShowArray) ProtoReflect() protoreflect.Message { - mi := &file_protocol_server_pbdata_proto_msgTypes[141] + mi := &file_protocol_server_pbdata_proto_msgTypes[145] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11007,7 +11243,7 @@ func (x *DB_VIPShowArray) ProtoReflect() protoreflect.Message { // Deprecated: Use DB_VIPShowArray.ProtoReflect.Descriptor instead. func (*DB_VIPShowArray) Descriptor() ([]byte, []int) { - return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{141} + return file_protocol_server_pbdata_proto_rawDescGZIP(), []int{145} } func (x *DB_VIPShowArray) GetArr() []*DB_VIPShow { @@ -12031,486 +12267,518 @@ var file_protocol_server_pbdata_proto_rawDesc = []byte{ 0x44, 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x50, 0x6c, - 0x61, 0x79, 0x65, 0x72, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x75, 0x0a, 0x0b, 0x44, 0x42, 0x5f, - 0x50, 0x61, 0x73, 0x73, 0x53, 0x68, 0x6f, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x68, 0x6f, 0x77, - 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x53, 0x68, 0x6f, 0x77, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x68, 0x6f, 0x77, 0x56, 0x6f, 0x6c, 0x75, - 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x68, 0x6f, 0x77, 0x56, 0x6f, - 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0x39, 0x0a, 0x10, 0x44, 0x42, 0x5f, 0x50, 0x61, 0x73, 0x73, 0x53, 0x68, 0x6f, 0x77, 0x41, - 0x72, 0x72, 0x61, 0x79, 0x12, 0x25, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x61, - 0x73, 0x73, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xe9, 0x02, 0x0a, 0x0b, - 0x44, 0x42, 0x5f, 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x49, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x53, - 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x53, 0x6b, - 0x69, 0x6c, 0x6c, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, 0x79, - 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x50, 0x65, 0x74, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x05, 0x50, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x6b, 0x69, - 0x6c, 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, - 0x6b, 0x69, 0x6c, 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, 0x69, - 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x53, 0x6b, - 0x69, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6c, 0x6c, - 0x44, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6c, 0x6c, - 0x44, 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x4b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x4b, 0x69, 0x6c, 0x6c, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x43, 0x0a, 0x0a, 0x49, 0x74, 0x65, 0x6d, 0x43, 0x6f, 0x6e, 0x73, 0x75, - 0x6d, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x2e, 0x49, 0x74, 0x65, - 0x6d, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x49, 0x74, - 0x65, 0x6d, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x1a, 0x3d, 0x0a, 0x0f, 0x49, 0x74, 0x65, 0x6d, - 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x39, 0x0a, 0x10, 0x44, 0x42, 0x5f, 0x50, 0x65, - 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x25, 0x0a, 0x03, 0x41, - 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x52, 0x03, 0x41, - 0x72, 0x72, 0x22, 0xa2, 0x02, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4c, - 0x6f, 0x74, 0x74, 0x65, 0x72, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, - 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x17, - 0x0a, 0x07, 0x49, 0x74, 0x65, 0x6d, 0x5f, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x47, 0x72, 0x61, 0x64, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x47, 0x72, 0x61, 0x64, 0x65, 0x12, 0x10, 0x0a, - 0x03, 0x4f, 0x64, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x4f, 0x64, 0x64, 0x12, - 0x1a, 0x0a, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x31, 0x12, 0x12, 0x0a, 0x04, 0x4f, - 0x64, 0x64, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4f, 0x64, 0x64, 0x32, 0x12, - 0x1a, 0x0a, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x32, 0x12, 0x12, 0x0a, 0x04, 0x4f, - 0x64, 0x64, 0x33, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4f, 0x64, 0x64, 0x33, 0x12, - 0x1a, 0x0a, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x33, 0x18, 0x0b, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x4f, - 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4f, - 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x34, 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x50, 0x68, - 0x6f, 0x6e, 0x65, 0x4c, 0x6f, 0x74, 0x74, 0x65, 0x72, 0x79, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, - 0x29, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4c, 0x6f, - 0x74, 0x74, 0x65, 0x72, 0x79, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xd8, 0x04, 0x0a, 0x12, 0x44, - 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, - 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, - 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x69, 0x6e, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, - 0x4d, 0x69, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, - 0x61, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, - 0x6e, 0x74, 0x4d, 0x61, 0x78, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x69, 0x61, - 0x6d, 0x6f, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x43, 0x6f, 0x73, 0x74, - 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x61, 0x78, 0x47, 0x6f, - 0x6c, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x4d, 0x61, 0x78, 0x47, 0x6f, 0x6c, - 0x64, 0x12, 0x41, 0x0a, 0x07, 0x47, 0x6f, 0x6c, 0x64, 0x45, 0x78, 0x63, 0x18, 0x06, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, - 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x2e, 0x47, - 0x6f, 0x6c, 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x47, 0x6f, 0x6c, - 0x64, 0x45, 0x78, 0x63, 0x12, 0x1e, 0x0a, 0x0a, 0x4d, 0x61, 0x78, 0x44, 0x69, 0x61, 0x6d, 0x6f, - 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x4d, 0x61, 0x78, 0x44, 0x69, 0x61, - 0x6d, 0x6f, 0x6e, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x49, - 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, - 0x49, 0x64, 0x12, 0x4a, 0x0a, 0x0a, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, - 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, - 0x6e, 0x64, 0x2e, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x0a, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x12, 0x1c, - 0x0a, 0x09, 0x43, 0x6f, 0x69, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x09, 0x43, 0x6f, 0x69, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x22, 0x0a, 0x0c, - 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0c, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, - 0x12, 0x28, 0x0a, 0x0f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x4e, 0x6f, 0x77, 0x50, 0x72, - 0x69, 0x63, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x44, 0x69, 0x61, 0x6d, 0x6f, - 0x6e, 0x64, 0x4e, 0x6f, 0x77, 0x50, 0x72, 0x69, 0x63, 0x65, 0x1a, 0x3a, 0x0a, 0x0c, 0x47, 0x6f, - 0x6c, 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, - 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x47, 0x0a, 0x17, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, - 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, - 0x12, 0x2c, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, - 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x5b, - 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x50, 0x72, 0x6f, - 0x70, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, - 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, - 0x09, 0x50, 0x72, 0x6f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x09, 0x50, 0x72, 0x6f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x41, 0x0a, 0x14, 0x44, - 0x42, 0x5f, 0x50, 0x69, 0x67, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x41, 0x72, - 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, - 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x30, - 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x78, 0x70, 0x12, 0x0e, - 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x10, - 0x0a, 0x03, 0x45, 0x78, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x45, 0x78, 0x70, - 0x22, 0x3b, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x78, 0x70, - 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, - 0x6c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x78, 0x70, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xa5, 0x05, - 0x0a, 0x0d, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x61, 0x79, 0x65, 0x72, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x78, 0x0a, 0x12, 0x44, 0x42, 0x5f, + 0x4e, 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, - 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, 0x49, - 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, - 0x65, 0x49, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x50, 0x61, 0x79, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x50, 0x61, 0x79, 0x4c, - 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x50, 0x61, 0x79, - 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x0d, 0x50, 0x61, 0x79, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, - 0x2e, 0x0a, 0x12, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x77, 0x65, 0x72, - 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x47, 0x61, 0x6d, - 0x65, 0x54, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, - 0x2e, 0x0a, 0x12, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x70, 0x65, 0x72, - 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x47, 0x61, 0x6d, - 0x65, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, - 0x2c, 0x0a, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x49, 0x6e, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x54, 0x6f, 0x74, 0x61, - 0x6c, 0x49, 0x6e, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, - 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x49, 0x6e, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, - 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x49, - 0x6e, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x4f, - 0x64, 0x64, 0x73, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x55, 0x70, 0x70, 0x65, 0x72, - 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x4f, 0x64, 0x64, - 0x73, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x4c, - 0x75, 0x63, 0x6b, 0x79, 0x52, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, - 0x4c, 0x75, 0x63, 0x6b, 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x43, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x43, 0x61, 0x72, 0x64, 0x52, 0x61, 0x74, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x0e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x61, 0x72, 0x64, 0x52, 0x61, 0x74, - 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x43, 0x61, 0x72, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e, 0x43, 0x61, 0x72, 0x64, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x05, - 0x52, 0x0d, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, - 0x22, 0x0a, 0x0c, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x18, - 0x10, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0c, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x61, - 0x74, 0x63, 0x68, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, 0x52, 0x61, - 0x74, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, - 0x62, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, - 0x41, 0x72, 0x72, 0x18, 0x12, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x43, 0x61, 0x72, 0x64, 0x4c, - 0x69, 0x62, 0x41, 0x72, 0x72, 0x22, 0x3d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, - 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x27, 0x0a, 0x03, 0x41, - 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, - 0x03, 0x41, 0x72, 0x72, 0x22, 0x5d, 0x0a, 0x09, 0x44, 0x42, 0x5f, 0x50, 0x6f, 0x74, 0x4f, 0x64, - 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, - 0x64, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x56, - 0x69, 0x70, 0x4f, 0x64, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x56, 0x69, 0x70, - 0x4f, 0x64, 0x64, 0x22, 0x35, 0x0a, 0x0e, 0x44, 0x42, 0x5f, 0x50, 0x6f, 0x74, 0x4f, 0x64, 0x64, - 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x23, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, - 0x6f, 0x74, 0x4f, 0x64, 0x64, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x97, 0x02, 0x0a, 0x0f, 0x44, - 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x0e, - 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x14, - 0x0a, 0x05, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x12, 0x35, 0x0a, 0x04, 0x43, 0x6f, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, - 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x43, 0x6f, 0x73, 0x74, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x04, 0x47, - 0x61, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x2e, 0x47, 0x61, 0x69, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x47, 0x61, - 0x69, 0x6e, 0x1a, 0x37, 0x0a, 0x09, 0x43, 0x6f, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, - 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, - 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x37, 0x0a, 0x09, 0x47, - 0x61, 0x69, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, - 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x46, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x52, 0x61, - 0x6e, 0x6b, 0x43, 0x79, 0x63, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x72, 0x74, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, - 0x03, 0x45, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x6e, 0x64, 0x22, - 0x3b, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x43, 0x79, 0x63, 0x6c, 0x65, 0x41, - 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x52, 0x61, - 0x6e, 0x6b, 0x43, 0x79, 0x63, 0x6c, 0x65, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x7a, 0x0a, 0x0c, - 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x0e, 0x0a, 0x02, - 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, - 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, - 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, - 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x12, - 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, - 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x05, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x22, 0x3b, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x52, - 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, - 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, - 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xff, 0x01, 0x0a, 0x0d, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, - 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, - 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x41, 0x77, 0x61, - 0x72, 0x64, 0x31, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x41, 0x77, 0x61, - 0x72, 0x64, 0x31, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, 0x4e, - 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, - 0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x49, 0x64, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x49, 0x64, 0x12, - 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x4e, 0x75, 0x6d, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, - 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x33, 0x49, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x33, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, - 0x72, 0x64, 0x33, 0x4e, 0x75, 0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x41, 0x77, - 0x61, 0x72, 0x64, 0x33, 0x4e, 0x75, 0x6d, 0x22, 0x3d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x52, 0x61, - 0x6e, 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x27, 0x0a, - 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x4d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, - 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x0e, 0x0a, 0x02, - 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0f, - 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, - 0x57, 0x6f, 0x72, 0x64, 0x73, 0x22, 0x47, 0x0a, 0x17, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, 0x73, - 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, - 0x12, 0x2c, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, - 0x69, 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x83, - 0x04, 0x0a, 0x07, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, - 0x69, 0x6e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x53, - 0x6b, 0x69, 0x6e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x4d, 0x6f, 0x64, 0x65, - 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x18, - 0x0a, 0x07, 0x53, 0x6b, 0x69, 0x6e, 0x50, 0x69, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x07, 0x53, 0x6b, 0x69, 0x6e, 0x50, 0x69, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6e, - 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6e, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x1e, 0x0a, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x3f, 0x0a, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x18, 0x08, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, - 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x2e, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, - 0x6d, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4e, 0x61, - 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, - 0x69, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, - 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x63, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, - 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x63, 0x6f, 0x6e, 0x12, 0x22, 0x0a, - 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x18, 0x0b, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, - 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, 0x79, - 0x70, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, - 0x69, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x75, 0x72, 0x6e, 0x18, - 0x0d, 0x20, 0x03, 0x28, 0x05, 0x52, 0x04, 0x54, 0x75, 0x72, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x54, - 0x75, 0x72, 0x6e, 0x4b, 0x65, 0x79, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x54, 0x75, - 0x72, 0x6e, 0x4b, 0x65, 0x79, 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, - 0x74, 0x65, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x22, 0x31, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x41, - 0x72, 0x72, 0x61, 0x79, 0x12, 0x21, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x0f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x6b, - 0x69, 0x6e, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xd7, 0x02, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x53, - 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x6b, 0x69, 0x6e, - 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, - 0x12, 0x14, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x06, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, - 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x2e, 0x55, 0x70, 0x49, - 0x74, 0x65, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, - 0x12, 0x20, 0x0a, 0x0b, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x64, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, - 0x49, 0x64, 0x12, 0x26, 0x0a, 0x0e, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x53, 0x6b, 0x69, 0x6e, - 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0e, 0x53, 0x6b, - 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0e, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, - 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, - 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, + 0x1a, 0x0a, 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x50, + 0x72, 0x6f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x50, 0x72, 0x6f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x50, 0x72, 0x6f, + 0x70, 0x44, 0x65, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x50, 0x72, 0x6f, 0x70, + 0x44, 0x65, 0x63, 0x22, 0x47, 0x0a, 0x17, 0x44, 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x59, 0x65, 0x61, + 0x72, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x2c, + 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x41, + 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xe9, 0x01, 0x0a, + 0x14, 0x44, 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x52, 0x61, 0x6e, 0x6b, 0x52, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x52, 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x49, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x52, 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x49, 0x64, 0x12, 0x46, 0x0a, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x4d, 0x61, 0x70, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, + 0x42, 0x5f, 0x4e, 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x2e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x4d, 0x61, 0x70, 0x1a, 0x3b, 0x0a, 0x0d, 0x41, + 0x77, 0x61, 0x72, 0x64, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4b, 0x0a, 0x19, 0x44, 0x42, 0x5f, 0x4e, + 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x2e, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x4e, + 0x65, 0x77, 0x59, 0x65, 0x61, 0x72, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x75, 0x0a, 0x0b, 0x44, 0x42, 0x5f, 0x50, 0x61, 0x73, 0x73, + 0x53, 0x68, 0x6f, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x68, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x53, 0x68, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x68, 0x6f, 0x77, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x68, 0x6f, 0x77, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, + 0x12, 0x1a, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x39, 0x0a, 0x10, + 0x44, 0x42, 0x5f, 0x50, 0x61, 0x73, 0x73, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x12, 0x25, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x61, 0x73, 0x73, 0x53, 0x68, + 0x6f, 0x77, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xe9, 0x02, 0x0a, 0x0b, 0x44, 0x42, 0x5f, 0x50, + 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x53, 0x6b, 0x69, 0x6c, 0x6c, + 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, + 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x50, 0x65, 0x74, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x50, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4c, 0x65, + 0x76, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x6b, 0x69, 0x6c, 0x6c, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4e, 0x61, + 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x12, + 0x1e, 0x0a, 0x0a, 0x53, 0x4b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x4b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x43, 0x0a, 0x0a, 0x49, 0x74, 0x65, 0x6d, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x18, 0x09, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, + 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x2e, 0x49, 0x74, 0x65, 0x6d, 0x43, 0x6f, 0x6e, + 0x73, 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x49, 0x74, 0x65, 0x6d, 0x43, 0x6f, + 0x6e, 0x73, 0x75, 0x6d, 0x1a, 0x3d, 0x0a, 0x0f, 0x49, 0x74, 0x65, 0x6d, 0x43, 0x6f, 0x6e, 0x73, + 0x75, 0x6d, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x39, 0x0a, 0x10, 0x44, 0x42, 0x5f, 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, + 0x6c, 0x6c, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x25, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, + 0x5f, 0x50, 0x65, 0x74, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xa2, + 0x02, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4c, 0x6f, 0x74, 0x74, 0x65, + 0x72, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, + 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x49, 0x74, + 0x65, 0x6d, 0x5f, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x49, 0x74, 0x65, + 0x6d, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x47, 0x72, 0x61, 0x64, 0x65, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x05, 0x47, 0x72, 0x61, 0x64, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x4f, 0x64, 0x64, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x4f, 0x64, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x31, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x31, 0x12, 0x12, 0x0a, 0x04, 0x4f, 0x64, 0x64, 0x32, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4f, 0x64, 0x64, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x32, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x32, 0x12, 0x12, 0x0a, 0x04, 0x4f, 0x64, 0x64, 0x33, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x4f, 0x64, 0x64, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x33, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4f, + 0x64, 0x64, 0x72, 0x61, 0x74, 0x65, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, + 0x74, 0x65, 0x34, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x4f, 0x64, 0x64, 0x72, 0x61, + 0x74, 0x65, 0x34, 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4c, + 0x6f, 0x74, 0x74, 0x65, 0x72, 0x79, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, 0x41, + 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4c, 0x6f, 0x74, 0x74, 0x65, 0x72, + 0x79, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xd8, 0x04, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x50, 0x69, + 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x12, 0x0e, 0x0a, + 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x20, 0x0a, + 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x69, 0x6e, 0x12, + 0x20, 0x0a, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x61, 0x78, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x42, 0x75, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x61, + 0x78, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x43, 0x6f, 0x73, 0x74, 0x44, 0x69, 0x61, 0x6d, + 0x6f, 0x6e, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x61, 0x78, 0x47, 0x6f, 0x6c, 0x64, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x4d, 0x61, 0x78, 0x47, 0x6f, 0x6c, 0x64, 0x12, 0x41, 0x0a, + 0x07, 0x47, 0x6f, 0x6c, 0x64, 0x45, 0x78, 0x63, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, + 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x2e, 0x47, 0x6f, 0x6c, 0x64, 0x45, + 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x47, 0x6f, 0x6c, 0x64, 0x45, 0x78, 0x63, + 0x12, 0x1e, 0x0a, 0x0a, 0x4d, 0x61, 0x78, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x4d, 0x61, 0x78, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, + 0x12, 0x1c, 0x0a, 0x09, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x49, 0x64, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x09, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x49, 0x64, 0x12, 0x4a, + 0x0a, 0x0a, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x18, 0x09, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, + 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x2e, 0x44, + 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, + 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x12, 0x1c, 0x0a, 0x09, 0x43, 0x6f, + 0x69, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x43, + 0x6f, 0x69, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x44, 0x69, 0x61, 0x6d, + 0x6f, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, + 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x28, 0x0a, 0x0f, + 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x4e, 0x6f, 0x77, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x4e, 0x6f, + 0x77, 0x50, 0x72, 0x69, 0x63, 0x65, 0x1a, 0x3a, 0x0a, 0x0c, 0x47, 0x6f, 0x6c, 0x64, 0x45, 0x78, + 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x3d, 0x0a, 0x0f, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x45, 0x78, 0x63, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, - 0x01, 0x22, 0x3b, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, - 0x6c, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, - 0x53, 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xbb, - 0x03, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, - 0x69, 0x67, 0x68, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x02, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, - 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, - 0x65, 0x65, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x50, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x03, 0x50, 0x6f, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, - 0x6c, 0x31, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, - 0x6c, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x32, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x32, 0x12, 0x1a, - 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x33, 0x18, 0x06, 0x20, 0x03, 0x28, 0x05, - 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, - 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x34, 0x18, 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, - 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, - 0x6c, 0x35, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, - 0x6c, 0x35, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x31, 0x18, 0x09, - 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x31, 0x12, 0x1a, - 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x32, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x05, - 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, - 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x33, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, - 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, - 0x6c, 0x34, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, - 0x6c, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x35, 0x18, 0x0d, - 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x35, 0x12, 0x18, - 0x0a, 0x07, 0x4d, 0x61, 0x72, 0x79, 0x4f, 0x75, 0x74, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x05, 0x52, - 0x07, 0x4d, 0x61, 0x72, 0x79, 0x4f, 0x75, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x61, 0x72, 0x79, - 0x4d, 0x69, 0x64, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x05, 0x52, 0x07, 0x4d, 0x61, 0x72, 0x79, 0x4d, - 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x4a, 0x61, 0x63, 0x6b, 0x50, 0x6f, 0x74, 0x18, 0x10, 0x20, - 0x03, 0x28, 0x05, 0x52, 0x07, 0x4a, 0x61, 0x63, 0x6b, 0x50, 0x6f, 0x74, 0x22, 0x45, 0x0a, 0x16, - 0x44, 0x42, 0x5f, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, - 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x2b, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, - 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x03, - 0x41, 0x72, 0x72, 0x22, 0x7d, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, - 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x44, 0x65, 0x73, 0x63, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x65, 0x73, 0x63, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x68, - 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, - 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x43, 0x6f, - 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x43, 0x6f, 0x69, 0x6e, 0x12, 0x12, - 0x0a, 0x04, 0x52, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x52, 0x61, - 0x74, 0x65, 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x43, - 0x68, 0x61, 0x6e, 0x63, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, 0x41, 0x72, - 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, - 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xfd, 0x02, 0x0a, 0x07, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, - 0x6b, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, - 0x64, 0x12, 0x14, 0x0a, 0x05, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x05, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x44, - 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x44, 0x65, 0x73, 0x12, 0x22, 0x0a, - 0x0c, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0c, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x08, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, - 0x0b, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0b, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, - 0x20, 0x0a, 0x0b, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x54, 0x69, 0x6d, 0x65, - 0x73, 0x12, 0x30, 0x0a, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x1a, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, - 0x6b, 0x2e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x41, 0x77, - 0x61, 0x72, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, - 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x1a, 0x0a, 0x08, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x03, 0x28, - 0x05, 0x52, 0x08, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x38, 0x0a, 0x0a, 0x41, - 0x77, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x31, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, 0x6b, - 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x21, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, - 0x61, 0x73, 0x6b, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x85, 0x02, 0x0a, 0x1b, 0x44, 0x42, 0x5f, - 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x47, 0x61, 0x6d, - 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x79, 0x73, 0x74, - 0x65, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, - 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x12, 0x2c, 0x0a, 0x11, - 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x4e, 0x61, 0x6d, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x54, 0x68, - 0x69, 0x72, 0x64, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x12, 0x12, 0x0a, 0x04, - 0x44, 0x65, 0x73, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x65, 0x73, 0x63, - 0x12, 0x34, 0x0a, 0x15, 0x53, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x15, 0x53, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x54, 0x68, 0x69, 0x72, 0x64, 0x49, - 0x44, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x54, 0x68, 0x69, 0x72, 0x64, 0x49, 0x44, - 0x22, 0x59, 0x0a, 0x20, 0x44, 0x42, 0x5f, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x41, - 0x72, 0x72, 0x61, 0x79, 0x12, 0x35, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x68, - 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x4d, - 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x43, 0x0a, 0x07, 0x44, - 0x42, 0x5f, 0x54, 0x69, 0x70, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x64, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x10, - 0x0a, 0x03, 0x44, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x44, 0x65, 0x73, - 0x22, 0x31, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x54, 0x69, 0x70, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x01, 0x22, 0x47, 0x0a, 0x17, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, + 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x2c, 0x0a, 0x03, + 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x5f, 0x44, 0x69, + 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x5b, 0x0a, 0x0f, 0x44, 0x42, + 0x5f, 0x50, 0x69, 0x67, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x12, 0x0e, 0x0a, + 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, + 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x50, 0x6f, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x50, 0x72, 0x6f, + 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x50, 0x72, + 0x6f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x50, 0x69, + 0x67, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, + 0x29, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x69, 0x67, 0x62, 0x61, 0x6e, 0x6b, + 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x30, 0x0a, 0x0c, 0x44, 0x42, + 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x78, 0x70, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, + 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x45, 0x78, 0x70, 0x22, 0x3b, 0x0a, 0x11, + 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x78, 0x70, 0x41, 0x72, 0x72, 0x61, + 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, + 0x72, 0x45, 0x78, 0x70, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xa5, 0x05, 0x0a, 0x0d, 0x44, 0x42, + 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x4e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x1e, 0x0a, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, 0x49, 0x64, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, 0x49, 0x64, 0x12, + 0x24, 0x0a, 0x0d, 0x50, 0x61, 0x79, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x50, 0x61, 0x79, 0x4c, 0x6f, 0x77, 0x65, 0x72, + 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x50, 0x61, 0x79, 0x55, 0x70, 0x70, 0x65, + 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x50, 0x61, + 0x79, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2e, 0x0a, 0x12, 0x47, + 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2e, 0x0a, 0x12, 0x47, + 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x11, 0x54, + 0x6f, 0x74, 0x61, 0x6c, 0x49, 0x6e, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x49, 0x6e, 0x4c, + 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x11, 0x54, 0x6f, 0x74, + 0x61, 0x6c, 0x49, 0x6e, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x49, 0x6e, 0x55, 0x70, 0x70, + 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x4c, + 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, + 0x26, 0x0a, 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x55, 0x70, 0x70, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x4f, 0x64, 0x64, 0x73, 0x55, 0x70, 0x70, + 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x75, 0x63, 0x6b, 0x79, + 0x52, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x4c, 0x75, 0x63, 0x6b, + 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, + 0x61, 0x72, 0x64, 0x52, 0x61, 0x74, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x43, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x61, 0x72, 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, + 0x0e, 0x43, 0x61, 0x72, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x18, + 0x0e, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e, 0x43, 0x61, 0x72, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, + 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0d, 0x4d, 0x61, + 0x74, 0x63, 0x68, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x22, 0x0a, 0x0c, 0x45, + 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x10, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x0c, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, + 0x20, 0x0a, 0x0b, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, 0x52, 0x61, 0x74, 0x65, 0x18, 0x11, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, 0x52, 0x61, 0x74, + 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, 0x41, 0x72, 0x72, 0x18, + 0x12, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x43, 0x61, 0x72, 0x64, 0x4c, 0x69, 0x62, 0x41, 0x72, + 0x72, 0x22, 0x3d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x54, 0x79, + 0x70, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x27, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, + 0x5f, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x03, 0x41, 0x72, 0x72, + 0x22, 0x5d, 0x0a, 0x09, 0x44, 0x42, 0x5f, 0x50, 0x6f, 0x74, 0x4f, 0x64, 0x64, 0x12, 0x0e, 0x0a, + 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x56, 0x69, 0x70, 0x4f, 0x64, + 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x05, 0x52, 0x06, 0x56, 0x69, 0x70, 0x4f, 0x64, 0x64, 0x22, + 0x35, 0x0a, 0x0e, 0x44, 0x42, 0x5f, 0x50, 0x6f, 0x74, 0x4f, 0x64, 0x64, 0x41, 0x72, 0x72, 0x61, + 0x79, 0x12, 0x23, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x6f, 0x74, 0x4f, 0x64, + 0x64, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x97, 0x02, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x50, 0x72, + 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x35, 0x0a, 0x04, 0x43, 0x6f, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x43, 0x6f, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x04, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x04, 0x47, 0x61, 0x69, 0x6e, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, + 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x2e, 0x47, + 0x61, 0x69, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x47, 0x61, 0x69, 0x6e, 0x1a, 0x37, + 0x0a, 0x09, 0x43, 0x6f, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x37, 0x0a, 0x09, 0x47, 0x61, 0x69, 0x6e, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x41, 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, + 0x42, 0x5f, 0x50, 0x72, 0x6f, 0x70, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x03, + 0x41, 0x72, 0x72, 0x22, 0x46, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x43, 0x79, + 0x63, 0x6c, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x02, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x6e, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x6e, 0x64, 0x22, 0x3b, 0x0a, 0x11, 0x44, + 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x43, 0x79, 0x63, 0x6c, 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x43, 0x79, + 0x63, 0x6c, 0x65, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x7a, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x52, + 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x52, 0x61, 0x6e, 0x6b, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, + 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x53, + 0x63, 0x6f, 0x72, 0x65, 0x22, 0x3b, 0x0a, 0x11, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, + 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x03, 0x41, 0x72, + 0x72, 0x22, 0xff, 0x01, 0x0a, 0x0d, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x02, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x52, 0x61, 0x6e, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, 0x49, + 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, 0x49, + 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, 0x4e, 0x75, 0x6d, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x31, 0x4e, 0x75, 0x6d, 0x12, + 0x1a, 0x0a, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x49, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x08, 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x41, + 0x77, 0x61, 0x72, 0x64, 0x32, 0x4e, 0x75, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, + 0x41, 0x77, 0x61, 0x72, 0x64, 0x32, 0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x41, 0x77, 0x61, + 0x72, 0x64, 0x33, 0x49, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x41, 0x77, 0x61, + 0x72, 0x64, 0x33, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x33, 0x4e, + 0x75, 0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x41, 0x77, 0x61, 0x72, 0x64, 0x33, + 0x4e, 0x75, 0x6d, 0x22, 0x3d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x27, 0x0a, 0x03, 0x41, 0x72, 0x72, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, + 0x44, 0x42, 0x5f, 0x52, 0x61, 0x6e, 0x6b, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x03, 0x41, + 0x72, 0x72, 0x22, 0x4d, 0x0a, 0x12, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x53, 0x65, 0x6e, 0x73, + 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0e, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x57, 0x6f, 0x72, 0x64, + 0x73, 0x22, 0x47, 0x0a, 0x17, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, + 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x2c, 0x0a, 0x03, + 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x57, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x83, 0x04, 0x0a, 0x07, 0x44, + 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x6b, 0x69, 0x6e, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x53, 0x6b, 0x69, 0x6e, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x53, 0x6b, + 0x69, 0x6e, 0x50, 0x69, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x53, 0x6b, 0x69, + 0x6e, 0x50, 0x69, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x53, 0x6b, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, 0x0a, + 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, + 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, + 0x6e, 0x2e, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0a, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x24, 0x0a, + 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, + 0x49, 0x63, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x53, 0x6b, 0x69, 0x6e, + 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x63, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x6b, 0x69, + 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x12, 0x24, 0x0a, + 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x75, 0x72, 0x6e, 0x18, 0x0d, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x04, 0x54, 0x75, 0x72, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x54, 0x75, 0x72, 0x6e, 0x4b, + 0x65, 0x79, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x54, 0x75, 0x72, 0x6e, 0x4b, 0x65, + 0x79, 0x1a, 0x3d, 0x0a, 0x0f, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x31, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x21, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x69, 0x70, 0x73, 0x52, 0x03, - 0x41, 0x72, 0x72, 0x22, 0xce, 0x06, 0x0a, 0x06, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x12, 0x0e, - 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, - 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, - 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x05, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x56, 0x69, 0x70, 0x45, - 0x78, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x56, 0x69, 0x70, 0x45, 0x78, 0x70, - 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x31, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x31, - 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x32, 0x18, 0x06, - 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x32, - 0x12, 0x18, 0x0a, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x33, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, - 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, - 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, - 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x36, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, - 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x36, 0x12, 0x3e, 0x0a, 0x0a, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, - 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x2e, 0x50, - 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, - 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x12, 0x28, 0x0a, 0x0f, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0d, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0f, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x50, - 0x72, 0x69, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x37, 0x18, - 0x0e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x37, 0x12, 0x1e, - 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x38, 0x18, 0x0f, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x38, 0x12, 0x14, - 0x0a, 0x05, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x18, 0x10, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x50, - 0x61, 0x72, 0x61, 0x6d, 0x12, 0x28, 0x0a, 0x0f, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x4f, 0x75, - 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x49, 0x44, 0x18, 0x11, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0f, 0x52, - 0x65, 0x77, 0x61, 0x72, 0x64, 0x4f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x49, 0x44, 0x12, 0x2f, - 0x0a, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x2e, 0x41, 0x77, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x52, 0x03, + 0x41, 0x72, 0x72, 0x22, 0xd7, 0x02, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x4c, 0x65, 0x76, + 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x06, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, 0x18, 0x04, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, + 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x2e, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x20, 0x0a, 0x0b, + 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0b, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x49, 0x64, 0x12, 0x26, + 0x0a, 0x0e, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, + 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0e, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, + 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, + 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x22, + 0x0a, 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, 0x65, 0x73, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x53, 0x6b, 0x69, 0x6e, 0x53, 0x6b, 0x69, 0x6c, 0x6c, 0x44, + 0x65, 0x73, 0x1a, 0x39, 0x0a, 0x0b, 0x55, 0x70, 0x49, 0x74, 0x65, 0x6d, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3b, 0x0a, + 0x11, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x41, 0x72, 0x72, + 0x61, 0x79, 0x12, 0x26, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x6b, 0x69, 0x6e, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0xbb, 0x03, 0x0a, 0x11, 0x44, + 0x42, 0x5f, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, + 0x12, 0x1e, 0x0a, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, 0x49, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x47, 0x61, 0x6d, 0x65, 0x46, 0x72, 0x65, 0x65, 0x49, 0x64, + 0x12, 0x10, 0x0a, 0x03, 0x50, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x50, + 0x6f, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x31, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x31, 0x12, 0x1a, + 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x32, 0x18, 0x05, 0x20, 0x03, 0x28, 0x05, + 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, + 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x33, 0x18, 0x06, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, + 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, + 0x6c, 0x34, 0x18, 0x07, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, + 0x6c, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x35, 0x18, 0x08, + 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x4e, 0x6f, 0x72, 0x6d, 0x43, 0x6f, 0x6c, 0x35, 0x12, 0x1a, + 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x31, 0x18, 0x09, 0x20, 0x03, 0x28, 0x05, + 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x31, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, + 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x32, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, + 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, + 0x6c, 0x33, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, + 0x6c, 0x33, 0x12, 0x1a, 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x34, 0x18, 0x0c, + 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x34, 0x12, 0x1a, + 0x0a, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x35, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x05, + 0x52, 0x08, 0x46, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x35, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x61, + 0x72, 0x79, 0x4f, 0x75, 0x74, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x05, 0x52, 0x07, 0x4d, 0x61, 0x72, + 0x79, 0x4f, 0x75, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x61, 0x72, 0x79, 0x4d, 0x69, 0x64, 0x18, + 0x0f, 0x20, 0x03, 0x28, 0x05, 0x52, 0x07, 0x4d, 0x61, 0x72, 0x79, 0x4d, 0x69, 0x64, 0x12, 0x18, + 0x0a, 0x07, 0x4a, 0x61, 0x63, 0x6b, 0x50, 0x6f, 0x74, 0x18, 0x10, 0x20, 0x03, 0x28, 0x05, 0x52, + 0x07, 0x4a, 0x61, 0x63, 0x6b, 0x50, 0x6f, 0x74, 0x22, 0x45, 0x0a, 0x16, 0x44, 0x42, 0x5f, 0x53, + 0x6c, 0x6f, 0x74, 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x41, 0x72, 0x72, + 0x61, 0x79, 0x12, 0x2b, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x53, 0x6c, 0x6f, 0x74, + 0x52, 0x61, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, + 0x7d, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x43, 0x68, 0x61, 0x6e, + 0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, + 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x44, 0x65, 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x44, 0x65, 0x73, 0x63, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x43, 0x68, 0x61, 0x6e, + 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x43, 0x6f, 0x69, 0x6e, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x43, 0x6f, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x52, 0x61, + 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x52, 0x61, 0x74, 0x65, 0x22, 0x41, + 0x0a, 0x14, 0x44, 0x42, 0x5f, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x63, + 0x65, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x29, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, + 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x03, 0x41, 0x72, + 0x72, 0x22, 0xfd, 0x02, 0x0a, 0x07, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x0e, 0x0a, + 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x14, 0x0a, + 0x05, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x44, 0x65, 0x73, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x44, 0x65, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x41, 0x63, 0x74, + 0x69, 0x76, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0c, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x08, 0x54, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x54, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, + 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x46, + 0x69, 0x6e, 0x69, 0x73, 0x68, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0b, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x30, 0x0a, + 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, 0x6b, 0x2e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x12, - 0x1c, 0x0a, 0x09, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x13, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x09, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, - 0x0e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x46, 0x72, 0x65, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, - 0x14, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x46, 0x72, 0x65, 0x65, - 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, - 0x67, 0x65, 0x39, 0x18, 0x15, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, - 0x6c, 0x65, 0x67, 0x65, 0x39, 0x12, 0x24, 0x0a, 0x0d, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, - 0x67, 0x65, 0x53, 0x68, 0x6f, 0x77, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x53, 0x68, 0x6f, 0x77, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, - 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, - 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, - 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x38, 0x0a, 0x0a, 0x41, 0x77, - 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x22, 0x2f, 0x0a, 0x0b, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x41, 0x72, - 0x72, 0x61, 0x79, 0x12, 0x20, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x0e, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, - 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x7c, 0x0a, 0x0a, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x53, - 0x68, 0x6f, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, - 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, 0x12, - 0x1a, 0x0a, 0x08, 0x56, 0x49, 0x50, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x08, 0x56, 0x49, 0x50, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x56, - 0x49, 0x50, 0x44, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x56, 0x49, 0x50, - 0x44, 0x65, 0x73, 0x22, 0x37, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x53, 0x68, 0x6f, - 0x77, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x24, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, - 0x56, 0x49, 0x50, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x03, 0x41, 0x72, 0x72, 0x42, 0x26, 0x5a, 0x24, - 0x6d, 0x6f, 0x6e, 0x67, 0x6f, 0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, - 0x67, 0x61, 0x6d, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x1a, 0x0a, 0x08, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x08, 0x47, 0x61, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x38, 0x0a, 0x0a, 0x41, 0x77, 0x61, 0x72, 0x64, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x31, 0x0a, 0x0c, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, 0x6b, 0x41, 0x72, 0x72, 0x61, + 0x79, 0x12, 0x21, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x03, 0x41, 0x72, 0x72, 0x22, 0x85, 0x02, 0x0a, 0x1b, 0x44, 0x42, 0x5f, 0x54, 0x68, 0x69, 0x72, + 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x70, + 0x70, 0x69, 0x6e, 0x67, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x02, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x47, 0x61, + 0x6d, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x53, 0x79, 0x73, 0x74, + 0x65, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x12, 0x2c, 0x0a, 0x11, 0x54, 0x68, 0x69, 0x72, + 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x11, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x47, + 0x61, 0x6d, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x54, 0x68, 0x69, + 0x72, 0x64, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x44, 0x12, 0x12, 0x0a, 0x04, 0x44, 0x65, 0x73, 0x63, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x65, 0x73, 0x63, 0x12, 0x34, 0x0a, 0x15, + 0x53, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x53, 0x63, 0x72, + 0x65, 0x65, 0x6e, 0x4f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x54, 0x68, 0x69, 0x72, 0x64, 0x49, 0x44, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x07, 0x54, 0x68, 0x69, 0x72, 0x64, 0x49, 0x44, 0x22, 0x59, 0x0a, 0x20, + 0x44, 0x42, 0x5f, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x47, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x12, 0x35, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x47, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, + 0x6e, 0x67, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, 0x43, 0x0a, 0x07, 0x44, 0x42, 0x5f, 0x54, 0x69, + 0x70, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, + 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x64, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x05, 0x52, 0x06, 0x47, 0x61, 0x6d, 0x65, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x44, 0x65, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x44, 0x65, 0x73, 0x22, 0x31, 0x0a, 0x0c, + 0x44, 0x42, 0x5f, 0x54, 0x69, 0x70, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, 0x21, 0x0a, 0x03, + 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x54, 0x69, 0x70, 0x73, 0x52, 0x03, 0x41, 0x72, 0x72, 0x22, + 0xce, 0x06, 0x0a, 0x06, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x56, 0x69, 0x70, 0x45, 0x78, 0x70, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x56, 0x69, 0x70, 0x45, 0x78, 0x70, 0x12, 0x1e, 0x0a, 0x0a, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x31, 0x18, 0x05, 0x20, 0x03, 0x28, 0x05, + 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x31, 0x12, 0x1e, 0x0a, 0x0a, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x32, 0x18, 0x06, 0x20, 0x03, 0x28, 0x05, + 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x32, 0x12, 0x18, 0x0a, 0x07, + 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x53, + 0x68, 0x6f, 0x70, 0x49, 0x64, 0x32, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x33, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x33, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x35, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x35, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x36, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x36, 0x12, 0x3e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x37, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x69, + 0x6c, 0x65, 0x67, 0x65, 0x37, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x12, 0x28, 0x0a, 0x0f, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x37, 0x50, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0f, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x37, 0x50, 0x72, 0x69, 0x63, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x37, 0x18, 0x0e, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x07, 0x53, 0x68, 0x6f, 0x70, 0x49, 0x64, 0x37, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, + 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x38, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x38, 0x12, 0x14, 0x0a, 0x05, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x18, 0x10, 0x20, 0x03, 0x28, 0x05, 0x52, 0x05, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x12, 0x28, 0x0a, 0x0f, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x4f, 0x75, 0x74, 0x6c, 0x69, 0x6e, + 0x65, 0x49, 0x44, 0x18, 0x11, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0f, 0x52, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x4f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x49, 0x44, 0x12, 0x2f, 0x0a, 0x05, 0x41, 0x77, + 0x61, 0x72, 0x64, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x2e, 0x41, 0x77, 0x61, 0x72, 0x64, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x41, 0x77, 0x61, 0x72, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x13, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x4d, 0x61, 0x74, + 0x63, 0x68, 0x46, 0x72, 0x65, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x46, 0x72, 0x65, 0x65, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x39, 0x18, + 0x15, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, + 0x39, 0x12, 0x24, 0x0a, 0x0d, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x53, 0x68, + 0x6f, 0x77, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, + 0x65, 0x67, 0x65, 0x53, 0x68, 0x6f, 0x77, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x72, 0x69, 0x76, 0x69, + 0x6c, 0x65, 0x67, 0x65, 0x37, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x38, 0x0a, 0x0a, 0x41, 0x77, 0x61, 0x72, 0x64, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x2f, 0x0a, 0x0b, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x41, 0x72, 0x72, 0x61, 0x79, 0x12, + 0x20, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x52, 0x03, 0x41, 0x72, + 0x72, 0x22, 0x7c, 0x0a, 0x0a, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x53, 0x68, 0x6f, 0x77, 0x12, + 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x6b, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x56, + 0x49, 0x50, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x56, + 0x49, 0x50, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x56, 0x49, 0x50, 0x44, 0x65, + 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x56, 0x49, 0x50, 0x44, 0x65, 0x73, 0x22, + 0x37, 0x0a, 0x0f, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x53, 0x68, 0x6f, 0x77, 0x41, 0x72, 0x72, + 0x61, 0x79, 0x12, 0x24, 0x0a, 0x03, 0x41, 0x72, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x42, 0x5f, 0x56, 0x49, 0x50, 0x53, + 0x68, 0x6f, 0x77, 0x52, 0x03, 0x41, 0x72, 0x72, 0x42, 0x26, 0x5a, 0x24, 0x6d, 0x6f, 0x6e, 0x67, + 0x6f, 0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x6d, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -12525,7 +12793,7 @@ func file_protocol_server_pbdata_proto_rawDescGZIP() []byte { return file_protocol_server_pbdata_proto_rawDescData } -var file_protocol_server_pbdata_proto_msgTypes = make([]protoimpl.MessageInfo, 158) +var file_protocol_server_pbdata_proto_msgTypes = make([]protoimpl.MessageInfo, 163) var file_protocol_server_pbdata_proto_goTypes = []interface{}{ (*DB_ActSign)(nil), // 0: server.DB_ActSign (*DB_ActSignArray)(nil), // 1: server.DB_ActSignArray @@ -12625,66 +12893,71 @@ var file_protocol_server_pbdata_proto_goTypes = []interface{}{ (*DB_NameGirlArray)(nil), // 95: server.DB_NameGirlArray (*DB_NewPlayer)(nil), // 96: server.DB_NewPlayer (*DB_NewPlayerArray)(nil), // 97: server.DB_NewPlayerArray - (*DB_PassShow)(nil), // 98: server.DB_PassShow - (*DB_PassShowArray)(nil), // 99: server.DB_PassShowArray - (*DB_PetSkill)(nil), // 100: server.DB_PetSkill - (*DB_PetSkillArray)(nil), // 101: server.DB_PetSkillArray - (*DB_PhoneLottery)(nil), // 102: server.DB_PhoneLottery - (*DB_PhoneLotteryArray)(nil), // 103: server.DB_PhoneLotteryArray - (*DB_PigBank_Diamond)(nil), // 104: server.DB_PigBank_Diamond - (*DB_PigBank_DiamondArray)(nil), // 105: server.DB_PigBank_DiamondArray - (*DB_Pigbank_Prop)(nil), // 106: server.DB_Pigbank_Prop - (*DB_Pigbank_PropArray)(nil), // 107: server.DB_Pigbank_PropArray - (*DB_PlayerExp)(nil), // 108: server.DB_PlayerExp - (*DB_PlayerExpArray)(nil), // 109: server.DB_PlayerExpArray - (*DB_PlayerType)(nil), // 110: server.DB_PlayerType - (*DB_PlayerTypeArray)(nil), // 111: server.DB_PlayerTypeArray - (*DB_PotOdd)(nil), // 112: server.DB_PotOdd - (*DB_PotOddArray)(nil), // 113: server.DB_PotOddArray - (*DB_PropExchange)(nil), // 114: server.DB_PropExchange - (*DB_PropExchangeArray)(nil), // 115: server.DB_PropExchangeArray - (*DB_RankCycle)(nil), // 116: server.DB_RankCycle - (*DB_RankCycleArray)(nil), // 117: server.DB_RankCycleArray - (*DB_RankLevel)(nil), // 118: server.DB_RankLevel - (*DB_RankLevelArray)(nil), // 119: server.DB_RankLevelArray - (*DB_RankReward)(nil), // 120: server.DB_RankReward - (*DB_RankRewardArray)(nil), // 121: server.DB_RankRewardArray - (*DB_Sensitive_Words)(nil), // 122: server.DB_Sensitive_Words - (*DB_Sensitive_WordsArray)(nil), // 123: server.DB_Sensitive_WordsArray - (*DB_Skin)(nil), // 124: server.DB_Skin - (*DB_SkinArray)(nil), // 125: server.DB_SkinArray - (*DB_SkinLevel)(nil), // 126: server.DB_SkinLevel - (*DB_SkinLevelArray)(nil), // 127: server.DB_SkinLevelArray - (*DB_SlotRateWeight)(nil), // 128: server.DB_SlotRateWeight - (*DB_SlotRateWeightArray)(nil), // 129: server.DB_SlotRateWeightArray - (*DB_SystemChance)(nil), // 130: server.DB_SystemChance - (*DB_SystemChanceArray)(nil), // 131: server.DB_SystemChanceArray - (*DB_Task)(nil), // 132: server.DB_Task - (*DB_TaskArray)(nil), // 133: server.DB_TaskArray - (*DB_ThirdPlatformGameMapping)(nil), // 134: server.DB_ThirdPlatformGameMapping - (*DB_ThirdPlatformGameMappingArray)(nil), // 135: server.DB_ThirdPlatformGameMappingArray - (*DB_Tips)(nil), // 136: server.DB_Tips - (*DB_TipsArray)(nil), // 137: server.DB_TipsArray - (*DB_VIP)(nil), // 138: server.DB_VIP - (*DB_VIPArray)(nil), // 139: server.DB_VIPArray - (*DB_VIPShow)(nil), // 140: server.DB_VIPShow - (*DB_VIPShowArray)(nil), // 141: server.DB_VIPShowArray - nil, // 142: server.DB_CollectBox.ItemIDEntry - nil, // 143: server.DB_GameItem.GainEntry - nil, // 144: server.DB_GameItem.CompoundEntry - nil, // 145: server.DB_GiftBox.ItemIDEntry - nil, // 146: server.DB_GiftCard.RewardsEntry - nil, // 147: server.DB_GiftCard.DayRewardsEntry - nil, // 148: server.DB_PetSkill.ItemConsumEntry - nil, // 149: server.DB_PigBank_Diamond.GoldExcEntry - nil, // 150: server.DB_PigBank_Diamond.DiamondExcEntry - nil, // 151: server.DB_PropExchange.CostEntry - nil, // 152: server.DB_PropExchange.GainEntry - nil, // 153: server.DB_Skin.UnlockItemEntry - nil, // 154: server.DB_SkinLevel.UpItemEntry - nil, // 155: server.DB_Task.AwardEntry - nil, // 156: server.DB_VIP.Privilege7Entry - nil, // 157: server.DB_VIP.AwardEntry + (*DB_NewYearActivity)(nil), // 98: server.DB_NewYearActivity + (*DB_NewYearActivityArray)(nil), // 99: server.DB_NewYearActivityArray + (*DB_NewYearRankReward)(nil), // 100: server.DB_NewYearRankReward + (*DB_NewYearRankRewardArray)(nil), // 101: server.DB_NewYearRankRewardArray + (*DB_PassShow)(nil), // 102: server.DB_PassShow + (*DB_PassShowArray)(nil), // 103: server.DB_PassShowArray + (*DB_PetSkill)(nil), // 104: server.DB_PetSkill + (*DB_PetSkillArray)(nil), // 105: server.DB_PetSkillArray + (*DB_PhoneLottery)(nil), // 106: server.DB_PhoneLottery + (*DB_PhoneLotteryArray)(nil), // 107: server.DB_PhoneLotteryArray + (*DB_PigBank_Diamond)(nil), // 108: server.DB_PigBank_Diamond + (*DB_PigBank_DiamondArray)(nil), // 109: server.DB_PigBank_DiamondArray + (*DB_Pigbank_Prop)(nil), // 110: server.DB_Pigbank_Prop + (*DB_Pigbank_PropArray)(nil), // 111: server.DB_Pigbank_PropArray + (*DB_PlayerExp)(nil), // 112: server.DB_PlayerExp + (*DB_PlayerExpArray)(nil), // 113: server.DB_PlayerExpArray + (*DB_PlayerType)(nil), // 114: server.DB_PlayerType + (*DB_PlayerTypeArray)(nil), // 115: server.DB_PlayerTypeArray + (*DB_PotOdd)(nil), // 116: server.DB_PotOdd + (*DB_PotOddArray)(nil), // 117: server.DB_PotOddArray + (*DB_PropExchange)(nil), // 118: server.DB_PropExchange + (*DB_PropExchangeArray)(nil), // 119: server.DB_PropExchangeArray + (*DB_RankCycle)(nil), // 120: server.DB_RankCycle + (*DB_RankCycleArray)(nil), // 121: server.DB_RankCycleArray + (*DB_RankLevel)(nil), // 122: server.DB_RankLevel + (*DB_RankLevelArray)(nil), // 123: server.DB_RankLevelArray + (*DB_RankReward)(nil), // 124: server.DB_RankReward + (*DB_RankRewardArray)(nil), // 125: server.DB_RankRewardArray + (*DB_Sensitive_Words)(nil), // 126: server.DB_Sensitive_Words + (*DB_Sensitive_WordsArray)(nil), // 127: server.DB_Sensitive_WordsArray + (*DB_Skin)(nil), // 128: server.DB_Skin + (*DB_SkinArray)(nil), // 129: server.DB_SkinArray + (*DB_SkinLevel)(nil), // 130: server.DB_SkinLevel + (*DB_SkinLevelArray)(nil), // 131: server.DB_SkinLevelArray + (*DB_SlotRateWeight)(nil), // 132: server.DB_SlotRateWeight + (*DB_SlotRateWeightArray)(nil), // 133: server.DB_SlotRateWeightArray + (*DB_SystemChance)(nil), // 134: server.DB_SystemChance + (*DB_SystemChanceArray)(nil), // 135: server.DB_SystemChanceArray + (*DB_Task)(nil), // 136: server.DB_Task + (*DB_TaskArray)(nil), // 137: server.DB_TaskArray + (*DB_ThirdPlatformGameMapping)(nil), // 138: server.DB_ThirdPlatformGameMapping + (*DB_ThirdPlatformGameMappingArray)(nil), // 139: server.DB_ThirdPlatformGameMappingArray + (*DB_Tips)(nil), // 140: server.DB_Tips + (*DB_TipsArray)(nil), // 141: server.DB_TipsArray + (*DB_VIP)(nil), // 142: server.DB_VIP + (*DB_VIPArray)(nil), // 143: server.DB_VIPArray + (*DB_VIPShow)(nil), // 144: server.DB_VIPShow + (*DB_VIPShowArray)(nil), // 145: server.DB_VIPShowArray + nil, // 146: server.DB_CollectBox.ItemIDEntry + nil, // 147: server.DB_GameItem.GainEntry + nil, // 148: server.DB_GameItem.CompoundEntry + nil, // 149: server.DB_GiftBox.ItemIDEntry + nil, // 150: server.DB_GiftCard.RewardsEntry + nil, // 151: server.DB_GiftCard.DayRewardsEntry + nil, // 152: server.DB_NewYearRankReward.AwardMapEntry + nil, // 153: server.DB_PetSkill.ItemConsumEntry + nil, // 154: server.DB_PigBank_Diamond.GoldExcEntry + nil, // 155: server.DB_PigBank_Diamond.DiamondExcEntry + nil, // 156: server.DB_PropExchange.CostEntry + nil, // 157: server.DB_PropExchange.GainEntry + nil, // 158: server.DB_Skin.UnlockItemEntry + nil, // 159: server.DB_SkinLevel.UpItemEntry + nil, // 160: server.DB_Task.AwardEntry + nil, // 161: server.DB_VIP.Privilege7Entry + nil, // 162: server.DB_VIP.AwardEntry } var file_protocol_server_pbdata_proto_depIdxs = []int32{ 0, // 0: server.DB_ActSignArray.Arr:type_name -> server.DB_ActSign @@ -12699,7 +12972,7 @@ var file_protocol_server_pbdata_proto_depIdxs = []int32{ 18, // 9: server.DB_ChessMatchRulesArray.Arr:type_name -> server.DB_ChessMatchRules 20, // 10: server.DB_ChessRankArray.Arr:type_name -> server.DB_ChessRank 22, // 11: server.DB_ClientVerArray.Arr:type_name -> server.DB_ClientVer - 142, // 12: server.DB_CollectBox.ItemID:type_name -> server.DB_CollectBox.ItemIDEntry + 146, // 12: server.DB_CollectBox.ItemID:type_name -> server.DB_CollectBox.ItemIDEntry 24, // 13: server.DB_CollectBoxArray.Arr:type_name -> server.DB_CollectBox 26, // 14: server.DB_CollectBoxGainArray.Arr:type_name -> server.DB_CollectBoxGain 28, // 15: server.DB_CrashSearchArray.Arr:type_name -> server.DB_CrashSearch @@ -12717,8 +12990,8 @@ var file_protocol_server_pbdata_proto_depIdxs = []int32{ 52, // 27: server.DB_GameBankruptcyArray.Arr:type_name -> server.DB_GameBankruptcy 54, // 28: server.DB_GameCoinPoolArray.Arr:type_name -> server.DB_GameCoinPool 56, // 29: server.DB_GameFreeArray.Arr:type_name -> server.DB_GameFree - 143, // 30: server.DB_GameItem.Gain:type_name -> server.DB_GameItem.GainEntry - 144, // 31: server.DB_GameItem.Compound:type_name -> server.DB_GameItem.CompoundEntry + 147, // 30: server.DB_GameItem.Gain:type_name -> server.DB_GameItem.GainEntry + 148, // 31: server.DB_GameItem.Compound:type_name -> server.DB_GameItem.CompoundEntry 58, // 32: server.DB_GameItemArray.Arr:type_name -> server.DB_GameItem 60, // 33: server.DB_GameMatchLevelArray.Arr:type_name -> server.DB_GameMatchLevel 62, // 34: server.DB_GameRuleArray.Arr:type_name -> server.DB_GameRule @@ -12727,10 +13000,10 @@ var file_protocol_server_pbdata_proto_depIdxs = []int32{ 68, // 37: server.DB_Game_IntroductionArray.Arr:type_name -> server.DB_Game_Introduction 70, // 38: server.DB_Game_PetArray.Arr:type_name -> server.DB_Game_Pet 72, // 39: server.DB_Game_RoleArray.Arr:type_name -> server.DB_Game_Role - 145, // 40: server.DB_GiftBox.ItemID:type_name -> server.DB_GiftBox.ItemIDEntry + 149, // 40: server.DB_GiftBox.ItemID:type_name -> server.DB_GiftBox.ItemIDEntry 74, // 41: server.DB_GiftBoxArray.Arr:type_name -> server.DB_GiftBox - 146, // 42: server.DB_GiftCard.Rewards:type_name -> server.DB_GiftCard.RewardsEntry - 147, // 43: server.DB_GiftCard.DayRewards:type_name -> server.DB_GiftCard.DayRewardsEntry + 150, // 42: server.DB_GiftCard.Rewards:type_name -> server.DB_GiftCard.RewardsEntry + 151, // 43: server.DB_GiftCard.DayRewards:type_name -> server.DB_GiftCard.DayRewardsEntry 76, // 44: server.DB_GiftCardArray.Arr:type_name -> server.DB_GiftCard 78, // 45: server.DB_IceAgeElementRateArray.Arr:type_name -> server.DB_IceAgeElementRate 80, // 46: server.DB_Legend_OddsArray.Arr:type_name -> server.DB_Legend_Odds @@ -12742,43 +13015,46 @@ var file_protocol_server_pbdata_proto_depIdxs = []int32{ 92, // 52: server.DB_NameBoyArray.Arr:type_name -> server.DB_NameBoy 94, // 53: server.DB_NameGirlArray.Arr:type_name -> server.DB_NameGirl 96, // 54: server.DB_NewPlayerArray.Arr:type_name -> server.DB_NewPlayer - 98, // 55: server.DB_PassShowArray.Arr:type_name -> server.DB_PassShow - 148, // 56: server.DB_PetSkill.ItemConsum:type_name -> server.DB_PetSkill.ItemConsumEntry - 100, // 57: server.DB_PetSkillArray.Arr:type_name -> server.DB_PetSkill - 102, // 58: server.DB_PhoneLotteryArray.Arr:type_name -> server.DB_PhoneLottery - 149, // 59: server.DB_PigBank_Diamond.GoldExc:type_name -> server.DB_PigBank_Diamond.GoldExcEntry - 150, // 60: server.DB_PigBank_Diamond.DiamondExc:type_name -> server.DB_PigBank_Diamond.DiamondExcEntry - 104, // 61: server.DB_PigBank_DiamondArray.Arr:type_name -> server.DB_PigBank_Diamond - 106, // 62: server.DB_Pigbank_PropArray.Arr:type_name -> server.DB_Pigbank_Prop - 108, // 63: server.DB_PlayerExpArray.Arr:type_name -> server.DB_PlayerExp - 110, // 64: server.DB_PlayerTypeArray.Arr:type_name -> server.DB_PlayerType - 112, // 65: server.DB_PotOddArray.Arr:type_name -> server.DB_PotOdd - 151, // 66: server.DB_PropExchange.Cost:type_name -> server.DB_PropExchange.CostEntry - 152, // 67: server.DB_PropExchange.Gain:type_name -> server.DB_PropExchange.GainEntry - 114, // 68: server.DB_PropExchangeArray.Arr:type_name -> server.DB_PropExchange - 116, // 69: server.DB_RankCycleArray.Arr:type_name -> server.DB_RankCycle - 118, // 70: server.DB_RankLevelArray.Arr:type_name -> server.DB_RankLevel - 120, // 71: server.DB_RankRewardArray.Arr:type_name -> server.DB_RankReward - 122, // 72: server.DB_Sensitive_WordsArray.Arr:type_name -> server.DB_Sensitive_Words - 153, // 73: server.DB_Skin.UnlockItem:type_name -> server.DB_Skin.UnlockItemEntry - 124, // 74: server.DB_SkinArray.Arr:type_name -> server.DB_Skin - 154, // 75: server.DB_SkinLevel.UpItem:type_name -> server.DB_SkinLevel.UpItemEntry - 126, // 76: server.DB_SkinLevelArray.Arr:type_name -> server.DB_SkinLevel - 128, // 77: server.DB_SlotRateWeightArray.Arr:type_name -> server.DB_SlotRateWeight - 130, // 78: server.DB_SystemChanceArray.Arr:type_name -> server.DB_SystemChance - 155, // 79: server.DB_Task.Award:type_name -> server.DB_Task.AwardEntry - 132, // 80: server.DB_TaskArray.Arr:type_name -> server.DB_Task - 134, // 81: server.DB_ThirdPlatformGameMappingArray.Arr:type_name -> server.DB_ThirdPlatformGameMapping - 136, // 82: server.DB_TipsArray.Arr:type_name -> server.DB_Tips - 156, // 83: server.DB_VIP.Privilege7:type_name -> server.DB_VIP.Privilege7Entry - 157, // 84: server.DB_VIP.Award:type_name -> server.DB_VIP.AwardEntry - 138, // 85: server.DB_VIPArray.Arr:type_name -> server.DB_VIP - 140, // 86: server.DB_VIPShowArray.Arr:type_name -> server.DB_VIPShow - 87, // [87:87] is the sub-list for method output_type - 87, // [87:87] is the sub-list for method input_type - 87, // [87:87] is the sub-list for extension type_name - 87, // [87:87] is the sub-list for extension extendee - 0, // [0:87] is the sub-list for field type_name + 98, // 55: server.DB_NewYearActivityArray.Arr:type_name -> server.DB_NewYearActivity + 152, // 56: server.DB_NewYearRankReward.AwardMap:type_name -> server.DB_NewYearRankReward.AwardMapEntry + 100, // 57: server.DB_NewYearRankRewardArray.Arr:type_name -> server.DB_NewYearRankReward + 102, // 58: server.DB_PassShowArray.Arr:type_name -> server.DB_PassShow + 153, // 59: server.DB_PetSkill.ItemConsum:type_name -> server.DB_PetSkill.ItemConsumEntry + 104, // 60: server.DB_PetSkillArray.Arr:type_name -> server.DB_PetSkill + 106, // 61: server.DB_PhoneLotteryArray.Arr:type_name -> server.DB_PhoneLottery + 154, // 62: server.DB_PigBank_Diamond.GoldExc:type_name -> server.DB_PigBank_Diamond.GoldExcEntry + 155, // 63: server.DB_PigBank_Diamond.DiamondExc:type_name -> server.DB_PigBank_Diamond.DiamondExcEntry + 108, // 64: server.DB_PigBank_DiamondArray.Arr:type_name -> server.DB_PigBank_Diamond + 110, // 65: server.DB_Pigbank_PropArray.Arr:type_name -> server.DB_Pigbank_Prop + 112, // 66: server.DB_PlayerExpArray.Arr:type_name -> server.DB_PlayerExp + 114, // 67: server.DB_PlayerTypeArray.Arr:type_name -> server.DB_PlayerType + 116, // 68: server.DB_PotOddArray.Arr:type_name -> server.DB_PotOdd + 156, // 69: server.DB_PropExchange.Cost:type_name -> server.DB_PropExchange.CostEntry + 157, // 70: server.DB_PropExchange.Gain:type_name -> server.DB_PropExchange.GainEntry + 118, // 71: server.DB_PropExchangeArray.Arr:type_name -> server.DB_PropExchange + 120, // 72: server.DB_RankCycleArray.Arr:type_name -> server.DB_RankCycle + 122, // 73: server.DB_RankLevelArray.Arr:type_name -> server.DB_RankLevel + 124, // 74: server.DB_RankRewardArray.Arr:type_name -> server.DB_RankReward + 126, // 75: server.DB_Sensitive_WordsArray.Arr:type_name -> server.DB_Sensitive_Words + 158, // 76: server.DB_Skin.UnlockItem:type_name -> server.DB_Skin.UnlockItemEntry + 128, // 77: server.DB_SkinArray.Arr:type_name -> server.DB_Skin + 159, // 78: server.DB_SkinLevel.UpItem:type_name -> server.DB_SkinLevel.UpItemEntry + 130, // 79: server.DB_SkinLevelArray.Arr:type_name -> server.DB_SkinLevel + 132, // 80: server.DB_SlotRateWeightArray.Arr:type_name -> server.DB_SlotRateWeight + 134, // 81: server.DB_SystemChanceArray.Arr:type_name -> server.DB_SystemChance + 160, // 82: server.DB_Task.Award:type_name -> server.DB_Task.AwardEntry + 136, // 83: server.DB_TaskArray.Arr:type_name -> server.DB_Task + 138, // 84: server.DB_ThirdPlatformGameMappingArray.Arr:type_name -> server.DB_ThirdPlatformGameMapping + 140, // 85: server.DB_TipsArray.Arr:type_name -> server.DB_Tips + 161, // 86: server.DB_VIP.Privilege7:type_name -> server.DB_VIP.Privilege7Entry + 162, // 87: server.DB_VIP.Award:type_name -> server.DB_VIP.AwardEntry + 142, // 88: server.DB_VIPArray.Arr:type_name -> server.DB_VIP + 144, // 89: server.DB_VIPShowArray.Arr:type_name -> server.DB_VIPShow + 90, // [90:90] is the sub-list for method output_type + 90, // [90:90] is the sub-list for method input_type + 90, // [90:90] is the sub-list for extension type_name + 90, // [90:90] is the sub-list for extension extendee + 0, // [0:90] is the sub-list for field type_name } func init() { file_protocol_server_pbdata_proto_init() } @@ -13964,7 +14240,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PassShow); i { + switch v := v.(*DB_NewYearActivity); i { case 0: return &v.state case 1: @@ -13976,7 +14252,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PassShowArray); i { + switch v := v.(*DB_NewYearActivityArray); i { case 0: return &v.state case 1: @@ -13988,7 +14264,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PetSkill); i { + switch v := v.(*DB_NewYearRankReward); i { case 0: return &v.state case 1: @@ -14000,7 +14276,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PetSkillArray); i { + switch v := v.(*DB_NewYearRankRewardArray); i { case 0: return &v.state case 1: @@ -14012,7 +14288,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PhoneLottery); i { + switch v := v.(*DB_PassShow); i { case 0: return &v.state case 1: @@ -14024,7 +14300,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PhoneLotteryArray); i { + switch v := v.(*DB_PassShowArray); i { case 0: return &v.state case 1: @@ -14036,7 +14312,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PigBank_Diamond); i { + switch v := v.(*DB_PetSkill); i { case 0: return &v.state case 1: @@ -14048,7 +14324,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PigBank_DiamondArray); i { + switch v := v.(*DB_PetSkillArray); i { case 0: return &v.state case 1: @@ -14060,7 +14336,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Pigbank_Prop); i { + switch v := v.(*DB_PhoneLottery); i { case 0: return &v.state case 1: @@ -14072,7 +14348,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Pigbank_PropArray); i { + switch v := v.(*DB_PhoneLotteryArray); i { case 0: return &v.state case 1: @@ -14084,7 +14360,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PlayerExp); i { + switch v := v.(*DB_PigBank_Diamond); i { case 0: return &v.state case 1: @@ -14096,7 +14372,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PlayerExpArray); i { + switch v := v.(*DB_PigBank_DiamondArray); i { case 0: return &v.state case 1: @@ -14108,7 +14384,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PlayerType); i { + switch v := v.(*DB_Pigbank_Prop); i { case 0: return &v.state case 1: @@ -14120,7 +14396,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PlayerTypeArray); i { + switch v := v.(*DB_Pigbank_PropArray); i { case 0: return &v.state case 1: @@ -14132,7 +14408,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PotOdd); i { + switch v := v.(*DB_PlayerExp); i { case 0: return &v.state case 1: @@ -14144,7 +14420,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PotOddArray); i { + switch v := v.(*DB_PlayerExpArray); i { case 0: return &v.state case 1: @@ -14156,7 +14432,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PropExchange); i { + switch v := v.(*DB_PlayerType); i { case 0: return &v.state case 1: @@ -14168,7 +14444,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_PropExchangeArray); i { + switch v := v.(*DB_PlayerTypeArray); i { case 0: return &v.state case 1: @@ -14180,7 +14456,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankCycle); i { + switch v := v.(*DB_PotOdd); i { case 0: return &v.state case 1: @@ -14192,7 +14468,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankCycleArray); i { + switch v := v.(*DB_PotOddArray); i { case 0: return &v.state case 1: @@ -14204,7 +14480,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankLevel); i { + switch v := v.(*DB_PropExchange); i { case 0: return &v.state case 1: @@ -14216,7 +14492,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankLevelArray); i { + switch v := v.(*DB_PropExchangeArray); i { case 0: return &v.state case 1: @@ -14228,7 +14504,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankReward); i { + switch v := v.(*DB_RankCycle); i { case 0: return &v.state case 1: @@ -14240,7 +14516,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_RankRewardArray); i { + switch v := v.(*DB_RankCycleArray); i { case 0: return &v.state case 1: @@ -14252,7 +14528,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Sensitive_Words); i { + switch v := v.(*DB_RankLevel); i { case 0: return &v.state case 1: @@ -14264,7 +14540,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Sensitive_WordsArray); i { + switch v := v.(*DB_RankLevelArray); i { case 0: return &v.state case 1: @@ -14276,7 +14552,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Skin); i { + switch v := v.(*DB_RankReward); i { case 0: return &v.state case 1: @@ -14288,7 +14564,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SkinArray); i { + switch v := v.(*DB_RankRewardArray); i { case 0: return &v.state case 1: @@ -14300,7 +14576,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SkinLevel); i { + switch v := v.(*DB_Sensitive_Words); i { case 0: return &v.state case 1: @@ -14312,7 +14588,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SkinLevelArray); i { + switch v := v.(*DB_Sensitive_WordsArray); i { case 0: return &v.state case 1: @@ -14324,7 +14600,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SlotRateWeight); i { + switch v := v.(*DB_Skin); i { case 0: return &v.state case 1: @@ -14336,7 +14612,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SlotRateWeightArray); i { + switch v := v.(*DB_SkinArray); i { case 0: return &v.state case 1: @@ -14348,7 +14624,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SystemChance); i { + switch v := v.(*DB_SkinLevel); i { case 0: return &v.state case 1: @@ -14360,7 +14636,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_SystemChanceArray); i { + switch v := v.(*DB_SkinLevelArray); i { case 0: return &v.state case 1: @@ -14372,7 +14648,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Task); i { + switch v := v.(*DB_SlotRateWeight); i { case 0: return &v.state case 1: @@ -14384,7 +14660,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_TaskArray); i { + switch v := v.(*DB_SlotRateWeightArray); i { case 0: return &v.state case 1: @@ -14396,7 +14672,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_ThirdPlatformGameMapping); i { + switch v := v.(*DB_SystemChance); i { case 0: return &v.state case 1: @@ -14408,7 +14684,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_ThirdPlatformGameMappingArray); i { + switch v := v.(*DB_SystemChanceArray); i { case 0: return &v.state case 1: @@ -14420,7 +14696,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[136].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_Tips); i { + switch v := v.(*DB_Task); i { case 0: return &v.state case 1: @@ -14432,7 +14708,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[137].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_TipsArray); i { + switch v := v.(*DB_TaskArray); i { case 0: return &v.state case 1: @@ -14444,7 +14720,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[138].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_VIP); i { + switch v := v.(*DB_ThirdPlatformGameMapping); i { case 0: return &v.state case 1: @@ -14456,7 +14732,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_VIPArray); i { + switch v := v.(*DB_ThirdPlatformGameMappingArray); i { case 0: return &v.state case 1: @@ -14468,7 +14744,7 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DB_VIPShow); i { + switch v := v.(*DB_Tips); i { case 0: return &v.state case 1: @@ -14480,6 +14756,54 @@ func file_protocol_server_pbdata_proto_init() { } } file_protocol_server_pbdata_proto_msgTypes[141].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DB_TipsArray); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_server_pbdata_proto_msgTypes[142].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DB_VIP); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_server_pbdata_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DB_VIPArray); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_server_pbdata_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DB_VIPShow); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_server_pbdata_proto_msgTypes[145].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DB_VIPShowArray); i { case 0: return &v.state @@ -14498,7 +14822,7 @@ func file_protocol_server_pbdata_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_protocol_server_pbdata_proto_rawDesc, NumEnums: 0, - NumMessages: 158, + NumMessages: 163, NumExtensions: 0, NumServices: 0, }, diff --git a/protocol/task/task.pb.go b/protocol/task/task.pb.go index ec0ff8d..8cd279d 100644 --- a/protocol/task/task.pb.go +++ b/protocol/task/task.pb.go @@ -332,7 +332,7 @@ type CSTaskReward struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Tp int32 `protobuf:"varint,1,opt,name=Tp,proto3" json:"Tp,omitempty"` // 任务类型 1:日常任务 2:周活跃任务 3:新手任务 4:邀请任务 5:成就系统 6:赛季通行证任务 + Tp int32 `protobuf:"varint,1,opt,name=Tp,proto3" json:"Tp,omitempty"` // 任务类型 1:日常任务 2:周活跃任务 3:新手任务 4:邀请任务 5:成就系统 6:赛季通行证任务 8: 年兽每日任务 9：年兽活动任务 Id int32 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"` // 任务id; 0 表示一键领取 } diff --git a/protocol/webapi/common.pb.go b/protocol/webapi/common.pb.go index 6766cbc..3800625 100644 --- a/protocol/webapi/common.pb.go +++ b/protocol/webapi/common.pb.go @@ -9860,6 +9860,244 @@ func (x *GamePigBankPropConfig) GetPropInfo() []*PigBankPropInfo { return nil } +//etcd /game/activity_nian +type ActivityNianConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Platform string `protobuf:"bytes,1,opt,name=Platform,proto3" json:"Platform,omitempty"` // 平台 + List []*NianInfo `protobuf:"bytes,2,rep,name=List,proto3" json:"List,omitempty"` + Switch int32 `protobuf:"varint,3,opt,name=Switch,proto3" json:"Switch,omitempty"` // 活动开关 1.开启 2.关闭 +} + +func (x *ActivityNianConfig) Reset() { + *x = ActivityNianConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_webapi_common_proto_msgTypes[104] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ActivityNianConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActivityNianConfig) ProtoMessage() {} + +func (x *ActivityNianConfig) ProtoReflect() protoreflect.Message { + mi := &file_protocol_webapi_common_proto_msgTypes[104] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActivityNianConfig.ProtoReflect.Descriptor instead. +func (*ActivityNianConfig) Descriptor() ([]byte, []int) { + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{104} +} + +func (x *ActivityNianConfig) GetPlatform() string { + if x != nil { + return x.Platform + } + return "" +} + +func (x *ActivityNianConfig) GetList() []*NianInfo { + if x != nil { + return x.List + } + return nil +} + +func (x *ActivityNianConfig) GetSwitch() int32 { + if x != nil { + return x.Switch + } + return 0 +} + +type NianInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ActivityStart string `protobuf:"bytes,1,opt,name=ActivityStart,proto3" json:"ActivityStart,omitempty"` // 活动开始时间 + ActivityEnd string `protobuf:"bytes,2,opt,name=ActivityEnd,proto3" json:"ActivityEnd,omitempty"` // 活动结束时间 + BuffStartTime int64 `protobuf:"varint,3,opt,name=BuffStartTime,proto3" json:"BuffStartTime,omitempty"` //Buff领取开始时间 18 + BuffEndTime int64 `protobuf:"varint,4,opt,name=BuffEndTime,proto3" json:"BuffEndTime,omitempty"` //Buff领取结束时间 21 + SignReward []*ItemInfo `protobuf:"bytes,5,rep,name=SignReward,proto3" json:"SignReward,omitempty"` // 签到奖励 + BossDieReward []*ItemInfo `protobuf:"bytes,6,rep,name=BossDieReward,proto3" json:"BossDieReward,omitempty"` // 击杀BOSS奖励 + BossDieOtherReward []*NianDropInfo `protobuf:"bytes,7,rep,name=BossDieOtherReward,proto3" json:"BossDieOtherReward,omitempty"` // 击杀Boss额外奖励 +} + +func (x *NianInfo) Reset() { + *x = NianInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_webapi_common_proto_msgTypes[105] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NianInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NianInfo) ProtoMessage() {} + +func (x *NianInfo) ProtoReflect() protoreflect.Message { + mi := &file_protocol_webapi_common_proto_msgTypes[105] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NianInfo.ProtoReflect.Descriptor instead. +func (*NianInfo) Descriptor() ([]byte, []int) { + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{105} +} + +func (x *NianInfo) GetActivityStart() string { + if x != nil { + return x.ActivityStart + } + return "" +} + +func (x *NianInfo) GetActivityEnd() string { + if x != nil { + return x.ActivityEnd + } + return "" +} + +func (x *NianInfo) GetBuffStartTime() int64 { + if x != nil { + return x.BuffStartTime + } + return 0 +} + +func (x *NianInfo) GetBuffEndTime() int64 { + if x != nil { + return x.BuffEndTime + } + return 0 +} + +func (x *NianInfo) GetSignReward() []*ItemInfo { + if x != nil { + return x.SignReward + } + return nil +} + +func (x *NianInfo) GetBossDieReward() []*ItemInfo { + if x != nil { + return x.BossDieReward + } + return nil +} + +func (x *NianInfo) GetBossDieOtherReward() []*NianDropInfo { + if x != nil { + return x.BossDieOtherReward + } + return nil +} + +type NianDropInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"` + ItemId int32 `protobuf:"varint,2,opt,name=ItemId,proto3" json:"ItemId,omitempty"` // 物品ID + ItemNum int64 `protobuf:"varint,3,opt,name=ItemNum,proto3" json:"ItemNum,omitempty"` // 物品数量 + DropRate int32 `protobuf:"varint,4,opt,name=DropRate,proto3" json:"DropRate,omitempty"` //掉落概率 + DropUp int32 `protobuf:"varint,5,opt,name=DropUp,proto3" json:"DropUp,omitempty"` //掉落上限 +} + +func (x *NianDropInfo) Reset() { + *x = NianDropInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_protocol_webapi_common_proto_msgTypes[106] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NianDropInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NianDropInfo) ProtoMessage() {} + +func (x *NianDropInfo) ProtoReflect() protoreflect.Message { + mi := &file_protocol_webapi_common_proto_msgTypes[106] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NianDropInfo.ProtoReflect.Descriptor instead. +func (*NianDropInfo) Descriptor() ([]byte, []int) { + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{106} +} + +func (x *NianDropInfo) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *NianDropInfo) GetItemId() int32 { + if x != nil { + return x.ItemId + } + return 0 +} + +func (x *NianDropInfo) GetItemNum() int64 { + if x != nil { + return x.ItemNum + } + return 0 +} + +func (x *NianDropInfo) GetDropRate() int32 { + if x != nil { + return x.DropRate + } + return 0 +} + +func (x *NianDropInfo) GetDropUp() int32 { + if x != nil { + return x.DropUp + } + return 0 +} + // etcd /game/act_redpacket type RedPacketConfig struct { state protoimpl.MessageState @@ -9874,7 +10112,7 @@ type RedPacketConfig struct { func (x *RedPacketConfig) Reset() { *x = RedPacketConfig{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_webapi_common_proto_msgTypes[104] + mi := &file_protocol_webapi_common_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9887,7 +10125,7 @@ func (x *RedPacketConfig) String() string { func (*RedPacketConfig) ProtoMessage() {} func (x *RedPacketConfig) ProtoReflect() protoreflect.Message { - mi := &file_protocol_webapi_common_proto_msgTypes[104] + mi := &file_protocol_webapi_common_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9900,7 +10138,7 @@ func (x *RedPacketConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use RedPacketConfig.ProtoReflect.Descriptor instead. func (*RedPacketConfig) Descriptor() ([]byte, []int) { - return file_protocol_webapi_common_proto_rawDescGZIP(), []int{104} + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{107} } func (x *RedPacketConfig) GetPlatform() string { @@ -9944,7 +10182,7 @@ type RedPacketInfo struct { func (x *RedPacketInfo) Reset() { *x = RedPacketInfo{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_webapi_common_proto_msgTypes[105] + mi := &file_protocol_webapi_common_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9957,7 +10195,7 @@ func (x *RedPacketInfo) String() string { func (*RedPacketInfo) ProtoMessage() {} func (x *RedPacketInfo) ProtoReflect() protoreflect.Message { - mi := &file_protocol_webapi_common_proto_msgTypes[105] + mi := &file_protocol_webapi_common_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9970,7 +10208,7 @@ func (x *RedPacketInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use RedPacketInfo.ProtoReflect.Descriptor instead. func (*RedPacketInfo) Descriptor() ([]byte, []int) { - return file_protocol_webapi_common_proto_rawDescGZIP(), []int{105} + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{108} } func (x *RedPacketInfo) GetId() int64 { @@ -10055,7 +10293,7 @@ type RedInfo struct { func (x *RedInfo) Reset() { *x = RedInfo{} if protoimpl.UnsafeEnabled { - mi := &file_protocol_webapi_common_proto_msgTypes[106] + mi := &file_protocol_webapi_common_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10068,7 +10306,7 @@ func (x *RedInfo) String() string { func (*RedInfo) ProtoMessage() {} func (x *RedInfo) ProtoReflect() protoreflect.Message { - mi := &file_protocol_webapi_common_proto_msgTypes[106] + mi := &file_protocol_webapi_common_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10081,7 +10319,7 @@ func (x *RedInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use RedInfo.ProtoReflect.Descriptor instead. func (*RedInfo) Descriptor() ([]byte, []int) { - return file_protocol_webapi_common_proto_rawDescGZIP(), []int{106} + return file_protocol_webapi_common_proto_rawDescGZIP(), []int{109} } func (x *RedInfo) GetNum() int64 { @@ -11625,38 +11863,74 @@ var file_protocol_webapi_common_proto_rawDesc = []byte{ 0x72, 0x6d, 0x12, 0x33, 0x0a, 0x08, 0x50, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x2e, 0x50, 0x69, 0x67, 0x42, 0x61, 0x6e, 0x6b, 0x50, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x50, - 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x7a, 0x0a, 0x0f, 0x52, 0x65, 0x64, 0x50, 0x61, - 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x50, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x50, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x29, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x2e, 0x52, 0x65, - 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x04, 0x4c, 0x69, 0x73, - 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x22, 0x94, 0x02, 0x0a, 0x0d, 0x52, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x02, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x4f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x02, 0x4f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x74, 0x61, 0x72, 0x74, 0x48, 0x4d, - 0x53, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x53, 0x74, 0x61, 0x72, 0x74, 0x48, 0x4d, - 0x53, 0x12, 0x16, 0x0a, 0x06, 0x45, 0x6e, 0x64, 0x48, 0x4d, 0x53, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x06, 0x45, 0x6e, 0x64, 0x48, 0x4d, 0x53, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x61, - 0x79, 0x54, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x53, 0x74, 0x61, 0x79, 0x54, - 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x08, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1c, 0x0a, - 0x09, 0x4c, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x09, 0x4c, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x49, - 0x74, 0x65, 0x6d, 0x49, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x49, 0x74, 0x65, - 0x6d, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x12, - 0x29, 0x0a, 0x07, 0x52, 0x65, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x0f, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x2e, 0x52, 0x65, 0x64, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x07, 0x52, 0x65, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2f, 0x0a, 0x07, 0x52, 0x65, - 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x10, 0x0a, 0x03, 0x4e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x03, 0x4e, 0x75, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x52, 0x61, 0x74, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x52, 0x61, 0x74, 0x65, 0x42, 0x26, 0x5a, 0x24, 0x6d, - 0x6f, 0x6e, 0x67, 0x6f, 0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, - 0x61, 0x6d, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x77, 0x65, 0x62, - 0x61, 0x70, 0x69, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x6e, 0x0a, 0x12, 0x41, 0x63, 0x74, 0x69, 0x76, + 0x69, 0x74, 0x79, 0x4e, 0x69, 0x61, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1a, 0x0a, + 0x08, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x24, 0x0a, 0x04, 0x4c, 0x69, 0x73, + 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, + 0x2e, 0x4e, 0x69, 0x61, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x06, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x22, 0xca, 0x02, 0x0a, 0x08, 0x4e, 0x69, 0x61, 0x6e, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x24, 0x0a, 0x0d, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, + 0x53, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x41, 0x63, 0x74, + 0x69, 0x76, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x41, 0x63, + 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x41, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x64, 0x12, 0x24, 0x0a, 0x0d, + 0x42, 0x75, 0x66, 0x66, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0d, 0x42, 0x75, 0x66, 0x66, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, + 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x42, 0x75, 0x66, 0x66, 0x45, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x42, 0x75, 0x66, 0x66, 0x45, 0x6e, 0x64, + 0x54, 0x69, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x77, 0x61, + 0x72, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, + 0x69, 0x2e, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x53, 0x69, 0x67, 0x6e, + 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, 0x0d, 0x42, 0x6f, 0x73, 0x73, 0x44, 0x69, + 0x65, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, + 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0d, 0x42, 0x6f, 0x73, 0x73, 0x44, 0x69, 0x65, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x44, + 0x0a, 0x12, 0x42, 0x6f, 0x73, 0x73, 0x44, 0x69, 0x65, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x52, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x77, 0x65, 0x62, + 0x61, 0x70, 0x69, 0x2e, 0x4e, 0x69, 0x61, 0x6e, 0x44, 0x72, 0x6f, 0x70, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x12, 0x42, 0x6f, 0x73, 0x73, 0x44, 0x69, 0x65, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x52, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x22, 0x84, 0x01, 0x0a, 0x0c, 0x4e, 0x69, 0x61, 0x6e, 0x44, 0x72, 0x6f, + 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x02, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x12, 0x18, 0x0a, + 0x07, 0x49, 0x74, 0x65, 0x6d, 0x4e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, + 0x49, 0x74, 0x65, 0x6d, 0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x52, + 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x52, + 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x44, 0x72, 0x6f, 0x70, 0x55, 0x70, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x44, 0x72, 0x6f, 0x70, 0x55, 0x70, 0x22, 0x7a, 0x0a, 0x0f, 0x52, + 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1a, + 0x0a, 0x08, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x29, 0x0a, 0x04, 0x4c, 0x69, + 0x73, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, + 0x69, 0x2e, 0x52, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x4c, + 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x50, 0x6c, 0x61, 0x79, + 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x94, 0x02, 0x0a, 0x0d, 0x52, 0x65, 0x64, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x4f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x4f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x48, 0x4d, 0x53, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x48, 0x4d, 0x53, 0x12, 0x16, 0x0a, 0x06, 0x45, 0x6e, 0x64, 0x48, 0x4d, 0x53, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x45, 0x6e, 0x64, 0x48, 0x4d, 0x53, 0x12, 0x16, 0x0a, + 0x06, 0x53, 0x74, 0x61, 0x79, 0x54, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x53, + 0x74, 0x61, 0x79, 0x54, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x4c, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x06, 0x49, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x54, 0x6f, 0x74, 0x61, 0x6c, + 0x4e, 0x75, 0x6d, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x54, 0x6f, 0x74, 0x61, 0x6c, + 0x4e, 0x75, 0x6d, 0x12, 0x29, 0x0a, 0x07, 0x52, 0x65, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x0a, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x2e, 0x52, 0x65, + 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x52, 0x65, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x2f, + 0x0a, 0x07, 0x52, 0x65, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x10, 0x0a, 0x03, 0x4e, 0x75, 0x6d, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x4e, 0x75, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x52, + 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x52, 0x61, 0x74, 0x65, 0x42, + 0x26, 0x5a, 0x24, 0x6d, 0x6f, 0x6e, 0x67, 0x6f, 0x2e, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x6d, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x2f, 0x77, 0x65, 0x62, 0x61, 0x70, 0x69, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -11671,7 +11945,7 @@ func file_protocol_webapi_common_proto_rawDescGZIP() []byte { return file_protocol_webapi_common_proto_rawDescData } -var file_protocol_webapi_common_proto_msgTypes = make([]protoimpl.MessageInfo, 117) +var file_protocol_webapi_common_proto_msgTypes = make([]protoimpl.MessageInfo, 120) var file_protocol_webapi_common_proto_goTypes = []interface{}{ (*MysqlDbSetting)(nil), // 0: webapi.MysqlDbSetting (*MongoDbSetting)(nil), // 1: webapi.MongoDbSetting @@ -11777,35 +12051,38 @@ var file_protocol_webapi_common_proto_goTypes = []interface{}{ (*GamePigBankDiamondConfig)(nil), // 101: webapi.GamePigBankDiamondConfig (*PigBankPropInfo)(nil), // 102: webapi.PigBankPropInfo (*GamePigBankPropConfig)(nil), // 103: webapi.GamePigBankPropConfig - (*RedPacketConfig)(nil), // 104: webapi.RedPacketConfig - (*RedPacketInfo)(nil), // 105: webapi.RedPacketInfo - (*RedInfo)(nil), // 106: webapi.RedInfo - nil, // 107: webapi.Platform.BindTelRewardEntry - nil, // 108: webapi.PlayerData.RankScoreEntry - nil, // 109: webapi.ItemShop.AwardEntry - nil, // 110: webapi.VIPcfg.AwardEntry - nil, // 111: webapi.VIPcfg.Privilege1Entry - nil, // 112: webapi.VIPcfg.Privilege7Entry - nil, // 113: webapi.VIPcfg.Privilege9Entry - nil, // 114: webapi.ActInviteConfig.PayScoreEntry - nil, // 115: webapi.SkinLevel.UpItemEntry - nil, // 116: webapi.SkinItem.UnlockParamEntry - (*server.DB_GameFree)(nil), // 117: server.DB_GameFree - (*server.DB_GameItem)(nil), // 118: server.DB_GameItem + (*ActivityNianConfig)(nil), // 104: webapi.ActivityNianConfig + (*NianInfo)(nil), // 105: webapi.NianInfo + (*NianDropInfo)(nil), // 106: webapi.NianDropInfo + (*RedPacketConfig)(nil), // 107: webapi.RedPacketConfig + (*RedPacketInfo)(nil), // 108: webapi.RedPacketInfo + (*RedInfo)(nil), // 109: webapi.RedInfo + nil, // 110: webapi.Platform.BindTelRewardEntry + nil, // 111: webapi.PlayerData.RankScoreEntry + nil, // 112: webapi.ItemShop.AwardEntry + nil, // 113: webapi.VIPcfg.AwardEntry + nil, // 114: webapi.VIPcfg.Privilege1Entry + nil, // 115: webapi.VIPcfg.Privilege7Entry + nil, // 116: webapi.VIPcfg.Privilege9Entry + nil, // 117: webapi.ActInviteConfig.PayScoreEntry + nil, // 118: webapi.SkinLevel.UpItemEntry + nil, // 119: webapi.SkinItem.UnlockParamEntry + (*server.DB_GameFree)(nil), // 120: server.DB_GameFree + (*server.DB_GameItem)(nil), // 121: server.DB_GameItem } var file_protocol_webapi_common_proto_depIdxs = []int32{ 2, // 0: webapi.Platform.Leaderboard:type_name -> webapi.RankSwitch 3, // 1: webapi.Platform.ClubConfig:type_name -> webapi.ClubConfig 4, // 2: webapi.Platform.ThirdGameMerchant:type_name -> webapi.ThirdGame - 107, // 3: webapi.Platform.BindTelReward:type_name -> webapi.Platform.BindTelRewardEntry + 110, // 3: webapi.Platform.BindTelReward:type_name -> webapi.Platform.BindTelRewardEntry 6, // 4: webapi.GameConfigGlobal.GameStatus:type_name -> webapi.GameStatus - 117, // 5: webapi.GameFree.DbGameFree:type_name -> server.DB_GameFree + 120, // 5: webapi.GameFree.DbGameFree:type_name -> server.DB_GameFree 8, // 6: webapi.PlatformGameConfig.DbGameFrees:type_name -> webapi.GameFree 0, // 7: webapi.PlatformDbConfig.Mysql:type_name -> webapi.MysqlDbSetting 1, // 8: webapi.PlatformDbConfig.MongoDb:type_name -> webapi.MongoDbSetting 1, // 9: webapi.PlatformDbConfig.MongoDbLog:type_name -> webapi.MongoDbSetting - 117, // 10: webapi.GameConfigGroup.DbGameFree:type_name -> server.DB_GameFree - 108, // 11: webapi.PlayerData.RankScore:type_name -> webapi.PlayerData.RankScoreEntry + 120, // 10: webapi.GameConfigGroup.DbGameFree:type_name -> server.DB_GameFree + 111, // 11: webapi.PlayerData.RankScore:type_name -> webapi.PlayerData.RankScoreEntry 32, // 12: webapi.PlayerData.Items:type_name -> webapi.ItemInfo 14, // 13: webapi.PlayerData.RoleUnlockList:type_name -> webapi.ModInfo 14, // 14: webapi.PlayerData.PetUnlockList:type_name -> webapi.ModInfo @@ -11818,7 +12095,7 @@ var file_protocol_webapi_common_proto_depIdxs = []int32{ 32, // 21: webapi.ExchangeShop.Items:type_name -> webapi.ItemInfo 25, // 22: webapi.ExchangeShopList.List:type_name -> webapi.ExchangeShop 29, // 23: webapi.ExchangeShopList.Weight:type_name -> webapi.ShopWeight - 109, // 24: webapi.ItemShop.Award:type_name -> webapi.ItemShop.AwardEntry + 112, // 24: webapi.ItemShop.Award:type_name -> webapi.ItemShop.AwardEntry 30, // 25: webapi.ItemShopList.List:type_name -> webapi.ItemShop 32, // 26: webapi.MatchInfoAward.ItemId:type_name -> webapi.ItemInfo 33, // 27: webapi.GameMatchDate.Award:type_name -> webapi.MatchInfoAward @@ -11839,14 +12116,14 @@ var file_protocol_webapi_common_proto_depIdxs = []int32{ 38, // 42: webapi.WelfareSpree.Item:type_name -> webapi.WelfareDate 48, // 43: webapi.WelfareFirstPayDataList.List:type_name -> webapi.WelfareSpree 48, // 44: webapi.WelfareContinuousPayDataList.List:type_name -> webapi.WelfareSpree - 110, // 45: webapi.VIPcfg.Award:type_name -> webapi.VIPcfg.AwardEntry - 111, // 46: webapi.VIPcfg.Privilege1:type_name -> webapi.VIPcfg.Privilege1Entry - 112, // 47: webapi.VIPcfg.Privilege7:type_name -> webapi.VIPcfg.Privilege7Entry - 113, // 48: webapi.VIPcfg.Privilege9:type_name -> webapi.VIPcfg.Privilege9Entry + 113, // 45: webapi.VIPcfg.Award:type_name -> webapi.VIPcfg.AwardEntry + 114, // 46: webapi.VIPcfg.Privilege1:type_name -> webapi.VIPcfg.Privilege1Entry + 115, // 47: webapi.VIPcfg.Privilege7:type_name -> webapi.VIPcfg.Privilege7Entry + 116, // 48: webapi.VIPcfg.Privilege9:type_name -> webapi.VIPcfg.Privilege9Entry 51, // 49: webapi.VIPcfgDataList.List:type_name -> webapi.VIPcfg 38, // 50: webapi.ChessRankConfig.Item:type_name -> webapi.WelfareDate 55, // 51: webapi.ChessRankcfgData.Datas:type_name -> webapi.ChessRankConfig - 114, // 52: webapi.ActInviteConfig.PayScore:type_name -> webapi.ActInviteConfig.PayScoreEntry + 117, // 52: webapi.ActInviteConfig.PayScore:type_name -> webapi.ActInviteConfig.PayScoreEntry 62, // 53: webapi.ActInviteConfig.Awards1:type_name -> webapi.RankAward 62, // 54: webapi.ActInviteConfig.Awards2:type_name -> webapi.RankAward 62, // 55: webapi.ActInviteConfig.Awards3:type_name -> webapi.RankAward @@ -11863,12 +12140,12 @@ var file_protocol_webapi_common_proto_depIdxs = []int32{ 69, // 66: webapi.DiamondLotteryData.Info:type_name -> webapi.DiamondLotteryInfo 70, // 67: webapi.DiamondLotteryData.Players:type_name -> webapi.DiamondLotteryPlayers 72, // 68: webapi.DiamondLotteryConfig.LotteryData:type_name -> webapi.DiamondLotteryData - 118, // 69: webapi.ItemConfig.Items:type_name -> server.DB_GameItem + 121, // 69: webapi.ItemConfig.Items:type_name -> server.DB_GameItem 32, // 70: webapi.RankAwardInfo.Item:type_name -> webapi.ItemInfo 75, // 71: webapi.RankTypeInfo.Award:type_name -> webapi.RankAwardInfo 76, // 72: webapi.RankTypeConfig.Info:type_name -> webapi.RankTypeInfo - 115, // 73: webapi.SkinLevel.UpItem:type_name -> webapi.SkinLevel.UpItemEntry - 116, // 74: webapi.SkinItem.UnlockParam:type_name -> webapi.SkinItem.UnlockParamEntry + 118, // 73: webapi.SkinLevel.UpItem:type_name -> webapi.SkinLevel.UpItemEntry + 119, // 74: webapi.SkinItem.UnlockParam:type_name -> webapi.SkinItem.UnlockParamEntry 78, // 75: webapi.SkinItem.Levels:type_name -> webapi.SkinLevel 79, // 76: webapi.SkinConfig.Items:type_name -> webapi.SkinItem 82, // 77: webapi.AwardLogConfig.AwardLog:type_name -> webapi.AwardLogData @@ -11887,13 +12164,17 @@ var file_protocol_webapi_common_proto_depIdxs = []int32{ 32, // 90: webapi.PigBankDiamondInfo.DiamondExc:type_name -> webapi.ItemInfo 100, // 91: webapi.GamePigBankDiamondConfig.DiamondInfo:type_name -> webapi.PigBankDiamondInfo 102, // 92: webapi.GamePigBankPropConfig.PropInfo:type_name -> webapi.PigBankPropInfo - 105, // 93: webapi.RedPacketConfig.List:type_name -> webapi.RedPacketInfo - 106, // 94: webapi.RedPacketInfo.RedList:type_name -> webapi.RedInfo - 95, // [95:95] is the sub-list for method output_type - 95, // [95:95] is the sub-list for method input_type - 95, // [95:95] is the sub-list for extension type_name - 95, // [95:95] is the sub-list for extension extendee - 0, // [0:95] is the sub-list for field type_name + 105, // 93: webapi.ActivityNianConfig.List:type_name -> webapi.NianInfo + 32, // 94: webapi.NianInfo.SignReward:type_name -> webapi.ItemInfo + 32, // 95: webapi.NianInfo.BossDieReward:type_name -> webapi.ItemInfo + 106, // 96: webapi.NianInfo.BossDieOtherReward:type_name -> webapi.NianDropInfo + 108, // 97: webapi.RedPacketConfig.List:type_name -> webapi.RedPacketInfo + 109, // 98: webapi.RedPacketInfo.RedList:type_name -> webapi.RedInfo + 99, // [99:99] is the sub-list for method output_type + 99, // [99:99] is the sub-list for method input_type + 99, // [99:99] is the sub-list for extension type_name + 99, // [99:99] is the sub-list for extension extendee + 0, // [0:99] is the sub-list for field type_name } func init() { file_protocol_webapi_common_proto_init() } @@ -13151,7 +13432,7 @@ func file_protocol_webapi_common_proto_init() { } } file_protocol_webapi_common_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RedPacketConfig); i { + switch v := v.(*ActivityNianConfig); i { case 0: return &v.state case 1: @@ -13163,7 +13444,7 @@ func file_protocol_webapi_common_proto_init() { } } file_protocol_webapi_common_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RedPacketInfo); i { + switch v := v.(*NianInfo); i { case 0: return &v.state case 1: @@ -13175,6 +13456,42 @@ func file_protocol_webapi_common_proto_init() { } } file_protocol_webapi_common_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NianDropInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_webapi_common_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RedPacketConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_webapi_common_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RedPacketInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_protocol_webapi_common_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RedInfo); i { case 0: return &v.state @@ -13193,7 +13510,7 @@ func file_protocol_webapi_common_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_protocol_webapi_common_proto_rawDesc, NumEnums: 0, - NumMessages: 117, + NumMessages: 120, NumExtensions: 0, NumServices: 0, }, From 799b7464efa1937300d8b726e066a361d0cff19c Mon Sep 17 00:00:00 2001 From: by <123456@qq.com> Date: Thu, 2 Jan 2025 13:42:01 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E5=B9=B4=E5=85=BD=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- worldsrv/welfmgr.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/worldsrv/welfmgr.go b/worldsrv/welfmgr.go index 30092b8..40de761 100644 --- a/worldsrv/welfmgr.go +++ b/worldsrv/welfmgr.go @@ -2203,6 +2203,9 @@ func (this *WelfareMgr) UpdateActivityNianStatus(cfg *webapi_proto.ActivityNianC // 每日重置年兽 func (this *WelfareMgr) DayReserNian(p *Player) { + if p.WelfData.NianData == nil { + return + } if time.Now().Unix() > p.WelfData.NianData.ActivityEndTime { this.ClearActivityNianData(p) }