// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: base_gcmessages.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_base_5fgcmessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_base_5fgcmessages_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021008 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "steammessages.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_base_5fgcmessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_base_5fgcmessages_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_base_5fgcmessages_2eproto;
class CGCStorePurchaseInit_LineItem;
struct CGCStorePurchaseInit_LineItemDefaultTypeInternal;
extern CGCStorePurchaseInit_LineItemDefaultTypeInternal _CGCStorePurchaseInit_LineItem_default_instance_;
class CMsgAcknowledgeRentalExpiration;
struct CMsgAcknowledgeRentalExpirationDefaultTypeInternal;
extern CMsgAcknowledgeRentalExpirationDefaultTypeInternal _CMsgAcknowledgeRentalExpiration_default_instance_;
class CMsgAdjustEquipSlot;
struct CMsgAdjustEquipSlotDefaultTypeInternal;
extern CMsgAdjustEquipSlotDefaultTypeInternal _CMsgAdjustEquipSlot_default_instance_;
class CMsgAdjustEquipSlots;
struct CMsgAdjustEquipSlotsDefaultTypeInternal;
extern CMsgAdjustEquipSlotsDefaultTypeInternal _CMsgAdjustEquipSlots_default_instance_;
class CMsgApplyEggEssence;
struct CMsgApplyEggEssenceDefaultTypeInternal;
extern CMsgApplyEggEssenceDefaultTypeInternal _CMsgApplyEggEssence_default_instance_;
class CMsgApplyPennantUpgrade;
struct CMsgApplyPennantUpgradeDefaultTypeInternal;
extern CMsgApplyPennantUpgradeDefaultTypeInternal _CMsgApplyPennantUpgrade_default_instance_;
class CMsgApplyStatTrakSwap;
struct CMsgApplyStatTrakSwapDefaultTypeInternal;
extern CMsgApplyStatTrakSwapDefaultTypeInternal _CMsgApplyStatTrakSwap_default_instance_;
class CMsgApplySticker;
struct CMsgApplyStickerDefaultTypeInternal;
extern CMsgApplyStickerDefaultTypeInternal _CMsgApplySticker_default_instance_;
class CMsgApplyStrangePart;
struct CMsgApplyStrangePartDefaultTypeInternal;
extern CMsgApplyStrangePartDefaultTypeInternal _CMsgApplyStrangePart_default_instance_;
class CMsgConVarValue;
struct CMsgConVarValueDefaultTypeInternal;
extern CMsgConVarValueDefaultTypeInternal _CMsgConVarValue_default_instance_;
class CMsgConsumableExhausted;
struct CMsgConsumableExhaustedDefaultTypeInternal;
extern CMsgConsumableExhaustedDefaultTypeInternal _CMsgConsumableExhausted_default_instance_;
class CMsgDevNewItemRequest;
struct CMsgDevNewItemRequestDefaultTypeInternal;
extern CMsgDevNewItemRequestDefaultTypeInternal _CMsgDevNewItemRequest_default_instance_;
class CMsgGCBannedWord;
struct CMsgGCBannedWordDefaultTypeInternal;
extern CMsgGCBannedWordDefaultTypeInternal _CMsgGCBannedWord_default_instance_;
class CMsgGCBannedWordListRequest;
struct CMsgGCBannedWordListRequestDefaultTypeInternal;
extern CMsgGCBannedWordListRequestDefaultTypeInternal _CMsgGCBannedWordListRequest_default_instance_;
class CMsgGCBannedWordListResponse;
struct CMsgGCBannedWordListResponseDefaultTypeInternal;
extern CMsgGCBannedWordListResponseDefaultTypeInternal _CMsgGCBannedWordListResponse_default_instance_;
class CMsgGCClientDisplayNotification;
struct CMsgGCClientDisplayNotificationDefaultTypeInternal;
extern CMsgGCClientDisplayNotificationDefaultTypeInternal _CMsgGCClientDisplayNotification_default_instance_;
class CMsgGCClientVersionUpdated;
struct CMsgGCClientVersionUpdatedDefaultTypeInternal;
extern CMsgGCClientVersionUpdatedDefaultTypeInternal _CMsgGCClientVersionUpdated_default_instance_;
class CMsgGCCollectItem;
struct CMsgGCCollectItemDefaultTypeInternal;
extern CMsgGCCollectItemDefaultTypeInternal _CMsgGCCollectItem_default_instance_;
class CMsgGCError;
struct CMsgGCErrorDefaultTypeInternal;
extern CMsgGCErrorDefaultTypeInternal _CMsgGCError_default_instance_;
class CMsgGCIncrementKillCountResponse;
struct CMsgGCIncrementKillCountResponseDefaultTypeInternal;
extern CMsgGCIncrementKillCountResponseDefaultTypeInternal _CMsgGCIncrementKillCountResponse_default_instance_;
class CMsgGCItemPreviewItemBoughtNotification;
struct CMsgGCItemPreviewItemBoughtNotificationDefaultTypeInternal;
extern CMsgGCItemPreviewItemBoughtNotificationDefaultTypeInternal _CMsgGCItemPreviewItemBoughtNotification_default_instance_;
class CMsgGCNameItemNotification;
struct CMsgGCNameItemNotificationDefaultTypeInternal;
extern CMsgGCNameItemNotificationDefaultTypeInternal _CMsgGCNameItemNotification_default_instance_;
class CMsgGCReportAbuse;
struct CMsgGCReportAbuseDefaultTypeInternal;
extern CMsgGCReportAbuseDefaultTypeInternal _CMsgGCReportAbuse_default_instance_;
class CMsgGCReportAbuseResponse;
struct CMsgGCReportAbuseResponseDefaultTypeInternal;
extern CMsgGCReportAbuseResponseDefaultTypeInternal _CMsgGCReportAbuseResponse_default_instance_;
class CMsgGCRequestAnnouncements;
struct CMsgGCRequestAnnouncementsDefaultTypeInternal;
extern CMsgGCRequestAnnouncementsDefaultTypeInternal _CMsgGCRequestAnnouncements_default_instance_;
class CMsgGCRequestAnnouncementsResponse;
struct CMsgGCRequestAnnouncementsResponseDefaultTypeInternal;
extern CMsgGCRequestAnnouncementsResponseDefaultTypeInternal _CMsgGCRequestAnnouncementsResponse_default_instance_;
class CMsgGCServerVersionUpdated;
struct CMsgGCServerVersionUpdatedDefaultTypeInternal;
extern CMsgGCServerVersionUpdatedDefaultTypeInternal _CMsgGCServerVersionUpdated_default_instance_;
class CMsgGCShowItemsPickedUp;
struct CMsgGCShowItemsPickedUpDefaultTypeInternal;
extern CMsgGCShowItemsPickedUpDefaultTypeInternal _CMsgGCShowItemsPickedUp_default_instance_;
class CMsgGCStorePurchaseCancel;
struct CMsgGCStorePurchaseCancelDefaultTypeInternal;
extern CMsgGCStorePurchaseCancelDefaultTypeInternal _CMsgGCStorePurchaseCancel_default_instance_;
class CMsgGCStorePurchaseCancelResponse;
struct CMsgGCStorePurchaseCancelResponseDefaultTypeInternal;
extern CMsgGCStorePurchaseCancelResponseDefaultTypeInternal _CMsgGCStorePurchaseCancelResponse_default_instance_;
class CMsgGCStorePurchaseFinalize;
struct CMsgGCStorePurchaseFinalizeDefaultTypeInternal;
extern CMsgGCStorePurchaseFinalizeDefaultTypeInternal _CMsgGCStorePurchaseFinalize_default_instance_;
class CMsgGCStorePurchaseFinalizeResponse;
struct CMsgGCStorePurchaseFinalizeResponseDefaultTypeInternal;
extern CMsgGCStorePurchaseFinalizeResponseDefaultTypeInternal _CMsgGCStorePurchaseFinalizeResponse_default_instance_;
class CMsgGCStorePurchaseInit;
struct CMsgGCStorePurchaseInitDefaultTypeInternal;
extern CMsgGCStorePurchaseInitDefaultTypeInternal _CMsgGCStorePurchaseInit_default_instance_;
class CMsgGCStorePurchaseInitResponse;
struct CMsgGCStorePurchaseInitResponseDefaultTypeInternal;
extern CMsgGCStorePurchaseInitResponseDefaultTypeInternal _CMsgGCStorePurchaseInitResponse_default_instance_;
class CMsgGCToGCBannedWordListBroadcast;
struct CMsgGCToGCBannedWordListBroadcastDefaultTypeInternal;
extern CMsgGCToGCBannedWordListBroadcastDefaultTypeInternal _CMsgGCToGCBannedWordListBroadcast_default_instance_;
class CMsgGCToGCBannedWordListUpdated;
struct CMsgGCToGCBannedWordListUpdatedDefaultTypeInternal;
extern CMsgGCToGCBannedWordListUpdatedDefaultTypeInternal _CMsgGCToGCBannedWordListUpdated_default_instance_;
class CMsgGCToGCBroadcastConsoleCommand;
struct CMsgGCToGCBroadcastConsoleCommandDefaultTypeInternal;
extern CMsgGCToGCBroadcastConsoleCommandDefaultTypeInternal _CMsgGCToGCBroadcastConsoleCommand_default_instance_;
class CMsgGCToGCDirtyMultipleSDOCache;
struct CMsgGCToGCDirtyMultipleSDOCacheDefaultTypeInternal;
extern CMsgGCToGCDirtyMultipleSDOCacheDefaultTypeInternal _CMsgGCToGCDirtyMultipleSDOCache_default_instance_;
class CMsgGCToGCDirtySDOCache;
struct CMsgGCToGCDirtySDOCacheDefaultTypeInternal;
extern CMsgGCToGCDirtySDOCacheDefaultTypeInternal _CMsgGCToGCDirtySDOCache_default_instance_;
class CMsgGCToGCIsTrustedServer;
struct CMsgGCToGCIsTrustedServerDefaultTypeInternal;
extern CMsgGCToGCIsTrustedServerDefaultTypeInternal _CMsgGCToGCIsTrustedServer_default_instance_;
class CMsgGCToGCIsTrustedServerResponse;
struct CMsgGCToGCIsTrustedServerResponseDefaultTypeInternal;
extern CMsgGCToGCIsTrustedServerResponseDefaultTypeInternal _CMsgGCToGCIsTrustedServerResponse_default_instance_;
class CMsgGCToGCRequestPassportItemGrant;
struct CMsgGCToGCRequestPassportItemGrantDefaultTypeInternal;
extern CMsgGCToGCRequestPassportItemGrantDefaultTypeInternal _CMsgGCToGCRequestPassportItemGrant_default_instance_;
class CMsgGCToGCUpdateSQLKeyValue;
struct CMsgGCToGCUpdateSQLKeyValueDefaultTypeInternal;
extern CMsgGCToGCUpdateSQLKeyValueDefaultTypeInternal _CMsgGCToGCUpdateSQLKeyValue_default_instance_;
class CMsgGCToGCWebAPIAccountChanged;
struct CMsgGCToGCWebAPIAccountChangedDefaultTypeInternal;
extern CMsgGCToGCWebAPIAccountChangedDefaultTypeInternal _CMsgGCToGCWebAPIAccountChanged_default_instance_;
class CMsgGameServerInfo;
struct CMsgGameServerInfoDefaultTypeInternal;
extern CMsgGameServerInfoDefaultTypeInternal _CMsgGameServerInfo_default_instance_;
class CMsgIncrementKillCountAttribute;
struct CMsgIncrementKillCountAttributeDefaultTypeInternal;
extern CMsgIncrementKillCountAttributeDefaultTypeInternal _CMsgIncrementKillCountAttribute_default_instance_;
class CMsgInvitationCreated;
struct CMsgInvitationCreatedDefaultTypeInternal;
extern CMsgInvitationCreatedDefaultTypeInternal _CMsgInvitationCreated_default_instance_;
class CMsgInviteToParty;
struct CMsgInviteToPartyDefaultTypeInternal;
extern CMsgInviteToPartyDefaultTypeInternal _CMsgInviteToParty_default_instance_;
class CMsgItemAcknowledged__DEPRECATED;
struct CMsgItemAcknowledged__DEPRECATEDDefaultTypeInternal;
extern CMsgItemAcknowledged__DEPRECATEDDefaultTypeInternal _CMsgItemAcknowledged__DEPRECATED_default_instance_;
class CMsgKickFromParty;
struct CMsgKickFromPartyDefaultTypeInternal;
extern CMsgKickFromPartyDefaultTypeInternal _CMsgKickFromParty_default_instance_;
class CMsgLANServerAvailable;
struct CMsgLANServerAvailableDefaultTypeInternal;
extern CMsgLANServerAvailableDefaultTypeInternal _CMsgLANServerAvailable_default_instance_;
class CMsgLeaveParty;
struct CMsgLeavePartyDefaultTypeInternal;
extern CMsgLeavePartyDefaultTypeInternal _CMsgLeaveParty_default_instance_;
class CMsgModifyItemAttribute;
struct CMsgModifyItemAttributeDefaultTypeInternal;
extern CMsgModifyItemAttributeDefaultTypeInternal _CMsgModifyItemAttribute_default_instance_;
class CMsgOpenCrate;
struct CMsgOpenCrateDefaultTypeInternal;
extern CMsgOpenCrateDefaultTypeInternal _CMsgOpenCrate_default_instance_;
class CMsgPartyInviteResponse;
struct CMsgPartyInviteResponseDefaultTypeInternal;
extern CMsgPartyInviteResponseDefaultTypeInternal _CMsgPartyInviteResponse_default_instance_;
class CMsgReplayUploadedToYouTube;
struct CMsgReplayUploadedToYouTubeDefaultTypeInternal;
extern CMsgReplayUploadedToYouTubeDefaultTypeInternal _CMsgReplayUploadedToYouTube_default_instance_;
class CMsgReplicateConVars;
struct CMsgReplicateConVarsDefaultTypeInternal;
extern CMsgReplicateConVarsDefaultTypeInternal _CMsgReplicateConVars_default_instance_;
class CMsgRequestInventoryRefresh;
struct CMsgRequestInventoryRefreshDefaultTypeInternal;
extern CMsgRequestInventoryRefreshDefaultTypeInternal _CMsgRequestInventoryRefresh_default_instance_;
class CMsgSDONoMemcached;
struct CMsgSDONoMemcachedDefaultTypeInternal;
extern CMsgSDONoMemcachedDefaultTypeInternal _CMsgSDONoMemcached_default_instance_;
class CMsgServerAvailable;
struct CMsgServerAvailableDefaultTypeInternal;
extern CMsgServerAvailableDefaultTypeInternal _CMsgServerAvailable_default_instance_;
class CMsgSetItemPositions;
struct CMsgSetItemPositionsDefaultTypeInternal;
extern CMsgSetItemPositionsDefaultTypeInternal _CMsgSetItemPositions_default_instance_;
class CMsgSetItemPositions_ItemPosition;
struct CMsgSetItemPositions_ItemPositionDefaultTypeInternal;
extern CMsgSetItemPositions_ItemPositionDefaultTypeInternal _CMsgSetItemPositions_ItemPosition_default_instance_;
class CMsgSortItems;
struct CMsgSortItemsDefaultTypeInternal;
extern CMsgSortItemsDefaultTypeInternal _CMsgSortItems_default_instance_;
class CMsgStoreGetUserData;
struct CMsgStoreGetUserDataDefaultTypeInternal;
extern CMsgStoreGetUserDataDefaultTypeInternal _CMsgStoreGetUserData_default_instance_;
class CMsgStoreGetUserDataResponse;
struct CMsgStoreGetUserDataResponseDefaultTypeInternal;
extern CMsgStoreGetUserDataResponseDefaultTypeInternal _CMsgStoreGetUserDataResponse_default_instance_;
class CMsgSystemBroadcast;
struct CMsgSystemBroadcastDefaultTypeInternal;
extern CMsgSystemBroadcastDefaultTypeInternal _CMsgSystemBroadcast_default_instance_;
class CMsgUpdateItemSchema;
struct CMsgUpdateItemSchemaDefaultTypeInternal;
extern CMsgUpdateItemSchemaDefaultTypeInternal _CMsgUpdateItemSchema_default_instance_;
class CMsgUseItem;
struct CMsgUseItemDefaultTypeInternal;
extern CMsgUseItemDefaultTypeInternal _CMsgUseItem_default_instance_;
class CSOEconClaimCode;
struct CSOEconClaimCodeDefaultTypeInternal;
extern CSOEconClaimCodeDefaultTypeInternal _CSOEconClaimCode_default_instance_;
class CSOEconEquipSlot;
struct CSOEconEquipSlotDefaultTypeInternal;
extern CSOEconEquipSlotDefaultTypeInternal _CSOEconEquipSlot_default_instance_;
class CSOEconGameAccountClient;
struct CSOEconGameAccountClientDefaultTypeInternal;
extern CSOEconGameAccountClientDefaultTypeInternal _CSOEconGameAccountClient_default_instance_;
class CSOEconItem;
struct CSOEconItemDefaultTypeInternal;
extern CSOEconItemDefaultTypeInternal _CSOEconItem_default_instance_;
class CSOEconItemAttribute;
struct CSOEconItemAttributeDefaultTypeInternal;
extern CSOEconItemAttributeDefaultTypeInternal _CSOEconItemAttribute_default_instance_;
class CSOEconItemDropRateBonus;
struct CSOEconItemDropRateBonusDefaultTypeInternal;
extern CSOEconItemDropRateBonusDefaultTypeInternal _CSOEconItemDropRateBonus_default_instance_;
class CSOEconItemEquipped;
struct CSOEconItemEquippedDefaultTypeInternal;
extern CSOEconItemEquippedDefaultTypeInternal _CSOEconItemEquipped_default_instance_;
class CSOEconItemEventTicket;
struct CSOEconItemEventTicketDefaultTypeInternal;
extern CSOEconItemEventTicketDefaultTypeInternal _CSOEconItemEventTicket_default_instance_;
class CSOEconItemLeagueViewPass;
struct CSOEconItemLeagueViewPassDefaultTypeInternal;
extern CSOEconItemLeagueViewPassDefaultTypeInternal _CSOEconItemLeagueViewPass_default_instance_;
class CSOEconRentalHistory;
struct CSOEconRentalHistoryDefaultTypeInternal;
extern CSOEconRentalHistoryDefaultTypeInternal _CSOEconRentalHistory_default_instance_;
class CSOItemCriteria;
struct CSOItemCriteriaDefaultTypeInternal;
extern CSOItemCriteriaDefaultTypeInternal _CSOItemCriteria_default_instance_;
class CSOItemCriteriaCondition;
struct CSOItemCriteriaConditionDefaultTypeInternal;
extern CSOItemCriteriaConditionDefaultTypeInternal _CSOItemCriteriaCondition_default_instance_;
class CSOItemRecipe;
struct CSOItemRecipeDefaultTypeInternal;
extern CSOItemRecipeDefaultTypeInternal _CSOItemRecipe_default_instance_;
class CSOLobbyInvite;
struct CSOLobbyInviteDefaultTypeInternal;
extern CSOLobbyInviteDefaultTypeInternal _CSOLobbyInvite_default_instance_;
class CSOPartyInvite;
struct CSOPartyInviteDefaultTypeInternal;
extern CSOPartyInviteDefaultTypeInternal _CSOPartyInvite_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CGCStorePurchaseInit_LineItem* Arena::CreateMaybeMessage<::CGCStorePurchaseInit_LineItem>(Arena*);
template<> ::CMsgAcknowledgeRentalExpiration* Arena::CreateMaybeMessage<::CMsgAcknowledgeRentalExpiration>(Arena*);
template<> ::CMsgAdjustEquipSlot* Arena::CreateMaybeMessage<::CMsgAdjustEquipSlot>(Arena*);
template<> ::CMsgAdjustEquipSlots* Arena::CreateMaybeMessage<::CMsgAdjustEquipSlots>(Arena*);
template<> ::CMsgApplyEggEssence* Arena::CreateMaybeMessage<::CMsgApplyEggEssence>(Arena*);
template<> ::CMsgApplyPennantUpgrade* Arena::CreateMaybeMessage<::CMsgApplyPennantUpgrade>(Arena*);
template<> ::CMsgApplyStatTrakSwap* Arena::CreateMaybeMessage<::CMsgApplyStatTrakSwap>(Arena*);
template<> ::CMsgApplySticker* Arena::CreateMaybeMessage<::CMsgApplySticker>(Arena*);
template<> ::CMsgApplyStrangePart* Arena::CreateMaybeMessage<::CMsgApplyStrangePart>(Arena*);
template<> ::CMsgConVarValue* Arena::CreateMaybeMessage<::CMsgConVarValue>(Arena*);
template<> ::CMsgConsumableExhausted* Arena::CreateMaybeMessage<::CMsgConsumableExhausted>(Arena*);
template<> ::CMsgDevNewItemRequest* Arena::CreateMaybeMessage<::CMsgDevNewItemRequest>(Arena*);
template<> ::CMsgGCBannedWord* Arena::CreateMaybeMessage<::CMsgGCBannedWord>(Arena*);
template<> ::CMsgGCBannedWordListRequest* Arena::CreateMaybeMessage<::CMsgGCBannedWordListRequest>(Arena*);
template<> ::CMsgGCBannedWordListResponse* Arena::CreateMaybeMessage<::CMsgGCBannedWordListResponse>(Arena*);
template<> ::CMsgGCClientDisplayNotification* Arena::CreateMaybeMessage<::CMsgGCClientDisplayNotification>(Arena*);
template<> ::CMsgGCClientVersionUpdated* Arena::CreateMaybeMessage<::CMsgGCClientVersionUpdated>(Arena*);
template<> ::CMsgGCCollectItem* Arena::CreateMaybeMessage<::CMsgGCCollectItem>(Arena*);
template<> ::CMsgGCError* Arena::CreateMaybeMessage<::CMsgGCError>(Arena*);
template<> ::CMsgGCIncrementKillCountResponse* Arena::CreateMaybeMessage<::CMsgGCIncrementKillCountResponse>(Arena*);
template<> ::CMsgGCItemPreviewItemBoughtNotification* Arena::CreateMaybeMessage<::CMsgGCItemPreviewItemBoughtNotification>(Arena*);
template<> ::CMsgGCNameItemNotification* Arena::CreateMaybeMessage<::CMsgGCNameItemNotification>(Arena*);
template<> ::CMsgGCReportAbuse* Arena::CreateMaybeMessage<::CMsgGCReportAbuse>(Arena*);
template<> ::CMsgGCReportAbuseResponse* Arena::CreateMaybeMessage<::CMsgGCReportAbuseResponse>(Arena*);
template<> ::CMsgGCRequestAnnouncements* Arena::CreateMaybeMessage<::CMsgGCRequestAnnouncements>(Arena*);
template<> ::CMsgGCRequestAnnouncementsResponse* Arena::CreateMaybeMessage<::CMsgGCRequestAnnouncementsResponse>(Arena*);
template<> ::CMsgGCServerVersionUpdated* Arena::CreateMaybeMessage<::CMsgGCServerVersionUpdated>(Arena*);
template<> ::CMsgGCShowItemsPickedUp* Arena::CreateMaybeMessage<::CMsgGCShowItemsPickedUp>(Arena*);
template<> ::CMsgGCStorePurchaseCancel* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseCancel>(Arena*);
template<> ::CMsgGCStorePurchaseCancelResponse* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseCancelResponse>(Arena*);
template<> ::CMsgGCStorePurchaseFinalize* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseFinalize>(Arena*);
template<> ::CMsgGCStorePurchaseFinalizeResponse* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseFinalizeResponse>(Arena*);
template<> ::CMsgGCStorePurchaseInit* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseInit>(Arena*);
template<> ::CMsgGCStorePurchaseInitResponse* Arena::CreateMaybeMessage<::CMsgGCStorePurchaseInitResponse>(Arena*);
template<> ::CMsgGCToGCBannedWordListBroadcast* Arena::CreateMaybeMessage<::CMsgGCToGCBannedWordListBroadcast>(Arena*);
template<> ::CMsgGCToGCBannedWordListUpdated* Arena::CreateMaybeMessage<::CMsgGCToGCBannedWordListUpdated>(Arena*);
template<> ::CMsgGCToGCBroadcastConsoleCommand* Arena::CreateMaybeMessage<::CMsgGCToGCBroadcastConsoleCommand>(Arena*);
template<> ::CMsgGCToGCDirtyMultipleSDOCache* Arena::CreateMaybeMessage<::CMsgGCToGCDirtyMultipleSDOCache>(Arena*);
template<> ::CMsgGCToGCDirtySDOCache* Arena::CreateMaybeMessage<::CMsgGCToGCDirtySDOCache>(Arena*);
template<> ::CMsgGCToGCIsTrustedServer* Arena::CreateMaybeMessage<::CMsgGCToGCIsTrustedServer>(Arena*);
template<> ::CMsgGCToGCIsTrustedServerResponse* Arena::CreateMaybeMessage<::CMsgGCToGCIsTrustedServerResponse>(Arena*);
template<> ::CMsgGCToGCRequestPassportItemGrant* Arena::CreateMaybeMessage<::CMsgGCToGCRequestPassportItemGrant>(Arena*);
template<> ::CMsgGCToGCUpdateSQLKeyValue* Arena::CreateMaybeMessage<::CMsgGCToGCUpdateSQLKeyValue>(Arena*);
template<> ::CMsgGCToGCWebAPIAccountChanged* Arena::CreateMaybeMessage<::CMsgGCToGCWebAPIAccountChanged>(Arena*);
template<> ::CMsgGameServerInfo* Arena::CreateMaybeMessage<::CMsgGameServerInfo>(Arena*);
template<> ::CMsgIncrementKillCountAttribute* Arena::CreateMaybeMessage<::CMsgIncrementKillCountAttribute>(Arena*);
template<> ::CMsgInvitationCreated* Arena::CreateMaybeMessage<::CMsgInvitationCreated>(Arena*);
template<> ::CMsgInviteToParty* Arena::CreateMaybeMessage<::CMsgInviteToParty>(Arena*);
template<> ::CMsgItemAcknowledged__DEPRECATED* Arena::CreateMaybeMessage<::CMsgItemAcknowledged__DEPRECATED>(Arena*);
template<> ::CMsgKickFromParty* Arena::CreateMaybeMessage<::CMsgKickFromParty>(Arena*);
template<> ::CMsgLANServerAvailable* Arena::CreateMaybeMessage<::CMsgLANServerAvailable>(Arena*);
template<> ::CMsgLeaveParty* Arena::CreateMaybeMessage<::CMsgLeaveParty>(Arena*);
template<> ::CMsgModifyItemAttribute* Arena::CreateMaybeMessage<::CMsgModifyItemAttribute>(Arena*);
template<> ::CMsgOpenCrate* Arena::CreateMaybeMessage<::CMsgOpenCrate>(Arena*);
template<> ::CMsgPartyInviteResponse* Arena::CreateMaybeMessage<::CMsgPartyInviteResponse>(Arena*);
template<> ::CMsgReplayUploadedToYouTube* Arena::CreateMaybeMessage<::CMsgReplayUploadedToYouTube>(Arena*);
template<> ::CMsgReplicateConVars* Arena::CreateMaybeMessage<::CMsgReplicateConVars>(Arena*);
template<> ::CMsgRequestInventoryRefresh* Arena::CreateMaybeMessage<::CMsgRequestInventoryRefresh>(Arena*);
template<> ::CMsgSDONoMemcached* Arena::CreateMaybeMessage<::CMsgSDONoMemcached>(Arena*);
template<> ::CMsgServerAvailable* Arena::CreateMaybeMessage<::CMsgServerAvailable>(Arena*);
template<> ::CMsgSetItemPositions* Arena::CreateMaybeMessage<::CMsgSetItemPositions>(Arena*);
template<> ::CMsgSetItemPositions_ItemPosition* Arena::CreateMaybeMessage<::CMsgSetItemPositions_ItemPosition>(Arena*);
template<> ::CMsgSortItems* Arena::CreateMaybeMessage<::CMsgSortItems>(Arena*);
template<> ::CMsgStoreGetUserData* Arena::CreateMaybeMessage<::CMsgStoreGetUserData>(Arena*);
template<> ::CMsgStoreGetUserDataResponse* Arena::CreateMaybeMessage<::CMsgStoreGetUserDataResponse>(Arena*);
template<> ::CMsgSystemBroadcast* Arena::CreateMaybeMessage<::CMsgSystemBroadcast>(Arena*);
template<> ::CMsgUpdateItemSchema* Arena::CreateMaybeMessage<::CMsgUpdateItemSchema>(Arena*);
template<> ::CMsgUseItem* Arena::CreateMaybeMessage<::CMsgUseItem>(Arena*);
template<> ::CSOEconClaimCode* Arena::CreateMaybeMessage<::CSOEconClaimCode>(Arena*);
template<> ::CSOEconEquipSlot* Arena::CreateMaybeMessage<::CSOEconEquipSlot>(Arena*);
template<> ::CSOEconGameAccountClient* Arena::CreateMaybeMessage<::CSOEconGameAccountClient>(Arena*);
template<> ::CSOEconItem* Arena::CreateMaybeMessage<::CSOEconItem>(Arena*);
template<> ::CSOEconItemAttribute* Arena::CreateMaybeMessage<::CSOEconItemAttribute>(Arena*);
template<> ::CSOEconItemDropRateBonus* Arena::CreateMaybeMessage<::CSOEconItemDropRateBonus>(Arena*);
template<> ::CSOEconItemEquipped* Arena::CreateMaybeMessage<::CSOEconItemEquipped>(Arena*);
template<> ::CSOEconItemEventTicket* Arena::CreateMaybeMessage<::CSOEconItemEventTicket>(Arena*);
template<> ::CSOEconItemLeagueViewPass* Arena::CreateMaybeMessage<::CSOEconItemLeagueViewPass>(Arena*);
template<> ::CSOEconRentalHistory* Arena::CreateMaybeMessage<::CSOEconRentalHistory>(Arena*);
template<> ::CSOItemCriteria* Arena::CreateMaybeMessage<::CSOItemCriteria>(Arena*);
template<> ::CSOItemCriteriaCondition* Arena::CreateMaybeMessage<::CSOItemCriteriaCondition>(Arena*);
template<> ::CSOItemRecipe* Arena::CreateMaybeMessage<::CSOItemRecipe>(Arena*);
template<> ::CSOLobbyInvite* Arena::CreateMaybeMessage<::CSOLobbyInvite>(Arena*);
template<> ::CSOPartyInvite* Arena::CreateMaybeMessage<::CSOPartyInvite>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum CMsgGameServerInfo_ServerType : int {
  CMsgGameServerInfo_ServerType_UNSPECIFIED = 0,
  CMsgGameServerInfo_ServerType_GAME = 1,
  CMsgGameServerInfo_ServerType_PROXY = 2
};
bool CMsgGameServerInfo_ServerType_IsValid(int value);
constexpr CMsgGameServerInfo_ServerType CMsgGameServerInfo_ServerType_ServerType_MIN = CMsgGameServerInfo_ServerType_UNSPECIFIED;
constexpr CMsgGameServerInfo_ServerType CMsgGameServerInfo_ServerType_ServerType_MAX = CMsgGameServerInfo_ServerType_PROXY;
constexpr int CMsgGameServerInfo_ServerType_ServerType_ARRAYSIZE = CMsgGameServerInfo_ServerType_ServerType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgGameServerInfo_ServerType_descriptor();
template<typename T>
inline const std::string& CMsgGameServerInfo_ServerType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgGameServerInfo_ServerType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgGameServerInfo_ServerType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgGameServerInfo_ServerType_descriptor(), enum_t_value);
}
inline bool CMsgGameServerInfo_ServerType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgGameServerInfo_ServerType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgGameServerInfo_ServerType>(
    CMsgGameServerInfo_ServerType_descriptor(), name, value);
}
enum EGCBaseMsg : int {
  k_EMsgGCSystemMessage = 4001,
  k_EMsgGCReplicateConVars = 4002,
  k_EMsgGCConVarUpdated = 4003,
  k_EMsgGCInQueue = 4008,
  k_EMsgGCInviteToParty = 4501,
  k_EMsgGCInvitationCreated = 4502,
  k_EMsgGCPartyInviteResponse = 4503,
  k_EMsgGCKickFromParty = 4504,
  k_EMsgGCLeaveParty = 4505,
  k_EMsgGCServerAvailable = 4506,
  k_EMsgGCClientConnectToServer = 4507,
  k_EMsgGCGameServerInfo = 4508,
  k_EMsgGCError = 4509,
  k_EMsgGCReplay_UploadedToYouTube = 4510,
  k_EMsgGCLANServerAvailable = 4511
};
bool EGCBaseMsg_IsValid(int value);
constexpr EGCBaseMsg EGCBaseMsg_MIN = k_EMsgGCSystemMessage;
constexpr EGCBaseMsg EGCBaseMsg_MAX = k_EMsgGCLANServerAvailable;
constexpr int EGCBaseMsg_ARRAYSIZE = EGCBaseMsg_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EGCBaseMsg_descriptor();
template<typename T>
inline const std::string& EGCBaseMsg_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EGCBaseMsg>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EGCBaseMsg_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EGCBaseMsg_descriptor(), enum_t_value);
}
inline bool EGCBaseMsg_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EGCBaseMsg* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EGCBaseMsg>(
    EGCBaseMsg_descriptor(), name, value);
}
enum EGCBaseProtoObjectTypes : int {
  k_EProtoObjectPartyInvite = 1001,
  k_EProtoObjectLobbyInvite = 1002
};
bool EGCBaseProtoObjectTypes_IsValid(int value);
constexpr EGCBaseProtoObjectTypes EGCBaseProtoObjectTypes_MIN = k_EProtoObjectPartyInvite;
constexpr EGCBaseProtoObjectTypes EGCBaseProtoObjectTypes_MAX = k_EProtoObjectLobbyInvite;
constexpr int EGCBaseProtoObjectTypes_ARRAYSIZE = EGCBaseProtoObjectTypes_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EGCBaseProtoObjectTypes_descriptor();
template<typename T>
inline const std::string& EGCBaseProtoObjectTypes_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EGCBaseProtoObjectTypes>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EGCBaseProtoObjectTypes_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EGCBaseProtoObjectTypes_descriptor(), enum_t_value);
}
inline bool EGCBaseProtoObjectTypes_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EGCBaseProtoObjectTypes* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EGCBaseProtoObjectTypes>(
    EGCBaseProtoObjectTypes_descriptor(), name, value);
}
enum GC_BannedWordType : int {
  GC_BANNED_WORD_DISABLE_WORD = 0,
  GC_BANNED_WORD_ENABLE_WORD = 1
};
bool GC_BannedWordType_IsValid(int value);
constexpr GC_BannedWordType GC_BannedWordType_MIN = GC_BANNED_WORD_DISABLE_WORD;
constexpr GC_BannedWordType GC_BannedWordType_MAX = GC_BANNED_WORD_ENABLE_WORD;
constexpr int GC_BannedWordType_ARRAYSIZE = GC_BannedWordType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GC_BannedWordType_descriptor();
template<typename T>
inline const std::string& GC_BannedWordType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GC_BannedWordType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GC_BannedWordType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GC_BannedWordType_descriptor(), enum_t_value);
}
inline bool GC_BannedWordType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GC_BannedWordType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GC_BannedWordType>(
    GC_BannedWordType_descriptor(), name, value);
}
// ===================================================================

class CGCStorePurchaseInit_LineItem final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CGCStorePurchaseInit_LineItem) */ {
 public:
  inline CGCStorePurchaseInit_LineItem() : CGCStorePurchaseInit_LineItem(nullptr) {}
  ~CGCStorePurchaseInit_LineItem() override;
  explicit PROTOBUF_CONSTEXPR CGCStorePurchaseInit_LineItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CGCStorePurchaseInit_LineItem(const CGCStorePurchaseInit_LineItem& from);
  CGCStorePurchaseInit_LineItem(CGCStorePurchaseInit_LineItem&& from) noexcept
    : CGCStorePurchaseInit_LineItem() {
    *this = ::std::move(from);
  }

  inline CGCStorePurchaseInit_LineItem& operator=(const CGCStorePurchaseInit_LineItem& from) {
    CopyFrom(from);
    return *this;
  }
  inline CGCStorePurchaseInit_LineItem& operator=(CGCStorePurchaseInit_LineItem&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CGCStorePurchaseInit_LineItem& default_instance() {
    return *internal_default_instance();
  }
  static inline const CGCStorePurchaseInit_LineItem* internal_default_instance() {
    return reinterpret_cast<const CGCStorePurchaseInit_LineItem*>(
               &_CGCStorePurchaseInit_LineItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CGCStorePurchaseInit_LineItem& a, CGCStorePurchaseInit_LineItem& b) {
    a.Swap(&b);
  }
  inline void Swap(CGCStorePurchaseInit_LineItem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CGCStorePurchaseInit_LineItem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CGCStorePurchaseInit_LineItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CGCStorePurchaseInit_LineItem>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CGCStorePurchaseInit_LineItem& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CGCStorePurchaseInit_LineItem& from) {
    CGCStorePurchaseInit_LineItem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CGCStorePurchaseInit_LineItem* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CGCStorePurchaseInit_LineItem";
  }
  protected:
  explicit CGCStorePurchaseInit_LineItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemDefIdFieldNumber = 1,
    kQuantityFieldNumber = 2,
    kCostInLocalCurrencyFieldNumber = 3,
    kSupplementalDataFieldNumber = 5,
    kPurchaseTypeFieldNumber = 4,
  };
  // optional uint32 item_def_id = 1;
  bool has_item_def_id() const;
  private:
  bool _internal_has_item_def_id() const;
  public:
  void clear_item_def_id();
  uint32_t item_def_id() const;
  void set_item_def_id(uint32_t value);
  private:
  uint32_t _internal_item_def_id() const;
  void _internal_set_item_def_id(uint32_t value);
  public:

  // optional uint32 quantity = 2;
  bool has_quantity() const;
  private:
  bool _internal_has_quantity() const;
  public:
  void clear_quantity();
  uint32_t quantity() const;
  void set_quantity(uint32_t value);
  private:
  uint32_t _internal_quantity() const;
  void _internal_set_quantity(uint32_t value);
  public:

  // optional uint64 cost_in_local_currency = 3;
  bool has_cost_in_local_currency() const;
  private:
  bool _internal_has_cost_in_local_currency() const;
  public:
  void clear_cost_in_local_currency();
  uint64_t cost_in_local_currency() const;
  void set_cost_in_local_currency(uint64_t value);
  private:
  uint64_t _internal_cost_in_local_currency() const;
  void _internal_set_cost_in_local_currency(uint64_t value);
  public:

  // optional uint64 supplemental_data = 5;
  bool has_supplemental_data() const;
  private:
  bool _internal_has_supplemental_data() const;
  public:
  void clear_supplemental_data();
  uint64_t supplemental_data() const;
  void set_supplemental_data(uint64_t value);
  private:
  uint64_t _internal_supplemental_data() const;
  void _internal_set_supplemental_data(uint64_t value);
  public:

  // optional uint32 purchase_type = 4;
  bool has_purchase_type() const;
  private:
  bool _internal_has_purchase_type() const;
  public:
  void clear_purchase_type();
  uint32_t purchase_type() const;
  void set_purchase_type(uint32_t value);
  private:
  uint32_t _internal_purchase_type() const;
  void _internal_set_purchase_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CGCStorePurchaseInit_LineItem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t item_def_id_;
    uint32_t quantity_;
    uint64_t cost_in_local_currency_;
    uint64_t supplemental_data_;
    uint32_t purchase_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseInit final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseInit) */ {
 public:
  inline CMsgGCStorePurchaseInit() : CMsgGCStorePurchaseInit(nullptr) {}
  ~CMsgGCStorePurchaseInit() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseInit(const CMsgGCStorePurchaseInit& from);
  CMsgGCStorePurchaseInit(CMsgGCStorePurchaseInit&& from) noexcept
    : CMsgGCStorePurchaseInit() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseInit& operator=(const CMsgGCStorePurchaseInit& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseInit& operator=(CMsgGCStorePurchaseInit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseInit& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseInit* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseInit*>(
               &_CMsgGCStorePurchaseInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CMsgGCStorePurchaseInit& a, CMsgGCStorePurchaseInit& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseInit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseInit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseInit>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseInit& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseInit& from) {
    CMsgGCStorePurchaseInit::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseInit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseInit";
  }
  protected:
  explicit CMsgGCStorePurchaseInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLineItemsFieldNumber = 4,
    kCountryFieldNumber = 1,
    kLanguageFieldNumber = 2,
    kCurrencyFieldNumber = 3,
  };
  // repeated .CGCStorePurchaseInit_LineItem line_items = 4;
  int line_items_size() const;
  private:
  int _internal_line_items_size() const;
  public:
  void clear_line_items();
  ::CGCStorePurchaseInit_LineItem* mutable_line_items(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CGCStorePurchaseInit_LineItem >*
      mutable_line_items();
  private:
  const ::CGCStorePurchaseInit_LineItem& _internal_line_items(int index) const;
  ::CGCStorePurchaseInit_LineItem* _internal_add_line_items();
  public:
  const ::CGCStorePurchaseInit_LineItem& line_items(int index) const;
  ::CGCStorePurchaseInit_LineItem* add_line_items();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CGCStorePurchaseInit_LineItem >&
      line_items() const;

  // optional string country = 1;
  bool has_country() const;
  private:
  bool _internal_has_country() const;
  public:
  void clear_country();
  const std::string& country() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_country(ArgT0&& arg0, ArgT... args);
  std::string* mutable_country();
  PROTOBUF_NODISCARD std::string* release_country();
  void set_allocated_country(std::string* country);
  private:
  const std::string& _internal_country() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_country(const std::string& value);
  std::string* _internal_mutable_country();
  public:

  // optional int32 language = 2;
  bool has_language() const;
  private:
  bool _internal_has_language() const;
  public:
  void clear_language();
  int32_t language() const;
  void set_language(int32_t value);
  private:
  int32_t _internal_language() const;
  void _internal_set_language(int32_t value);
  public:

  // optional int32 currency = 3;
  bool has_currency() const;
  private:
  bool _internal_has_currency() const;
  public:
  void clear_currency();
  int32_t currency() const;
  void set_currency(int32_t value);
  private:
  int32_t _internal_currency() const;
  void _internal_set_currency(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseInit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CGCStorePurchaseInit_LineItem > line_items_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_;
    int32_t language_;
    int32_t currency_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseInitResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseInitResponse) */ {
 public:
  inline CMsgGCStorePurchaseInitResponse() : CMsgGCStorePurchaseInitResponse(nullptr) {}
  ~CMsgGCStorePurchaseInitResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseInitResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseInitResponse(const CMsgGCStorePurchaseInitResponse& from);
  CMsgGCStorePurchaseInitResponse(CMsgGCStorePurchaseInitResponse&& from) noexcept
    : CMsgGCStorePurchaseInitResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseInitResponse& operator=(const CMsgGCStorePurchaseInitResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseInitResponse& operator=(CMsgGCStorePurchaseInitResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseInitResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseInitResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseInitResponse*>(
               &_CMsgGCStorePurchaseInitResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CMsgGCStorePurchaseInitResponse& a, CMsgGCStorePurchaseInitResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseInitResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseInitResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseInitResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseInitResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseInitResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseInitResponse& from) {
    CMsgGCStorePurchaseInitResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseInitResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseInitResponse";
  }
  protected:
  explicit CMsgGCStorePurchaseInitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemIdsFieldNumber = 4,
    kUrlFieldNumber = 3,
    kTxnIdFieldNumber = 2,
    kResultFieldNumber = 1,
  };
  // repeated uint64 item_ids = 4;
  int item_ids_size() const;
  private:
  int _internal_item_ids_size() const;
  public:
  void clear_item_ids();
  private:
  uint64_t _internal_item_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_item_ids() const;
  void _internal_add_item_ids(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_item_ids();
  public:
  uint64_t item_ids(int index) const;
  void set_item_ids(int index, uint64_t value);
  void add_item_ids(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      item_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_item_ids();

  // optional string url = 3;
  bool has_url() const;
  private:
  bool _internal_has_url() const;
  public:
  void clear_url();
  const std::string& url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_url();
  PROTOBUF_NODISCARD std::string* release_url();
  void set_allocated_url(std::string* url);
  private:
  const std::string& _internal_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
  std::string* _internal_mutable_url();
  public:

  // optional uint64 txn_id = 2;
  bool has_txn_id() const;
  private:
  bool _internal_has_txn_id() const;
  public:
  void clear_txn_id();
  uint64_t txn_id() const;
  void set_txn_id(uint64_t value);
  private:
  uint64_t _internal_txn_id() const;
  void _internal_set_txn_id(uint64_t value);
  public:

  // optional int32 result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  int32_t result() const;
  void set_result(int32_t value);
  private:
  int32_t _internal_result() const;
  void _internal_set_result(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseInitResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > item_ids_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    uint64_t txn_id_;
    int32_t result_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOPartyInvite final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOPartyInvite) */ {
 public:
  inline CSOPartyInvite() : CSOPartyInvite(nullptr) {}
  ~CSOPartyInvite() override;
  explicit PROTOBUF_CONSTEXPR CSOPartyInvite(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOPartyInvite(const CSOPartyInvite& from);
  CSOPartyInvite(CSOPartyInvite&& from) noexcept
    : CSOPartyInvite() {
    *this = ::std::move(from);
  }

  inline CSOPartyInvite& operator=(const CSOPartyInvite& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOPartyInvite& operator=(CSOPartyInvite&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOPartyInvite& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOPartyInvite* internal_default_instance() {
    return reinterpret_cast<const CSOPartyInvite*>(
               &_CSOPartyInvite_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CSOPartyInvite& a, CSOPartyInvite& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOPartyInvite* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOPartyInvite* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOPartyInvite* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOPartyInvite>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOPartyInvite& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOPartyInvite& from) {
    CSOPartyInvite::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOPartyInvite* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOPartyInvite";
  }
  protected:
  explicit CSOPartyInvite(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSenderNameFieldNumber = 3,
    kGroupIdFieldNumber = 1,
    kSenderIdFieldNumber = 2,
  };
  // optional string sender_name = 3;
  bool has_sender_name() const;
  private:
  bool _internal_has_sender_name() const;
  public:
  void clear_sender_name();
  const std::string& sender_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sender_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sender_name();
  PROTOBUF_NODISCARD std::string* release_sender_name();
  void set_allocated_sender_name(std::string* sender_name);
  private:
  const std::string& _internal_sender_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sender_name(const std::string& value);
  std::string* _internal_mutable_sender_name();
  public:

  // optional uint64 group_id = 1 [(.key_field) = true];
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  uint64_t group_id() const;
  void set_group_id(uint64_t value);
  private:
  uint64_t _internal_group_id() const;
  void _internal_set_group_id(uint64_t value);
  public:

  // optional fixed64 sender_id = 2;
  bool has_sender_id() const;
  private:
  bool _internal_has_sender_id() const;
  public:
  void clear_sender_id();
  uint64_t sender_id() const;
  void set_sender_id(uint64_t value);
  private:
  uint64_t _internal_sender_id() const;
  void _internal_set_sender_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOPartyInvite)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sender_name_;
    uint64_t group_id_;
    uint64_t sender_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOLobbyInvite final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOLobbyInvite) */ {
 public:
  inline CSOLobbyInvite() : CSOLobbyInvite(nullptr) {}
  ~CSOLobbyInvite() override;
  explicit PROTOBUF_CONSTEXPR CSOLobbyInvite(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOLobbyInvite(const CSOLobbyInvite& from);
  CSOLobbyInvite(CSOLobbyInvite&& from) noexcept
    : CSOLobbyInvite() {
    *this = ::std::move(from);
  }

  inline CSOLobbyInvite& operator=(const CSOLobbyInvite& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOLobbyInvite& operator=(CSOLobbyInvite&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOLobbyInvite& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOLobbyInvite* internal_default_instance() {
    return reinterpret_cast<const CSOLobbyInvite*>(
               &_CSOLobbyInvite_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CSOLobbyInvite& a, CSOLobbyInvite& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOLobbyInvite* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOLobbyInvite* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOLobbyInvite* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOLobbyInvite>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOLobbyInvite& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOLobbyInvite& from) {
    CSOLobbyInvite::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOLobbyInvite* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOLobbyInvite";
  }
  protected:
  explicit CSOLobbyInvite(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSenderNameFieldNumber = 3,
    kGroupIdFieldNumber = 1,
    kSenderIdFieldNumber = 2,
  };
  // optional string sender_name = 3;
  bool has_sender_name() const;
  private:
  bool _internal_has_sender_name() const;
  public:
  void clear_sender_name();
  const std::string& sender_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sender_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sender_name();
  PROTOBUF_NODISCARD std::string* release_sender_name();
  void set_allocated_sender_name(std::string* sender_name);
  private:
  const std::string& _internal_sender_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sender_name(const std::string& value);
  std::string* _internal_mutable_sender_name();
  public:

  // optional uint64 group_id = 1 [(.key_field) = true];
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  uint64_t group_id() const;
  void set_group_id(uint64_t value);
  private:
  uint64_t _internal_group_id() const;
  void _internal_set_group_id(uint64_t value);
  public:

  // optional fixed64 sender_id = 2;
  bool has_sender_id() const;
  private:
  bool _internal_has_sender_id() const;
  public:
  void clear_sender_id();
  uint64_t sender_id() const;
  void set_sender_id(uint64_t value);
  private:
  uint64_t _internal_sender_id() const;
  void _internal_set_sender_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOLobbyInvite)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sender_name_;
    uint64_t group_id_;
    uint64_t sender_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSystemBroadcast final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSystemBroadcast) */ {
 public:
  inline CMsgSystemBroadcast() : CMsgSystemBroadcast(nullptr) {}
  ~CMsgSystemBroadcast() override;
  explicit PROTOBUF_CONSTEXPR CMsgSystemBroadcast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSystemBroadcast(const CMsgSystemBroadcast& from);
  CMsgSystemBroadcast(CMsgSystemBroadcast&& from) noexcept
    : CMsgSystemBroadcast() {
    *this = ::std::move(from);
  }

  inline CMsgSystemBroadcast& operator=(const CMsgSystemBroadcast& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSystemBroadcast& operator=(CMsgSystemBroadcast&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSystemBroadcast& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSystemBroadcast* internal_default_instance() {
    return reinterpret_cast<const CMsgSystemBroadcast*>(
               &_CMsgSystemBroadcast_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CMsgSystemBroadcast& a, CMsgSystemBroadcast& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSystemBroadcast* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSystemBroadcast* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSystemBroadcast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSystemBroadcast>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSystemBroadcast& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSystemBroadcast& from) {
    CMsgSystemBroadcast::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSystemBroadcast* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSystemBroadcast";
  }
  protected:
  explicit CMsgSystemBroadcast(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageFieldNumber = 1,
  };
  // optional string message = 1;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // @@protoc_insertion_point(class_scope:CMsgSystemBroadcast)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgInviteToParty final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgInviteToParty) */ {
 public:
  inline CMsgInviteToParty() : CMsgInviteToParty(nullptr) {}
  ~CMsgInviteToParty() override;
  explicit PROTOBUF_CONSTEXPR CMsgInviteToParty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgInviteToParty(const CMsgInviteToParty& from);
  CMsgInviteToParty(CMsgInviteToParty&& from) noexcept
    : CMsgInviteToParty() {
    *this = ::std::move(from);
  }

  inline CMsgInviteToParty& operator=(const CMsgInviteToParty& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgInviteToParty& operator=(CMsgInviteToParty&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgInviteToParty& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgInviteToParty* internal_default_instance() {
    return reinterpret_cast<const CMsgInviteToParty*>(
               &_CMsgInviteToParty_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CMsgInviteToParty& a, CMsgInviteToParty& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgInviteToParty* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgInviteToParty* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgInviteToParty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgInviteToParty>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgInviteToParty& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgInviteToParty& from) {
    CMsgInviteToParty::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgInviteToParty* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgInviteToParty";
  }
  protected:
  explicit CMsgInviteToParty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSteamIdFieldNumber = 1,
    kClientVersionFieldNumber = 2,
    kTeamInviteFieldNumber = 3,
  };
  // optional fixed64 steam_id = 1;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // optional uint32 client_version = 2;
  bool has_client_version() const;
  private:
  bool _internal_has_client_version() const;
  public:
  void clear_client_version();
  uint32_t client_version() const;
  void set_client_version(uint32_t value);
  private:
  uint32_t _internal_client_version() const;
  void _internal_set_client_version(uint32_t value);
  public:

  // optional uint32 team_invite = 3;
  bool has_team_invite() const;
  private:
  bool _internal_has_team_invite() const;
  public:
  void clear_team_invite();
  uint32_t team_invite() const;
  void set_team_invite(uint32_t value);
  private:
  uint32_t _internal_team_invite() const;
  void _internal_set_team_invite(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgInviteToParty)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t steam_id_;
    uint32_t client_version_;
    uint32_t team_invite_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgInvitationCreated final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgInvitationCreated) */ {
 public:
  inline CMsgInvitationCreated() : CMsgInvitationCreated(nullptr) {}
  ~CMsgInvitationCreated() override;
  explicit PROTOBUF_CONSTEXPR CMsgInvitationCreated(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgInvitationCreated(const CMsgInvitationCreated& from);
  CMsgInvitationCreated(CMsgInvitationCreated&& from) noexcept
    : CMsgInvitationCreated() {
    *this = ::std::move(from);
  }

  inline CMsgInvitationCreated& operator=(const CMsgInvitationCreated& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgInvitationCreated& operator=(CMsgInvitationCreated&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgInvitationCreated& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgInvitationCreated* internal_default_instance() {
    return reinterpret_cast<const CMsgInvitationCreated*>(
               &_CMsgInvitationCreated_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CMsgInvitationCreated& a, CMsgInvitationCreated& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgInvitationCreated* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgInvitationCreated* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgInvitationCreated* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgInvitationCreated>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgInvitationCreated& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgInvitationCreated& from) {
    CMsgInvitationCreated::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgInvitationCreated* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgInvitationCreated";
  }
  protected:
  explicit CMsgInvitationCreated(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGroupIdFieldNumber = 1,
    kSteamIdFieldNumber = 2,
  };
  // optional uint64 group_id = 1;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  uint64_t group_id() const;
  void set_group_id(uint64_t value);
  private:
  uint64_t _internal_group_id() const;
  void _internal_set_group_id(uint64_t value);
  public:

  // optional fixed64 steam_id = 2;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgInvitationCreated)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t group_id_;
    uint64_t steam_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgPartyInviteResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgPartyInviteResponse) */ {
 public:
  inline CMsgPartyInviteResponse() : CMsgPartyInviteResponse(nullptr) {}
  ~CMsgPartyInviteResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgPartyInviteResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgPartyInviteResponse(const CMsgPartyInviteResponse& from);
  CMsgPartyInviteResponse(CMsgPartyInviteResponse&& from) noexcept
    : CMsgPartyInviteResponse() {
    *this = ::std::move(from);
  }

  inline CMsgPartyInviteResponse& operator=(const CMsgPartyInviteResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgPartyInviteResponse& operator=(CMsgPartyInviteResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgPartyInviteResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgPartyInviteResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgPartyInviteResponse*>(
               &_CMsgPartyInviteResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CMsgPartyInviteResponse& a, CMsgPartyInviteResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgPartyInviteResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgPartyInviteResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgPartyInviteResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgPartyInviteResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgPartyInviteResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgPartyInviteResponse& from) {
    CMsgPartyInviteResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgPartyInviteResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgPartyInviteResponse";
  }
  protected:
  explicit CMsgPartyInviteResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPartyIdFieldNumber = 1,
    kAcceptFieldNumber = 2,
    kClientVersionFieldNumber = 3,
    kTeamInviteFieldNumber = 4,
  };
  // optional uint64 party_id = 1;
  bool has_party_id() const;
  private:
  bool _internal_has_party_id() const;
  public:
  void clear_party_id();
  uint64_t party_id() const;
  void set_party_id(uint64_t value);
  private:
  uint64_t _internal_party_id() const;
  void _internal_set_party_id(uint64_t value);
  public:

  // optional bool accept = 2;
  bool has_accept() const;
  private:
  bool _internal_has_accept() const;
  public:
  void clear_accept();
  bool accept() const;
  void set_accept(bool value);
  private:
  bool _internal_accept() const;
  void _internal_set_accept(bool value);
  public:

  // optional uint32 client_version = 3;
  bool has_client_version() const;
  private:
  bool _internal_has_client_version() const;
  public:
  void clear_client_version();
  uint32_t client_version() const;
  void set_client_version(uint32_t value);
  private:
  uint32_t _internal_client_version() const;
  void _internal_set_client_version(uint32_t value);
  public:

  // optional uint32 team_invite = 4;
  bool has_team_invite() const;
  private:
  bool _internal_has_team_invite() const;
  public:
  void clear_team_invite();
  uint32_t team_invite() const;
  void set_team_invite(uint32_t value);
  private:
  uint32_t _internal_team_invite() const;
  void _internal_set_team_invite(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgPartyInviteResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t party_id_;
    bool accept_;
    uint32_t client_version_;
    uint32_t team_invite_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgKickFromParty final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgKickFromParty) */ {
 public:
  inline CMsgKickFromParty() : CMsgKickFromParty(nullptr) {}
  ~CMsgKickFromParty() override;
  explicit PROTOBUF_CONSTEXPR CMsgKickFromParty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgKickFromParty(const CMsgKickFromParty& from);
  CMsgKickFromParty(CMsgKickFromParty&& from) noexcept
    : CMsgKickFromParty() {
    *this = ::std::move(from);
  }

  inline CMsgKickFromParty& operator=(const CMsgKickFromParty& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgKickFromParty& operator=(CMsgKickFromParty&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgKickFromParty& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgKickFromParty* internal_default_instance() {
    return reinterpret_cast<const CMsgKickFromParty*>(
               &_CMsgKickFromParty_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CMsgKickFromParty& a, CMsgKickFromParty& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgKickFromParty* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgKickFromParty* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgKickFromParty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgKickFromParty>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgKickFromParty& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgKickFromParty& from) {
    CMsgKickFromParty::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgKickFromParty* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgKickFromParty";
  }
  protected:
  explicit CMsgKickFromParty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSteamIdFieldNumber = 1,
  };
  // optional fixed64 steam_id = 1;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgKickFromParty)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t steam_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgLeaveParty final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgLeaveParty) */ {
 public:
  inline CMsgLeaveParty() : CMsgLeaveParty(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgLeaveParty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgLeaveParty(const CMsgLeaveParty& from);
  CMsgLeaveParty(CMsgLeaveParty&& from) noexcept
    : CMsgLeaveParty() {
    *this = ::std::move(from);
  }

  inline CMsgLeaveParty& operator=(const CMsgLeaveParty& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgLeaveParty& operator=(CMsgLeaveParty&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgLeaveParty& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgLeaveParty* internal_default_instance() {
    return reinterpret_cast<const CMsgLeaveParty*>(
               &_CMsgLeaveParty_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CMsgLeaveParty& a, CMsgLeaveParty& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgLeaveParty* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgLeaveParty* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgLeaveParty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgLeaveParty>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgLeaveParty& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgLeaveParty& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgLeaveParty";
  }
  protected:
  explicit CMsgLeaveParty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgLeaveParty)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerAvailable final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgServerAvailable) */ {
 public:
  inline CMsgServerAvailable() : CMsgServerAvailable(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgServerAvailable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerAvailable(const CMsgServerAvailable& from);
  CMsgServerAvailable(CMsgServerAvailable&& from) noexcept
    : CMsgServerAvailable() {
    *this = ::std::move(from);
  }

  inline CMsgServerAvailable& operator=(const CMsgServerAvailable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerAvailable& operator=(CMsgServerAvailable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerAvailable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerAvailable* internal_default_instance() {
    return reinterpret_cast<const CMsgServerAvailable*>(
               &_CMsgServerAvailable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CMsgServerAvailable& a, CMsgServerAvailable& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerAvailable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerAvailable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerAvailable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerAvailable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgServerAvailable& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgServerAvailable& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerAvailable";
  }
  protected:
  explicit CMsgServerAvailable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgServerAvailable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgLANServerAvailable final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgLANServerAvailable) */ {
 public:
  inline CMsgLANServerAvailable() : CMsgLANServerAvailable(nullptr) {}
  ~CMsgLANServerAvailable() override;
  explicit PROTOBUF_CONSTEXPR CMsgLANServerAvailable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgLANServerAvailable(const CMsgLANServerAvailable& from);
  CMsgLANServerAvailable(CMsgLANServerAvailable&& from) noexcept
    : CMsgLANServerAvailable() {
    *this = ::std::move(from);
  }

  inline CMsgLANServerAvailable& operator=(const CMsgLANServerAvailable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgLANServerAvailable& operator=(CMsgLANServerAvailable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgLANServerAvailable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgLANServerAvailable* internal_default_instance() {
    return reinterpret_cast<const CMsgLANServerAvailable*>(
               &_CMsgLANServerAvailable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CMsgLANServerAvailable& a, CMsgLANServerAvailable& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgLANServerAvailable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgLANServerAvailable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgLANServerAvailable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgLANServerAvailable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgLANServerAvailable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgLANServerAvailable& from) {
    CMsgLANServerAvailable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgLANServerAvailable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgLANServerAvailable";
  }
  protected:
  explicit CMsgLANServerAvailable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLobbyIdFieldNumber = 1,
  };
  // optional fixed64 lobby_id = 1;
  bool has_lobby_id() const;
  private:
  bool _internal_has_lobby_id() const;
  public:
  void clear_lobby_id();
  uint64_t lobby_id() const;
  void set_lobby_id(uint64_t value);
  private:
  uint64_t _internal_lobby_id() const;
  void _internal_set_lobby_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgLANServerAvailable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t lobby_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconGameAccountClient final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconGameAccountClient) */ {
 public:
  inline CSOEconGameAccountClient() : CSOEconGameAccountClient(nullptr) {}
  ~CSOEconGameAccountClient() override;
  explicit PROTOBUF_CONSTEXPR CSOEconGameAccountClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconGameAccountClient(const CSOEconGameAccountClient& from);
  CSOEconGameAccountClient(CSOEconGameAccountClient&& from) noexcept
    : CSOEconGameAccountClient() {
    *this = ::std::move(from);
  }

  inline CSOEconGameAccountClient& operator=(const CSOEconGameAccountClient& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconGameAccountClient& operator=(CSOEconGameAccountClient&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconGameAccountClient& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconGameAccountClient* internal_default_instance() {
    return reinterpret_cast<const CSOEconGameAccountClient*>(
               &_CSOEconGameAccountClient_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CSOEconGameAccountClient& a, CSOEconGameAccountClient& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconGameAccountClient* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconGameAccountClient* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconGameAccountClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconGameAccountClient>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconGameAccountClient& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconGameAccountClient& from) {
    CSOEconGameAccountClient::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconGameAccountClient* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconGameAccountClient";
  }
  protected:
  explicit CSOEconGameAccountClient(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAdditionalBackpackSlotsFieldNumber = 1,
    kTradeBanExpirationFieldNumber = 6,
    kBonusXpTimestampRefreshFieldNumber = 12,
    kBonusXpUsedflagsFieldNumber = 13,
    kElevatedStateFieldNumber = 14,
    kElevatedTimestampFieldNumber = 15,
  };
  // optional uint32 additional_backpack_slots = 1 [default = 0];
  bool has_additional_backpack_slots() const;
  private:
  bool _internal_has_additional_backpack_slots() const;
  public:
  void clear_additional_backpack_slots();
  uint32_t additional_backpack_slots() const;
  void set_additional_backpack_slots(uint32_t value);
  private:
  uint32_t _internal_additional_backpack_slots() const;
  void _internal_set_additional_backpack_slots(uint32_t value);
  public:

  // optional fixed32 trade_ban_expiration = 6;
  bool has_trade_ban_expiration() const;
  private:
  bool _internal_has_trade_ban_expiration() const;
  public:
  void clear_trade_ban_expiration();
  uint32_t trade_ban_expiration() const;
  void set_trade_ban_expiration(uint32_t value);
  private:
  uint32_t _internal_trade_ban_expiration() const;
  void _internal_set_trade_ban_expiration(uint32_t value);
  public:

  // optional fixed32 bonus_xp_timestamp_refresh = 12;
  bool has_bonus_xp_timestamp_refresh() const;
  private:
  bool _internal_has_bonus_xp_timestamp_refresh() const;
  public:
  void clear_bonus_xp_timestamp_refresh();
  uint32_t bonus_xp_timestamp_refresh() const;
  void set_bonus_xp_timestamp_refresh(uint32_t value);
  private:
  uint32_t _internal_bonus_xp_timestamp_refresh() const;
  void _internal_set_bonus_xp_timestamp_refresh(uint32_t value);
  public:

  // optional uint32 bonus_xp_usedflags = 13;
  bool has_bonus_xp_usedflags() const;
  private:
  bool _internal_has_bonus_xp_usedflags() const;
  public:
  void clear_bonus_xp_usedflags();
  uint32_t bonus_xp_usedflags() const;
  void set_bonus_xp_usedflags(uint32_t value);
  private:
  uint32_t _internal_bonus_xp_usedflags() const;
  void _internal_set_bonus_xp_usedflags(uint32_t value);
  public:

  // optional uint32 elevated_state = 14;
  bool has_elevated_state() const;
  private:
  bool _internal_has_elevated_state() const;
  public:
  void clear_elevated_state();
  uint32_t elevated_state() const;
  void set_elevated_state(uint32_t value);
  private:
  uint32_t _internal_elevated_state() const;
  void _internal_set_elevated_state(uint32_t value);
  public:

  // optional uint32 elevated_timestamp = 15;
  bool has_elevated_timestamp() const;
  private:
  bool _internal_has_elevated_timestamp() const;
  public:
  void clear_elevated_timestamp();
  uint32_t elevated_timestamp() const;
  void set_elevated_timestamp(uint32_t value);
  private:
  uint32_t _internal_elevated_timestamp() const;
  void _internal_set_elevated_timestamp(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconGameAccountClient)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t additional_backpack_slots_;
    uint32_t trade_ban_expiration_;
    uint32_t bonus_xp_timestamp_refresh_;
    uint32_t bonus_xp_usedflags_;
    uint32_t elevated_state_;
    uint32_t elevated_timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOItemCriteriaCondition final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOItemCriteriaCondition) */ {
 public:
  inline CSOItemCriteriaCondition() : CSOItemCriteriaCondition(nullptr) {}
  ~CSOItemCriteriaCondition() override;
  explicit PROTOBUF_CONSTEXPR CSOItemCriteriaCondition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOItemCriteriaCondition(const CSOItemCriteriaCondition& from);
  CSOItemCriteriaCondition(CSOItemCriteriaCondition&& from) noexcept
    : CSOItemCriteriaCondition() {
    *this = ::std::move(from);
  }

  inline CSOItemCriteriaCondition& operator=(const CSOItemCriteriaCondition& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOItemCriteriaCondition& operator=(CSOItemCriteriaCondition&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOItemCriteriaCondition& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOItemCriteriaCondition* internal_default_instance() {
    return reinterpret_cast<const CSOItemCriteriaCondition*>(
               &_CSOItemCriteriaCondition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CSOItemCriteriaCondition& a, CSOItemCriteriaCondition& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOItemCriteriaCondition* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOItemCriteriaCondition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOItemCriteriaCondition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOItemCriteriaCondition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOItemCriteriaCondition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOItemCriteriaCondition& from) {
    CSOItemCriteriaCondition::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOItemCriteriaCondition* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOItemCriteriaCondition";
  }
  protected:
  explicit CSOItemCriteriaCondition(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFieldFieldNumber = 2,
    kStringValueFieldNumber = 5,
    kOpFieldNumber = 1,
    kRequiredFieldNumber = 3,
    kFloatValueFieldNumber = 4,
  };
  // optional string field = 2;
  bool has_field() const;
  private:
  bool _internal_has_field() const;
  public:
  void clear_field();
  const std::string& field() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_field(ArgT0&& arg0, ArgT... args);
  std::string* mutable_field();
  PROTOBUF_NODISCARD std::string* release_field();
  void set_allocated_field(std::string* field);
  private:
  const std::string& _internal_field() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_field(const std::string& value);
  std::string* _internal_mutable_field();
  public:

  // optional string string_value = 5;
  bool has_string_value() const;
  private:
  bool _internal_has_string_value() const;
  public:
  void clear_string_value();
  const std::string& string_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* string_value);
  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
  std::string* _internal_mutable_string_value();
  public:

  // optional int32 op = 1;
  bool has_op() const;
  private:
  bool _internal_has_op() const;
  public:
  void clear_op();
  int32_t op() const;
  void set_op(int32_t value);
  private:
  int32_t _internal_op() const;
  void _internal_set_op(int32_t value);
  public:

  // optional bool required = 3;
  bool has_required() const;
  private:
  bool _internal_has_required() const;
  public:
  void clear_required();
  bool required() const;
  void set_required(bool value);
  private:
  bool _internal_required() const;
  void _internal_set_required(bool value);
  public:

  // optional float float_value = 4;
  bool has_float_value() const;
  private:
  bool _internal_has_float_value() const;
  public:
  void clear_float_value();
  float float_value() const;
  void set_float_value(float value);
  private:
  float _internal_float_value() const;
  void _internal_set_float_value(float value);
  public:

  // @@protoc_insertion_point(class_scope:CSOItemCriteriaCondition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
    int32_t op_;
    bool required_;
    float float_value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOItemCriteria final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOItemCriteria) */ {
 public:
  inline CSOItemCriteria() : CSOItemCriteria(nullptr) {}
  ~CSOItemCriteria() override;
  explicit PROTOBUF_CONSTEXPR CSOItemCriteria(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOItemCriteria(const CSOItemCriteria& from);
  CSOItemCriteria(CSOItemCriteria&& from) noexcept
    : CSOItemCriteria() {
    *this = ::std::move(from);
  }

  inline CSOItemCriteria& operator=(const CSOItemCriteria& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOItemCriteria& operator=(CSOItemCriteria&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOItemCriteria& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOItemCriteria* internal_default_instance() {
    return reinterpret_cast<const CSOItemCriteria*>(
               &_CSOItemCriteria_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CSOItemCriteria& a, CSOItemCriteria& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOItemCriteria* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOItemCriteria* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOItemCriteria* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOItemCriteria>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOItemCriteria& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOItemCriteria& from) {
    CSOItemCriteria::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOItemCriteria* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOItemCriteria";
  }
  protected:
  explicit CSOItemCriteria(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConditionsFieldNumber = 9,
    kItemLevelFieldNumber = 1,
    kItemQualityFieldNumber = 2,
    kInitialInventoryFieldNumber = 5,
    kInitialQuantityFieldNumber = 6,
    kItemLevelSetFieldNumber = 3,
    kItemQualitySetFieldNumber = 4,
    kIgnoreEnabledFlagFieldNumber = 8,
    kItemRaritySetFieldNumber = 11,
    kItemRarityFieldNumber = 10,
    kRecentOnlyFieldNumber = 12,
  };
  // repeated .CSOItemCriteriaCondition conditions = 9;
  int conditions_size() const;
  private:
  int _internal_conditions_size() const;
  public:
  void clear_conditions();
  ::CSOItemCriteriaCondition* mutable_conditions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteriaCondition >*
      mutable_conditions();
  private:
  const ::CSOItemCriteriaCondition& _internal_conditions(int index) const;
  ::CSOItemCriteriaCondition* _internal_add_conditions();
  public:
  const ::CSOItemCriteriaCondition& conditions(int index) const;
  ::CSOItemCriteriaCondition* add_conditions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteriaCondition >&
      conditions() const;

  // optional uint32 item_level = 1;
  bool has_item_level() const;
  private:
  bool _internal_has_item_level() const;
  public:
  void clear_item_level();
  uint32_t item_level() const;
  void set_item_level(uint32_t value);
  private:
  uint32_t _internal_item_level() const;
  void _internal_set_item_level(uint32_t value);
  public:

  // optional int32 item_quality = 2;
  bool has_item_quality() const;
  private:
  bool _internal_has_item_quality() const;
  public:
  void clear_item_quality();
  int32_t item_quality() const;
  void set_item_quality(int32_t value);
  private:
  int32_t _internal_item_quality() const;
  void _internal_set_item_quality(int32_t value);
  public:

  // optional uint32 initial_inventory = 5;
  bool has_initial_inventory() const;
  private:
  bool _internal_has_initial_inventory() const;
  public:
  void clear_initial_inventory();
  uint32_t initial_inventory() const;
  void set_initial_inventory(uint32_t value);
  private:
  uint32_t _internal_initial_inventory() const;
  void _internal_set_initial_inventory(uint32_t value);
  public:

  // optional uint32 initial_quantity = 6;
  bool has_initial_quantity() const;
  private:
  bool _internal_has_initial_quantity() const;
  public:
  void clear_initial_quantity();
  uint32_t initial_quantity() const;
  void set_initial_quantity(uint32_t value);
  private:
  uint32_t _internal_initial_quantity() const;
  void _internal_set_initial_quantity(uint32_t value);
  public:

  // optional bool item_level_set = 3;
  bool has_item_level_set() const;
  private:
  bool _internal_has_item_level_set() const;
  public:
  void clear_item_level_set();
  bool item_level_set() const;
  void set_item_level_set(bool value);
  private:
  bool _internal_item_level_set() const;
  void _internal_set_item_level_set(bool value);
  public:

  // optional bool item_quality_set = 4;
  bool has_item_quality_set() const;
  private:
  bool _internal_has_item_quality_set() const;
  public:
  void clear_item_quality_set();
  bool item_quality_set() const;
  void set_item_quality_set(bool value);
  private:
  bool _internal_item_quality_set() const;
  void _internal_set_item_quality_set(bool value);
  public:

  // optional bool ignore_enabled_flag = 8;
  bool has_ignore_enabled_flag() const;
  private:
  bool _internal_has_ignore_enabled_flag() const;
  public:
  void clear_ignore_enabled_flag();
  bool ignore_enabled_flag() const;
  void set_ignore_enabled_flag(bool value);
  private:
  bool _internal_ignore_enabled_flag() const;
  void _internal_set_ignore_enabled_flag(bool value);
  public:

  // optional bool item_rarity_set = 11;
  bool has_item_rarity_set() const;
  private:
  bool _internal_has_item_rarity_set() const;
  public:
  void clear_item_rarity_set();
  bool item_rarity_set() const;
  void set_item_rarity_set(bool value);
  private:
  bool _internal_item_rarity_set() const;
  void _internal_set_item_rarity_set(bool value);
  public:

  // optional int32 item_rarity = 10;
  bool has_item_rarity() const;
  private:
  bool _internal_has_item_rarity() const;
  public:
  void clear_item_rarity();
  int32_t item_rarity() const;
  void set_item_rarity(int32_t value);
  private:
  int32_t _internal_item_rarity() const;
  void _internal_set_item_rarity(int32_t value);
  public:

  // optional bool recent_only = 12;
  bool has_recent_only() const;
  private:
  bool _internal_has_recent_only() const;
  public:
  void clear_recent_only();
  bool recent_only() const;
  void set_recent_only(bool value);
  private:
  bool _internal_recent_only() const;
  void _internal_set_recent_only(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSOItemCriteria)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteriaCondition > conditions_;
    uint32_t item_level_;
    int32_t item_quality_;
    uint32_t initial_inventory_;
    uint32_t initial_quantity_;
    bool item_level_set_;
    bool item_quality_set_;
    bool ignore_enabled_flag_;
    bool item_rarity_set_;
    int32_t item_rarity_;
    bool recent_only_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOItemRecipe final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOItemRecipe) */ {
 public:
  inline CSOItemRecipe() : CSOItemRecipe(nullptr) {}
  ~CSOItemRecipe() override;
  explicit PROTOBUF_CONSTEXPR CSOItemRecipe(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOItemRecipe(const CSOItemRecipe& from);
  CSOItemRecipe(CSOItemRecipe&& from) noexcept
    : CSOItemRecipe() {
    *this = ::std::move(from);
  }

  inline CSOItemRecipe& operator=(const CSOItemRecipe& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOItemRecipe& operator=(CSOItemRecipe&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOItemRecipe& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOItemRecipe* internal_default_instance() {
    return reinterpret_cast<const CSOItemRecipe*>(
               &_CSOItemRecipe_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(CSOItemRecipe& a, CSOItemRecipe& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOItemRecipe* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOItemRecipe* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOItemRecipe* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOItemRecipe>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOItemRecipe& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOItemRecipe& from) {
    CSOItemRecipe::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOItemRecipe* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOItemRecipe";
  }
  protected:
  explicit CSOItemRecipe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInputItemsCriteriaFieldNumber = 20,
    kOutputItemsCriteriaFieldNumber = 21,
    kInputItemDupeCountsFieldNumber = 22,
    kNameFieldNumber = 2,
    kNAFieldNumber = 3,
    kDescInputsFieldNumber = 4,
    kDescOutputsFieldNumber = 5,
    kDiAFieldNumber = 6,
    kDiBFieldNumber = 7,
    kDiCFieldNumber = 8,
    kDoAFieldNumber = 9,
    kDoBFieldNumber = 10,
    kDoCFieldNumber = 11,
    kDefIndexFieldNumber = 1,
    kRequiresAllSameClassFieldNumber = 12,
    kRequiresAllSameSlotFieldNumber = 13,
    kClassUsageForOutputFieldNumber = 14,
    kSlotUsageForOutputFieldNumber = 15,
    kSetForOutputFieldNumber = 16,
  };
  // repeated .CSOItemCriteria input_items_criteria = 20;
  int input_items_criteria_size() const;
  private:
  int _internal_input_items_criteria_size() const;
  public:
  void clear_input_items_criteria();
  ::CSOItemCriteria* mutable_input_items_criteria(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >*
      mutable_input_items_criteria();
  private:
  const ::CSOItemCriteria& _internal_input_items_criteria(int index) const;
  ::CSOItemCriteria* _internal_add_input_items_criteria();
  public:
  const ::CSOItemCriteria& input_items_criteria(int index) const;
  ::CSOItemCriteria* add_input_items_criteria();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >&
      input_items_criteria() const;

  // repeated .CSOItemCriteria output_items_criteria = 21;
  int output_items_criteria_size() const;
  private:
  int _internal_output_items_criteria_size() const;
  public:
  void clear_output_items_criteria();
  ::CSOItemCriteria* mutable_output_items_criteria(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >*
      mutable_output_items_criteria();
  private:
  const ::CSOItemCriteria& _internal_output_items_criteria(int index) const;
  ::CSOItemCriteria* _internal_add_output_items_criteria();
  public:
  const ::CSOItemCriteria& output_items_criteria(int index) const;
  ::CSOItemCriteria* add_output_items_criteria();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >&
      output_items_criteria() const;

  // repeated uint32 input_item_dupe_counts = 22;
  int input_item_dupe_counts_size() const;
  private:
  int _internal_input_item_dupe_counts_size() const;
  public:
  void clear_input_item_dupe_counts();
  private:
  uint32_t _internal_input_item_dupe_counts(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_input_item_dupe_counts() const;
  void _internal_add_input_item_dupe_counts(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_input_item_dupe_counts();
  public:
  uint32_t input_item_dupe_counts(int index) const;
  void set_input_item_dupe_counts(int index, uint32_t value);
  void add_input_item_dupe_counts(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      input_item_dupe_counts() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_input_item_dupe_counts();

  // optional string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string n_a = 3;
  bool has_n_a() const;
  private:
  bool _internal_has_n_a() const;
  public:
  void clear_n_a();
  const std::string& n_a() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_n_a(ArgT0&& arg0, ArgT... args);
  std::string* mutable_n_a();
  PROTOBUF_NODISCARD std::string* release_n_a();
  void set_allocated_n_a(std::string* n_a);
  private:
  const std::string& _internal_n_a() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_n_a(const std::string& value);
  std::string* _internal_mutable_n_a();
  public:

  // optional string desc_inputs = 4;
  bool has_desc_inputs() const;
  private:
  bool _internal_has_desc_inputs() const;
  public:
  void clear_desc_inputs();
  const std::string& desc_inputs() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_desc_inputs(ArgT0&& arg0, ArgT... args);
  std::string* mutable_desc_inputs();
  PROTOBUF_NODISCARD std::string* release_desc_inputs();
  void set_allocated_desc_inputs(std::string* desc_inputs);
  private:
  const std::string& _internal_desc_inputs() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_desc_inputs(const std::string& value);
  std::string* _internal_mutable_desc_inputs();
  public:

  // optional string desc_outputs = 5;
  bool has_desc_outputs() const;
  private:
  bool _internal_has_desc_outputs() const;
  public:
  void clear_desc_outputs();
  const std::string& desc_outputs() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_desc_outputs(ArgT0&& arg0, ArgT... args);
  std::string* mutable_desc_outputs();
  PROTOBUF_NODISCARD std::string* release_desc_outputs();
  void set_allocated_desc_outputs(std::string* desc_outputs);
  private:
  const std::string& _internal_desc_outputs() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_desc_outputs(const std::string& value);
  std::string* _internal_mutable_desc_outputs();
  public:

  // optional string di_a = 6;
  bool has_di_a() const;
  private:
  bool _internal_has_di_a() const;
  public:
  void clear_di_a();
  const std::string& di_a() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_di_a(ArgT0&& arg0, ArgT... args);
  std::string* mutable_di_a();
  PROTOBUF_NODISCARD std::string* release_di_a();
  void set_allocated_di_a(std::string* di_a);
  private:
  const std::string& _internal_di_a() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_di_a(const std::string& value);
  std::string* _internal_mutable_di_a();
  public:

  // optional string di_b = 7;
  bool has_di_b() const;
  private:
  bool _internal_has_di_b() const;
  public:
  void clear_di_b();
  const std::string& di_b() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_di_b(ArgT0&& arg0, ArgT... args);
  std::string* mutable_di_b();
  PROTOBUF_NODISCARD std::string* release_di_b();
  void set_allocated_di_b(std::string* di_b);
  private:
  const std::string& _internal_di_b() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_di_b(const std::string& value);
  std::string* _internal_mutable_di_b();
  public:

  // optional string di_c = 8;
  bool has_di_c() const;
  private:
  bool _internal_has_di_c() const;
  public:
  void clear_di_c();
  const std::string& di_c() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_di_c(ArgT0&& arg0, ArgT... args);
  std::string* mutable_di_c();
  PROTOBUF_NODISCARD std::string* release_di_c();
  void set_allocated_di_c(std::string* di_c);
  private:
  const std::string& _internal_di_c() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_di_c(const std::string& value);
  std::string* _internal_mutable_di_c();
  public:

  // optional string do_a = 9;
  bool has_do_a() const;
  private:
  bool _internal_has_do_a() const;
  public:
  void clear_do_a();
  const std::string& do_a() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_do_a(ArgT0&& arg0, ArgT... args);
  std::string* mutable_do_a();
  PROTOBUF_NODISCARD std::string* release_do_a();
  void set_allocated_do_a(std::string* do_a);
  private:
  const std::string& _internal_do_a() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_do_a(const std::string& value);
  std::string* _internal_mutable_do_a();
  public:

  // optional string do_b = 10;
  bool has_do_b() const;
  private:
  bool _internal_has_do_b() const;
  public:
  void clear_do_b();
  const std::string& do_b() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_do_b(ArgT0&& arg0, ArgT... args);
  std::string* mutable_do_b();
  PROTOBUF_NODISCARD std::string* release_do_b();
  void set_allocated_do_b(std::string* do_b);
  private:
  const std::string& _internal_do_b() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_do_b(const std::string& value);
  std::string* _internal_mutable_do_b();
  public:

  // optional string do_c = 11;
  bool has_do_c() const;
  private:
  bool _internal_has_do_c() const;
  public:
  void clear_do_c();
  const std::string& do_c() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_do_c(ArgT0&& arg0, ArgT... args);
  std::string* mutable_do_c();
  PROTOBUF_NODISCARD std::string* release_do_c();
  void set_allocated_do_c(std::string* do_c);
  private:
  const std::string& _internal_do_c() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_do_c(const std::string& value);
  std::string* _internal_mutable_do_c();
  public:

  // optional uint32 def_index = 1;
  bool has_def_index() const;
  private:
  bool _internal_has_def_index() const;
  public:
  void clear_def_index();
  uint32_t def_index() const;
  void set_def_index(uint32_t value);
  private:
  uint32_t _internal_def_index() const;
  void _internal_set_def_index(uint32_t value);
  public:

  // optional bool requires_all_same_class = 12;
  bool has_requires_all_same_class() const;
  private:
  bool _internal_has_requires_all_same_class() const;
  public:
  void clear_requires_all_same_class();
  bool requires_all_same_class() const;
  void set_requires_all_same_class(bool value);
  private:
  bool _internal_requires_all_same_class() const;
  void _internal_set_requires_all_same_class(bool value);
  public:

  // optional bool requires_all_same_slot = 13;
  bool has_requires_all_same_slot() const;
  private:
  bool _internal_has_requires_all_same_slot() const;
  public:
  void clear_requires_all_same_slot();
  bool requires_all_same_slot() const;
  void set_requires_all_same_slot(bool value);
  private:
  bool _internal_requires_all_same_slot() const;
  void _internal_set_requires_all_same_slot(bool value);
  public:

  // optional int32 class_usage_for_output = 14;
  bool has_class_usage_for_output() const;
  private:
  bool _internal_has_class_usage_for_output() const;
  public:
  void clear_class_usage_for_output();
  int32_t class_usage_for_output() const;
  void set_class_usage_for_output(int32_t value);
  private:
  int32_t _internal_class_usage_for_output() const;
  void _internal_set_class_usage_for_output(int32_t value);
  public:

  // optional int32 slot_usage_for_output = 15;
  bool has_slot_usage_for_output() const;
  private:
  bool _internal_has_slot_usage_for_output() const;
  public:
  void clear_slot_usage_for_output();
  int32_t slot_usage_for_output() const;
  void set_slot_usage_for_output(int32_t value);
  private:
  int32_t _internal_slot_usage_for_output() const;
  void _internal_set_slot_usage_for_output(int32_t value);
  public:

  // optional int32 set_for_output = 16;
  bool has_set_for_output() const;
  private:
  bool _internal_has_set_for_output() const;
  public:
  void clear_set_for_output();
  int32_t set_for_output() const;
  void set_set_for_output(int32_t value);
  private:
  int32_t _internal_set_for_output() const;
  void _internal_set_set_for_output(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOItemRecipe)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria > input_items_criteria_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria > output_items_criteria_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > input_item_dupe_counts_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr n_a_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr desc_inputs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr desc_outputs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr di_a_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr di_b_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr di_c_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr do_a_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr do_b_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr do_c_;
    uint32_t def_index_;
    bool requires_all_same_class_;
    bool requires_all_same_slot_;
    int32_t class_usage_for_output_;
    int32_t slot_usage_for_output_;
    int32_t set_for_output_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgDevNewItemRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgDevNewItemRequest) */ {
 public:
  inline CMsgDevNewItemRequest() : CMsgDevNewItemRequest(nullptr) {}
  ~CMsgDevNewItemRequest() override;
  explicit PROTOBUF_CONSTEXPR CMsgDevNewItemRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgDevNewItemRequest(const CMsgDevNewItemRequest& from);
  CMsgDevNewItemRequest(CMsgDevNewItemRequest&& from) noexcept
    : CMsgDevNewItemRequest() {
    *this = ::std::move(from);
  }

  inline CMsgDevNewItemRequest& operator=(const CMsgDevNewItemRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgDevNewItemRequest& operator=(CMsgDevNewItemRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgDevNewItemRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgDevNewItemRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgDevNewItemRequest*>(
               &_CMsgDevNewItemRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(CMsgDevNewItemRequest& a, CMsgDevNewItemRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgDevNewItemRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgDevNewItemRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgDevNewItemRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgDevNewItemRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgDevNewItemRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgDevNewItemRequest& from) {
    CMsgDevNewItemRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgDevNewItemRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgDevNewItemRequest";
  }
  protected:
  explicit CMsgDevNewItemRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCriteriaFieldNumber = 2,
    kReceiverFieldNumber = 1,
  };
  // optional .CSOItemCriteria criteria = 2;
  bool has_criteria() const;
  private:
  bool _internal_has_criteria() const;
  public:
  void clear_criteria();
  const ::CSOItemCriteria& criteria() const;
  PROTOBUF_NODISCARD ::CSOItemCriteria* release_criteria();
  ::CSOItemCriteria* mutable_criteria();
  void set_allocated_criteria(::CSOItemCriteria* criteria);
  private:
  const ::CSOItemCriteria& _internal_criteria() const;
  ::CSOItemCriteria* _internal_mutable_criteria();
  public:
  void unsafe_arena_set_allocated_criteria(
      ::CSOItemCriteria* criteria);
  ::CSOItemCriteria* unsafe_arena_release_criteria();

  // optional fixed64 receiver = 1;
  bool has_receiver() const;
  private:
  bool _internal_has_receiver() const;
  public:
  void clear_receiver();
  uint64_t receiver() const;
  void set_receiver(uint64_t value);
  private:
  uint64_t _internal_receiver() const;
  void _internal_set_receiver(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgDevNewItemRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CSOItemCriteria* criteria_;
    uint64_t receiver_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgIncrementKillCountAttribute final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgIncrementKillCountAttribute) */ {
 public:
  inline CMsgIncrementKillCountAttribute() : CMsgIncrementKillCountAttribute(nullptr) {}
  ~CMsgIncrementKillCountAttribute() override;
  explicit PROTOBUF_CONSTEXPR CMsgIncrementKillCountAttribute(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgIncrementKillCountAttribute(const CMsgIncrementKillCountAttribute& from);
  CMsgIncrementKillCountAttribute(CMsgIncrementKillCountAttribute&& from) noexcept
    : CMsgIncrementKillCountAttribute() {
    *this = ::std::move(from);
  }

  inline CMsgIncrementKillCountAttribute& operator=(const CMsgIncrementKillCountAttribute& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgIncrementKillCountAttribute& operator=(CMsgIncrementKillCountAttribute&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgIncrementKillCountAttribute& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgIncrementKillCountAttribute* internal_default_instance() {
    return reinterpret_cast<const CMsgIncrementKillCountAttribute*>(
               &_CMsgIncrementKillCountAttribute_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(CMsgIncrementKillCountAttribute& a, CMsgIncrementKillCountAttribute& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgIncrementKillCountAttribute* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgIncrementKillCountAttribute* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgIncrementKillCountAttribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgIncrementKillCountAttribute>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgIncrementKillCountAttribute& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgIncrementKillCountAttribute& from) {
    CMsgIncrementKillCountAttribute::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgIncrementKillCountAttribute* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgIncrementKillCountAttribute";
  }
  protected:
  explicit CMsgIncrementKillCountAttribute(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKillerAccountIdFieldNumber = 1,
    kVictimAccountIdFieldNumber = 2,
    kItemIdFieldNumber = 3,
    kEventTypeFieldNumber = 4,
    kAmountFieldNumber = 5,
  };
  // optional fixed32 killer_account_id = 1;
  bool has_killer_account_id() const;
  private:
  bool _internal_has_killer_account_id() const;
  public:
  void clear_killer_account_id();
  uint32_t killer_account_id() const;
  void set_killer_account_id(uint32_t value);
  private:
  uint32_t _internal_killer_account_id() const;
  void _internal_set_killer_account_id(uint32_t value);
  public:

  // optional fixed32 victim_account_id = 2;
  bool has_victim_account_id() const;
  private:
  bool _internal_has_victim_account_id() const;
  public:
  void clear_victim_account_id();
  uint32_t victim_account_id() const;
  void set_victim_account_id(uint32_t value);
  private:
  uint32_t _internal_victim_account_id() const;
  void _internal_set_victim_account_id(uint32_t value);
  public:

  // optional uint64 item_id = 3;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // optional uint32 event_type = 4;
  bool has_event_type() const;
  private:
  bool _internal_has_event_type() const;
  public:
  void clear_event_type();
  uint32_t event_type() const;
  void set_event_type(uint32_t value);
  private:
  uint32_t _internal_event_type() const;
  void _internal_set_event_type(uint32_t value);
  public:

  // optional uint32 amount = 5;
  bool has_amount() const;
  private:
  bool _internal_has_amount() const;
  public:
  void clear_amount();
  uint32_t amount() const;
  void set_amount(uint32_t value);
  private:
  uint32_t _internal_amount() const;
  void _internal_set_amount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgIncrementKillCountAttribute)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t killer_account_id_;
    uint32_t victim_account_id_;
    uint64_t item_id_;
    uint32_t event_type_;
    uint32_t amount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgApplySticker final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgApplySticker) */ {
 public:
  inline CMsgApplySticker() : CMsgApplySticker(nullptr) {}
  ~CMsgApplySticker() override;
  explicit PROTOBUF_CONSTEXPR CMsgApplySticker(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgApplySticker(const CMsgApplySticker& from);
  CMsgApplySticker(CMsgApplySticker&& from) noexcept
    : CMsgApplySticker() {
    *this = ::std::move(from);
  }

  inline CMsgApplySticker& operator=(const CMsgApplySticker& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgApplySticker& operator=(CMsgApplySticker&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgApplySticker& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgApplySticker* internal_default_instance() {
    return reinterpret_cast<const CMsgApplySticker*>(
               &_CMsgApplySticker_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(CMsgApplySticker& a, CMsgApplySticker& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgApplySticker* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgApplySticker* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgApplySticker* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgApplySticker>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgApplySticker& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgApplySticker& from) {
    CMsgApplySticker::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgApplySticker* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgApplySticker";
  }
  protected:
  explicit CMsgApplySticker(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStickerItemIdFieldNumber = 1,
    kItemItemIdFieldNumber = 2,
    kStickerSlotFieldNumber = 3,
    kBaseitemDefidxFieldNumber = 4,
    kStickerWearFieldNumber = 5,
    kStickerRotationFieldNumber = 6,
    kStickerScaleFieldNumber = 7,
    kStickerOffsetXFieldNumber = 8,
    kStickerOffsetYFieldNumber = 9,
    kStickerOffsetZFieldNumber = 10,
    kStickerWearTargetFieldNumber = 11,
  };
  // optional uint64 sticker_item_id = 1;
  bool has_sticker_item_id() const;
  private:
  bool _internal_has_sticker_item_id() const;
  public:
  void clear_sticker_item_id();
  uint64_t sticker_item_id() const;
  void set_sticker_item_id(uint64_t value);
  private:
  uint64_t _internal_sticker_item_id() const;
  void _internal_set_sticker_item_id(uint64_t value);
  public:

  // optional uint64 item_item_id = 2;
  bool has_item_item_id() const;
  private:
  bool _internal_has_item_item_id() const;
  public:
  void clear_item_item_id();
  uint64_t item_item_id() const;
  void set_item_item_id(uint64_t value);
  private:
  uint64_t _internal_item_item_id() const;
  void _internal_set_item_item_id(uint64_t value);
  public:

  // optional uint32 sticker_slot = 3;
  bool has_sticker_slot() const;
  private:
  bool _internal_has_sticker_slot() const;
  public:
  void clear_sticker_slot();
  uint32_t sticker_slot() const;
  void set_sticker_slot(uint32_t value);
  private:
  uint32_t _internal_sticker_slot() const;
  void _internal_set_sticker_slot(uint32_t value);
  public:

  // optional uint32 baseitem_defidx = 4;
  bool has_baseitem_defidx() const;
  private:
  bool _internal_has_baseitem_defidx() const;
  public:
  void clear_baseitem_defidx();
  uint32_t baseitem_defidx() const;
  void set_baseitem_defidx(uint32_t value);
  private:
  uint32_t _internal_baseitem_defidx() const;
  void _internal_set_baseitem_defidx(uint32_t value);
  public:

  // optional float sticker_wear = 5;
  bool has_sticker_wear() const;
  private:
  bool _internal_has_sticker_wear() const;
  public:
  void clear_sticker_wear();
  float sticker_wear() const;
  void set_sticker_wear(float value);
  private:
  float _internal_sticker_wear() const;
  void _internal_set_sticker_wear(float value);
  public:

  // optional float sticker_rotation = 6;
  bool has_sticker_rotation() const;
  private:
  bool _internal_has_sticker_rotation() const;
  public:
  void clear_sticker_rotation();
  float sticker_rotation() const;
  void set_sticker_rotation(float value);
  private:
  float _internal_sticker_rotation() const;
  void _internal_set_sticker_rotation(float value);
  public:

  // optional float sticker_scale = 7;
  bool has_sticker_scale() const;
  private:
  bool _internal_has_sticker_scale() const;
  public:
  void clear_sticker_scale();
  float sticker_scale() const;
  void set_sticker_scale(float value);
  private:
  float _internal_sticker_scale() const;
  void _internal_set_sticker_scale(float value);
  public:

  // optional float sticker_offset_x = 8;
  bool has_sticker_offset_x() const;
  private:
  bool _internal_has_sticker_offset_x() const;
  public:
  void clear_sticker_offset_x();
  float sticker_offset_x() const;
  void set_sticker_offset_x(float value);
  private:
  float _internal_sticker_offset_x() const;
  void _internal_set_sticker_offset_x(float value);
  public:

  // optional float sticker_offset_y = 9;
  bool has_sticker_offset_y() const;
  private:
  bool _internal_has_sticker_offset_y() const;
  public:
  void clear_sticker_offset_y();
  float sticker_offset_y() const;
  void set_sticker_offset_y(float value);
  private:
  float _internal_sticker_offset_y() const;
  void _internal_set_sticker_offset_y(float value);
  public:

  // optional float sticker_offset_z = 10;
  bool has_sticker_offset_z() const;
  private:
  bool _internal_has_sticker_offset_z() const;
  public:
  void clear_sticker_offset_z();
  float sticker_offset_z() const;
  void set_sticker_offset_z(float value);
  private:
  float _internal_sticker_offset_z() const;
  void _internal_set_sticker_offset_z(float value);
  public:

  // optional float sticker_wear_target = 11;
  bool has_sticker_wear_target() const;
  private:
  bool _internal_has_sticker_wear_target() const;
  public:
  void clear_sticker_wear_target();
  float sticker_wear_target() const;
  void set_sticker_wear_target(float value);
  private:
  float _internal_sticker_wear_target() const;
  void _internal_set_sticker_wear_target(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgApplySticker)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t sticker_item_id_;
    uint64_t item_item_id_;
    uint32_t sticker_slot_;
    uint32_t baseitem_defidx_;
    float sticker_wear_;
    float sticker_rotation_;
    float sticker_scale_;
    float sticker_offset_x_;
    float sticker_offset_y_;
    float sticker_offset_z_;
    float sticker_wear_target_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgModifyItemAttribute final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgModifyItemAttribute) */ {
 public:
  inline CMsgModifyItemAttribute() : CMsgModifyItemAttribute(nullptr) {}
  ~CMsgModifyItemAttribute() override;
  explicit PROTOBUF_CONSTEXPR CMsgModifyItemAttribute(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgModifyItemAttribute(const CMsgModifyItemAttribute& from);
  CMsgModifyItemAttribute(CMsgModifyItemAttribute&& from) noexcept
    : CMsgModifyItemAttribute() {
    *this = ::std::move(from);
  }

  inline CMsgModifyItemAttribute& operator=(const CMsgModifyItemAttribute& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgModifyItemAttribute& operator=(CMsgModifyItemAttribute&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgModifyItemAttribute& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgModifyItemAttribute* internal_default_instance() {
    return reinterpret_cast<const CMsgModifyItemAttribute*>(
               &_CMsgModifyItemAttribute_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(CMsgModifyItemAttribute& a, CMsgModifyItemAttribute& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgModifyItemAttribute* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgModifyItemAttribute* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgModifyItemAttribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgModifyItemAttribute>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgModifyItemAttribute& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgModifyItemAttribute& from) {
    CMsgModifyItemAttribute::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgModifyItemAttribute* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgModifyItemAttribute";
  }
  protected:
  explicit CMsgModifyItemAttribute(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemIdFieldNumber = 1,
    kAttrDefidxFieldNumber = 2,
    kAttrValueFieldNumber = 3,
  };
  // optional uint64 item_id = 1;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // optional uint32 attr_defidx = 2;
  bool has_attr_defidx() const;
  private:
  bool _internal_has_attr_defidx() const;
  public:
  void clear_attr_defidx();
  uint32_t attr_defidx() const;
  void set_attr_defidx(uint32_t value);
  private:
  uint32_t _internal_attr_defidx() const;
  void _internal_set_attr_defidx(uint32_t value);
  public:

  // optional uint32 attr_value = 3;
  bool has_attr_value() const;
  private:
  bool _internal_has_attr_value() const;
  public:
  void clear_attr_value();
  uint32_t attr_value() const;
  void set_attr_value(uint32_t value);
  private:
  uint32_t _internal_attr_value() const;
  void _internal_set_attr_value(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgModifyItemAttribute)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t item_id_;
    uint32_t attr_defidx_;
    uint32_t attr_value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgApplyStatTrakSwap final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgApplyStatTrakSwap) */ {
 public:
  inline CMsgApplyStatTrakSwap() : CMsgApplyStatTrakSwap(nullptr) {}
  ~CMsgApplyStatTrakSwap() override;
  explicit PROTOBUF_CONSTEXPR CMsgApplyStatTrakSwap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgApplyStatTrakSwap(const CMsgApplyStatTrakSwap& from);
  CMsgApplyStatTrakSwap(CMsgApplyStatTrakSwap&& from) noexcept
    : CMsgApplyStatTrakSwap() {
    *this = ::std::move(from);
  }

  inline CMsgApplyStatTrakSwap& operator=(const CMsgApplyStatTrakSwap& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgApplyStatTrakSwap& operator=(CMsgApplyStatTrakSwap&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgApplyStatTrakSwap& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgApplyStatTrakSwap* internal_default_instance() {
    return reinterpret_cast<const CMsgApplyStatTrakSwap*>(
               &_CMsgApplyStatTrakSwap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(CMsgApplyStatTrakSwap& a, CMsgApplyStatTrakSwap& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgApplyStatTrakSwap* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgApplyStatTrakSwap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgApplyStatTrakSwap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgApplyStatTrakSwap>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgApplyStatTrakSwap& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgApplyStatTrakSwap& from) {
    CMsgApplyStatTrakSwap::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgApplyStatTrakSwap* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgApplyStatTrakSwap";
  }
  protected:
  explicit CMsgApplyStatTrakSwap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kToolItemIdFieldNumber = 1,
    kItem1ItemIdFieldNumber = 2,
    kItem2ItemIdFieldNumber = 3,
  };
  // optional uint64 tool_item_id = 1;
  bool has_tool_item_id() const;
  private:
  bool _internal_has_tool_item_id() const;
  public:
  void clear_tool_item_id();
  uint64_t tool_item_id() const;
  void set_tool_item_id(uint64_t value);
  private:
  uint64_t _internal_tool_item_id() const;
  void _internal_set_tool_item_id(uint64_t value);
  public:

  // optional uint64 item_1_item_id = 2;
  bool has_item_1_item_id() const;
  private:
  bool _internal_has_item_1_item_id() const;
  public:
  void clear_item_1_item_id();
  uint64_t item_1_item_id() const;
  void set_item_1_item_id(uint64_t value);
  private:
  uint64_t _internal_item_1_item_id() const;
  void _internal_set_item_1_item_id(uint64_t value);
  public:

  // optional uint64 item_2_item_id = 3;
  bool has_item_2_item_id() const;
  private:
  bool _internal_has_item_2_item_id() const;
  public:
  void clear_item_2_item_id();
  uint64_t item_2_item_id() const;
  void set_item_2_item_id(uint64_t value);
  private:
  uint64_t _internal_item_2_item_id() const;
  void _internal_set_item_2_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgApplyStatTrakSwap)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t tool_item_id_;
    uint64_t item_1_item_id_;
    uint64_t item_2_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgApplyStrangePart final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgApplyStrangePart) */ {
 public:
  inline CMsgApplyStrangePart() : CMsgApplyStrangePart(nullptr) {}
  ~CMsgApplyStrangePart() override;
  explicit PROTOBUF_CONSTEXPR CMsgApplyStrangePart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgApplyStrangePart(const CMsgApplyStrangePart& from);
  CMsgApplyStrangePart(CMsgApplyStrangePart&& from) noexcept
    : CMsgApplyStrangePart() {
    *this = ::std::move(from);
  }

  inline CMsgApplyStrangePart& operator=(const CMsgApplyStrangePart& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgApplyStrangePart& operator=(CMsgApplyStrangePart&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgApplyStrangePart& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgApplyStrangePart* internal_default_instance() {
    return reinterpret_cast<const CMsgApplyStrangePart*>(
               &_CMsgApplyStrangePart_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(CMsgApplyStrangePart& a, CMsgApplyStrangePart& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgApplyStrangePart* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgApplyStrangePart* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgApplyStrangePart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgApplyStrangePart>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgApplyStrangePart& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgApplyStrangePart& from) {
    CMsgApplyStrangePart::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgApplyStrangePart* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgApplyStrangePart";
  }
  protected:
  explicit CMsgApplyStrangePart(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStrangePartItemIdFieldNumber = 1,
    kItemItemIdFieldNumber = 2,
  };
  // optional uint64 strange_part_item_id = 1;
  bool has_strange_part_item_id() const;
  private:
  bool _internal_has_strange_part_item_id() const;
  public:
  void clear_strange_part_item_id();
  uint64_t strange_part_item_id() const;
  void set_strange_part_item_id(uint64_t value);
  private:
  uint64_t _internal_strange_part_item_id() const;
  void _internal_set_strange_part_item_id(uint64_t value);
  public:

  // optional uint64 item_item_id = 2;
  bool has_item_item_id() const;
  private:
  bool _internal_has_item_item_id() const;
  public:
  void clear_item_item_id();
  uint64_t item_item_id() const;
  void set_item_item_id(uint64_t value);
  private:
  uint64_t _internal_item_item_id() const;
  void _internal_set_item_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgApplyStrangePart)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t strange_part_item_id_;
    uint64_t item_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgApplyPennantUpgrade final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgApplyPennantUpgrade) */ {
 public:
  inline CMsgApplyPennantUpgrade() : CMsgApplyPennantUpgrade(nullptr) {}
  ~CMsgApplyPennantUpgrade() override;
  explicit PROTOBUF_CONSTEXPR CMsgApplyPennantUpgrade(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgApplyPennantUpgrade(const CMsgApplyPennantUpgrade& from);
  CMsgApplyPennantUpgrade(CMsgApplyPennantUpgrade&& from) noexcept
    : CMsgApplyPennantUpgrade() {
    *this = ::std::move(from);
  }

  inline CMsgApplyPennantUpgrade& operator=(const CMsgApplyPennantUpgrade& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgApplyPennantUpgrade& operator=(CMsgApplyPennantUpgrade&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgApplyPennantUpgrade& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgApplyPennantUpgrade* internal_default_instance() {
    return reinterpret_cast<const CMsgApplyPennantUpgrade*>(
               &_CMsgApplyPennantUpgrade_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(CMsgApplyPennantUpgrade& a, CMsgApplyPennantUpgrade& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgApplyPennantUpgrade* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgApplyPennantUpgrade* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgApplyPennantUpgrade* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgApplyPennantUpgrade>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgApplyPennantUpgrade& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgApplyPennantUpgrade& from) {
    CMsgApplyPennantUpgrade::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgApplyPennantUpgrade* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgApplyPennantUpgrade";
  }
  protected:
  explicit CMsgApplyPennantUpgrade(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUpgradeItemIdFieldNumber = 1,
    kPennantItemIdFieldNumber = 2,
  };
  // optional uint64 upgrade_item_id = 1;
  bool has_upgrade_item_id() const;
  private:
  bool _internal_has_upgrade_item_id() const;
  public:
  void clear_upgrade_item_id();
  uint64_t upgrade_item_id() const;
  void set_upgrade_item_id(uint64_t value);
  private:
  uint64_t _internal_upgrade_item_id() const;
  void _internal_set_upgrade_item_id(uint64_t value);
  public:

  // optional uint64 pennant_item_id = 2;
  bool has_pennant_item_id() const;
  private:
  bool _internal_has_pennant_item_id() const;
  public:
  void clear_pennant_item_id();
  uint64_t pennant_item_id() const;
  void set_pennant_item_id(uint64_t value);
  private:
  uint64_t _internal_pennant_item_id() const;
  void _internal_set_pennant_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgApplyPennantUpgrade)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t upgrade_item_id_;
    uint64_t pennant_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgApplyEggEssence final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgApplyEggEssence) */ {
 public:
  inline CMsgApplyEggEssence() : CMsgApplyEggEssence(nullptr) {}
  ~CMsgApplyEggEssence() override;
  explicit PROTOBUF_CONSTEXPR CMsgApplyEggEssence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgApplyEggEssence(const CMsgApplyEggEssence& from);
  CMsgApplyEggEssence(CMsgApplyEggEssence&& from) noexcept
    : CMsgApplyEggEssence() {
    *this = ::std::move(from);
  }

  inline CMsgApplyEggEssence& operator=(const CMsgApplyEggEssence& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgApplyEggEssence& operator=(CMsgApplyEggEssence&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgApplyEggEssence& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgApplyEggEssence* internal_default_instance() {
    return reinterpret_cast<const CMsgApplyEggEssence*>(
               &_CMsgApplyEggEssence_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(CMsgApplyEggEssence& a, CMsgApplyEggEssence& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgApplyEggEssence* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgApplyEggEssence* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgApplyEggEssence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgApplyEggEssence>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgApplyEggEssence& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgApplyEggEssence& from) {
    CMsgApplyEggEssence::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgApplyEggEssence* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgApplyEggEssence";
  }
  protected:
  explicit CMsgApplyEggEssence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEssenceItemIdFieldNumber = 1,
    kEggItemIdFieldNumber = 2,
  };
  // optional uint64 essence_item_id = 1;
  bool has_essence_item_id() const;
  private:
  bool _internal_has_essence_item_id() const;
  public:
  void clear_essence_item_id();
  uint64_t essence_item_id() const;
  void set_essence_item_id(uint64_t value);
  private:
  uint64_t _internal_essence_item_id() const;
  void _internal_set_essence_item_id(uint64_t value);
  public:

  // optional uint64 egg_item_id = 2;
  bool has_egg_item_id() const;
  private:
  bool _internal_has_egg_item_id() const;
  public:
  void clear_egg_item_id();
  uint64_t egg_item_id() const;
  void set_egg_item_id(uint64_t value);
  private:
  uint64_t _internal_egg_item_id() const;
  void _internal_set_egg_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgApplyEggEssence)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t essence_item_id_;
    uint64_t egg_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItemAttribute final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItemAttribute) */ {
 public:
  inline CSOEconItemAttribute() : CSOEconItemAttribute(nullptr) {}
  ~CSOEconItemAttribute() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItemAttribute(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItemAttribute(const CSOEconItemAttribute& from);
  CSOEconItemAttribute(CSOEconItemAttribute&& from) noexcept
    : CSOEconItemAttribute() {
    *this = ::std::move(from);
  }

  inline CSOEconItemAttribute& operator=(const CSOEconItemAttribute& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItemAttribute& operator=(CSOEconItemAttribute&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItemAttribute& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItemAttribute* internal_default_instance() {
    return reinterpret_cast<const CSOEconItemAttribute*>(
               &_CSOEconItemAttribute_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(CSOEconItemAttribute& a, CSOEconItemAttribute& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItemAttribute* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItemAttribute* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItemAttribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItemAttribute>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItemAttribute& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItemAttribute& from) {
    CSOEconItemAttribute::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItemAttribute* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItemAttribute";
  }
  protected:
  explicit CSOEconItemAttribute(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValueBytesFieldNumber = 3,
    kDefIndexFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional bytes value_bytes = 3;
  bool has_value_bytes() const;
  private:
  bool _internal_has_value_bytes() const;
  public:
  void clear_value_bytes();
  const std::string& value_bytes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value_bytes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value_bytes();
  PROTOBUF_NODISCARD std::string* release_value_bytes();
  void set_allocated_value_bytes(std::string* value_bytes);
  private:
  const std::string& _internal_value_bytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value_bytes(const std::string& value);
  std::string* _internal_mutable_value_bytes();
  public:

  // optional uint32 def_index = 1;
  bool has_def_index() const;
  private:
  bool _internal_has_def_index() const;
  public:
  void clear_def_index();
  uint32_t def_index() const;
  void set_def_index(uint32_t value);
  private:
  uint32_t _internal_def_index() const;
  void _internal_set_def_index(uint32_t value);
  public:

  // optional uint32 value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  uint32_t value() const;
  void set_value(uint32_t value);
  private:
  uint32_t _internal_value() const;
  void _internal_set_value(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItemAttribute)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_bytes_;
    uint32_t def_index_;
    uint32_t value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItemEquipped final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItemEquipped) */ {
 public:
  inline CSOEconItemEquipped() : CSOEconItemEquipped(nullptr) {}
  ~CSOEconItemEquipped() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItemEquipped(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItemEquipped(const CSOEconItemEquipped& from);
  CSOEconItemEquipped(CSOEconItemEquipped&& from) noexcept
    : CSOEconItemEquipped() {
    *this = ::std::move(from);
  }

  inline CSOEconItemEquipped& operator=(const CSOEconItemEquipped& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItemEquipped& operator=(CSOEconItemEquipped&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItemEquipped& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItemEquipped* internal_default_instance() {
    return reinterpret_cast<const CSOEconItemEquipped*>(
               &_CSOEconItemEquipped_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(CSOEconItemEquipped& a, CSOEconItemEquipped& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItemEquipped* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItemEquipped* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItemEquipped* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItemEquipped>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItemEquipped& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItemEquipped& from) {
    CSOEconItemEquipped::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItemEquipped* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItemEquipped";
  }
  protected:
  explicit CSOEconItemEquipped(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNewClassFieldNumber = 1,
    kNewSlotFieldNumber = 2,
  };
  // optional uint32 new_class = 1;
  bool has_new_class() const;
  private:
  bool _internal_has_new_class() const;
  public:
  void clear_new_class();
  uint32_t new_class() const;
  void set_new_class(uint32_t value);
  private:
  uint32_t _internal_new_class() const;
  void _internal_set_new_class(uint32_t value);
  public:

  // optional uint32 new_slot = 2;
  bool has_new_slot() const;
  private:
  bool _internal_has_new_slot() const;
  public:
  void clear_new_slot();
  uint32_t new_slot() const;
  void set_new_slot(uint32_t value);
  private:
  uint32_t _internal_new_slot() const;
  void _internal_set_new_slot(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItemEquipped)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t new_class_;
    uint32_t new_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItem final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItem) */ {
 public:
  inline CSOEconItem() : CSOEconItem(nullptr) {}
  ~CSOEconItem() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItem(const CSOEconItem& from);
  CSOEconItem(CSOEconItem&& from) noexcept
    : CSOEconItem() {
    *this = ::std::move(from);
  }

  inline CSOEconItem& operator=(const CSOEconItem& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItem& operator=(CSOEconItem&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItem& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItem* internal_default_instance() {
    return reinterpret_cast<const CSOEconItem*>(
               &_CSOEconItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(CSOEconItem& a, CSOEconItem& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItem>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItem& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItem& from) {
    CSOEconItem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItem* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItem";
  }
  protected:
  explicit CSOEconItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAttributeFieldNumber = 12,
    kEquippedStateFieldNumber = 18,
    kCustomNameFieldNumber = 10,
    kCustomDescFieldNumber = 11,
    kInteriorItemFieldNumber = 13,
    kIdFieldNumber = 1,
    kAccountIdFieldNumber = 2,
    kInventoryFieldNumber = 3,
    kDefIndexFieldNumber = 4,
    kQuantityFieldNumber = 5,
    kLevelFieldNumber = 6,
    kQualityFieldNumber = 7,
    kFlagsFieldNumber = 8,
    kOriginFieldNumber = 9,
    kInUseFieldNumber = 14,
    kStyleFieldNumber = 15,
    kOriginalIdFieldNumber = 16,
    kRarityFieldNumber = 19,
  };
  // repeated .CSOEconItemAttribute attribute = 12;
  int attribute_size() const;
  private:
  int _internal_attribute_size() const;
  public:
  void clear_attribute();
  ::CSOEconItemAttribute* mutable_attribute(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemAttribute >*
      mutable_attribute();
  private:
  const ::CSOEconItemAttribute& _internal_attribute(int index) const;
  ::CSOEconItemAttribute* _internal_add_attribute();
  public:
  const ::CSOEconItemAttribute& attribute(int index) const;
  ::CSOEconItemAttribute* add_attribute();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemAttribute >&
      attribute() const;

  // repeated .CSOEconItemEquipped equipped_state = 18;
  int equipped_state_size() const;
  private:
  int _internal_equipped_state_size() const;
  public:
  void clear_equipped_state();
  ::CSOEconItemEquipped* mutable_equipped_state(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemEquipped >*
      mutable_equipped_state();
  private:
  const ::CSOEconItemEquipped& _internal_equipped_state(int index) const;
  ::CSOEconItemEquipped* _internal_add_equipped_state();
  public:
  const ::CSOEconItemEquipped& equipped_state(int index) const;
  ::CSOEconItemEquipped* add_equipped_state();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemEquipped >&
      equipped_state() const;

  // optional string custom_name = 10;
  bool has_custom_name() const;
  private:
  bool _internal_has_custom_name() const;
  public:
  void clear_custom_name();
  const std::string& custom_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_custom_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_custom_name();
  PROTOBUF_NODISCARD std::string* release_custom_name();
  void set_allocated_custom_name(std::string* custom_name);
  private:
  const std::string& _internal_custom_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_custom_name(const std::string& value);
  std::string* _internal_mutable_custom_name();
  public:

  // optional string custom_desc = 11;
  bool has_custom_desc() const;
  private:
  bool _internal_has_custom_desc() const;
  public:
  void clear_custom_desc();
  const std::string& custom_desc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_custom_desc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_custom_desc();
  PROTOBUF_NODISCARD std::string* release_custom_desc();
  void set_allocated_custom_desc(std::string* custom_desc);
  private:
  const std::string& _internal_custom_desc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_custom_desc(const std::string& value);
  std::string* _internal_mutable_custom_desc();
  public:

  // optional .CSOEconItem interior_item = 13;
  bool has_interior_item() const;
  private:
  bool _internal_has_interior_item() const;
  public:
  void clear_interior_item();
  const ::CSOEconItem& interior_item() const;
  PROTOBUF_NODISCARD ::CSOEconItem* release_interior_item();
  ::CSOEconItem* mutable_interior_item();
  void set_allocated_interior_item(::CSOEconItem* interior_item);
  private:
  const ::CSOEconItem& _internal_interior_item() const;
  ::CSOEconItem* _internal_mutable_interior_item();
  public:
  void unsafe_arena_set_allocated_interior_item(
      ::CSOEconItem* interior_item);
  ::CSOEconItem* unsafe_arena_release_interior_item();

  // optional uint64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint64_t id() const;
  void set_id(uint64_t value);
  private:
  uint64_t _internal_id() const;
  void _internal_set_id(uint64_t value);
  public:

  // optional uint32 account_id = 2;
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 inventory = 3;
  bool has_inventory() const;
  private:
  bool _internal_has_inventory() const;
  public:
  void clear_inventory();
  uint32_t inventory() const;
  void set_inventory(uint32_t value);
  private:
  uint32_t _internal_inventory() const;
  void _internal_set_inventory(uint32_t value);
  public:

  // optional uint32 def_index = 4;
  bool has_def_index() const;
  private:
  bool _internal_has_def_index() const;
  public:
  void clear_def_index();
  uint32_t def_index() const;
  void set_def_index(uint32_t value);
  private:
  uint32_t _internal_def_index() const;
  void _internal_set_def_index(uint32_t value);
  public:

  // optional uint32 quantity = 5;
  bool has_quantity() const;
  private:
  bool _internal_has_quantity() const;
  public:
  void clear_quantity();
  uint32_t quantity() const;
  void set_quantity(uint32_t value);
  private:
  uint32_t _internal_quantity() const;
  void _internal_set_quantity(uint32_t value);
  public:

  // optional uint32 level = 6;
  bool has_level() const;
  private:
  bool _internal_has_level() const;
  public:
  void clear_level();
  uint32_t level() const;
  void set_level(uint32_t value);
  private:
  uint32_t _internal_level() const;
  void _internal_set_level(uint32_t value);
  public:

  // optional uint32 quality = 7;
  bool has_quality() const;
  private:
  bool _internal_has_quality() const;
  public:
  void clear_quality();
  uint32_t quality() const;
  void set_quality(uint32_t value);
  private:
  uint32_t _internal_quality() const;
  void _internal_set_quality(uint32_t value);
  public:

  // optional uint32 flags = 8 [default = 0];
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional uint32 origin = 9;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  uint32_t origin() const;
  void set_origin(uint32_t value);
  private:
  uint32_t _internal_origin() const;
  void _internal_set_origin(uint32_t value);
  public:

  // optional bool in_use = 14 [default = false];
  bool has_in_use() const;
  private:
  bool _internal_has_in_use() const;
  public:
  void clear_in_use();
  bool in_use() const;
  void set_in_use(bool value);
  private:
  bool _internal_in_use() const;
  void _internal_set_in_use(bool value);
  public:

  // optional uint32 style = 15 [default = 0];
  bool has_style() const;
  private:
  bool _internal_has_style() const;
  public:
  void clear_style();
  uint32_t style() const;
  void set_style(uint32_t value);
  private:
  uint32_t _internal_style() const;
  void _internal_set_style(uint32_t value);
  public:

  // optional uint64 original_id = 16 [default = 0];
  bool has_original_id() const;
  private:
  bool _internal_has_original_id() const;
  public:
  void clear_original_id();
  uint64_t original_id() const;
  void set_original_id(uint64_t value);
  private:
  uint64_t _internal_original_id() const;
  void _internal_set_original_id(uint64_t value);
  public:

  // optional uint32 rarity = 19;
  bool has_rarity() const;
  private:
  bool _internal_has_rarity() const;
  public:
  void clear_rarity();
  uint32_t rarity() const;
  void set_rarity(uint32_t value);
  private:
  uint32_t _internal_rarity() const;
  void _internal_set_rarity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemAttribute > attribute_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemEquipped > equipped_state_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr custom_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr custom_desc_;
    ::CSOEconItem* interior_item_;
    uint64_t id_;
    uint32_t account_id_;
    uint32_t inventory_;
    uint32_t def_index_;
    uint32_t quantity_;
    uint32_t level_;
    uint32_t quality_;
    uint32_t flags_;
    uint32_t origin_;
    bool in_use_;
    uint32_t style_;
    uint64_t original_id_;
    uint32_t rarity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSortItems final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSortItems) */ {
 public:
  inline CMsgSortItems() : CMsgSortItems(nullptr) {}
  ~CMsgSortItems() override;
  explicit PROTOBUF_CONSTEXPR CMsgSortItems(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSortItems(const CMsgSortItems& from);
  CMsgSortItems(CMsgSortItems&& from) noexcept
    : CMsgSortItems() {
    *this = ::std::move(from);
  }

  inline CMsgSortItems& operator=(const CMsgSortItems& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSortItems& operator=(CMsgSortItems&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSortItems& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSortItems* internal_default_instance() {
    return reinterpret_cast<const CMsgSortItems*>(
               &_CMsgSortItems_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(CMsgSortItems& a, CMsgSortItems& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSortItems* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSortItems* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSortItems* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSortItems>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSortItems& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSortItems& from) {
    CMsgSortItems::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSortItems* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSortItems";
  }
  protected:
  explicit CMsgSortItems(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSortTypeFieldNumber = 1,
  };
  // optional uint32 sort_type = 1;
  bool has_sort_type() const;
  private:
  bool _internal_has_sort_type() const;
  public:
  void clear_sort_type();
  uint32_t sort_type() const;
  void set_sort_type(uint32_t value);
  private:
  uint32_t _internal_sort_type() const;
  void _internal_set_sort_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSortItems)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t sort_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconClaimCode final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconClaimCode) */ {
 public:
  inline CSOEconClaimCode() : CSOEconClaimCode(nullptr) {}
  ~CSOEconClaimCode() override;
  explicit PROTOBUF_CONSTEXPR CSOEconClaimCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconClaimCode(const CSOEconClaimCode& from);
  CSOEconClaimCode(CSOEconClaimCode&& from) noexcept
    : CSOEconClaimCode() {
    *this = ::std::move(from);
  }

  inline CSOEconClaimCode& operator=(const CSOEconClaimCode& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconClaimCode& operator=(CSOEconClaimCode&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconClaimCode& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconClaimCode* internal_default_instance() {
    return reinterpret_cast<const CSOEconClaimCode*>(
               &_CSOEconClaimCode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(CSOEconClaimCode& a, CSOEconClaimCode& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconClaimCode* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconClaimCode* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconClaimCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconClaimCode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconClaimCode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconClaimCode& from) {
    CSOEconClaimCode::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconClaimCode* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconClaimCode";
  }
  protected:
  explicit CSOEconClaimCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCodeFieldNumber = 4,
    kAccountIdFieldNumber = 1,
    kCodeTypeFieldNumber = 2,
    kTimeAcquiredFieldNumber = 3,
  };
  // optional string code = 4;
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  const std::string& code() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_code(ArgT0&& arg0, ArgT... args);
  std::string* mutable_code();
  PROTOBUF_NODISCARD std::string* release_code();
  void set_allocated_code(std::string* code);
  private:
  const std::string& _internal_code() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_code(const std::string& value);
  std::string* _internal_mutable_code();
  public:

  // optional uint32 account_id = 1;
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 code_type = 2;
  bool has_code_type() const;
  private:
  bool _internal_has_code_type() const;
  public:
  void clear_code_type();
  uint32_t code_type() const;
  void set_code_type(uint32_t value);
  private:
  uint32_t _internal_code_type() const;
  void _internal_set_code_type(uint32_t value);
  public:

  // optional uint32 time_acquired = 3;
  bool has_time_acquired() const;
  private:
  bool _internal_has_time_acquired() const;
  public:
  void clear_time_acquired();
  uint32_t time_acquired() const;
  void set_time_acquired(uint32_t value);
  private:
  uint32_t _internal_time_acquired() const;
  void _internal_set_time_acquired(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconClaimCode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
    uint32_t account_id_;
    uint32_t code_type_;
    uint32_t time_acquired_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgStoreGetUserData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgStoreGetUserData) */ {
 public:
  inline CMsgStoreGetUserData() : CMsgStoreGetUserData(nullptr) {}
  ~CMsgStoreGetUserData() override;
  explicit PROTOBUF_CONSTEXPR CMsgStoreGetUserData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgStoreGetUserData(const CMsgStoreGetUserData& from);
  CMsgStoreGetUserData(CMsgStoreGetUserData&& from) noexcept
    : CMsgStoreGetUserData() {
    *this = ::std::move(from);
  }

  inline CMsgStoreGetUserData& operator=(const CMsgStoreGetUserData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgStoreGetUserData& operator=(CMsgStoreGetUserData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgStoreGetUserData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgStoreGetUserData* internal_default_instance() {
    return reinterpret_cast<const CMsgStoreGetUserData*>(
               &_CMsgStoreGetUserData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(CMsgStoreGetUserData& a, CMsgStoreGetUserData& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgStoreGetUserData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgStoreGetUserData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgStoreGetUserData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgStoreGetUserData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgStoreGetUserData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgStoreGetUserData& from) {
    CMsgStoreGetUserData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgStoreGetUserData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgStoreGetUserData";
  }
  protected:
  explicit CMsgStoreGetUserData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPriceSheetVersionFieldNumber = 1,
    kCurrencyFieldNumber = 2,
  };
  // optional fixed32 price_sheet_version = 1;
  bool has_price_sheet_version() const;
  private:
  bool _internal_has_price_sheet_version() const;
  public:
  void clear_price_sheet_version();
  uint32_t price_sheet_version() const;
  void set_price_sheet_version(uint32_t value);
  private:
  uint32_t _internal_price_sheet_version() const;
  void _internal_set_price_sheet_version(uint32_t value);
  public:

  // optional int32 currency = 2;
  bool has_currency() const;
  private:
  bool _internal_has_currency() const;
  public:
  void clear_currency();
  int32_t currency() const;
  void set_currency(int32_t value);
  private:
  int32_t _internal_currency() const;
  void _internal_set_currency(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgStoreGetUserData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t price_sheet_version_;
    int32_t currency_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgStoreGetUserDataResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgStoreGetUserDataResponse) */ {
 public:
  inline CMsgStoreGetUserDataResponse() : CMsgStoreGetUserDataResponse(nullptr) {}
  ~CMsgStoreGetUserDataResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgStoreGetUserDataResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgStoreGetUserDataResponse(const CMsgStoreGetUserDataResponse& from);
  CMsgStoreGetUserDataResponse(CMsgStoreGetUserDataResponse&& from) noexcept
    : CMsgStoreGetUserDataResponse() {
    *this = ::std::move(from);
  }

  inline CMsgStoreGetUserDataResponse& operator=(const CMsgStoreGetUserDataResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgStoreGetUserDataResponse& operator=(CMsgStoreGetUserDataResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgStoreGetUserDataResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgStoreGetUserDataResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgStoreGetUserDataResponse*>(
               &_CMsgStoreGetUserDataResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(CMsgStoreGetUserDataResponse& a, CMsgStoreGetUserDataResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgStoreGetUserDataResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgStoreGetUserDataResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgStoreGetUserDataResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgStoreGetUserDataResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgStoreGetUserDataResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgStoreGetUserDataResponse& from) {
    CMsgStoreGetUserDataResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgStoreGetUserDataResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgStoreGetUserDataResponse";
  }
  protected:
  explicit CMsgStoreGetUserDataResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCountryDeprecatedFieldNumber = 3,
    kPriceSheetFieldNumber = 8,
    kResultFieldNumber = 1,
    kCurrencyDeprecatedFieldNumber = 2,
    kPriceSheetVersionFieldNumber = 4,
  };
  // optional string country_deprecated = 3;
  bool has_country_deprecated() const;
  private:
  bool _internal_has_country_deprecated() const;
  public:
  void clear_country_deprecated();
  const std::string& country_deprecated() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_country_deprecated(ArgT0&& arg0, ArgT... args);
  std::string* mutable_country_deprecated();
  PROTOBUF_NODISCARD std::string* release_country_deprecated();
  void set_allocated_country_deprecated(std::string* country_deprecated);
  private:
  const std::string& _internal_country_deprecated() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_country_deprecated(const std::string& value);
  std::string* _internal_mutable_country_deprecated();
  public:

  // optional bytes price_sheet = 8;
  bool has_price_sheet() const;
  private:
  bool _internal_has_price_sheet() const;
  public:
  void clear_price_sheet();
  const std::string& price_sheet() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_price_sheet(ArgT0&& arg0, ArgT... args);
  std::string* mutable_price_sheet();
  PROTOBUF_NODISCARD std::string* release_price_sheet();
  void set_allocated_price_sheet(std::string* price_sheet);
  private:
  const std::string& _internal_price_sheet() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_price_sheet(const std::string& value);
  std::string* _internal_mutable_price_sheet();
  public:

  // optional int32 result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  int32_t result() const;
  void set_result(int32_t value);
  private:
  int32_t _internal_result() const;
  void _internal_set_result(int32_t value);
  public:

  // optional int32 currency_deprecated = 2;
  bool has_currency_deprecated() const;
  private:
  bool _internal_has_currency_deprecated() const;
  public:
  void clear_currency_deprecated();
  int32_t currency_deprecated() const;
  void set_currency_deprecated(int32_t value);
  private:
  int32_t _internal_currency_deprecated() const;
  void _internal_set_currency_deprecated(int32_t value);
  public:

  // optional fixed32 price_sheet_version = 4;
  bool has_price_sheet_version() const;
  private:
  bool _internal_has_price_sheet_version() const;
  public:
  void clear_price_sheet_version();
  uint32_t price_sheet_version() const;
  void set_price_sheet_version(uint32_t value);
  private:
  uint32_t _internal_price_sheet_version() const;
  void _internal_set_price_sheet_version(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgStoreGetUserDataResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_deprecated_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr price_sheet_;
    int32_t result_;
    int32_t currency_deprecated_;
    uint32_t price_sheet_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgUpdateItemSchema final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgUpdateItemSchema) */ {
 public:
  inline CMsgUpdateItemSchema() : CMsgUpdateItemSchema(nullptr) {}
  ~CMsgUpdateItemSchema() override;
  explicit PROTOBUF_CONSTEXPR CMsgUpdateItemSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgUpdateItemSchema(const CMsgUpdateItemSchema& from);
  CMsgUpdateItemSchema(CMsgUpdateItemSchema&& from) noexcept
    : CMsgUpdateItemSchema() {
    *this = ::std::move(from);
  }

  inline CMsgUpdateItemSchema& operator=(const CMsgUpdateItemSchema& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgUpdateItemSchema& operator=(CMsgUpdateItemSchema&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgUpdateItemSchema& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgUpdateItemSchema* internal_default_instance() {
    return reinterpret_cast<const CMsgUpdateItemSchema*>(
               &_CMsgUpdateItemSchema_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(CMsgUpdateItemSchema& a, CMsgUpdateItemSchema& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgUpdateItemSchema* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgUpdateItemSchema* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgUpdateItemSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgUpdateItemSchema>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgUpdateItemSchema& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgUpdateItemSchema& from) {
    CMsgUpdateItemSchema::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgUpdateItemSchema* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgUpdateItemSchema";
  }
  protected:
  explicit CMsgUpdateItemSchema(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemsGameFieldNumber = 1,
    kItemsGameUrlFieldNumber = 4,
    kItemSchemaVersionFieldNumber = 2,
  };
  // optional bytes items_game = 1;
  bool has_items_game() const;
  private:
  bool _internal_has_items_game() const;
  public:
  void clear_items_game();
  const std::string& items_game() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_items_game(ArgT0&& arg0, ArgT... args);
  std::string* mutable_items_game();
  PROTOBUF_NODISCARD std::string* release_items_game();
  void set_allocated_items_game(std::string* items_game);
  private:
  const std::string& _internal_items_game() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_items_game(const std::string& value);
  std::string* _internal_mutable_items_game();
  public:

  // optional string items_game_url = 4;
  bool has_items_game_url() const;
  private:
  bool _internal_has_items_game_url() const;
  public:
  void clear_items_game_url();
  const std::string& items_game_url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_items_game_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_items_game_url();
  PROTOBUF_NODISCARD std::string* release_items_game_url();
  void set_allocated_items_game_url(std::string* items_game_url);
  private:
  const std::string& _internal_items_game_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_items_game_url(const std::string& value);
  std::string* _internal_mutable_items_game_url();
  public:

  // optional fixed32 item_schema_version = 2;
  bool has_item_schema_version() const;
  private:
  bool _internal_has_item_schema_version() const;
  public:
  void clear_item_schema_version();
  uint32_t item_schema_version() const;
  void set_item_schema_version(uint32_t value);
  private:
  uint32_t _internal_item_schema_version() const;
  void _internal_set_item_schema_version(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgUpdateItemSchema)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr items_game_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr items_game_url_;
    uint32_t item_schema_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCError final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCError) */ {
 public:
  inline CMsgGCError() : CMsgGCError(nullptr) {}
  ~CMsgGCError() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCError(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCError(const CMsgGCError& from);
  CMsgGCError(CMsgGCError&& from) noexcept
    : CMsgGCError() {
    *this = ::std::move(from);
  }

  inline CMsgGCError& operator=(const CMsgGCError& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCError& operator=(CMsgGCError&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCError& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCError* internal_default_instance() {
    return reinterpret_cast<const CMsgGCError*>(
               &_CMsgGCError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(CMsgGCError& a, CMsgGCError& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCError* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCError* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCError>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCError& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCError& from) {
    CMsgGCError::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCError* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCError";
  }
  protected:
  explicit CMsgGCError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kErrorTextFieldNumber = 1,
  };
  // optional string error_text = 1;
  bool has_error_text() const;
  private:
  bool _internal_has_error_text() const;
  public:
  void clear_error_text();
  const std::string& error_text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_error_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_error_text();
  PROTOBUF_NODISCARD std::string* release_error_text();
  void set_allocated_error_text(std::string* error_text);
  private:
  const std::string& _internal_error_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_text(const std::string& value);
  std::string* _internal_mutable_error_text();
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCError)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgRequestInventoryRefresh final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgRequestInventoryRefresh) */ {
 public:
  inline CMsgRequestInventoryRefresh() : CMsgRequestInventoryRefresh(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgRequestInventoryRefresh(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgRequestInventoryRefresh(const CMsgRequestInventoryRefresh& from);
  CMsgRequestInventoryRefresh(CMsgRequestInventoryRefresh&& from) noexcept
    : CMsgRequestInventoryRefresh() {
    *this = ::std::move(from);
  }

  inline CMsgRequestInventoryRefresh& operator=(const CMsgRequestInventoryRefresh& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgRequestInventoryRefresh& operator=(CMsgRequestInventoryRefresh&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgRequestInventoryRefresh& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgRequestInventoryRefresh* internal_default_instance() {
    return reinterpret_cast<const CMsgRequestInventoryRefresh*>(
               &_CMsgRequestInventoryRefresh_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(CMsgRequestInventoryRefresh& a, CMsgRequestInventoryRefresh& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgRequestInventoryRefresh* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgRequestInventoryRefresh* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgRequestInventoryRefresh* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgRequestInventoryRefresh>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgRequestInventoryRefresh& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgRequestInventoryRefresh& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgRequestInventoryRefresh";
  }
  protected:
  explicit CMsgRequestInventoryRefresh(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgRequestInventoryRefresh)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgConVarValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgConVarValue) */ {
 public:
  inline CMsgConVarValue() : CMsgConVarValue(nullptr) {}
  ~CMsgConVarValue() override;
  explicit PROTOBUF_CONSTEXPR CMsgConVarValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgConVarValue(const CMsgConVarValue& from);
  CMsgConVarValue(CMsgConVarValue&& from) noexcept
    : CMsgConVarValue() {
    *this = ::std::move(from);
  }

  inline CMsgConVarValue& operator=(const CMsgConVarValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgConVarValue& operator=(CMsgConVarValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgConVarValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgConVarValue* internal_default_instance() {
    return reinterpret_cast<const CMsgConVarValue*>(
               &_CMsgConVarValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(CMsgConVarValue& a, CMsgConVarValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgConVarValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgConVarValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgConVarValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgConVarValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgConVarValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgConVarValue& from) {
    CMsgConVarValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgConVarValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgConVarValue";
  }
  protected:
  explicit CMsgConVarValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // @@protoc_insertion_point(class_scope:CMsgConVarValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgReplicateConVars final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgReplicateConVars) */ {
 public:
  inline CMsgReplicateConVars() : CMsgReplicateConVars(nullptr) {}
  ~CMsgReplicateConVars() override;
  explicit PROTOBUF_CONSTEXPR CMsgReplicateConVars(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgReplicateConVars(const CMsgReplicateConVars& from);
  CMsgReplicateConVars(CMsgReplicateConVars&& from) noexcept
    : CMsgReplicateConVars() {
    *this = ::std::move(from);
  }

  inline CMsgReplicateConVars& operator=(const CMsgReplicateConVars& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgReplicateConVars& operator=(CMsgReplicateConVars&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgReplicateConVars& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgReplicateConVars* internal_default_instance() {
    return reinterpret_cast<const CMsgReplicateConVars*>(
               &_CMsgReplicateConVars_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(CMsgReplicateConVars& a, CMsgReplicateConVars& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgReplicateConVars* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgReplicateConVars* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgReplicateConVars* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgReplicateConVars>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgReplicateConVars& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgReplicateConVars& from) {
    CMsgReplicateConVars::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgReplicateConVars* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgReplicateConVars";
  }
  protected:
  explicit CMsgReplicateConVars(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConvarsFieldNumber = 1,
  };
  // repeated .CMsgConVarValue convars = 1;
  int convars_size() const;
  private:
  int _internal_convars_size() const;
  public:
  void clear_convars();
  ::CMsgConVarValue* mutable_convars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgConVarValue >*
      mutable_convars();
  private:
  const ::CMsgConVarValue& _internal_convars(int index) const;
  ::CMsgConVarValue* _internal_add_convars();
  public:
  const ::CMsgConVarValue& convars(int index) const;
  ::CMsgConVarValue* add_convars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgConVarValue >&
      convars() const;

  // @@protoc_insertion_point(class_scope:CMsgReplicateConVars)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgConVarValue > convars_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgUseItem final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgUseItem) */ {
 public:
  inline CMsgUseItem() : CMsgUseItem(nullptr) {}
  ~CMsgUseItem() override;
  explicit PROTOBUF_CONSTEXPR CMsgUseItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgUseItem(const CMsgUseItem& from);
  CMsgUseItem(CMsgUseItem&& from) noexcept
    : CMsgUseItem() {
    *this = ::std::move(from);
  }

  inline CMsgUseItem& operator=(const CMsgUseItem& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgUseItem& operator=(CMsgUseItem&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgUseItem& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgUseItem* internal_default_instance() {
    return reinterpret_cast<const CMsgUseItem*>(
               &_CMsgUseItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(CMsgUseItem& a, CMsgUseItem& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgUseItem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgUseItem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgUseItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgUseItem>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgUseItem& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgUseItem& from) {
    CMsgUseItem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgUseItem* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgUseItem";
  }
  protected:
  explicit CMsgUseItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGiftPotentialTargetsFieldNumber = 3,
    kItemIdFieldNumber = 1,
    kTargetSteamIdFieldNumber = 2,
    kInitiatorSteamIdFieldNumber = 5,
    kDuelClassLockFieldNumber = 4,
  };
  // repeated uint32 gift__potential_targets = 3;
  int gift__potential_targets_size() const;
  private:
  int _internal_gift__potential_targets_size() const;
  public:
  void clear_gift__potential_targets();
  private:
  uint32_t _internal_gift__potential_targets(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_gift__potential_targets() const;
  void _internal_add_gift__potential_targets(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_gift__potential_targets();
  public:
  uint32_t gift__potential_targets(int index) const;
  void set_gift__potential_targets(int index, uint32_t value);
  void add_gift__potential_targets(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      gift__potential_targets() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_gift__potential_targets();

  // optional uint64 item_id = 1;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // optional fixed64 target_steam_id = 2;
  bool has_target_steam_id() const;
  private:
  bool _internal_has_target_steam_id() const;
  public:
  void clear_target_steam_id();
  uint64_t target_steam_id() const;
  void set_target_steam_id(uint64_t value);
  private:
  uint64_t _internal_target_steam_id() const;
  void _internal_set_target_steam_id(uint64_t value);
  public:

  // optional fixed64 initiator_steam_id = 5;
  bool has_initiator_steam_id() const;
  private:
  bool _internal_has_initiator_steam_id() const;
  public:
  void clear_initiator_steam_id();
  uint64_t initiator_steam_id() const;
  void set_initiator_steam_id(uint64_t value);
  private:
  uint64_t _internal_initiator_steam_id() const;
  void _internal_set_initiator_steam_id(uint64_t value);
  public:

  // optional uint32 duel__class_lock = 4;
  bool has_duel__class_lock() const;
  private:
  bool _internal_has_duel__class_lock() const;
  public:
  void clear_duel__class_lock();
  uint32_t duel__class_lock() const;
  void set_duel__class_lock(uint32_t value);
  private:
  uint32_t _internal_duel__class_lock() const;
  void _internal_set_duel__class_lock(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgUseItem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > gift__potential_targets_;
    uint64_t item_id_;
    uint64_t target_steam_id_;
    uint64_t initiator_steam_id_;
    uint32_t duel__class_lock_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgReplayUploadedToYouTube final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgReplayUploadedToYouTube) */ {
 public:
  inline CMsgReplayUploadedToYouTube() : CMsgReplayUploadedToYouTube(nullptr) {}
  ~CMsgReplayUploadedToYouTube() override;
  explicit PROTOBUF_CONSTEXPR CMsgReplayUploadedToYouTube(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgReplayUploadedToYouTube(const CMsgReplayUploadedToYouTube& from);
  CMsgReplayUploadedToYouTube(CMsgReplayUploadedToYouTube&& from) noexcept
    : CMsgReplayUploadedToYouTube() {
    *this = ::std::move(from);
  }

  inline CMsgReplayUploadedToYouTube& operator=(const CMsgReplayUploadedToYouTube& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgReplayUploadedToYouTube& operator=(CMsgReplayUploadedToYouTube&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgReplayUploadedToYouTube& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgReplayUploadedToYouTube* internal_default_instance() {
    return reinterpret_cast<const CMsgReplayUploadedToYouTube*>(
               &_CMsgReplayUploadedToYouTube_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(CMsgReplayUploadedToYouTube& a, CMsgReplayUploadedToYouTube& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgReplayUploadedToYouTube* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgReplayUploadedToYouTube* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgReplayUploadedToYouTube* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgReplayUploadedToYouTube>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgReplayUploadedToYouTube& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgReplayUploadedToYouTube& from) {
    CMsgReplayUploadedToYouTube::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgReplayUploadedToYouTube* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgReplayUploadedToYouTube";
  }
  protected:
  explicit CMsgReplayUploadedToYouTube(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kYoutubeUrlFieldNumber = 1,
    kYoutubeAccountNameFieldNumber = 2,
    kSessionIdFieldNumber = 3,
  };
  // optional string youtube_url = 1;
  bool has_youtube_url() const;
  private:
  bool _internal_has_youtube_url() const;
  public:
  void clear_youtube_url();
  const std::string& youtube_url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_youtube_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_youtube_url();
  PROTOBUF_NODISCARD std::string* release_youtube_url();
  void set_allocated_youtube_url(std::string* youtube_url);
  private:
  const std::string& _internal_youtube_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_youtube_url(const std::string& value);
  std::string* _internal_mutable_youtube_url();
  public:

  // optional string youtube_account_name = 2;
  bool has_youtube_account_name() const;
  private:
  bool _internal_has_youtube_account_name() const;
  public:
  void clear_youtube_account_name();
  const std::string& youtube_account_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_youtube_account_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_youtube_account_name();
  PROTOBUF_NODISCARD std::string* release_youtube_account_name();
  void set_allocated_youtube_account_name(std::string* youtube_account_name);
  private:
  const std::string& _internal_youtube_account_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_youtube_account_name(const std::string& value);
  std::string* _internal_mutable_youtube_account_name();
  public:

  // optional uint64 session_id = 3;
  bool has_session_id() const;
  private:
  bool _internal_has_session_id() const;
  public:
  void clear_session_id();
  uint64_t session_id() const;
  void set_session_id(uint64_t value);
  private:
  uint64_t _internal_session_id() const;
  void _internal_set_session_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgReplayUploadedToYouTube)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr youtube_url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr youtube_account_name_;
    uint64_t session_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgConsumableExhausted final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgConsumableExhausted) */ {
 public:
  inline CMsgConsumableExhausted() : CMsgConsumableExhausted(nullptr) {}
  ~CMsgConsumableExhausted() override;
  explicit PROTOBUF_CONSTEXPR CMsgConsumableExhausted(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgConsumableExhausted(const CMsgConsumableExhausted& from);
  CMsgConsumableExhausted(CMsgConsumableExhausted&& from) noexcept
    : CMsgConsumableExhausted() {
    *this = ::std::move(from);
  }

  inline CMsgConsumableExhausted& operator=(const CMsgConsumableExhausted& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgConsumableExhausted& operator=(CMsgConsumableExhausted&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgConsumableExhausted& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgConsumableExhausted* internal_default_instance() {
    return reinterpret_cast<const CMsgConsumableExhausted*>(
               &_CMsgConsumableExhausted_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(CMsgConsumableExhausted& a, CMsgConsumableExhausted& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgConsumableExhausted* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgConsumableExhausted* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgConsumableExhausted* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgConsumableExhausted>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgConsumableExhausted& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgConsumableExhausted& from) {
    CMsgConsumableExhausted::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgConsumableExhausted* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgConsumableExhausted";
  }
  protected:
  explicit CMsgConsumableExhausted(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemDefIdFieldNumber = 1,
  };
  // optional int32 item_def_id = 1;
  bool has_item_def_id() const;
  private:
  bool _internal_has_item_def_id() const;
  public:
  void clear_item_def_id();
  int32_t item_def_id() const;
  void set_item_def_id(int32_t value);
  private:
  int32_t _internal_item_def_id() const;
  void _internal_set_item_def_id(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgConsumableExhausted)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t item_def_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgItemAcknowledged__DEPRECATED final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgItemAcknowledged__DEPRECATED) */ {
 public:
  inline CMsgItemAcknowledged__DEPRECATED() : CMsgItemAcknowledged__DEPRECATED(nullptr) {}
  ~CMsgItemAcknowledged__DEPRECATED() override;
  explicit PROTOBUF_CONSTEXPR CMsgItemAcknowledged__DEPRECATED(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgItemAcknowledged__DEPRECATED(const CMsgItemAcknowledged__DEPRECATED& from);
  CMsgItemAcknowledged__DEPRECATED(CMsgItemAcknowledged__DEPRECATED&& from) noexcept
    : CMsgItemAcknowledged__DEPRECATED() {
    *this = ::std::move(from);
  }

  inline CMsgItemAcknowledged__DEPRECATED& operator=(const CMsgItemAcknowledged__DEPRECATED& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgItemAcknowledged__DEPRECATED& operator=(CMsgItemAcknowledged__DEPRECATED&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgItemAcknowledged__DEPRECATED& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgItemAcknowledged__DEPRECATED* internal_default_instance() {
    return reinterpret_cast<const CMsgItemAcknowledged__DEPRECATED*>(
               &_CMsgItemAcknowledged__DEPRECATED_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(CMsgItemAcknowledged__DEPRECATED& a, CMsgItemAcknowledged__DEPRECATED& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgItemAcknowledged__DEPRECATED* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgItemAcknowledged__DEPRECATED* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgItemAcknowledged__DEPRECATED* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgItemAcknowledged__DEPRECATED>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgItemAcknowledged__DEPRECATED& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgItemAcknowledged__DEPRECATED& from) {
    CMsgItemAcknowledged__DEPRECATED::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgItemAcknowledged__DEPRECATED* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgItemAcknowledged__DEPRECATED";
  }
  protected:
  explicit CMsgItemAcknowledged__DEPRECATED(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAccountIdFieldNumber = 1,
    kInventoryFieldNumber = 2,
    kDefIndexFieldNumber = 3,
    kQualityFieldNumber = 4,
    kRarityFieldNumber = 5,
    kOriginFieldNumber = 6,
    kItemIdFieldNumber = 7,
  };
  // optional uint32 account_id = 1;
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 inventory = 2;
  bool has_inventory() const;
  private:
  bool _internal_has_inventory() const;
  public:
  void clear_inventory();
  uint32_t inventory() const;
  void set_inventory(uint32_t value);
  private:
  uint32_t _internal_inventory() const;
  void _internal_set_inventory(uint32_t value);
  public:

  // optional uint32 def_index = 3;
  bool has_def_index() const;
  private:
  bool _internal_has_def_index() const;
  public:
  void clear_def_index();
  uint32_t def_index() const;
  void set_def_index(uint32_t value);
  private:
  uint32_t _internal_def_index() const;
  void _internal_set_def_index(uint32_t value);
  public:

  // optional uint32 quality = 4;
  bool has_quality() const;
  private:
  bool _internal_has_quality() const;
  public:
  void clear_quality();
  uint32_t quality() const;
  void set_quality(uint32_t value);
  private:
  uint32_t _internal_quality() const;
  void _internal_set_quality(uint32_t value);
  public:

  // optional uint32 rarity = 5;
  bool has_rarity() const;
  private:
  bool _internal_has_rarity() const;
  public:
  void clear_rarity();
  uint32_t rarity() const;
  void set_rarity(uint32_t value);
  private:
  uint32_t _internal_rarity() const;
  void _internal_set_rarity(uint32_t value);
  public:

  // optional uint32 origin = 6;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  uint32_t origin() const;
  void set_origin(uint32_t value);
  private:
  uint32_t _internal_origin() const;
  void _internal_set_origin(uint32_t value);
  public:

  // optional uint64 item_id = 7;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgItemAcknowledged__DEPRECATED)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t account_id_;
    uint32_t inventory_;
    uint32_t def_index_;
    uint32_t quality_;
    uint32_t rarity_;
    uint32_t origin_;
    uint64_t item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSetItemPositions_ItemPosition final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSetItemPositions.ItemPosition) */ {
 public:
  inline CMsgSetItemPositions_ItemPosition() : CMsgSetItemPositions_ItemPosition(nullptr) {}
  ~CMsgSetItemPositions_ItemPosition() override;
  explicit PROTOBUF_CONSTEXPR CMsgSetItemPositions_ItemPosition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSetItemPositions_ItemPosition(const CMsgSetItemPositions_ItemPosition& from);
  CMsgSetItemPositions_ItemPosition(CMsgSetItemPositions_ItemPosition&& from) noexcept
    : CMsgSetItemPositions_ItemPosition() {
    *this = ::std::move(from);
  }

  inline CMsgSetItemPositions_ItemPosition& operator=(const CMsgSetItemPositions_ItemPosition& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSetItemPositions_ItemPosition& operator=(CMsgSetItemPositions_ItemPosition&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSetItemPositions_ItemPosition& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSetItemPositions_ItemPosition* internal_default_instance() {
    return reinterpret_cast<const CMsgSetItemPositions_ItemPosition*>(
               &_CMsgSetItemPositions_ItemPosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(CMsgSetItemPositions_ItemPosition& a, CMsgSetItemPositions_ItemPosition& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSetItemPositions_ItemPosition* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSetItemPositions_ItemPosition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSetItemPositions_ItemPosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSetItemPositions_ItemPosition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSetItemPositions_ItemPosition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSetItemPositions_ItemPosition& from) {
    CMsgSetItemPositions_ItemPosition::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSetItemPositions_ItemPosition* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSetItemPositions.ItemPosition";
  }
  protected:
  explicit CMsgSetItemPositions_ItemPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLegacyItemIdFieldNumber = 1,
    kPositionFieldNumber = 2,
    kItemIdFieldNumber = 3,
  };
  // optional uint32 legacy_item_id = 1;
  bool has_legacy_item_id() const;
  private:
  bool _internal_has_legacy_item_id() const;
  public:
  void clear_legacy_item_id();
  uint32_t legacy_item_id() const;
  void set_legacy_item_id(uint32_t value);
  private:
  uint32_t _internal_legacy_item_id() const;
  void _internal_set_legacy_item_id(uint32_t value);
  public:

  // optional uint32 position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  uint32_t position() const;
  void set_position(uint32_t value);
  private:
  uint32_t _internal_position() const;
  void _internal_set_position(uint32_t value);
  public:

  // optional uint64 item_id = 3;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSetItemPositions.ItemPosition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t legacy_item_id_;
    uint32_t position_;
    uint64_t item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSetItemPositions final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSetItemPositions) */ {
 public:
  inline CMsgSetItemPositions() : CMsgSetItemPositions(nullptr) {}
  ~CMsgSetItemPositions() override;
  explicit PROTOBUF_CONSTEXPR CMsgSetItemPositions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSetItemPositions(const CMsgSetItemPositions& from);
  CMsgSetItemPositions(CMsgSetItemPositions&& from) noexcept
    : CMsgSetItemPositions() {
    *this = ::std::move(from);
  }

  inline CMsgSetItemPositions& operator=(const CMsgSetItemPositions& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSetItemPositions& operator=(CMsgSetItemPositions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSetItemPositions& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSetItemPositions* internal_default_instance() {
    return reinterpret_cast<const CMsgSetItemPositions*>(
               &_CMsgSetItemPositions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(CMsgSetItemPositions& a, CMsgSetItemPositions& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSetItemPositions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSetItemPositions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSetItemPositions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSetItemPositions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSetItemPositions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSetItemPositions& from) {
    CMsgSetItemPositions::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSetItemPositions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSetItemPositions";
  }
  protected:
  explicit CMsgSetItemPositions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgSetItemPositions_ItemPosition ItemPosition;

  // accessors -------------------------------------------------------

  enum : int {
    kItemPositionsFieldNumber = 1,
  };
  // repeated .CMsgSetItemPositions.ItemPosition item_positions = 1;
  int item_positions_size() const;
  private:
  int _internal_item_positions_size() const;
  public:
  void clear_item_positions();
  ::CMsgSetItemPositions_ItemPosition* mutable_item_positions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSetItemPositions_ItemPosition >*
      mutable_item_positions();
  private:
  const ::CMsgSetItemPositions_ItemPosition& _internal_item_positions(int index) const;
  ::CMsgSetItemPositions_ItemPosition* _internal_add_item_positions();
  public:
  const ::CMsgSetItemPositions_ItemPosition& item_positions(int index) const;
  ::CMsgSetItemPositions_ItemPosition* add_item_positions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSetItemPositions_ItemPosition >&
      item_positions() const;

  // @@protoc_insertion_point(class_scope:CMsgSetItemPositions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSetItemPositions_ItemPosition > item_positions_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCReportAbuse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCReportAbuse) */ {
 public:
  inline CMsgGCReportAbuse() : CMsgGCReportAbuse(nullptr) {}
  ~CMsgGCReportAbuse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCReportAbuse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCReportAbuse(const CMsgGCReportAbuse& from);
  CMsgGCReportAbuse(CMsgGCReportAbuse&& from) noexcept
    : CMsgGCReportAbuse() {
    *this = ::std::move(from);
  }

  inline CMsgGCReportAbuse& operator=(const CMsgGCReportAbuse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCReportAbuse& operator=(CMsgGCReportAbuse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCReportAbuse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCReportAbuse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCReportAbuse*>(
               &_CMsgGCReportAbuse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(CMsgGCReportAbuse& a, CMsgGCReportAbuse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCReportAbuse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCReportAbuse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCReportAbuse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCReportAbuse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCReportAbuse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCReportAbuse& from) {
    CMsgGCReportAbuse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCReportAbuse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCReportAbuse";
  }
  protected:
  explicit CMsgGCReportAbuse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDescriptionFieldNumber = 4,
    kTargetSteamIdFieldNumber = 1,
    kAbuseTypeFieldNumber = 2,
    kContentTypeFieldNumber = 3,
    kGidFieldNumber = 5,
    kTargetGameServerIpFieldNumber = 6,
    kTargetGameServerPortFieldNumber = 7,
  };
  // optional string description = 4;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional fixed64 target_steam_id = 1;
  bool has_target_steam_id() const;
  private:
  bool _internal_has_target_steam_id() const;
  public:
  void clear_target_steam_id();
  uint64_t target_steam_id() const;
  void set_target_steam_id(uint64_t value);
  private:
  uint64_t _internal_target_steam_id() const;
  void _internal_set_target_steam_id(uint64_t value);
  public:

  // optional uint32 abuse_type = 2;
  bool has_abuse_type() const;
  private:
  bool _internal_has_abuse_type() const;
  public:
  void clear_abuse_type();
  uint32_t abuse_type() const;
  void set_abuse_type(uint32_t value);
  private:
  uint32_t _internal_abuse_type() const;
  void _internal_set_abuse_type(uint32_t value);
  public:

  // optional uint32 content_type = 3;
  bool has_content_type() const;
  private:
  bool _internal_has_content_type() const;
  public:
  void clear_content_type();
  uint32_t content_type() const;
  void set_content_type(uint32_t value);
  private:
  uint32_t _internal_content_type() const;
  void _internal_set_content_type(uint32_t value);
  public:

  // optional uint64 gid = 5;
  bool has_gid() const;
  private:
  bool _internal_has_gid() const;
  public:
  void clear_gid();
  uint64_t gid() const;
  void set_gid(uint64_t value);
  private:
  uint64_t _internal_gid() const;
  void _internal_set_gid(uint64_t value);
  public:

  // optional fixed32 target_game_server_ip = 6;
  bool has_target_game_server_ip() const;
  private:
  bool _internal_has_target_game_server_ip() const;
  public:
  void clear_target_game_server_ip();
  uint32_t target_game_server_ip() const;
  void set_target_game_server_ip(uint32_t value);
  private:
  uint32_t _internal_target_game_server_ip() const;
  void _internal_set_target_game_server_ip(uint32_t value);
  public:

  // optional uint32 target_game_server_port = 7;
  bool has_target_game_server_port() const;
  private:
  bool _internal_has_target_game_server_port() const;
  public:
  void clear_target_game_server_port();
  uint32_t target_game_server_port() const;
  void set_target_game_server_port(uint32_t value);
  private:
  uint32_t _internal_target_game_server_port() const;
  void _internal_set_target_game_server_port(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCReportAbuse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    uint64_t target_steam_id_;
    uint32_t abuse_type_;
    uint32_t content_type_;
    uint64_t gid_;
    uint32_t target_game_server_ip_;
    uint32_t target_game_server_port_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCReportAbuseResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCReportAbuseResponse) */ {
 public:
  inline CMsgGCReportAbuseResponse() : CMsgGCReportAbuseResponse(nullptr) {}
  ~CMsgGCReportAbuseResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCReportAbuseResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCReportAbuseResponse(const CMsgGCReportAbuseResponse& from);
  CMsgGCReportAbuseResponse(CMsgGCReportAbuseResponse&& from) noexcept
    : CMsgGCReportAbuseResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCReportAbuseResponse& operator=(const CMsgGCReportAbuseResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCReportAbuseResponse& operator=(CMsgGCReportAbuseResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCReportAbuseResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCReportAbuseResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCReportAbuseResponse*>(
               &_CMsgGCReportAbuseResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(CMsgGCReportAbuseResponse& a, CMsgGCReportAbuseResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCReportAbuseResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCReportAbuseResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCReportAbuseResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCReportAbuseResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCReportAbuseResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCReportAbuseResponse& from) {
    CMsgGCReportAbuseResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCReportAbuseResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCReportAbuseResponse";
  }
  protected:
  explicit CMsgGCReportAbuseResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kErrorMessageFieldNumber = 3,
    kTargetSteamIdFieldNumber = 1,
    kResultFieldNumber = 2,
  };
  // optional string error_message = 3;
  bool has_error_message() const;
  private:
  bool _internal_has_error_message() const;
  public:
  void clear_error_message();
  const std::string& error_message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_error_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_error_message();
  PROTOBUF_NODISCARD std::string* release_error_message();
  void set_allocated_error_message(std::string* error_message);
  private:
  const std::string& _internal_error_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_message(const std::string& value);
  std::string* _internal_mutable_error_message();
  public:

  // optional fixed64 target_steam_id = 1;
  bool has_target_steam_id() const;
  private:
  bool _internal_has_target_steam_id() const;
  public:
  void clear_target_steam_id();
  uint64_t target_steam_id() const;
  void set_target_steam_id(uint64_t value);
  private:
  uint64_t _internal_target_steam_id() const;
  void _internal_set_target_steam_id(uint64_t value);
  public:

  // optional uint32 result = 2;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  uint32_t result() const;
  void set_result(uint32_t value);
  private:
  uint32_t _internal_result() const;
  void _internal_set_result(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCReportAbuseResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
    uint64_t target_steam_id_;
    uint32_t result_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCNameItemNotification final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCNameItemNotification) */ {
 public:
  inline CMsgGCNameItemNotification() : CMsgGCNameItemNotification(nullptr) {}
  ~CMsgGCNameItemNotification() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCNameItemNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCNameItemNotification(const CMsgGCNameItemNotification& from);
  CMsgGCNameItemNotification(CMsgGCNameItemNotification&& from) noexcept
    : CMsgGCNameItemNotification() {
    *this = ::std::move(from);
  }

  inline CMsgGCNameItemNotification& operator=(const CMsgGCNameItemNotification& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCNameItemNotification& operator=(CMsgGCNameItemNotification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCNameItemNotification& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCNameItemNotification* internal_default_instance() {
    return reinterpret_cast<const CMsgGCNameItemNotification*>(
               &_CMsgGCNameItemNotification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(CMsgGCNameItemNotification& a, CMsgGCNameItemNotification& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCNameItemNotification* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCNameItemNotification* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCNameItemNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCNameItemNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCNameItemNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCNameItemNotification& from) {
    CMsgGCNameItemNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCNameItemNotification* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCNameItemNotification";
  }
  protected:
  explicit CMsgGCNameItemNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemNameCustomFieldNumber = 3,
    kPlayerSteamidFieldNumber = 1,
    kItemDefIndexFieldNumber = 2,
  };
  // optional string item_name_custom = 3;
  bool has_item_name_custom() const;
  private:
  bool _internal_has_item_name_custom() const;
  public:
  void clear_item_name_custom();
  const std::string& item_name_custom() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_item_name_custom(ArgT0&& arg0, ArgT... args);
  std::string* mutable_item_name_custom();
  PROTOBUF_NODISCARD std::string* release_item_name_custom();
  void set_allocated_item_name_custom(std::string* item_name_custom);
  private:
  const std::string& _internal_item_name_custom() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_item_name_custom(const std::string& value);
  std::string* _internal_mutable_item_name_custom();
  public:

  // optional fixed64 player_steamid = 1;
  bool has_player_steamid() const;
  private:
  bool _internal_has_player_steamid() const;
  public:
  void clear_player_steamid();
  uint64_t player_steamid() const;
  void set_player_steamid(uint64_t value);
  private:
  uint64_t _internal_player_steamid() const;
  void _internal_set_player_steamid(uint64_t value);
  public:

  // optional uint32 item_def_index = 2;
  bool has_item_def_index() const;
  private:
  bool _internal_has_item_def_index() const;
  public:
  void clear_item_def_index();
  uint32_t item_def_index() const;
  void set_item_def_index(uint32_t value);
  private:
  uint32_t _internal_item_def_index() const;
  void _internal_set_item_def_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCNameItemNotification)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr item_name_custom_;
    uint64_t player_steamid_;
    uint32_t item_def_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCClientDisplayNotification final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCClientDisplayNotification) */ {
 public:
  inline CMsgGCClientDisplayNotification() : CMsgGCClientDisplayNotification(nullptr) {}
  ~CMsgGCClientDisplayNotification() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCClientDisplayNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCClientDisplayNotification(const CMsgGCClientDisplayNotification& from);
  CMsgGCClientDisplayNotification(CMsgGCClientDisplayNotification&& from) noexcept
    : CMsgGCClientDisplayNotification() {
    *this = ::std::move(from);
  }

  inline CMsgGCClientDisplayNotification& operator=(const CMsgGCClientDisplayNotification& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCClientDisplayNotification& operator=(CMsgGCClientDisplayNotification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCClientDisplayNotification& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCClientDisplayNotification* internal_default_instance() {
    return reinterpret_cast<const CMsgGCClientDisplayNotification*>(
               &_CMsgGCClientDisplayNotification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(CMsgGCClientDisplayNotification& a, CMsgGCClientDisplayNotification& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCClientDisplayNotification* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCClientDisplayNotification* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCClientDisplayNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCClientDisplayNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCClientDisplayNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCClientDisplayNotification& from) {
    CMsgGCClientDisplayNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCClientDisplayNotification* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCClientDisplayNotification";
  }
  protected:
  explicit CMsgGCClientDisplayNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBodySubstringKeysFieldNumber = 3,
    kBodySubstringValuesFieldNumber = 4,
    kNotificationTitleLocalizationKeyFieldNumber = 1,
    kNotificationBodyLocalizationKeyFieldNumber = 2,
  };
  // repeated string body_substring_keys = 3;
  int body_substring_keys_size() const;
  private:
  int _internal_body_substring_keys_size() const;
  public:
  void clear_body_substring_keys();
  const std::string& body_substring_keys(int index) const;
  std::string* mutable_body_substring_keys(int index);
  void set_body_substring_keys(int index, const std::string& value);
  void set_body_substring_keys(int index, std::string&& value);
  void set_body_substring_keys(int index, const char* value);
  void set_body_substring_keys(int index, const char* value, size_t size);
  std::string* add_body_substring_keys();
  void add_body_substring_keys(const std::string& value);
  void add_body_substring_keys(std::string&& value);
  void add_body_substring_keys(const char* value);
  void add_body_substring_keys(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& body_substring_keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_body_substring_keys();
  private:
  const std::string& _internal_body_substring_keys(int index) const;
  std::string* _internal_add_body_substring_keys();
  public:

  // repeated string body_substring_values = 4;
  int body_substring_values_size() const;
  private:
  int _internal_body_substring_values_size() const;
  public:
  void clear_body_substring_values();
  const std::string& body_substring_values(int index) const;
  std::string* mutable_body_substring_values(int index);
  void set_body_substring_values(int index, const std::string& value);
  void set_body_substring_values(int index, std::string&& value);
  void set_body_substring_values(int index, const char* value);
  void set_body_substring_values(int index, const char* value, size_t size);
  std::string* add_body_substring_values();
  void add_body_substring_values(const std::string& value);
  void add_body_substring_values(std::string&& value);
  void add_body_substring_values(const char* value);
  void add_body_substring_values(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& body_substring_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_body_substring_values();
  private:
  const std::string& _internal_body_substring_values(int index) const;
  std::string* _internal_add_body_substring_values();
  public:

  // optional string notification_title_localization_key = 1;
  bool has_notification_title_localization_key() const;
  private:
  bool _internal_has_notification_title_localization_key() const;
  public:
  void clear_notification_title_localization_key();
  const std::string& notification_title_localization_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_notification_title_localization_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_notification_title_localization_key();
  PROTOBUF_NODISCARD std::string* release_notification_title_localization_key();
  void set_allocated_notification_title_localization_key(std::string* notification_title_localization_key);
  private:
  const std::string& _internal_notification_title_localization_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_notification_title_localization_key(const std::string& value);
  std::string* _internal_mutable_notification_title_localization_key();
  public:

  // optional string notification_body_localization_key = 2;
  bool has_notification_body_localization_key() const;
  private:
  bool _internal_has_notification_body_localization_key() const;
  public:
  void clear_notification_body_localization_key();
  const std::string& notification_body_localization_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_notification_body_localization_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_notification_body_localization_key();
  PROTOBUF_NODISCARD std::string* release_notification_body_localization_key();
  void set_allocated_notification_body_localization_key(std::string* notification_body_localization_key);
  private:
  const std::string& _internal_notification_body_localization_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_notification_body_localization_key(const std::string& value);
  std::string* _internal_mutable_notification_body_localization_key();
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCClientDisplayNotification)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> body_substring_keys_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> body_substring_values_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr notification_title_localization_key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr notification_body_localization_key_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCShowItemsPickedUp final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCShowItemsPickedUp) */ {
 public:
  inline CMsgGCShowItemsPickedUp() : CMsgGCShowItemsPickedUp(nullptr) {}
  ~CMsgGCShowItemsPickedUp() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCShowItemsPickedUp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCShowItemsPickedUp(const CMsgGCShowItemsPickedUp& from);
  CMsgGCShowItemsPickedUp(CMsgGCShowItemsPickedUp&& from) noexcept
    : CMsgGCShowItemsPickedUp() {
    *this = ::std::move(from);
  }

  inline CMsgGCShowItemsPickedUp& operator=(const CMsgGCShowItemsPickedUp& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCShowItemsPickedUp& operator=(CMsgGCShowItemsPickedUp&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCShowItemsPickedUp& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCShowItemsPickedUp* internal_default_instance() {
    return reinterpret_cast<const CMsgGCShowItemsPickedUp*>(
               &_CMsgGCShowItemsPickedUp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(CMsgGCShowItemsPickedUp& a, CMsgGCShowItemsPickedUp& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCShowItemsPickedUp* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCShowItemsPickedUp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCShowItemsPickedUp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCShowItemsPickedUp>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCShowItemsPickedUp& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCShowItemsPickedUp& from) {
    CMsgGCShowItemsPickedUp::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCShowItemsPickedUp* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCShowItemsPickedUp";
  }
  protected:
  explicit CMsgGCShowItemsPickedUp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPlayerSteamidFieldNumber = 1,
  };
  // optional fixed64 player_steamid = 1;
  bool has_player_steamid() const;
  private:
  bool _internal_has_player_steamid() const;
  public:
  void clear_player_steamid();
  uint64_t player_steamid() const;
  void set_player_steamid(uint64_t value);
  private:
  uint64_t _internal_player_steamid() const;
  void _internal_set_player_steamid(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCShowItemsPickedUp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t player_steamid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCIncrementKillCountResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCIncrementKillCountResponse) */ {
 public:
  inline CMsgGCIncrementKillCountResponse() : CMsgGCIncrementKillCountResponse(nullptr) {}
  ~CMsgGCIncrementKillCountResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCIncrementKillCountResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCIncrementKillCountResponse(const CMsgGCIncrementKillCountResponse& from);
  CMsgGCIncrementKillCountResponse(CMsgGCIncrementKillCountResponse&& from) noexcept
    : CMsgGCIncrementKillCountResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCIncrementKillCountResponse& operator=(const CMsgGCIncrementKillCountResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCIncrementKillCountResponse& operator=(CMsgGCIncrementKillCountResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCIncrementKillCountResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCIncrementKillCountResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCIncrementKillCountResponse*>(
               &_CMsgGCIncrementKillCountResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(CMsgGCIncrementKillCountResponse& a, CMsgGCIncrementKillCountResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCIncrementKillCountResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCIncrementKillCountResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCIncrementKillCountResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCIncrementKillCountResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCIncrementKillCountResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCIncrementKillCountResponse& from) {
    CMsgGCIncrementKillCountResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCIncrementKillCountResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCIncrementKillCountResponse";
  }
  protected:
  explicit CMsgGCIncrementKillCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKillerAccountIdFieldNumber = 1,
    kNumKillsFieldNumber = 2,
    kItemDefFieldNumber = 3,
    kLevelTypeFieldNumber = 4,
  };
  // optional uint32 killer_account_id = 1 [(.key_field) = true];
  bool has_killer_account_id() const;
  private:
  bool _internal_has_killer_account_id() const;
  public:
  void clear_killer_account_id();
  uint32_t killer_account_id() const;
  void set_killer_account_id(uint32_t value);
  private:
  uint32_t _internal_killer_account_id() const;
  void _internal_set_killer_account_id(uint32_t value);
  public:

  // optional uint32 num_kills = 2;
  bool has_num_kills() const;
  private:
  bool _internal_has_num_kills() const;
  public:
  void clear_num_kills();
  uint32_t num_kills() const;
  void set_num_kills(uint32_t value);
  private:
  uint32_t _internal_num_kills() const;
  void _internal_set_num_kills(uint32_t value);
  public:

  // optional uint32 item_def = 3;
  bool has_item_def() const;
  private:
  bool _internal_has_item_def() const;
  public:
  void clear_item_def();
  uint32_t item_def() const;
  void set_item_def(uint32_t value);
  private:
  uint32_t _internal_item_def() const;
  void _internal_set_item_def(uint32_t value);
  public:

  // optional uint32 level_type = 4;
  bool has_level_type() const;
  private:
  bool _internal_has_level_type() const;
  public:
  void clear_level_type();
  uint32_t level_type() const;
  void set_level_type(uint32_t value);
  private:
  uint32_t _internal_level_type() const;
  void _internal_set_level_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCIncrementKillCountResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t killer_account_id_;
    uint32_t num_kills_;
    uint32_t item_def_;
    uint32_t level_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItemDropRateBonus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItemDropRateBonus) */ {
 public:
  inline CSOEconItemDropRateBonus() : CSOEconItemDropRateBonus(nullptr) {}
  ~CSOEconItemDropRateBonus() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItemDropRateBonus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItemDropRateBonus(const CSOEconItemDropRateBonus& from);
  CSOEconItemDropRateBonus(CSOEconItemDropRateBonus&& from) noexcept
    : CSOEconItemDropRateBonus() {
    *this = ::std::move(from);
  }

  inline CSOEconItemDropRateBonus& operator=(const CSOEconItemDropRateBonus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItemDropRateBonus& operator=(CSOEconItemDropRateBonus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItemDropRateBonus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItemDropRateBonus* internal_default_instance() {
    return reinterpret_cast<const CSOEconItemDropRateBonus*>(
               &_CSOEconItemDropRateBonus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(CSOEconItemDropRateBonus& a, CSOEconItemDropRateBonus& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItemDropRateBonus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItemDropRateBonus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItemDropRateBonus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItemDropRateBonus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItemDropRateBonus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItemDropRateBonus& from) {
    CSOEconItemDropRateBonus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItemDropRateBonus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItemDropRateBonus";
  }
  protected:
  explicit CSOEconItemDropRateBonus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAccountIdFieldNumber = 1,
    kExpirationDateFieldNumber = 2,
    kBonusFieldNumber = 3,
    kBonusCountFieldNumber = 4,
    kItemIdFieldNumber = 5,
    kDefIndexFieldNumber = 6,
  };
  // optional uint32 account_id = 1;
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional fixed32 expiration_date = 2;
  bool has_expiration_date() const;
  private:
  bool _internal_has_expiration_date() const;
  public:
  void clear_expiration_date();
  uint32_t expiration_date() const;
  void set_expiration_date(uint32_t value);
  private:
  uint32_t _internal_expiration_date() const;
  void _internal_set_expiration_date(uint32_t value);
  public:

  // optional float bonus = 3;
  bool has_bonus() const;
  private:
  bool _internal_has_bonus() const;
  public:
  void clear_bonus();
  float bonus() const;
  void set_bonus(float value);
  private:
  float _internal_bonus() const;
  void _internal_set_bonus(float value);
  public:

  // optional uint32 bonus_count = 4;
  bool has_bonus_count() const;
  private:
  bool _internal_has_bonus_count() const;
  public:
  void clear_bonus_count();
  uint32_t bonus_count() const;
  void set_bonus_count(uint32_t value);
  private:
  uint32_t _internal_bonus_count() const;
  void _internal_set_bonus_count(uint32_t value);
  public:

  // optional uint64 item_id = 5;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // optional uint32 def_index = 6;
  bool has_def_index() const;
  private:
  bool _internal_has_def_index() const;
  public:
  void clear_def_index();
  uint32_t def_index() const;
  void set_def_index(uint32_t value);
  private:
  uint32_t _internal_def_index() const;
  void _internal_set_def_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItemDropRateBonus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t account_id_;
    uint32_t expiration_date_;
    float bonus_;
    uint32_t bonus_count_;
    uint64_t item_id_;
    uint32_t def_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItemLeagueViewPass final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItemLeagueViewPass) */ {
 public:
  inline CSOEconItemLeagueViewPass() : CSOEconItemLeagueViewPass(nullptr) {}
  ~CSOEconItemLeagueViewPass() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItemLeagueViewPass(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItemLeagueViewPass(const CSOEconItemLeagueViewPass& from);
  CSOEconItemLeagueViewPass(CSOEconItemLeagueViewPass&& from) noexcept
    : CSOEconItemLeagueViewPass() {
    *this = ::std::move(from);
  }

  inline CSOEconItemLeagueViewPass& operator=(const CSOEconItemLeagueViewPass& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItemLeagueViewPass& operator=(CSOEconItemLeagueViewPass&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItemLeagueViewPass& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItemLeagueViewPass* internal_default_instance() {
    return reinterpret_cast<const CSOEconItemLeagueViewPass*>(
               &_CSOEconItemLeagueViewPass_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(CSOEconItemLeagueViewPass& a, CSOEconItemLeagueViewPass& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItemLeagueViewPass* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItemLeagueViewPass* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItemLeagueViewPass* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItemLeagueViewPass>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItemLeagueViewPass& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItemLeagueViewPass& from) {
    CSOEconItemLeagueViewPass::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItemLeagueViewPass* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItemLeagueViewPass";
  }
  protected:
  explicit CSOEconItemLeagueViewPass(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAccountIdFieldNumber = 1,
    kLeagueIdFieldNumber = 2,
    kAdminFieldNumber = 3,
    kItemindexFieldNumber = 4,
  };
  // optional uint32 account_id = 1 [(.key_field) = true];
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 league_id = 2 [(.key_field) = true];
  bool has_league_id() const;
  private:
  bool _internal_has_league_id() const;
  public:
  void clear_league_id();
  uint32_t league_id() const;
  void set_league_id(uint32_t value);
  private:
  uint32_t _internal_league_id() const;
  void _internal_set_league_id(uint32_t value);
  public:

  // optional uint32 admin = 3;
  bool has_admin() const;
  private:
  bool _internal_has_admin() const;
  public:
  void clear_admin();
  uint32_t admin() const;
  void set_admin(uint32_t value);
  private:
  uint32_t _internal_admin() const;
  void _internal_set_admin(uint32_t value);
  public:

  // optional uint32 itemindex = 4;
  bool has_itemindex() const;
  private:
  bool _internal_has_itemindex() const;
  public:
  void clear_itemindex();
  uint32_t itemindex() const;
  void set_itemindex(uint32_t value);
  private:
  uint32_t _internal_itemindex() const;
  void _internal_set_itemindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItemLeagueViewPass)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t account_id_;
    uint32_t league_id_;
    uint32_t admin_;
    uint32_t itemindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconItemEventTicket final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconItemEventTicket) */ {
 public:
  inline CSOEconItemEventTicket() : CSOEconItemEventTicket(nullptr) {}
  ~CSOEconItemEventTicket() override;
  explicit PROTOBUF_CONSTEXPR CSOEconItemEventTicket(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconItemEventTicket(const CSOEconItemEventTicket& from);
  CSOEconItemEventTicket(CSOEconItemEventTicket&& from) noexcept
    : CSOEconItemEventTicket() {
    *this = ::std::move(from);
  }

  inline CSOEconItemEventTicket& operator=(const CSOEconItemEventTicket& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconItemEventTicket& operator=(CSOEconItemEventTicket&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconItemEventTicket& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconItemEventTicket* internal_default_instance() {
    return reinterpret_cast<const CSOEconItemEventTicket*>(
               &_CSOEconItemEventTicket_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(CSOEconItemEventTicket& a, CSOEconItemEventTicket& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconItemEventTicket* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconItemEventTicket* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconItemEventTicket* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconItemEventTicket>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconItemEventTicket& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconItemEventTicket& from) {
    CSOEconItemEventTicket::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconItemEventTicket* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconItemEventTicket";
  }
  protected:
  explicit CSOEconItemEventTicket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAccountIdFieldNumber = 1,
    kEventIdFieldNumber = 2,
    kItemIdFieldNumber = 3,
  };
  // optional uint32 account_id = 1;
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 event_id = 2;
  bool has_event_id() const;
  private:
  bool _internal_has_event_id() const;
  public:
  void clear_event_id();
  uint32_t event_id() const;
  void set_event_id(uint32_t value);
  private:
  uint32_t _internal_event_id() const;
  void _internal_set_event_id(uint32_t value);
  public:

  // optional uint64 item_id = 3;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconItemEventTicket)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t account_id_;
    uint32_t event_id_;
    uint64_t item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCItemPreviewItemBoughtNotification final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCItemPreviewItemBoughtNotification) */ {
 public:
  inline CMsgGCItemPreviewItemBoughtNotification() : CMsgGCItemPreviewItemBoughtNotification(nullptr) {}
  ~CMsgGCItemPreviewItemBoughtNotification() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCItemPreviewItemBoughtNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCItemPreviewItemBoughtNotification(const CMsgGCItemPreviewItemBoughtNotification& from);
  CMsgGCItemPreviewItemBoughtNotification(CMsgGCItemPreviewItemBoughtNotification&& from) noexcept
    : CMsgGCItemPreviewItemBoughtNotification() {
    *this = ::std::move(from);
  }

  inline CMsgGCItemPreviewItemBoughtNotification& operator=(const CMsgGCItemPreviewItemBoughtNotification& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCItemPreviewItemBoughtNotification& operator=(CMsgGCItemPreviewItemBoughtNotification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCItemPreviewItemBoughtNotification& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCItemPreviewItemBoughtNotification* internal_default_instance() {
    return reinterpret_cast<const CMsgGCItemPreviewItemBoughtNotification*>(
               &_CMsgGCItemPreviewItemBoughtNotification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(CMsgGCItemPreviewItemBoughtNotification& a, CMsgGCItemPreviewItemBoughtNotification& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCItemPreviewItemBoughtNotification* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCItemPreviewItemBoughtNotification* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCItemPreviewItemBoughtNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCItemPreviewItemBoughtNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCItemPreviewItemBoughtNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCItemPreviewItemBoughtNotification& from) {
    CMsgGCItemPreviewItemBoughtNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCItemPreviewItemBoughtNotification* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCItemPreviewItemBoughtNotification";
  }
  protected:
  explicit CMsgGCItemPreviewItemBoughtNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemDefIndexFieldNumber = 1,
  };
  // optional uint32 item_def_index = 1;
  bool has_item_def_index() const;
  private:
  bool _internal_has_item_def_index() const;
  public:
  void clear_item_def_index();
  uint32_t item_def_index() const;
  void set_item_def_index(uint32_t value);
  private:
  uint32_t _internal_item_def_index() const;
  void _internal_set_item_def_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCItemPreviewItemBoughtNotification)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t item_def_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseCancel final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseCancel) */ {
 public:
  inline CMsgGCStorePurchaseCancel() : CMsgGCStorePurchaseCancel(nullptr) {}
  ~CMsgGCStorePurchaseCancel() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseCancel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseCancel(const CMsgGCStorePurchaseCancel& from);
  CMsgGCStorePurchaseCancel(CMsgGCStorePurchaseCancel&& from) noexcept
    : CMsgGCStorePurchaseCancel() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseCancel& operator=(const CMsgGCStorePurchaseCancel& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseCancel& operator=(CMsgGCStorePurchaseCancel&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseCancel& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseCancel* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseCancel*>(
               &_CMsgGCStorePurchaseCancel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(CMsgGCStorePurchaseCancel& a, CMsgGCStorePurchaseCancel& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseCancel* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseCancel* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseCancel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseCancel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseCancel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseCancel& from) {
    CMsgGCStorePurchaseCancel::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseCancel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseCancel";
  }
  protected:
  explicit CMsgGCStorePurchaseCancel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTxnIdFieldNumber = 1,
  };
  // optional uint64 txn_id = 1;
  bool has_txn_id() const;
  private:
  bool _internal_has_txn_id() const;
  public:
  void clear_txn_id();
  uint64_t txn_id() const;
  void set_txn_id(uint64_t value);
  private:
  uint64_t _internal_txn_id() const;
  void _internal_set_txn_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseCancel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t txn_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseCancelResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseCancelResponse) */ {
 public:
  inline CMsgGCStorePurchaseCancelResponse() : CMsgGCStorePurchaseCancelResponse(nullptr) {}
  ~CMsgGCStorePurchaseCancelResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseCancelResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseCancelResponse(const CMsgGCStorePurchaseCancelResponse& from);
  CMsgGCStorePurchaseCancelResponse(CMsgGCStorePurchaseCancelResponse&& from) noexcept
    : CMsgGCStorePurchaseCancelResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseCancelResponse& operator=(const CMsgGCStorePurchaseCancelResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseCancelResponse& operator=(CMsgGCStorePurchaseCancelResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseCancelResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseCancelResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseCancelResponse*>(
               &_CMsgGCStorePurchaseCancelResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(CMsgGCStorePurchaseCancelResponse& a, CMsgGCStorePurchaseCancelResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseCancelResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseCancelResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseCancelResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseCancelResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseCancelResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseCancelResponse& from) {
    CMsgGCStorePurchaseCancelResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseCancelResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseCancelResponse";
  }
  protected:
  explicit CMsgGCStorePurchaseCancelResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kResultFieldNumber = 1,
  };
  // optional uint32 result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  uint32_t result() const;
  void set_result(uint32_t value);
  private:
  uint32_t _internal_result() const;
  void _internal_set_result(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseCancelResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t result_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseFinalize final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseFinalize) */ {
 public:
  inline CMsgGCStorePurchaseFinalize() : CMsgGCStorePurchaseFinalize(nullptr) {}
  ~CMsgGCStorePurchaseFinalize() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseFinalize(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseFinalize(const CMsgGCStorePurchaseFinalize& from);
  CMsgGCStorePurchaseFinalize(CMsgGCStorePurchaseFinalize&& from) noexcept
    : CMsgGCStorePurchaseFinalize() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseFinalize& operator=(const CMsgGCStorePurchaseFinalize& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseFinalize& operator=(CMsgGCStorePurchaseFinalize&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseFinalize& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseFinalize* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseFinalize*>(
               &_CMsgGCStorePurchaseFinalize_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(CMsgGCStorePurchaseFinalize& a, CMsgGCStorePurchaseFinalize& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseFinalize* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseFinalize* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseFinalize* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseFinalize>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseFinalize& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseFinalize& from) {
    CMsgGCStorePurchaseFinalize::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseFinalize* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseFinalize";
  }
  protected:
  explicit CMsgGCStorePurchaseFinalize(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTxnIdFieldNumber = 1,
  };
  // optional uint64 txn_id = 1;
  bool has_txn_id() const;
  private:
  bool _internal_has_txn_id() const;
  public:
  void clear_txn_id();
  uint64_t txn_id() const;
  void set_txn_id(uint64_t value);
  private:
  uint64_t _internal_txn_id() const;
  void _internal_set_txn_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseFinalize)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t txn_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCStorePurchaseFinalizeResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCStorePurchaseFinalizeResponse) */ {
 public:
  inline CMsgGCStorePurchaseFinalizeResponse() : CMsgGCStorePurchaseFinalizeResponse(nullptr) {}
  ~CMsgGCStorePurchaseFinalizeResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCStorePurchaseFinalizeResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCStorePurchaseFinalizeResponse(const CMsgGCStorePurchaseFinalizeResponse& from);
  CMsgGCStorePurchaseFinalizeResponse(CMsgGCStorePurchaseFinalizeResponse&& from) noexcept
    : CMsgGCStorePurchaseFinalizeResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCStorePurchaseFinalizeResponse& operator=(const CMsgGCStorePurchaseFinalizeResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCStorePurchaseFinalizeResponse& operator=(CMsgGCStorePurchaseFinalizeResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCStorePurchaseFinalizeResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCStorePurchaseFinalizeResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCStorePurchaseFinalizeResponse*>(
               &_CMsgGCStorePurchaseFinalizeResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(CMsgGCStorePurchaseFinalizeResponse& a, CMsgGCStorePurchaseFinalizeResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCStorePurchaseFinalizeResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCStorePurchaseFinalizeResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCStorePurchaseFinalizeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCStorePurchaseFinalizeResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCStorePurchaseFinalizeResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCStorePurchaseFinalizeResponse& from) {
    CMsgGCStorePurchaseFinalizeResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCStorePurchaseFinalizeResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCStorePurchaseFinalizeResponse";
  }
  protected:
  explicit CMsgGCStorePurchaseFinalizeResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kItemIdsFieldNumber = 2,
    kResultFieldNumber = 1,
  };
  // repeated uint64 item_ids = 2;
  int item_ids_size() const;
  private:
  int _internal_item_ids_size() const;
  public:
  void clear_item_ids();
  private:
  uint64_t _internal_item_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_item_ids() const;
  void _internal_add_item_ids(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_item_ids();
  public:
  uint64_t item_ids(int index) const;
  void set_item_ids(int index, uint64_t value);
  void add_item_ids(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      item_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_item_ids();

  // optional uint32 result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  uint32_t result() const;
  void set_result(uint32_t value);
  private:
  uint32_t _internal_result() const;
  void _internal_set_result(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCStorePurchaseFinalizeResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > item_ids_;
    uint32_t result_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCBannedWordListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCBannedWordListRequest) */ {
 public:
  inline CMsgGCBannedWordListRequest() : CMsgGCBannedWordListRequest(nullptr) {}
  ~CMsgGCBannedWordListRequest() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCBannedWordListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCBannedWordListRequest(const CMsgGCBannedWordListRequest& from);
  CMsgGCBannedWordListRequest(CMsgGCBannedWordListRequest&& from) noexcept
    : CMsgGCBannedWordListRequest() {
    *this = ::std::move(from);
  }

  inline CMsgGCBannedWordListRequest& operator=(const CMsgGCBannedWordListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCBannedWordListRequest& operator=(CMsgGCBannedWordListRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCBannedWordListRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCBannedWordListRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgGCBannedWordListRequest*>(
               &_CMsgGCBannedWordListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(CMsgGCBannedWordListRequest& a, CMsgGCBannedWordListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCBannedWordListRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCBannedWordListRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCBannedWordListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCBannedWordListRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCBannedWordListRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCBannedWordListRequest& from) {
    CMsgGCBannedWordListRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCBannedWordListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCBannedWordListRequest";
  }
  protected:
  explicit CMsgGCBannedWordListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBanListGroupIdFieldNumber = 1,
    kWordIdFieldNumber = 2,
  };
  // optional uint32 ban_list_group_id = 1;
  bool has_ban_list_group_id() const;
  private:
  bool _internal_has_ban_list_group_id() const;
  public:
  void clear_ban_list_group_id();
  uint32_t ban_list_group_id() const;
  void set_ban_list_group_id(uint32_t value);
  private:
  uint32_t _internal_ban_list_group_id() const;
  void _internal_set_ban_list_group_id(uint32_t value);
  public:

  // optional uint32 word_id = 2;
  bool has_word_id() const;
  private:
  bool _internal_has_word_id() const;
  public:
  void clear_word_id();
  uint32_t word_id() const;
  void set_word_id(uint32_t value);
  private:
  uint32_t _internal_word_id() const;
  void _internal_set_word_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCBannedWordListRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t ban_list_group_id_;
    uint32_t word_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCRequestAnnouncements final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgGCRequestAnnouncements) */ {
 public:
  inline CMsgGCRequestAnnouncements() : CMsgGCRequestAnnouncements(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgGCRequestAnnouncements(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCRequestAnnouncements(const CMsgGCRequestAnnouncements& from);
  CMsgGCRequestAnnouncements(CMsgGCRequestAnnouncements&& from) noexcept
    : CMsgGCRequestAnnouncements() {
    *this = ::std::move(from);
  }

  inline CMsgGCRequestAnnouncements& operator=(const CMsgGCRequestAnnouncements& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCRequestAnnouncements& operator=(CMsgGCRequestAnnouncements&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCRequestAnnouncements& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCRequestAnnouncements* internal_default_instance() {
    return reinterpret_cast<const CMsgGCRequestAnnouncements*>(
               &_CMsgGCRequestAnnouncements_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(CMsgGCRequestAnnouncements& a, CMsgGCRequestAnnouncements& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCRequestAnnouncements* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCRequestAnnouncements* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCRequestAnnouncements* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCRequestAnnouncements>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgGCRequestAnnouncements& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgGCRequestAnnouncements& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCRequestAnnouncements";
  }
  protected:
  explicit CMsgGCRequestAnnouncements(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgGCRequestAnnouncements)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCRequestAnnouncementsResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCRequestAnnouncementsResponse) */ {
 public:
  inline CMsgGCRequestAnnouncementsResponse() : CMsgGCRequestAnnouncementsResponse(nullptr) {}
  ~CMsgGCRequestAnnouncementsResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCRequestAnnouncementsResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCRequestAnnouncementsResponse(const CMsgGCRequestAnnouncementsResponse& from);
  CMsgGCRequestAnnouncementsResponse(CMsgGCRequestAnnouncementsResponse&& from) noexcept
    : CMsgGCRequestAnnouncementsResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCRequestAnnouncementsResponse& operator=(const CMsgGCRequestAnnouncementsResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCRequestAnnouncementsResponse& operator=(CMsgGCRequestAnnouncementsResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCRequestAnnouncementsResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCRequestAnnouncementsResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCRequestAnnouncementsResponse*>(
               &_CMsgGCRequestAnnouncementsResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(CMsgGCRequestAnnouncementsResponse& a, CMsgGCRequestAnnouncementsResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCRequestAnnouncementsResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCRequestAnnouncementsResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCRequestAnnouncementsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCRequestAnnouncementsResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCRequestAnnouncementsResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCRequestAnnouncementsResponse& from) {
    CMsgGCRequestAnnouncementsResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCRequestAnnouncementsResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCRequestAnnouncementsResponse";
  }
  protected:
  explicit CMsgGCRequestAnnouncementsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAnnouncementTitleFieldNumber = 1,
    kAnnouncementFieldNumber = 2,
    kNextmatchTitleFieldNumber = 3,
    kNextmatchFieldNumber = 4,
  };
  // optional string announcement_title = 1;
  bool has_announcement_title() const;
  private:
  bool _internal_has_announcement_title() const;
  public:
  void clear_announcement_title();
  const std::string& announcement_title() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_announcement_title(ArgT0&& arg0, ArgT... args);
  std::string* mutable_announcement_title();
  PROTOBUF_NODISCARD std::string* release_announcement_title();
  void set_allocated_announcement_title(std::string* announcement_title);
  private:
  const std::string& _internal_announcement_title() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_announcement_title(const std::string& value);
  std::string* _internal_mutable_announcement_title();
  public:

  // optional string announcement = 2;
  bool has_announcement() const;
  private:
  bool _internal_has_announcement() const;
  public:
  void clear_announcement();
  const std::string& announcement() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_announcement(ArgT0&& arg0, ArgT... args);
  std::string* mutable_announcement();
  PROTOBUF_NODISCARD std::string* release_announcement();
  void set_allocated_announcement(std::string* announcement);
  private:
  const std::string& _internal_announcement() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_announcement(const std::string& value);
  std::string* _internal_mutable_announcement();
  public:

  // optional string nextmatch_title = 3;
  bool has_nextmatch_title() const;
  private:
  bool _internal_has_nextmatch_title() const;
  public:
  void clear_nextmatch_title();
  const std::string& nextmatch_title() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_nextmatch_title(ArgT0&& arg0, ArgT... args);
  std::string* mutable_nextmatch_title();
  PROTOBUF_NODISCARD std::string* release_nextmatch_title();
  void set_allocated_nextmatch_title(std::string* nextmatch_title);
  private:
  const std::string& _internal_nextmatch_title() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nextmatch_title(const std::string& value);
  std::string* _internal_mutable_nextmatch_title();
  public:

  // optional string nextmatch = 4;
  bool has_nextmatch() const;
  private:
  bool _internal_has_nextmatch() const;
  public:
  void clear_nextmatch();
  const std::string& nextmatch() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_nextmatch(ArgT0&& arg0, ArgT... args);
  std::string* mutable_nextmatch();
  PROTOBUF_NODISCARD std::string* release_nextmatch();
  void set_allocated_nextmatch(std::string* nextmatch);
  private:
  const std::string& _internal_nextmatch() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nextmatch(const std::string& value);
  std::string* _internal_mutable_nextmatch();
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCRequestAnnouncementsResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr announcement_title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr announcement_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nextmatch_title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nextmatch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCBannedWord final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCBannedWord) */ {
 public:
  inline CMsgGCBannedWord() : CMsgGCBannedWord(nullptr) {}
  ~CMsgGCBannedWord() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCBannedWord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCBannedWord(const CMsgGCBannedWord& from);
  CMsgGCBannedWord(CMsgGCBannedWord&& from) noexcept
    : CMsgGCBannedWord() {
    *this = ::std::move(from);
  }

  inline CMsgGCBannedWord& operator=(const CMsgGCBannedWord& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCBannedWord& operator=(CMsgGCBannedWord&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCBannedWord& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCBannedWord* internal_default_instance() {
    return reinterpret_cast<const CMsgGCBannedWord*>(
               &_CMsgGCBannedWord_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(CMsgGCBannedWord& a, CMsgGCBannedWord& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCBannedWord* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCBannedWord* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCBannedWord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCBannedWord>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCBannedWord& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCBannedWord& from) {
    CMsgGCBannedWord::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCBannedWord* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCBannedWord";
  }
  protected:
  explicit CMsgGCBannedWord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWordFieldNumber = 3,
    kWordIdFieldNumber = 1,
    kWordTypeFieldNumber = 2,
  };
  // optional string word = 3;
  bool has_word() const;
  private:
  bool _internal_has_word() const;
  public:
  void clear_word();
  const std::string& word() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_word(ArgT0&& arg0, ArgT... args);
  std::string* mutable_word();
  PROTOBUF_NODISCARD std::string* release_word();
  void set_allocated_word(std::string* word);
  private:
  const std::string& _internal_word() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_word(const std::string& value);
  std::string* _internal_mutable_word();
  public:

  // optional uint32 word_id = 1;
  bool has_word_id() const;
  private:
  bool _internal_has_word_id() const;
  public:
  void clear_word_id();
  uint32_t word_id() const;
  void set_word_id(uint32_t value);
  private:
  uint32_t _internal_word_id() const;
  void _internal_set_word_id(uint32_t value);
  public:

  // optional .GC_BannedWordType word_type = 2 [default = GC_BANNED_WORD_DISABLE_WORD];
  bool has_word_type() const;
  private:
  bool _internal_has_word_type() const;
  public:
  void clear_word_type();
  ::GC_BannedWordType word_type() const;
  void set_word_type(::GC_BannedWordType value);
  private:
  ::GC_BannedWordType _internal_word_type() const;
  void _internal_set_word_type(::GC_BannedWordType value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCBannedWord)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr word_;
    uint32_t word_id_;
    int word_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCBannedWordListResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCBannedWordListResponse) */ {
 public:
  inline CMsgGCBannedWordListResponse() : CMsgGCBannedWordListResponse(nullptr) {}
  ~CMsgGCBannedWordListResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCBannedWordListResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCBannedWordListResponse(const CMsgGCBannedWordListResponse& from);
  CMsgGCBannedWordListResponse(CMsgGCBannedWordListResponse&& from) noexcept
    : CMsgGCBannedWordListResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCBannedWordListResponse& operator=(const CMsgGCBannedWordListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCBannedWordListResponse& operator=(CMsgGCBannedWordListResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCBannedWordListResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCBannedWordListResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCBannedWordListResponse*>(
               &_CMsgGCBannedWordListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(CMsgGCBannedWordListResponse& a, CMsgGCBannedWordListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCBannedWordListResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCBannedWordListResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCBannedWordListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCBannedWordListResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCBannedWordListResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCBannedWordListResponse& from) {
    CMsgGCBannedWordListResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCBannedWordListResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCBannedWordListResponse";
  }
  protected:
  explicit CMsgGCBannedWordListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWordListFieldNumber = 2,
    kBanListGroupIdFieldNumber = 1,
  };
  // repeated .CMsgGCBannedWord word_list = 2;
  int word_list_size() const;
  private:
  int _internal_word_list_size() const;
  public:
  void clear_word_list();
  ::CMsgGCBannedWord* mutable_word_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgGCBannedWord >*
      mutable_word_list();
  private:
  const ::CMsgGCBannedWord& _internal_word_list(int index) const;
  ::CMsgGCBannedWord* _internal_add_word_list();
  public:
  const ::CMsgGCBannedWord& word_list(int index) const;
  ::CMsgGCBannedWord* add_word_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgGCBannedWord >&
      word_list() const;

  // optional uint32 ban_list_group_id = 1;
  bool has_ban_list_group_id() const;
  private:
  bool _internal_has_ban_list_group_id() const;
  public:
  void clear_ban_list_group_id();
  uint32_t ban_list_group_id() const;
  void set_ban_list_group_id(uint32_t value);
  private:
  uint32_t _internal_ban_list_group_id() const;
  void _internal_set_ban_list_group_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCBannedWordListResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgGCBannedWord > word_list_;
    uint32_t ban_list_group_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCBannedWordListBroadcast final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCBannedWordListBroadcast) */ {
 public:
  inline CMsgGCToGCBannedWordListBroadcast() : CMsgGCToGCBannedWordListBroadcast(nullptr) {}
  ~CMsgGCToGCBannedWordListBroadcast() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCBannedWordListBroadcast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCBannedWordListBroadcast(const CMsgGCToGCBannedWordListBroadcast& from);
  CMsgGCToGCBannedWordListBroadcast(CMsgGCToGCBannedWordListBroadcast&& from) noexcept
    : CMsgGCToGCBannedWordListBroadcast() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCBannedWordListBroadcast& operator=(const CMsgGCToGCBannedWordListBroadcast& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCBannedWordListBroadcast& operator=(CMsgGCToGCBannedWordListBroadcast&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCBannedWordListBroadcast& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCBannedWordListBroadcast* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCBannedWordListBroadcast*>(
               &_CMsgGCToGCBannedWordListBroadcast_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(CMsgGCToGCBannedWordListBroadcast& a, CMsgGCToGCBannedWordListBroadcast& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCBannedWordListBroadcast* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCBannedWordListBroadcast* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCBannedWordListBroadcast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCBannedWordListBroadcast>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCBannedWordListBroadcast& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCBannedWordListBroadcast& from) {
    CMsgGCToGCBannedWordListBroadcast::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCBannedWordListBroadcast* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCBannedWordListBroadcast";
  }
  protected:
  explicit CMsgGCToGCBannedWordListBroadcast(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBroadcastFieldNumber = 1,
  };
  // optional .CMsgGCBannedWordListResponse broadcast = 1;
  bool has_broadcast() const;
  private:
  bool _internal_has_broadcast() const;
  public:
  void clear_broadcast();
  const ::CMsgGCBannedWordListResponse& broadcast() const;
  PROTOBUF_NODISCARD ::CMsgGCBannedWordListResponse* release_broadcast();
  ::CMsgGCBannedWordListResponse* mutable_broadcast();
  void set_allocated_broadcast(::CMsgGCBannedWordListResponse* broadcast);
  private:
  const ::CMsgGCBannedWordListResponse& _internal_broadcast() const;
  ::CMsgGCBannedWordListResponse* _internal_mutable_broadcast();
  public:
  void unsafe_arena_set_allocated_broadcast(
      ::CMsgGCBannedWordListResponse* broadcast);
  ::CMsgGCBannedWordListResponse* unsafe_arena_release_broadcast();

  // @@protoc_insertion_point(class_scope:CMsgGCToGCBannedWordListBroadcast)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgGCBannedWordListResponse* broadcast_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCBannedWordListUpdated final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCBannedWordListUpdated) */ {
 public:
  inline CMsgGCToGCBannedWordListUpdated() : CMsgGCToGCBannedWordListUpdated(nullptr) {}
  ~CMsgGCToGCBannedWordListUpdated() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCBannedWordListUpdated(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCBannedWordListUpdated(const CMsgGCToGCBannedWordListUpdated& from);
  CMsgGCToGCBannedWordListUpdated(CMsgGCToGCBannedWordListUpdated&& from) noexcept
    : CMsgGCToGCBannedWordListUpdated() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCBannedWordListUpdated& operator=(const CMsgGCToGCBannedWordListUpdated& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCBannedWordListUpdated& operator=(CMsgGCToGCBannedWordListUpdated&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCBannedWordListUpdated& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCBannedWordListUpdated* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCBannedWordListUpdated*>(
               &_CMsgGCToGCBannedWordListUpdated_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  friend void swap(CMsgGCToGCBannedWordListUpdated& a, CMsgGCToGCBannedWordListUpdated& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCBannedWordListUpdated* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCBannedWordListUpdated* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCBannedWordListUpdated* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCBannedWordListUpdated>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCBannedWordListUpdated& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCBannedWordListUpdated& from) {
    CMsgGCToGCBannedWordListUpdated::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCBannedWordListUpdated* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCBannedWordListUpdated";
  }
  protected:
  explicit CMsgGCToGCBannedWordListUpdated(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGroupIdFieldNumber = 1,
  };
  // optional uint32 group_id = 1;
  bool has_group_id() const;
  private:
  bool _internal_has_group_id() const;
  public:
  void clear_group_id();
  uint32_t group_id() const;
  void set_group_id(uint32_t value);
  private:
  uint32_t _internal_group_id() const;
  void _internal_set_group_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCBannedWordListUpdated)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t group_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCDirtySDOCache final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCDirtySDOCache) */ {
 public:
  inline CMsgGCToGCDirtySDOCache() : CMsgGCToGCDirtySDOCache(nullptr) {}
  ~CMsgGCToGCDirtySDOCache() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCDirtySDOCache(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCDirtySDOCache(const CMsgGCToGCDirtySDOCache& from);
  CMsgGCToGCDirtySDOCache(CMsgGCToGCDirtySDOCache&& from) noexcept
    : CMsgGCToGCDirtySDOCache() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCDirtySDOCache& operator=(const CMsgGCToGCDirtySDOCache& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCDirtySDOCache& operator=(CMsgGCToGCDirtySDOCache&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCDirtySDOCache& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCDirtySDOCache* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCDirtySDOCache*>(
               &_CMsgGCToGCDirtySDOCache_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(CMsgGCToGCDirtySDOCache& a, CMsgGCToGCDirtySDOCache& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCDirtySDOCache* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCDirtySDOCache* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCDirtySDOCache* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCDirtySDOCache>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCDirtySDOCache& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCDirtySDOCache& from) {
    CMsgGCToGCDirtySDOCache::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCDirtySDOCache* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCDirtySDOCache";
  }
  protected:
  explicit CMsgGCToGCDirtySDOCache(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyUint64FieldNumber = 2,
    kSdoTypeFieldNumber = 1,
  };
  // optional uint64 key_uint64 = 2;
  bool has_key_uint64() const;
  private:
  bool _internal_has_key_uint64() const;
  public:
  void clear_key_uint64();
  uint64_t key_uint64() const;
  void set_key_uint64(uint64_t value);
  private:
  uint64_t _internal_key_uint64() const;
  void _internal_set_key_uint64(uint64_t value);
  public:

  // optional uint32 sdo_type = 1;
  bool has_sdo_type() const;
  private:
  bool _internal_has_sdo_type() const;
  public:
  void clear_sdo_type();
  uint32_t sdo_type() const;
  void set_sdo_type(uint32_t value);
  private:
  uint32_t _internal_sdo_type() const;
  void _internal_set_sdo_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCDirtySDOCache)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t key_uint64_;
    uint32_t sdo_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCDirtyMultipleSDOCache final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCDirtyMultipleSDOCache) */ {
 public:
  inline CMsgGCToGCDirtyMultipleSDOCache() : CMsgGCToGCDirtyMultipleSDOCache(nullptr) {}
  ~CMsgGCToGCDirtyMultipleSDOCache() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCDirtyMultipleSDOCache(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCDirtyMultipleSDOCache(const CMsgGCToGCDirtyMultipleSDOCache& from);
  CMsgGCToGCDirtyMultipleSDOCache(CMsgGCToGCDirtyMultipleSDOCache&& from) noexcept
    : CMsgGCToGCDirtyMultipleSDOCache() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCDirtyMultipleSDOCache& operator=(const CMsgGCToGCDirtyMultipleSDOCache& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCDirtyMultipleSDOCache& operator=(CMsgGCToGCDirtyMultipleSDOCache&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCDirtyMultipleSDOCache& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCDirtyMultipleSDOCache* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCDirtyMultipleSDOCache*>(
               &_CMsgGCToGCDirtyMultipleSDOCache_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(CMsgGCToGCDirtyMultipleSDOCache& a, CMsgGCToGCDirtyMultipleSDOCache& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCDirtyMultipleSDOCache* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCDirtyMultipleSDOCache* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCDirtyMultipleSDOCache* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCDirtyMultipleSDOCache>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCDirtyMultipleSDOCache& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCDirtyMultipleSDOCache& from) {
    CMsgGCToGCDirtyMultipleSDOCache::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCDirtyMultipleSDOCache* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCDirtyMultipleSDOCache";
  }
  protected:
  explicit CMsgGCToGCDirtyMultipleSDOCache(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyUint64FieldNumber = 2,
    kSdoTypeFieldNumber = 1,
  };
  // repeated uint64 key_uint64 = 2;
  int key_uint64_size() const;
  private:
  int _internal_key_uint64_size() const;
  public:
  void clear_key_uint64();
  private:
  uint64_t _internal_key_uint64(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_key_uint64() const;
  void _internal_add_key_uint64(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_key_uint64();
  public:
  uint64_t key_uint64(int index) const;
  void set_key_uint64(int index, uint64_t value);
  void add_key_uint64(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      key_uint64() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_key_uint64();

  // optional uint32 sdo_type = 1;
  bool has_sdo_type() const;
  private:
  bool _internal_has_sdo_type() const;
  public:
  void clear_sdo_type();
  uint32_t sdo_type() const;
  void set_sdo_type(uint32_t value);
  private:
  uint32_t _internal_sdo_type() const;
  void _internal_set_sdo_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCDirtyMultipleSDOCache)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > key_uint64_;
    uint32_t sdo_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCCollectItem final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCCollectItem) */ {
 public:
  inline CMsgGCCollectItem() : CMsgGCCollectItem(nullptr) {}
  ~CMsgGCCollectItem() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCCollectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCCollectItem(const CMsgGCCollectItem& from);
  CMsgGCCollectItem(CMsgGCCollectItem&& from) noexcept
    : CMsgGCCollectItem() {
    *this = ::std::move(from);
  }

  inline CMsgGCCollectItem& operator=(const CMsgGCCollectItem& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCCollectItem& operator=(CMsgGCCollectItem&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCCollectItem& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCCollectItem* internal_default_instance() {
    return reinterpret_cast<const CMsgGCCollectItem*>(
               &_CMsgGCCollectItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(CMsgGCCollectItem& a, CMsgGCCollectItem& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCCollectItem* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCCollectItem* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCCollectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCCollectItem>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCCollectItem& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCCollectItem& from) {
    CMsgGCCollectItem::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCCollectItem* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCCollectItem";
  }
  protected:
  explicit CMsgGCCollectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCollectionItemIdFieldNumber = 1,
    kSubjectItemIdFieldNumber = 2,
  };
  // optional uint64 collection_item_id = 1;
  bool has_collection_item_id() const;
  private:
  bool _internal_has_collection_item_id() const;
  public:
  void clear_collection_item_id();
  uint64_t collection_item_id() const;
  void set_collection_item_id(uint64_t value);
  private:
  uint64_t _internal_collection_item_id() const;
  void _internal_set_collection_item_id(uint64_t value);
  public:

  // optional uint64 subject_item_id = 2;
  bool has_subject_item_id() const;
  private:
  bool _internal_has_subject_item_id() const;
  public:
  void clear_subject_item_id();
  uint64_t subject_item_id() const;
  void set_subject_item_id(uint64_t value);
  private:
  uint64_t _internal_subject_item_id() const;
  void _internal_set_subject_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCCollectItem)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t collection_item_id_;
    uint64_t subject_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSDONoMemcached final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgSDONoMemcached) */ {
 public:
  inline CMsgSDONoMemcached() : CMsgSDONoMemcached(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgSDONoMemcached(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSDONoMemcached(const CMsgSDONoMemcached& from);
  CMsgSDONoMemcached(CMsgSDONoMemcached&& from) noexcept
    : CMsgSDONoMemcached() {
    *this = ::std::move(from);
  }

  inline CMsgSDONoMemcached& operator=(const CMsgSDONoMemcached& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSDONoMemcached& operator=(CMsgSDONoMemcached&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSDONoMemcached& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSDONoMemcached* internal_default_instance() {
    return reinterpret_cast<const CMsgSDONoMemcached*>(
               &_CMsgSDONoMemcached_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(CMsgSDONoMemcached& a, CMsgSDONoMemcached& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSDONoMemcached* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSDONoMemcached* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSDONoMemcached* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSDONoMemcached>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgSDONoMemcached& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgSDONoMemcached& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSDONoMemcached";
  }
  protected:
  explicit CMsgSDONoMemcached(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgSDONoMemcached)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCUpdateSQLKeyValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCUpdateSQLKeyValue) */ {
 public:
  inline CMsgGCToGCUpdateSQLKeyValue() : CMsgGCToGCUpdateSQLKeyValue(nullptr) {}
  ~CMsgGCToGCUpdateSQLKeyValue() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCUpdateSQLKeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCUpdateSQLKeyValue(const CMsgGCToGCUpdateSQLKeyValue& from);
  CMsgGCToGCUpdateSQLKeyValue(CMsgGCToGCUpdateSQLKeyValue&& from) noexcept
    : CMsgGCToGCUpdateSQLKeyValue() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCUpdateSQLKeyValue& operator=(const CMsgGCToGCUpdateSQLKeyValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCUpdateSQLKeyValue& operator=(CMsgGCToGCUpdateSQLKeyValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCUpdateSQLKeyValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCUpdateSQLKeyValue* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCUpdateSQLKeyValue*>(
               &_CMsgGCToGCUpdateSQLKeyValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(CMsgGCToGCUpdateSQLKeyValue& a, CMsgGCToGCUpdateSQLKeyValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCUpdateSQLKeyValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCUpdateSQLKeyValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCUpdateSQLKeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCUpdateSQLKeyValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCUpdateSQLKeyValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCUpdateSQLKeyValue& from) {
    CMsgGCToGCUpdateSQLKeyValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCUpdateSQLKeyValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCUpdateSQLKeyValue";
  }
  protected:
  explicit CMsgGCToGCUpdateSQLKeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyNameFieldNumber = 1,
  };
  // optional string key_name = 1;
  bool has_key_name() const;
  private:
  bool _internal_has_key_name() const;
  public:
  void clear_key_name();
  const std::string& key_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_name();
  PROTOBUF_NODISCARD std::string* release_key_name();
  void set_allocated_key_name(std::string* key_name);
  private:
  const std::string& _internal_key_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_name(const std::string& value);
  std::string* _internal_mutable_key_name();
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCUpdateSQLKeyValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCIsTrustedServer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCIsTrustedServer) */ {
 public:
  inline CMsgGCToGCIsTrustedServer() : CMsgGCToGCIsTrustedServer(nullptr) {}
  ~CMsgGCToGCIsTrustedServer() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCIsTrustedServer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCIsTrustedServer(const CMsgGCToGCIsTrustedServer& from);
  CMsgGCToGCIsTrustedServer(CMsgGCToGCIsTrustedServer&& from) noexcept
    : CMsgGCToGCIsTrustedServer() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCIsTrustedServer& operator=(const CMsgGCToGCIsTrustedServer& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCIsTrustedServer& operator=(CMsgGCToGCIsTrustedServer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCIsTrustedServer& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCIsTrustedServer* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCIsTrustedServer*>(
               &_CMsgGCToGCIsTrustedServer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(CMsgGCToGCIsTrustedServer& a, CMsgGCToGCIsTrustedServer& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCIsTrustedServer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCIsTrustedServer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCIsTrustedServer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCIsTrustedServer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCIsTrustedServer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCIsTrustedServer& from) {
    CMsgGCToGCIsTrustedServer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCIsTrustedServer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCIsTrustedServer";
  }
  protected:
  explicit CMsgGCToGCIsTrustedServer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSteamIdFieldNumber = 1,
  };
  // optional fixed64 steam_id = 1;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCIsTrustedServer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t steam_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCIsTrustedServerResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCIsTrustedServerResponse) */ {
 public:
  inline CMsgGCToGCIsTrustedServerResponse() : CMsgGCToGCIsTrustedServerResponse(nullptr) {}
  ~CMsgGCToGCIsTrustedServerResponse() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCIsTrustedServerResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCIsTrustedServerResponse(const CMsgGCToGCIsTrustedServerResponse& from);
  CMsgGCToGCIsTrustedServerResponse(CMsgGCToGCIsTrustedServerResponse&& from) noexcept
    : CMsgGCToGCIsTrustedServerResponse() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCIsTrustedServerResponse& operator=(const CMsgGCToGCIsTrustedServerResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCIsTrustedServerResponse& operator=(CMsgGCToGCIsTrustedServerResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCIsTrustedServerResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCIsTrustedServerResponse* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCIsTrustedServerResponse*>(
               &_CMsgGCToGCIsTrustedServerResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(CMsgGCToGCIsTrustedServerResponse& a, CMsgGCToGCIsTrustedServerResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCIsTrustedServerResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCIsTrustedServerResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCIsTrustedServerResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCIsTrustedServerResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCIsTrustedServerResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCIsTrustedServerResponse& from) {
    CMsgGCToGCIsTrustedServerResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCIsTrustedServerResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCIsTrustedServerResponse";
  }
  protected:
  explicit CMsgGCToGCIsTrustedServerResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIsTrustedFieldNumber = 1,
  };
  // optional bool is_trusted = 1;
  bool has_is_trusted() const;
  private:
  bool _internal_has_is_trusted() const;
  public:
  void clear_is_trusted();
  bool is_trusted() const;
  void set_is_trusted(bool value);
  private:
  bool _internal_is_trusted() const;
  void _internal_set_is_trusted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCIsTrustedServerResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool is_trusted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCBroadcastConsoleCommand final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCBroadcastConsoleCommand) */ {
 public:
  inline CMsgGCToGCBroadcastConsoleCommand() : CMsgGCToGCBroadcastConsoleCommand(nullptr) {}
  ~CMsgGCToGCBroadcastConsoleCommand() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCBroadcastConsoleCommand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCBroadcastConsoleCommand(const CMsgGCToGCBroadcastConsoleCommand& from);
  CMsgGCToGCBroadcastConsoleCommand(CMsgGCToGCBroadcastConsoleCommand&& from) noexcept
    : CMsgGCToGCBroadcastConsoleCommand() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCBroadcastConsoleCommand& operator=(const CMsgGCToGCBroadcastConsoleCommand& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCBroadcastConsoleCommand& operator=(CMsgGCToGCBroadcastConsoleCommand&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCBroadcastConsoleCommand& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCBroadcastConsoleCommand* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCBroadcastConsoleCommand*>(
               &_CMsgGCToGCBroadcastConsoleCommand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  friend void swap(CMsgGCToGCBroadcastConsoleCommand& a, CMsgGCToGCBroadcastConsoleCommand& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCBroadcastConsoleCommand* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCBroadcastConsoleCommand* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCBroadcastConsoleCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCBroadcastConsoleCommand>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCBroadcastConsoleCommand& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCBroadcastConsoleCommand& from) {
    CMsgGCToGCBroadcastConsoleCommand::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCBroadcastConsoleCommand* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCBroadcastConsoleCommand";
  }
  protected:
  explicit CMsgGCToGCBroadcastConsoleCommand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConCommandFieldNumber = 1,
  };
  // optional string con_command = 1;
  bool has_con_command() const;
  private:
  bool _internal_has_con_command() const;
  public:
  void clear_con_command();
  const std::string& con_command() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_con_command(ArgT0&& arg0, ArgT... args);
  std::string* mutable_con_command();
  PROTOBUF_NODISCARD std::string* release_con_command();
  void set_allocated_con_command(std::string* con_command);
  private:
  const std::string& _internal_con_command() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_con_command(const std::string& value);
  std::string* _internal_mutable_con_command();
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCBroadcastConsoleCommand)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr con_command_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCServerVersionUpdated final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCServerVersionUpdated) */ {
 public:
  inline CMsgGCServerVersionUpdated() : CMsgGCServerVersionUpdated(nullptr) {}
  ~CMsgGCServerVersionUpdated() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCServerVersionUpdated(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCServerVersionUpdated(const CMsgGCServerVersionUpdated& from);
  CMsgGCServerVersionUpdated(CMsgGCServerVersionUpdated&& from) noexcept
    : CMsgGCServerVersionUpdated() {
    *this = ::std::move(from);
  }

  inline CMsgGCServerVersionUpdated& operator=(const CMsgGCServerVersionUpdated& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCServerVersionUpdated& operator=(CMsgGCServerVersionUpdated&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCServerVersionUpdated& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCServerVersionUpdated* internal_default_instance() {
    return reinterpret_cast<const CMsgGCServerVersionUpdated*>(
               &_CMsgGCServerVersionUpdated_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(CMsgGCServerVersionUpdated& a, CMsgGCServerVersionUpdated& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCServerVersionUpdated* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCServerVersionUpdated* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCServerVersionUpdated* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCServerVersionUpdated>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCServerVersionUpdated& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCServerVersionUpdated& from) {
    CMsgGCServerVersionUpdated::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCServerVersionUpdated* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCServerVersionUpdated";
  }
  protected:
  explicit CMsgGCServerVersionUpdated(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kServerVersionFieldNumber = 1,
  };
  // optional uint32 server_version = 1;
  bool has_server_version() const;
  private:
  bool _internal_has_server_version() const;
  public:
  void clear_server_version();
  uint32_t server_version() const;
  void set_server_version(uint32_t value);
  private:
  uint32_t _internal_server_version() const;
  void _internal_set_server_version(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCServerVersionUpdated)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t server_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCClientVersionUpdated final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCClientVersionUpdated) */ {
 public:
  inline CMsgGCClientVersionUpdated() : CMsgGCClientVersionUpdated(nullptr) {}
  ~CMsgGCClientVersionUpdated() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCClientVersionUpdated(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCClientVersionUpdated(const CMsgGCClientVersionUpdated& from);
  CMsgGCClientVersionUpdated(CMsgGCClientVersionUpdated&& from) noexcept
    : CMsgGCClientVersionUpdated() {
    *this = ::std::move(from);
  }

  inline CMsgGCClientVersionUpdated& operator=(const CMsgGCClientVersionUpdated& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCClientVersionUpdated& operator=(CMsgGCClientVersionUpdated&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCClientVersionUpdated& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCClientVersionUpdated* internal_default_instance() {
    return reinterpret_cast<const CMsgGCClientVersionUpdated*>(
               &_CMsgGCClientVersionUpdated_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  friend void swap(CMsgGCClientVersionUpdated& a, CMsgGCClientVersionUpdated& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCClientVersionUpdated* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCClientVersionUpdated* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCClientVersionUpdated* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCClientVersionUpdated>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCClientVersionUpdated& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCClientVersionUpdated& from) {
    CMsgGCClientVersionUpdated::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCClientVersionUpdated* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCClientVersionUpdated";
  }
  protected:
  explicit CMsgGCClientVersionUpdated(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClientVersionFieldNumber = 1,
  };
  // optional uint32 client_version = 1;
  bool has_client_version() const;
  private:
  bool _internal_has_client_version() const;
  public:
  void clear_client_version();
  uint32_t client_version() const;
  void set_client_version(uint32_t value);
  private:
  uint32_t _internal_client_version() const;
  void _internal_set_client_version(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCClientVersionUpdated)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t client_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCWebAPIAccountChanged final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CMsgGCToGCWebAPIAccountChanged) */ {
 public:
  inline CMsgGCToGCWebAPIAccountChanged() : CMsgGCToGCWebAPIAccountChanged(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCWebAPIAccountChanged(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCWebAPIAccountChanged(const CMsgGCToGCWebAPIAccountChanged& from);
  CMsgGCToGCWebAPIAccountChanged(CMsgGCToGCWebAPIAccountChanged&& from) noexcept
    : CMsgGCToGCWebAPIAccountChanged() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCWebAPIAccountChanged& operator=(const CMsgGCToGCWebAPIAccountChanged& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCWebAPIAccountChanged& operator=(CMsgGCToGCWebAPIAccountChanged&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCWebAPIAccountChanged& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCWebAPIAccountChanged* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCWebAPIAccountChanged*>(
               &_CMsgGCToGCWebAPIAccountChanged_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

  friend void swap(CMsgGCToGCWebAPIAccountChanged& a, CMsgGCToGCWebAPIAccountChanged& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCWebAPIAccountChanged* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCWebAPIAccountChanged* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCWebAPIAccountChanged* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCWebAPIAccountChanged>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CMsgGCToGCWebAPIAccountChanged& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CMsgGCToGCWebAPIAccountChanged& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCWebAPIAccountChanged";
  }
  protected:
  explicit CMsgGCToGCWebAPIAccountChanged(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:CMsgGCToGCWebAPIAccountChanged)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGCToGCRequestPassportItemGrant final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGCToGCRequestPassportItemGrant) */ {
 public:
  inline CMsgGCToGCRequestPassportItemGrant() : CMsgGCToGCRequestPassportItemGrant(nullptr) {}
  ~CMsgGCToGCRequestPassportItemGrant() override;
  explicit PROTOBUF_CONSTEXPR CMsgGCToGCRequestPassportItemGrant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGCToGCRequestPassportItemGrant(const CMsgGCToGCRequestPassportItemGrant& from);
  CMsgGCToGCRequestPassportItemGrant(CMsgGCToGCRequestPassportItemGrant&& from) noexcept
    : CMsgGCToGCRequestPassportItemGrant() {
    *this = ::std::move(from);
  }

  inline CMsgGCToGCRequestPassportItemGrant& operator=(const CMsgGCToGCRequestPassportItemGrant& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGCToGCRequestPassportItemGrant& operator=(CMsgGCToGCRequestPassportItemGrant&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGCToGCRequestPassportItemGrant& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGCToGCRequestPassportItemGrant* internal_default_instance() {
    return reinterpret_cast<const CMsgGCToGCRequestPassportItemGrant*>(
               &_CMsgGCToGCRequestPassportItemGrant_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

  friend void swap(CMsgGCToGCRequestPassportItemGrant& a, CMsgGCToGCRequestPassportItemGrant& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGCToGCRequestPassportItemGrant* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGCToGCRequestPassportItemGrant* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGCToGCRequestPassportItemGrant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGCToGCRequestPassportItemGrant>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGCToGCRequestPassportItemGrant& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGCToGCRequestPassportItemGrant& from) {
    CMsgGCToGCRequestPassportItemGrant::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGCToGCRequestPassportItemGrant* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGCToGCRequestPassportItemGrant";
  }
  protected:
  explicit CMsgGCToGCRequestPassportItemGrant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSteamIdFieldNumber = 1,
    kLeagueIdFieldNumber = 2,
    kRewardFlagFieldNumber = 3,
  };
  // optional fixed64 steam_id = 1;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // optional uint32 league_id = 2;
  bool has_league_id() const;
  private:
  bool _internal_has_league_id() const;
  public:
  void clear_league_id();
  uint32_t league_id() const;
  void set_league_id(uint32_t value);
  private:
  uint32_t _internal_league_id() const;
  void _internal_set_league_id(uint32_t value);
  public:

  // optional int32 reward_flag = 3;
  bool has_reward_flag() const;
  private:
  bool _internal_has_reward_flag() const;
  public:
  void clear_reward_flag();
  int32_t reward_flag() const;
  void set_reward_flag(int32_t value);
  private:
  int32_t _internal_reward_flag() const;
  void _internal_set_reward_flag(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGCToGCRequestPassportItemGrant)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t steam_id_;
    uint32_t league_id_;
    int32_t reward_flag_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgGameServerInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgGameServerInfo) */ {
 public:
  inline CMsgGameServerInfo() : CMsgGameServerInfo(nullptr) {}
  ~CMsgGameServerInfo() override;
  explicit PROTOBUF_CONSTEXPR CMsgGameServerInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgGameServerInfo(const CMsgGameServerInfo& from);
  CMsgGameServerInfo(CMsgGameServerInfo&& from) noexcept
    : CMsgGameServerInfo() {
    *this = ::std::move(from);
  }

  inline CMsgGameServerInfo& operator=(const CMsgGameServerInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgGameServerInfo& operator=(CMsgGameServerInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgGameServerInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgGameServerInfo* internal_default_instance() {
    return reinterpret_cast<const CMsgGameServerInfo*>(
               &_CMsgGameServerInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

  friend void swap(CMsgGameServerInfo& a, CMsgGameServerInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgGameServerInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgGameServerInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgGameServerInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgGameServerInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgGameServerInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgGameServerInfo& from) {
    CMsgGameServerInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgGameServerInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgGameServerInfo";
  }
  protected:
  explicit CMsgGameServerInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgGameServerInfo_ServerType ServerType;
  static constexpr ServerType UNSPECIFIED =
    CMsgGameServerInfo_ServerType_UNSPECIFIED;
  static constexpr ServerType GAME =
    CMsgGameServerInfo_ServerType_GAME;
  static constexpr ServerType PROXY =
    CMsgGameServerInfo_ServerType_PROXY;
  static inline bool ServerType_IsValid(int value) {
    return CMsgGameServerInfo_ServerType_IsValid(value);
  }
  static constexpr ServerType ServerType_MIN =
    CMsgGameServerInfo_ServerType_ServerType_MIN;
  static constexpr ServerType ServerType_MAX =
    CMsgGameServerInfo_ServerType_ServerType_MAX;
  static constexpr int ServerType_ARRAYSIZE =
    CMsgGameServerInfo_ServerType_ServerType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ServerType_descriptor() {
    return CMsgGameServerInfo_ServerType_descriptor();
  }
  template<typename T>
  static inline const std::string& ServerType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ServerType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ServerType_Name.");
    return CMsgGameServerInfo_ServerType_Name(enum_t_value);
  }
  static inline bool ServerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ServerType* value) {
    return CMsgGameServerInfo_ServerType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kServerKeyFieldNumber = 5,
    kServerPublicIpAddrFieldNumber = 1,
    kServerPrivateIpAddrFieldNumber = 2,
    kServerPortFieldNumber = 3,
    kServerTvPortFieldNumber = 4,
    kServerHibernationFieldNumber = 6,
    kServerTypeFieldNumber = 7,
    kServerRegionFieldNumber = 8,
    kServerLoadavgFieldNumber = 9,
    kServerTvBroadcastTimeFieldNumber = 10,
    kServerGameTimeFieldNumber = 11,
    kServerRelayConnectedSteamIdFieldNumber = 12,
    kRelaySlotsMaxFieldNumber = 13,
    kRelaysConnectedFieldNumber = 14,
    kRelayedGameServerSteamIdFieldNumber = 16,
    kRelayClientsConnectedFieldNumber = 15,
    kParentRelayCountFieldNumber = 17,
    kTvSecretCodeFieldNumber = 18,
  };
  // optional string server_key = 5;
  bool has_server_key() const;
  private:
  bool _internal_has_server_key() const;
  public:
  void clear_server_key();
  const std::string& server_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_key();
  PROTOBUF_NODISCARD std::string* release_server_key();
  void set_allocated_server_key(std::string* server_key);
  private:
  const std::string& _internal_server_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_key(const std::string& value);
  std::string* _internal_mutable_server_key();
  public:

  // optional fixed32 server_public_ip_addr = 1;
  bool has_server_public_ip_addr() const;
  private:
  bool _internal_has_server_public_ip_addr() const;
  public:
  void clear_server_public_ip_addr();
  uint32_t server_public_ip_addr() const;
  void set_server_public_ip_addr(uint32_t value);
  private:
  uint32_t _internal_server_public_ip_addr() const;
  void _internal_set_server_public_ip_addr(uint32_t value);
  public:

  // optional fixed32 server_private_ip_addr = 2;
  bool has_server_private_ip_addr() const;
  private:
  bool _internal_has_server_private_ip_addr() const;
  public:
  void clear_server_private_ip_addr();
  uint32_t server_private_ip_addr() const;
  void set_server_private_ip_addr(uint32_t value);
  private:
  uint32_t _internal_server_private_ip_addr() const;
  void _internal_set_server_private_ip_addr(uint32_t value);
  public:

  // optional uint32 server_port = 3;
  bool has_server_port() const;
  private:
  bool _internal_has_server_port() const;
  public:
  void clear_server_port();
  uint32_t server_port() const;
  void set_server_port(uint32_t value);
  private:
  uint32_t _internal_server_port() const;
  void _internal_set_server_port(uint32_t value);
  public:

  // optional uint32 server_tv_port = 4;
  bool has_server_tv_port() const;
  private:
  bool _internal_has_server_tv_port() const;
  public:
  void clear_server_tv_port();
  uint32_t server_tv_port() const;
  void set_server_tv_port(uint32_t value);
  private:
  uint32_t _internal_server_tv_port() const;
  void _internal_set_server_tv_port(uint32_t value);
  public:

  // optional bool server_hibernation = 6;
  bool has_server_hibernation() const;
  private:
  bool _internal_has_server_hibernation() const;
  public:
  void clear_server_hibernation();
  bool server_hibernation() const;
  void set_server_hibernation(bool value);
  private:
  bool _internal_server_hibernation() const;
  void _internal_set_server_hibernation(bool value);
  public:

  // optional .CMsgGameServerInfo.ServerType server_type = 7 [default = UNSPECIFIED];
  bool has_server_type() const;
  private:
  bool _internal_has_server_type() const;
  public:
  void clear_server_type();
  ::CMsgGameServerInfo_ServerType server_type() const;
  void set_server_type(::CMsgGameServerInfo_ServerType value);
  private:
  ::CMsgGameServerInfo_ServerType _internal_server_type() const;
  void _internal_set_server_type(::CMsgGameServerInfo_ServerType value);
  public:

  // optional uint32 server_region = 8;
  bool has_server_region() const;
  private:
  bool _internal_has_server_region() const;
  public:
  void clear_server_region();
  uint32_t server_region() const;
  void set_server_region(uint32_t value);
  private:
  uint32_t _internal_server_region() const;
  void _internal_set_server_region(uint32_t value);
  public:

  // optional float server_loadavg = 9;
  bool has_server_loadavg() const;
  private:
  bool _internal_has_server_loadavg() const;
  public:
  void clear_server_loadavg();
  float server_loadavg() const;
  void set_server_loadavg(float value);
  private:
  float _internal_server_loadavg() const;
  void _internal_set_server_loadavg(float value);
  public:

  // optional float server_tv_broadcast_time = 10;
  bool has_server_tv_broadcast_time() const;
  private:
  bool _internal_has_server_tv_broadcast_time() const;
  public:
  void clear_server_tv_broadcast_time();
  float server_tv_broadcast_time() const;
  void set_server_tv_broadcast_time(float value);
  private:
  float _internal_server_tv_broadcast_time() const;
  void _internal_set_server_tv_broadcast_time(float value);
  public:

  // optional float server_game_time = 11;
  bool has_server_game_time() const;
  private:
  bool _internal_has_server_game_time() const;
  public:
  void clear_server_game_time();
  float server_game_time() const;
  void set_server_game_time(float value);
  private:
  float _internal_server_game_time() const;
  void _internal_set_server_game_time(float value);
  public:

  // optional fixed64 server_relay_connected_steam_id = 12;
  bool has_server_relay_connected_steam_id() const;
  private:
  bool _internal_has_server_relay_connected_steam_id() const;
  public:
  void clear_server_relay_connected_steam_id();
  uint64_t server_relay_connected_steam_id() const;
  void set_server_relay_connected_steam_id(uint64_t value);
  private:
  uint64_t _internal_server_relay_connected_steam_id() const;
  void _internal_set_server_relay_connected_steam_id(uint64_t value);
  public:

  // optional uint32 relay_slots_max = 13;
  bool has_relay_slots_max() const;
  private:
  bool _internal_has_relay_slots_max() const;
  public:
  void clear_relay_slots_max();
  uint32_t relay_slots_max() const;
  void set_relay_slots_max(uint32_t value);
  private:
  uint32_t _internal_relay_slots_max() const;
  void _internal_set_relay_slots_max(uint32_t value);
  public:

  // optional int32 relays_connected = 14;
  bool has_relays_connected() const;
  private:
  bool _internal_has_relays_connected() const;
  public:
  void clear_relays_connected();
  int32_t relays_connected() const;
  void set_relays_connected(int32_t value);
  private:
  int32_t _internal_relays_connected() const;
  void _internal_set_relays_connected(int32_t value);
  public:

  // optional fixed64 relayed_game_server_steam_id = 16;
  bool has_relayed_game_server_steam_id() const;
  private:
  bool _internal_has_relayed_game_server_steam_id() const;
  public:
  void clear_relayed_game_server_steam_id();
  uint64_t relayed_game_server_steam_id() const;
  void set_relayed_game_server_steam_id(uint64_t value);
  private:
  uint64_t _internal_relayed_game_server_steam_id() const;
  void _internal_set_relayed_game_server_steam_id(uint64_t value);
  public:

  // optional int32 relay_clients_connected = 15;
  bool has_relay_clients_connected() const;
  private:
  bool _internal_has_relay_clients_connected() const;
  public:
  void clear_relay_clients_connected();
  int32_t relay_clients_connected() const;
  void set_relay_clients_connected(int32_t value);
  private:
  int32_t _internal_relay_clients_connected() const;
  void _internal_set_relay_clients_connected(int32_t value);
  public:

  // optional uint32 parent_relay_count = 17;
  bool has_parent_relay_count() const;
  private:
  bool _internal_has_parent_relay_count() const;
  public:
  void clear_parent_relay_count();
  uint32_t parent_relay_count() const;
  void set_parent_relay_count(uint32_t value);
  private:
  uint32_t _internal_parent_relay_count() const;
  void _internal_set_parent_relay_count(uint32_t value);
  public:

  // optional fixed64 tv_secret_code = 18;
  bool has_tv_secret_code() const;
  private:
  bool _internal_has_tv_secret_code() const;
  public:
  void clear_tv_secret_code();
  uint64_t tv_secret_code() const;
  void set_tv_secret_code(uint64_t value);
  private:
  uint64_t _internal_tv_secret_code() const;
  void _internal_set_tv_secret_code(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgGameServerInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_key_;
    uint32_t server_public_ip_addr_;
    uint32_t server_private_ip_addr_;
    uint32_t server_port_;
    uint32_t server_tv_port_;
    bool server_hibernation_;
    int server_type_;
    uint32_t server_region_;
    float server_loadavg_;
    float server_tv_broadcast_time_;
    float server_game_time_;
    uint64_t server_relay_connected_steam_id_;
    uint32_t relay_slots_max_;
    int32_t relays_connected_;
    uint64_t relayed_game_server_steam_id_;
    int32_t relay_clients_connected_;
    uint32_t parent_relay_count_;
    uint64_t tv_secret_code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconEquipSlot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconEquipSlot) */ {
 public:
  inline CSOEconEquipSlot() : CSOEconEquipSlot(nullptr) {}
  ~CSOEconEquipSlot() override;
  explicit PROTOBUF_CONSTEXPR CSOEconEquipSlot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconEquipSlot(const CSOEconEquipSlot& from);
  CSOEconEquipSlot(CSOEconEquipSlot&& from) noexcept
    : CSOEconEquipSlot() {
    *this = ::std::move(from);
  }

  inline CSOEconEquipSlot& operator=(const CSOEconEquipSlot& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconEquipSlot& operator=(CSOEconEquipSlot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconEquipSlot& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconEquipSlot* internal_default_instance() {
    return reinterpret_cast<const CSOEconEquipSlot*>(
               &_CSOEconEquipSlot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

  friend void swap(CSOEconEquipSlot& a, CSOEconEquipSlot& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconEquipSlot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconEquipSlot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconEquipSlot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconEquipSlot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconEquipSlot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconEquipSlot& from) {
    CSOEconEquipSlot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconEquipSlot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconEquipSlot";
  }
  protected:
  explicit CSOEconEquipSlot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAccountIdFieldNumber = 1,
    kClassIdFieldNumber = 2,
    kItemIdFieldNumber = 4,
    kSlotIdFieldNumber = 3,
    kItemDefinitionFieldNumber = 5,
  };
  // optional uint32 account_id = 1 [(.key_field) = true];
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 class_id = 2 [(.key_field) = true];
  bool has_class_id() const;
  private:
  bool _internal_has_class_id() const;
  public:
  void clear_class_id();
  uint32_t class_id() const;
  void set_class_id(uint32_t value);
  private:
  uint32_t _internal_class_id() const;
  void _internal_set_class_id(uint32_t value);
  public:

  // optional uint64 item_id = 4;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // optional uint32 slot_id = 3 [(.key_field) = true];
  bool has_slot_id() const;
  private:
  bool _internal_has_slot_id() const;
  public:
  void clear_slot_id();
  uint32_t slot_id() const;
  void set_slot_id(uint32_t value);
  private:
  uint32_t _internal_slot_id() const;
  void _internal_set_slot_id(uint32_t value);
  public:

  // optional uint32 item_definition = 5;
  bool has_item_definition() const;
  private:
  bool _internal_has_item_definition() const;
  public:
  void clear_item_definition();
  uint32_t item_definition() const;
  void set_item_definition(uint32_t value);
  private:
  uint32_t _internal_item_definition() const;
  void _internal_set_item_definition(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconEquipSlot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t account_id_;
    uint32_t class_id_;
    uint64_t item_id_;
    uint32_t slot_id_;
    uint32_t item_definition_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgAdjustEquipSlot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgAdjustEquipSlot) */ {
 public:
  inline CMsgAdjustEquipSlot() : CMsgAdjustEquipSlot(nullptr) {}
  ~CMsgAdjustEquipSlot() override;
  explicit PROTOBUF_CONSTEXPR CMsgAdjustEquipSlot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgAdjustEquipSlot(const CMsgAdjustEquipSlot& from);
  CMsgAdjustEquipSlot(CMsgAdjustEquipSlot&& from) noexcept
    : CMsgAdjustEquipSlot() {
    *this = ::std::move(from);
  }

  inline CMsgAdjustEquipSlot& operator=(const CMsgAdjustEquipSlot& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgAdjustEquipSlot& operator=(CMsgAdjustEquipSlot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgAdjustEquipSlot& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgAdjustEquipSlot* internal_default_instance() {
    return reinterpret_cast<const CMsgAdjustEquipSlot*>(
               &_CMsgAdjustEquipSlot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

  friend void swap(CMsgAdjustEquipSlot& a, CMsgAdjustEquipSlot& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgAdjustEquipSlot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgAdjustEquipSlot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgAdjustEquipSlot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgAdjustEquipSlot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgAdjustEquipSlot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgAdjustEquipSlot& from) {
    CMsgAdjustEquipSlot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgAdjustEquipSlot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgAdjustEquipSlot";
  }
  protected:
  explicit CMsgAdjustEquipSlot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClassIdFieldNumber = 1,
    kSlotIdFieldNumber = 2,
    kItemIdFieldNumber = 3,
  };
  // optional uint32 class_id = 1;
  bool has_class_id() const;
  private:
  bool _internal_has_class_id() const;
  public:
  void clear_class_id();
  uint32_t class_id() const;
  void set_class_id(uint32_t value);
  private:
  uint32_t _internal_class_id() const;
  void _internal_set_class_id(uint32_t value);
  public:

  // optional uint32 slot_id = 2;
  bool has_slot_id() const;
  private:
  bool _internal_has_slot_id() const;
  public:
  void clear_slot_id();
  uint32_t slot_id() const;
  void set_slot_id(uint32_t value);
  private:
  uint32_t _internal_slot_id() const;
  void _internal_set_slot_id(uint32_t value);
  public:

  // optional uint64 item_id = 3;
  bool has_item_id() const;
  private:
  bool _internal_has_item_id() const;
  public:
  void clear_item_id();
  uint64_t item_id() const;
  void set_item_id(uint64_t value);
  private:
  uint64_t _internal_item_id() const;
  void _internal_set_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgAdjustEquipSlot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t class_id_;
    uint32_t slot_id_;
    uint64_t item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgAdjustEquipSlots final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgAdjustEquipSlots) */ {
 public:
  inline CMsgAdjustEquipSlots() : CMsgAdjustEquipSlots(nullptr) {}
  ~CMsgAdjustEquipSlots() override;
  explicit PROTOBUF_CONSTEXPR CMsgAdjustEquipSlots(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgAdjustEquipSlots(const CMsgAdjustEquipSlots& from);
  CMsgAdjustEquipSlots(CMsgAdjustEquipSlots&& from) noexcept
    : CMsgAdjustEquipSlots() {
    *this = ::std::move(from);
  }

  inline CMsgAdjustEquipSlots& operator=(const CMsgAdjustEquipSlots& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgAdjustEquipSlots& operator=(CMsgAdjustEquipSlots&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgAdjustEquipSlots& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgAdjustEquipSlots* internal_default_instance() {
    return reinterpret_cast<const CMsgAdjustEquipSlots*>(
               &_CMsgAdjustEquipSlots_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

  friend void swap(CMsgAdjustEquipSlots& a, CMsgAdjustEquipSlots& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgAdjustEquipSlots* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgAdjustEquipSlots* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgAdjustEquipSlots* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgAdjustEquipSlots>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgAdjustEquipSlots& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgAdjustEquipSlots& from) {
    CMsgAdjustEquipSlots::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgAdjustEquipSlots* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgAdjustEquipSlots";
  }
  protected:
  explicit CMsgAdjustEquipSlots(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSlotsFieldNumber = 1,
    kChangeNumFieldNumber = 2,
  };
  // repeated .CMsgAdjustEquipSlot slots = 1;
  int slots_size() const;
  private:
  int _internal_slots_size() const;
  public:
  void clear_slots();
  ::CMsgAdjustEquipSlot* mutable_slots(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgAdjustEquipSlot >*
      mutable_slots();
  private:
  const ::CMsgAdjustEquipSlot& _internal_slots(int index) const;
  ::CMsgAdjustEquipSlot* _internal_add_slots();
  public:
  const ::CMsgAdjustEquipSlot& slots(int index) const;
  ::CMsgAdjustEquipSlot* add_slots();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgAdjustEquipSlot >&
      slots() const;

  // optional uint32 change_num = 2;
  bool has_change_num() const;
  private:
  bool _internal_has_change_num() const;
  public:
  void clear_change_num();
  uint32_t change_num() const;
  void set_change_num(uint32_t value);
  private:
  uint32_t _internal_change_num() const;
  void _internal_set_change_num(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgAdjustEquipSlots)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgAdjustEquipSlot > slots_;
    uint32_t change_num_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgOpenCrate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgOpenCrate) */ {
 public:
  inline CMsgOpenCrate() : CMsgOpenCrate(nullptr) {}
  ~CMsgOpenCrate() override;
  explicit PROTOBUF_CONSTEXPR CMsgOpenCrate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgOpenCrate(const CMsgOpenCrate& from);
  CMsgOpenCrate(CMsgOpenCrate&& from) noexcept
    : CMsgOpenCrate() {
    *this = ::std::move(from);
  }

  inline CMsgOpenCrate& operator=(const CMsgOpenCrate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgOpenCrate& operator=(CMsgOpenCrate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgOpenCrate& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgOpenCrate* internal_default_instance() {
    return reinterpret_cast<const CMsgOpenCrate*>(
               &_CMsgOpenCrate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  friend void swap(CMsgOpenCrate& a, CMsgOpenCrate& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgOpenCrate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgOpenCrate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgOpenCrate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgOpenCrate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgOpenCrate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgOpenCrate& from) {
    CMsgOpenCrate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgOpenCrate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgOpenCrate";
  }
  protected:
  explicit CMsgOpenCrate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kToolItemIdFieldNumber = 1,
    kSubjectItemIdFieldNumber = 2,
    kForRentalFieldNumber = 3,
    kPointsRemainingFieldNumber = 4,
  };
  // optional uint64 tool_item_id = 1;
  bool has_tool_item_id() const;
  private:
  bool _internal_has_tool_item_id() const;
  public:
  void clear_tool_item_id();
  uint64_t tool_item_id() const;
  void set_tool_item_id(uint64_t value);
  private:
  uint64_t _internal_tool_item_id() const;
  void _internal_set_tool_item_id(uint64_t value);
  public:

  // optional uint64 subject_item_id = 2;
  bool has_subject_item_id() const;
  private:
  bool _internal_has_subject_item_id() const;
  public:
  void clear_subject_item_id();
  uint64_t subject_item_id() const;
  void set_subject_item_id(uint64_t value);
  private:
  uint64_t _internal_subject_item_id() const;
  void _internal_set_subject_item_id(uint64_t value);
  public:

  // optional bool for_rental = 3;
  bool has_for_rental() const;
  private:
  bool _internal_has_for_rental() const;
  public:
  void clear_for_rental();
  bool for_rental() const;
  void set_for_rental(bool value);
  private:
  bool _internal_for_rental() const;
  void _internal_set_for_rental(bool value);
  public:

  // optional uint32 points_remaining = 4;
  bool has_points_remaining() const;
  private:
  bool _internal_has_points_remaining() const;
  public:
  void clear_points_remaining();
  uint32_t points_remaining() const;
  void set_points_remaining(uint32_t value);
  private:
  uint32_t _internal_points_remaining() const;
  void _internal_set_points_remaining(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgOpenCrate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t tool_item_id_;
    uint64_t subject_item_id_;
    bool for_rental_;
    uint32_t points_remaining_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CSOEconRentalHistory final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSOEconRentalHistory) */ {
 public:
  inline CSOEconRentalHistory() : CSOEconRentalHistory(nullptr) {}
  ~CSOEconRentalHistory() override;
  explicit PROTOBUF_CONSTEXPR CSOEconRentalHistory(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSOEconRentalHistory(const CSOEconRentalHistory& from);
  CSOEconRentalHistory(CSOEconRentalHistory&& from) noexcept
    : CSOEconRentalHistory() {
    *this = ::std::move(from);
  }

  inline CSOEconRentalHistory& operator=(const CSOEconRentalHistory& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSOEconRentalHistory& operator=(CSOEconRentalHistory&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSOEconRentalHistory& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSOEconRentalHistory* internal_default_instance() {
    return reinterpret_cast<const CSOEconRentalHistory*>(
               &_CSOEconRentalHistory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  friend void swap(CSOEconRentalHistory& a, CSOEconRentalHistory& b) {
    a.Swap(&b);
  }
  inline void Swap(CSOEconRentalHistory* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSOEconRentalHistory* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSOEconRentalHistory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSOEconRentalHistory>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSOEconRentalHistory& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSOEconRentalHistory& from) {
    CSOEconRentalHistory::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSOEconRentalHistory* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSOEconRentalHistory";
  }
  protected:
  explicit CSOEconRentalHistory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCrateItemIdFieldNumber = 2,
    kAccountIdFieldNumber = 1,
    kCrateDefIndexFieldNumber = 3,
    kIssueDateFieldNumber = 4,
    kExpirationDateFieldNumber = 5,
  };
  // optional uint64 crate_item_id = 2 [(.key_field) = true];
  bool has_crate_item_id() const;
  private:
  bool _internal_has_crate_item_id() const;
  public:
  void clear_crate_item_id();
  uint64_t crate_item_id() const;
  void set_crate_item_id(uint64_t value);
  private:
  uint64_t _internal_crate_item_id() const;
  void _internal_set_crate_item_id(uint64_t value);
  public:

  // optional uint32 account_id = 1 [(.key_field) = true];
  bool has_account_id() const;
  private:
  bool _internal_has_account_id() const;
  public:
  void clear_account_id();
  uint32_t account_id() const;
  void set_account_id(uint32_t value);
  private:
  uint32_t _internal_account_id() const;
  void _internal_set_account_id(uint32_t value);
  public:

  // optional uint32 crate_def_index = 3;
  bool has_crate_def_index() const;
  private:
  bool _internal_has_crate_def_index() const;
  public:
  void clear_crate_def_index();
  uint32_t crate_def_index() const;
  void set_crate_def_index(uint32_t value);
  private:
  uint32_t _internal_crate_def_index() const;
  void _internal_set_crate_def_index(uint32_t value);
  public:

  // optional uint32 issue_date = 4;
  bool has_issue_date() const;
  private:
  bool _internal_has_issue_date() const;
  public:
  void clear_issue_date();
  uint32_t issue_date() const;
  void set_issue_date(uint32_t value);
  private:
  uint32_t _internal_issue_date() const;
  void _internal_set_issue_date(uint32_t value);
  public:

  // optional uint32 expiration_date = 5;
  bool has_expiration_date() const;
  private:
  bool _internal_has_expiration_date() const;
  public:
  void clear_expiration_date();
  uint32_t expiration_date() const;
  void set_expiration_date(uint32_t value);
  private:
  uint32_t _internal_expiration_date() const;
  void _internal_set_expiration_date(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSOEconRentalHistory)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t crate_item_id_;
    uint32_t account_id_;
    uint32_t crate_def_index_;
    uint32_t issue_date_;
    uint32_t expiration_date_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgAcknowledgeRentalExpiration final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgAcknowledgeRentalExpiration) */ {
 public:
  inline CMsgAcknowledgeRentalExpiration() : CMsgAcknowledgeRentalExpiration(nullptr) {}
  ~CMsgAcknowledgeRentalExpiration() override;
  explicit PROTOBUF_CONSTEXPR CMsgAcknowledgeRentalExpiration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgAcknowledgeRentalExpiration(const CMsgAcknowledgeRentalExpiration& from);
  CMsgAcknowledgeRentalExpiration(CMsgAcknowledgeRentalExpiration&& from) noexcept
    : CMsgAcknowledgeRentalExpiration() {
    *this = ::std::move(from);
  }

  inline CMsgAcknowledgeRentalExpiration& operator=(const CMsgAcknowledgeRentalExpiration& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgAcknowledgeRentalExpiration& operator=(CMsgAcknowledgeRentalExpiration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgAcknowledgeRentalExpiration& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgAcknowledgeRentalExpiration* internal_default_instance() {
    return reinterpret_cast<const CMsgAcknowledgeRentalExpiration*>(
               &_CMsgAcknowledgeRentalExpiration_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  friend void swap(CMsgAcknowledgeRentalExpiration& a, CMsgAcknowledgeRentalExpiration& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgAcknowledgeRentalExpiration* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgAcknowledgeRentalExpiration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgAcknowledgeRentalExpiration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgAcknowledgeRentalExpiration>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgAcknowledgeRentalExpiration& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgAcknowledgeRentalExpiration& from) {
    CMsgAcknowledgeRentalExpiration::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgAcknowledgeRentalExpiration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgAcknowledgeRentalExpiration";
  }
  protected:
  explicit CMsgAcknowledgeRentalExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCrateItemIdFieldNumber = 1,
  };
  // optional uint64 crate_item_id = 1;
  bool has_crate_item_id() const;
  private:
  bool _internal_has_crate_item_id() const;
  public:
  void clear_crate_item_id();
  uint64_t crate_item_id() const;
  void set_crate_item_id(uint64_t value);
  private:
  uint64_t _internal_crate_item_id() const;
  void _internal_set_crate_item_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgAcknowledgeRentalExpiration)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t crate_item_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_base_5fgcmessages_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CGCStorePurchaseInit_LineItem

// optional uint32 item_def_id = 1;
inline bool CGCStorePurchaseInit_LineItem::_internal_has_item_def_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CGCStorePurchaseInit_LineItem::has_item_def_id() const {
  return _internal_has_item_def_id();
}
inline void CGCStorePurchaseInit_LineItem::clear_item_def_id() {
  _impl_.item_def_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CGCStorePurchaseInit_LineItem::_internal_item_def_id() const {
  return _impl_.item_def_id_;
}
inline uint32_t CGCStorePurchaseInit_LineItem::item_def_id() const {
  // @@protoc_insertion_point(field_get:CGCStorePurchaseInit_LineItem.item_def_id)
  return _internal_item_def_id();
}
inline void CGCStorePurchaseInit_LineItem::_internal_set_item_def_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_def_id_ = value;
}
inline void CGCStorePurchaseInit_LineItem::set_item_def_id(uint32_t value) {
  _internal_set_item_def_id(value);
  // @@protoc_insertion_point(field_set:CGCStorePurchaseInit_LineItem.item_def_id)
}

// optional uint32 quantity = 2;
inline bool CGCStorePurchaseInit_LineItem::_internal_has_quantity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CGCStorePurchaseInit_LineItem::has_quantity() const {
  return _internal_has_quantity();
}
inline void CGCStorePurchaseInit_LineItem::clear_quantity() {
  _impl_.quantity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CGCStorePurchaseInit_LineItem::_internal_quantity() const {
  return _impl_.quantity_;
}
inline uint32_t CGCStorePurchaseInit_LineItem::quantity() const {
  // @@protoc_insertion_point(field_get:CGCStorePurchaseInit_LineItem.quantity)
  return _internal_quantity();
}
inline void CGCStorePurchaseInit_LineItem::_internal_set_quantity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.quantity_ = value;
}
inline void CGCStorePurchaseInit_LineItem::set_quantity(uint32_t value) {
  _internal_set_quantity(value);
  // @@protoc_insertion_point(field_set:CGCStorePurchaseInit_LineItem.quantity)
}

// optional uint64 cost_in_local_currency = 3;
inline bool CGCStorePurchaseInit_LineItem::_internal_has_cost_in_local_currency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CGCStorePurchaseInit_LineItem::has_cost_in_local_currency() const {
  return _internal_has_cost_in_local_currency();
}
inline void CGCStorePurchaseInit_LineItem::clear_cost_in_local_currency() {
  _impl_.cost_in_local_currency_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CGCStorePurchaseInit_LineItem::_internal_cost_in_local_currency() const {
  return _impl_.cost_in_local_currency_;
}
inline uint64_t CGCStorePurchaseInit_LineItem::cost_in_local_currency() const {
  // @@protoc_insertion_point(field_get:CGCStorePurchaseInit_LineItem.cost_in_local_currency)
  return _internal_cost_in_local_currency();
}
inline void CGCStorePurchaseInit_LineItem::_internal_set_cost_in_local_currency(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.cost_in_local_currency_ = value;
}
inline void CGCStorePurchaseInit_LineItem::set_cost_in_local_currency(uint64_t value) {
  _internal_set_cost_in_local_currency(value);
  // @@protoc_insertion_point(field_set:CGCStorePurchaseInit_LineItem.cost_in_local_currency)
}

// optional uint32 purchase_type = 4;
inline bool CGCStorePurchaseInit_LineItem::_internal_has_purchase_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CGCStorePurchaseInit_LineItem::has_purchase_type() const {
  return _internal_has_purchase_type();
}
inline void CGCStorePurchaseInit_LineItem::clear_purchase_type() {
  _impl_.purchase_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CGCStorePurchaseInit_LineItem::_internal_purchase_type() const {
  return _impl_.purchase_type_;
}
inline uint32_t CGCStorePurchaseInit_LineItem::purchase_type() const {
  // @@protoc_insertion_point(field_get:CGCStorePurchaseInit_LineItem.purchase_type)
  return _internal_purchase_type();
}
inline void CGCStorePurchaseInit_LineItem::_internal_set_purchase_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.purchase_type_ = value;
}
inline void CGCStorePurchaseInit_LineItem::set_purchase_type(uint32_t value) {
  _internal_set_purchase_type(value);
  // @@protoc_insertion_point(field_set:CGCStorePurchaseInit_LineItem.purchase_type)
}

// optional uint64 supplemental_data = 5;
inline bool CGCStorePurchaseInit_LineItem::_internal_has_supplemental_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CGCStorePurchaseInit_LineItem::has_supplemental_data() const {
  return _internal_has_supplemental_data();
}
inline void CGCStorePurchaseInit_LineItem::clear_supplemental_data() {
  _impl_.supplemental_data_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CGCStorePurchaseInit_LineItem::_internal_supplemental_data() const {
  return _impl_.supplemental_data_;
}
inline uint64_t CGCStorePurchaseInit_LineItem::supplemental_data() const {
  // @@protoc_insertion_point(field_get:CGCStorePurchaseInit_LineItem.supplemental_data)
  return _internal_supplemental_data();
}
inline void CGCStorePurchaseInit_LineItem::_internal_set_supplemental_data(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.supplemental_data_ = value;
}
inline void CGCStorePurchaseInit_LineItem::set_supplemental_data(uint64_t value) {
  _internal_set_supplemental_data(value);
  // @@protoc_insertion_point(field_set:CGCStorePurchaseInit_LineItem.supplemental_data)
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseInit

// optional string country = 1;
inline bool CMsgGCStorePurchaseInit::_internal_has_country() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInit::has_country() const {
  return _internal_has_country();
}
inline void CMsgGCStorePurchaseInit::clear_country() {
  _impl_.country_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCStorePurchaseInit::country() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInit.country)
  return _internal_country();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCStorePurchaseInit::set_country(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInit.country)
}
inline std::string* CMsgGCStorePurchaseInit::mutable_country() {
  std::string* _s = _internal_mutable_country();
  // @@protoc_insertion_point(field_mutable:CMsgGCStorePurchaseInit.country)
  return _s;
}
inline const std::string& CMsgGCStorePurchaseInit::_internal_country() const {
  return _impl_.country_.Get();
}
inline void CMsgGCStorePurchaseInit::_internal_set_country(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.country_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCStorePurchaseInit::_internal_mutable_country() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.country_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCStorePurchaseInit::release_country() {
  // @@protoc_insertion_point(field_release:CMsgGCStorePurchaseInit.country)
  if (!_internal_has_country()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.country_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_.IsDefault()) {
    _impl_.country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCStorePurchaseInit::set_allocated_country(std::string* country) {
  if (country != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.country_.SetAllocated(country, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_.IsDefault()) {
    _impl_.country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCStorePurchaseInit.country)
}

// optional int32 language = 2;
inline bool CMsgGCStorePurchaseInit::_internal_has_language() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInit::has_language() const {
  return _internal_has_language();
}
inline void CMsgGCStorePurchaseInit::clear_language() {
  _impl_.language_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgGCStorePurchaseInit::_internal_language() const {
  return _impl_.language_;
}
inline int32_t CMsgGCStorePurchaseInit::language() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInit.language)
  return _internal_language();
}
inline void CMsgGCStorePurchaseInit::_internal_set_language(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.language_ = value;
}
inline void CMsgGCStorePurchaseInit::set_language(int32_t value) {
  _internal_set_language(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInit.language)
}

// optional int32 currency = 3;
inline bool CMsgGCStorePurchaseInit::_internal_has_currency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInit::has_currency() const {
  return _internal_has_currency();
}
inline void CMsgGCStorePurchaseInit::clear_currency() {
  _impl_.currency_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgGCStorePurchaseInit::_internal_currency() const {
  return _impl_.currency_;
}
inline int32_t CMsgGCStorePurchaseInit::currency() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInit.currency)
  return _internal_currency();
}
inline void CMsgGCStorePurchaseInit::_internal_set_currency(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.currency_ = value;
}
inline void CMsgGCStorePurchaseInit::set_currency(int32_t value) {
  _internal_set_currency(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInit.currency)
}

// repeated .CGCStorePurchaseInit_LineItem line_items = 4;
inline int CMsgGCStorePurchaseInit::_internal_line_items_size() const {
  return _impl_.line_items_.size();
}
inline int CMsgGCStorePurchaseInit::line_items_size() const {
  return _internal_line_items_size();
}
inline void CMsgGCStorePurchaseInit::clear_line_items() {
  _impl_.line_items_.Clear();
}
inline ::CGCStorePurchaseInit_LineItem* CMsgGCStorePurchaseInit::mutable_line_items(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgGCStorePurchaseInit.line_items)
  return _impl_.line_items_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CGCStorePurchaseInit_LineItem >*
CMsgGCStorePurchaseInit::mutable_line_items() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCStorePurchaseInit.line_items)
  return &_impl_.line_items_;
}
inline const ::CGCStorePurchaseInit_LineItem& CMsgGCStorePurchaseInit::_internal_line_items(int index) const {
  return _impl_.line_items_.Get(index);
}
inline const ::CGCStorePurchaseInit_LineItem& CMsgGCStorePurchaseInit::line_items(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInit.line_items)
  return _internal_line_items(index);
}
inline ::CGCStorePurchaseInit_LineItem* CMsgGCStorePurchaseInit::_internal_add_line_items() {
  return _impl_.line_items_.Add();
}
inline ::CGCStorePurchaseInit_LineItem* CMsgGCStorePurchaseInit::add_line_items() {
  ::CGCStorePurchaseInit_LineItem* _add = _internal_add_line_items();
  // @@protoc_insertion_point(field_add:CMsgGCStorePurchaseInit.line_items)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CGCStorePurchaseInit_LineItem >&
CMsgGCStorePurchaseInit::line_items() const {
  // @@protoc_insertion_point(field_list:CMsgGCStorePurchaseInit.line_items)
  return _impl_.line_items_;
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseInitResponse

// optional int32 result = 1;
inline bool CMsgGCStorePurchaseInitResponse::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInitResponse::has_result() const {
  return _internal_has_result();
}
inline void CMsgGCStorePurchaseInitResponse::clear_result() {
  _impl_.result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgGCStorePurchaseInitResponse::_internal_result() const {
  return _impl_.result_;
}
inline int32_t CMsgGCStorePurchaseInitResponse::result() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInitResponse.result)
  return _internal_result();
}
inline void CMsgGCStorePurchaseInitResponse::_internal_set_result(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.result_ = value;
}
inline void CMsgGCStorePurchaseInitResponse::set_result(int32_t value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInitResponse.result)
}

// optional uint64 txn_id = 2;
inline bool CMsgGCStorePurchaseInitResponse::_internal_has_txn_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInitResponse::has_txn_id() const {
  return _internal_has_txn_id();
}
inline void CMsgGCStorePurchaseInitResponse::clear_txn_id() {
  _impl_.txn_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgGCStorePurchaseInitResponse::_internal_txn_id() const {
  return _impl_.txn_id_;
}
inline uint64_t CMsgGCStorePurchaseInitResponse::txn_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInitResponse.txn_id)
  return _internal_txn_id();
}
inline void CMsgGCStorePurchaseInitResponse::_internal_set_txn_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.txn_id_ = value;
}
inline void CMsgGCStorePurchaseInitResponse::set_txn_id(uint64_t value) {
  _internal_set_txn_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInitResponse.txn_id)
}

// optional string url = 3;
inline bool CMsgGCStorePurchaseInitResponse::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseInitResponse::has_url() const {
  return _internal_has_url();
}
inline void CMsgGCStorePurchaseInitResponse::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCStorePurchaseInitResponse::url() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInitResponse.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCStorePurchaseInitResponse::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInitResponse.url)
}
inline std::string* CMsgGCStorePurchaseInitResponse::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:CMsgGCStorePurchaseInitResponse.url)
  return _s;
}
inline const std::string& CMsgGCStorePurchaseInitResponse::_internal_url() const {
  return _impl_.url_.Get();
}
inline void CMsgGCStorePurchaseInitResponse::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCStorePurchaseInitResponse::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCStorePurchaseInitResponse::release_url() {
  // @@protoc_insertion_point(field_release:CMsgGCStorePurchaseInitResponse.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCStorePurchaseInitResponse::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.url_.IsDefault()) {
    _impl_.url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCStorePurchaseInitResponse.url)
}

// repeated uint64 item_ids = 4;
inline int CMsgGCStorePurchaseInitResponse::_internal_item_ids_size() const {
  return _impl_.item_ids_.size();
}
inline int CMsgGCStorePurchaseInitResponse::item_ids_size() const {
  return _internal_item_ids_size();
}
inline void CMsgGCStorePurchaseInitResponse::clear_item_ids() {
  _impl_.item_ids_.Clear();
}
inline uint64_t CMsgGCStorePurchaseInitResponse::_internal_item_ids(int index) const {
  return _impl_.item_ids_.Get(index);
}
inline uint64_t CMsgGCStorePurchaseInitResponse::item_ids(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseInitResponse.item_ids)
  return _internal_item_ids(index);
}
inline void CMsgGCStorePurchaseInitResponse::set_item_ids(int index, uint64_t value) {
  _impl_.item_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseInitResponse.item_ids)
}
inline void CMsgGCStorePurchaseInitResponse::_internal_add_item_ids(uint64_t value) {
  _impl_.item_ids_.Add(value);
}
inline void CMsgGCStorePurchaseInitResponse::add_item_ids(uint64_t value) {
  _internal_add_item_ids(value);
  // @@protoc_insertion_point(field_add:CMsgGCStorePurchaseInitResponse.item_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCStorePurchaseInitResponse::_internal_item_ids() const {
  return _impl_.item_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCStorePurchaseInitResponse::item_ids() const {
  // @@protoc_insertion_point(field_list:CMsgGCStorePurchaseInitResponse.item_ids)
  return _internal_item_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCStorePurchaseInitResponse::_internal_mutable_item_ids() {
  return &_impl_.item_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCStorePurchaseInitResponse::mutable_item_ids() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCStorePurchaseInitResponse.item_ids)
  return _internal_mutable_item_ids();
}

// -------------------------------------------------------------------

// CSOPartyInvite

// optional uint64 group_id = 1 [(.key_field) = true];
inline bool CSOPartyInvite::_internal_has_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOPartyInvite::has_group_id() const {
  return _internal_has_group_id();
}
inline void CSOPartyInvite::clear_group_id() {
  _impl_.group_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CSOPartyInvite::_internal_group_id() const {
  return _impl_.group_id_;
}
inline uint64_t CSOPartyInvite::group_id() const {
  // @@protoc_insertion_point(field_get:CSOPartyInvite.group_id)
  return _internal_group_id();
}
inline void CSOPartyInvite::_internal_set_group_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.group_id_ = value;
}
inline void CSOPartyInvite::set_group_id(uint64_t value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:CSOPartyInvite.group_id)
}

// optional fixed64 sender_id = 2;
inline bool CSOPartyInvite::_internal_has_sender_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOPartyInvite::has_sender_id() const {
  return _internal_has_sender_id();
}
inline void CSOPartyInvite::clear_sender_id() {
  _impl_.sender_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CSOPartyInvite::_internal_sender_id() const {
  return _impl_.sender_id_;
}
inline uint64_t CSOPartyInvite::sender_id() const {
  // @@protoc_insertion_point(field_get:CSOPartyInvite.sender_id)
  return _internal_sender_id();
}
inline void CSOPartyInvite::_internal_set_sender_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sender_id_ = value;
}
inline void CSOPartyInvite::set_sender_id(uint64_t value) {
  _internal_set_sender_id(value);
  // @@protoc_insertion_point(field_set:CSOPartyInvite.sender_id)
}

// optional string sender_name = 3;
inline bool CSOPartyInvite::_internal_has_sender_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOPartyInvite::has_sender_name() const {
  return _internal_has_sender_name();
}
inline void CSOPartyInvite::clear_sender_name() {
  _impl_.sender_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOPartyInvite::sender_name() const {
  // @@protoc_insertion_point(field_get:CSOPartyInvite.sender_name)
  return _internal_sender_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOPartyInvite::set_sender_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.sender_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOPartyInvite.sender_name)
}
inline std::string* CSOPartyInvite::mutable_sender_name() {
  std::string* _s = _internal_mutable_sender_name();
  // @@protoc_insertion_point(field_mutable:CSOPartyInvite.sender_name)
  return _s;
}
inline const std::string& CSOPartyInvite::_internal_sender_name() const {
  return _impl_.sender_name_.Get();
}
inline void CSOPartyInvite::_internal_set_sender_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sender_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOPartyInvite::_internal_mutable_sender_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.sender_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOPartyInvite::release_sender_name() {
  // @@protoc_insertion_point(field_release:CSOPartyInvite.sender_name)
  if (!_internal_has_sender_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.sender_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sender_name_.IsDefault()) {
    _impl_.sender_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOPartyInvite::set_allocated_sender_name(std::string* sender_name) {
  if (sender_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.sender_name_.SetAllocated(sender_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sender_name_.IsDefault()) {
    _impl_.sender_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOPartyInvite.sender_name)
}

// -------------------------------------------------------------------

// CSOLobbyInvite

// optional uint64 group_id = 1 [(.key_field) = true];
inline bool CSOLobbyInvite::_internal_has_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOLobbyInvite::has_group_id() const {
  return _internal_has_group_id();
}
inline void CSOLobbyInvite::clear_group_id() {
  _impl_.group_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CSOLobbyInvite::_internal_group_id() const {
  return _impl_.group_id_;
}
inline uint64_t CSOLobbyInvite::group_id() const {
  // @@protoc_insertion_point(field_get:CSOLobbyInvite.group_id)
  return _internal_group_id();
}
inline void CSOLobbyInvite::_internal_set_group_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.group_id_ = value;
}
inline void CSOLobbyInvite::set_group_id(uint64_t value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:CSOLobbyInvite.group_id)
}

// optional fixed64 sender_id = 2;
inline bool CSOLobbyInvite::_internal_has_sender_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOLobbyInvite::has_sender_id() const {
  return _internal_has_sender_id();
}
inline void CSOLobbyInvite::clear_sender_id() {
  _impl_.sender_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CSOLobbyInvite::_internal_sender_id() const {
  return _impl_.sender_id_;
}
inline uint64_t CSOLobbyInvite::sender_id() const {
  // @@protoc_insertion_point(field_get:CSOLobbyInvite.sender_id)
  return _internal_sender_id();
}
inline void CSOLobbyInvite::_internal_set_sender_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sender_id_ = value;
}
inline void CSOLobbyInvite::set_sender_id(uint64_t value) {
  _internal_set_sender_id(value);
  // @@protoc_insertion_point(field_set:CSOLobbyInvite.sender_id)
}

// optional string sender_name = 3;
inline bool CSOLobbyInvite::_internal_has_sender_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOLobbyInvite::has_sender_name() const {
  return _internal_has_sender_name();
}
inline void CSOLobbyInvite::clear_sender_name() {
  _impl_.sender_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOLobbyInvite::sender_name() const {
  // @@protoc_insertion_point(field_get:CSOLobbyInvite.sender_name)
  return _internal_sender_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOLobbyInvite::set_sender_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.sender_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOLobbyInvite.sender_name)
}
inline std::string* CSOLobbyInvite::mutable_sender_name() {
  std::string* _s = _internal_mutable_sender_name();
  // @@protoc_insertion_point(field_mutable:CSOLobbyInvite.sender_name)
  return _s;
}
inline const std::string& CSOLobbyInvite::_internal_sender_name() const {
  return _impl_.sender_name_.Get();
}
inline void CSOLobbyInvite::_internal_set_sender_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sender_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOLobbyInvite::_internal_mutable_sender_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.sender_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOLobbyInvite::release_sender_name() {
  // @@protoc_insertion_point(field_release:CSOLobbyInvite.sender_name)
  if (!_internal_has_sender_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.sender_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sender_name_.IsDefault()) {
    _impl_.sender_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOLobbyInvite::set_allocated_sender_name(std::string* sender_name) {
  if (sender_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.sender_name_.SetAllocated(sender_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sender_name_.IsDefault()) {
    _impl_.sender_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOLobbyInvite.sender_name)
}

// -------------------------------------------------------------------

// CMsgSystemBroadcast

// optional string message = 1;
inline bool CMsgSystemBroadcast::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSystemBroadcast::has_message() const {
  return _internal_has_message();
}
inline void CMsgSystemBroadcast::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSystemBroadcast::message() const {
  // @@protoc_insertion_point(field_get:CMsgSystemBroadcast.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSystemBroadcast::set_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSystemBroadcast.message)
}
inline std::string* CMsgSystemBroadcast::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:CMsgSystemBroadcast.message)
  return _s;
}
inline const std::string& CMsgSystemBroadcast::_internal_message() const {
  return _impl_.message_.Get();
}
inline void CMsgSystemBroadcast::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSystemBroadcast::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSystemBroadcast::release_message() {
  // @@protoc_insertion_point(field_release:CMsgSystemBroadcast.message)
  if (!_internal_has_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSystemBroadcast::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSystemBroadcast.message)
}

// -------------------------------------------------------------------

// CMsgInviteToParty

// optional fixed64 steam_id = 1;
inline bool CMsgInviteToParty::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgInviteToParty::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CMsgInviteToParty::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgInviteToParty::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CMsgInviteToParty::steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgInviteToParty.steam_id)
  return _internal_steam_id();
}
inline void CMsgInviteToParty::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.steam_id_ = value;
}
inline void CMsgInviteToParty::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgInviteToParty.steam_id)
}

// optional uint32 client_version = 2;
inline bool CMsgInviteToParty::_internal_has_client_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgInviteToParty::has_client_version() const {
  return _internal_has_client_version();
}
inline void CMsgInviteToParty::clear_client_version() {
  _impl_.client_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgInviteToParty::_internal_client_version() const {
  return _impl_.client_version_;
}
inline uint32_t CMsgInviteToParty::client_version() const {
  // @@protoc_insertion_point(field_get:CMsgInviteToParty.client_version)
  return _internal_client_version();
}
inline void CMsgInviteToParty::_internal_set_client_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.client_version_ = value;
}
inline void CMsgInviteToParty::set_client_version(uint32_t value) {
  _internal_set_client_version(value);
  // @@protoc_insertion_point(field_set:CMsgInviteToParty.client_version)
}

// optional uint32 team_invite = 3;
inline bool CMsgInviteToParty::_internal_has_team_invite() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgInviteToParty::has_team_invite() const {
  return _internal_has_team_invite();
}
inline void CMsgInviteToParty::clear_team_invite() {
  _impl_.team_invite_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgInviteToParty::_internal_team_invite() const {
  return _impl_.team_invite_;
}
inline uint32_t CMsgInviteToParty::team_invite() const {
  // @@protoc_insertion_point(field_get:CMsgInviteToParty.team_invite)
  return _internal_team_invite();
}
inline void CMsgInviteToParty::_internal_set_team_invite(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.team_invite_ = value;
}
inline void CMsgInviteToParty::set_team_invite(uint32_t value) {
  _internal_set_team_invite(value);
  // @@protoc_insertion_point(field_set:CMsgInviteToParty.team_invite)
}

// -------------------------------------------------------------------

// CMsgInvitationCreated

// optional uint64 group_id = 1;
inline bool CMsgInvitationCreated::_internal_has_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgInvitationCreated::has_group_id() const {
  return _internal_has_group_id();
}
inline void CMsgInvitationCreated::clear_group_id() {
  _impl_.group_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgInvitationCreated::_internal_group_id() const {
  return _impl_.group_id_;
}
inline uint64_t CMsgInvitationCreated::group_id() const {
  // @@protoc_insertion_point(field_get:CMsgInvitationCreated.group_id)
  return _internal_group_id();
}
inline void CMsgInvitationCreated::_internal_set_group_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.group_id_ = value;
}
inline void CMsgInvitationCreated::set_group_id(uint64_t value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:CMsgInvitationCreated.group_id)
}

// optional fixed64 steam_id = 2;
inline bool CMsgInvitationCreated::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgInvitationCreated::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CMsgInvitationCreated::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgInvitationCreated::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CMsgInvitationCreated::steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgInvitationCreated.steam_id)
  return _internal_steam_id();
}
inline void CMsgInvitationCreated::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.steam_id_ = value;
}
inline void CMsgInvitationCreated::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgInvitationCreated.steam_id)
}

// -------------------------------------------------------------------

// CMsgPartyInviteResponse

// optional uint64 party_id = 1;
inline bool CMsgPartyInviteResponse::_internal_has_party_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgPartyInviteResponse::has_party_id() const {
  return _internal_has_party_id();
}
inline void CMsgPartyInviteResponse::clear_party_id() {
  _impl_.party_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgPartyInviteResponse::_internal_party_id() const {
  return _impl_.party_id_;
}
inline uint64_t CMsgPartyInviteResponse::party_id() const {
  // @@protoc_insertion_point(field_get:CMsgPartyInviteResponse.party_id)
  return _internal_party_id();
}
inline void CMsgPartyInviteResponse::_internal_set_party_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.party_id_ = value;
}
inline void CMsgPartyInviteResponse::set_party_id(uint64_t value) {
  _internal_set_party_id(value);
  // @@protoc_insertion_point(field_set:CMsgPartyInviteResponse.party_id)
}

// optional bool accept = 2;
inline bool CMsgPartyInviteResponse::_internal_has_accept() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgPartyInviteResponse::has_accept() const {
  return _internal_has_accept();
}
inline void CMsgPartyInviteResponse::clear_accept() {
  _impl_.accept_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CMsgPartyInviteResponse::_internal_accept() const {
  return _impl_.accept_;
}
inline bool CMsgPartyInviteResponse::accept() const {
  // @@protoc_insertion_point(field_get:CMsgPartyInviteResponse.accept)
  return _internal_accept();
}
inline void CMsgPartyInviteResponse::_internal_set_accept(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.accept_ = value;
}
inline void CMsgPartyInviteResponse::set_accept(bool value) {
  _internal_set_accept(value);
  // @@protoc_insertion_point(field_set:CMsgPartyInviteResponse.accept)
}

// optional uint32 client_version = 3;
inline bool CMsgPartyInviteResponse::_internal_has_client_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgPartyInviteResponse::has_client_version() const {
  return _internal_has_client_version();
}
inline void CMsgPartyInviteResponse::clear_client_version() {
  _impl_.client_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgPartyInviteResponse::_internal_client_version() const {
  return _impl_.client_version_;
}
inline uint32_t CMsgPartyInviteResponse::client_version() const {
  // @@protoc_insertion_point(field_get:CMsgPartyInviteResponse.client_version)
  return _internal_client_version();
}
inline void CMsgPartyInviteResponse::_internal_set_client_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.client_version_ = value;
}
inline void CMsgPartyInviteResponse::set_client_version(uint32_t value) {
  _internal_set_client_version(value);
  // @@protoc_insertion_point(field_set:CMsgPartyInviteResponse.client_version)
}

// optional uint32 team_invite = 4;
inline bool CMsgPartyInviteResponse::_internal_has_team_invite() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgPartyInviteResponse::has_team_invite() const {
  return _internal_has_team_invite();
}
inline void CMsgPartyInviteResponse::clear_team_invite() {
  _impl_.team_invite_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgPartyInviteResponse::_internal_team_invite() const {
  return _impl_.team_invite_;
}
inline uint32_t CMsgPartyInviteResponse::team_invite() const {
  // @@protoc_insertion_point(field_get:CMsgPartyInviteResponse.team_invite)
  return _internal_team_invite();
}
inline void CMsgPartyInviteResponse::_internal_set_team_invite(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.team_invite_ = value;
}
inline void CMsgPartyInviteResponse::set_team_invite(uint32_t value) {
  _internal_set_team_invite(value);
  // @@protoc_insertion_point(field_set:CMsgPartyInviteResponse.team_invite)
}

// -------------------------------------------------------------------

// CMsgKickFromParty

// optional fixed64 steam_id = 1;
inline bool CMsgKickFromParty::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgKickFromParty::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CMsgKickFromParty::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgKickFromParty::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CMsgKickFromParty::steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgKickFromParty.steam_id)
  return _internal_steam_id();
}
inline void CMsgKickFromParty::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.steam_id_ = value;
}
inline void CMsgKickFromParty::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgKickFromParty.steam_id)
}

// -------------------------------------------------------------------

// CMsgLeaveParty

// -------------------------------------------------------------------

// CMsgServerAvailable

// -------------------------------------------------------------------

// CMsgLANServerAvailable

// optional fixed64 lobby_id = 1;
inline bool CMsgLANServerAvailable::_internal_has_lobby_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgLANServerAvailable::has_lobby_id() const {
  return _internal_has_lobby_id();
}
inline void CMsgLANServerAvailable::clear_lobby_id() {
  _impl_.lobby_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgLANServerAvailable::_internal_lobby_id() const {
  return _impl_.lobby_id_;
}
inline uint64_t CMsgLANServerAvailable::lobby_id() const {
  // @@protoc_insertion_point(field_get:CMsgLANServerAvailable.lobby_id)
  return _internal_lobby_id();
}
inline void CMsgLANServerAvailable::_internal_set_lobby_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.lobby_id_ = value;
}
inline void CMsgLANServerAvailable::set_lobby_id(uint64_t value) {
  _internal_set_lobby_id(value);
  // @@protoc_insertion_point(field_set:CMsgLANServerAvailable.lobby_id)
}

// -------------------------------------------------------------------

// CSOEconGameAccountClient

// optional uint32 additional_backpack_slots = 1 [default = 0];
inline bool CSOEconGameAccountClient::_internal_has_additional_backpack_slots() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_additional_backpack_slots() const {
  return _internal_has_additional_backpack_slots();
}
inline void CSOEconGameAccountClient::clear_additional_backpack_slots() {
  _impl_.additional_backpack_slots_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconGameAccountClient::_internal_additional_backpack_slots() const {
  return _impl_.additional_backpack_slots_;
}
inline uint32_t CSOEconGameAccountClient::additional_backpack_slots() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.additional_backpack_slots)
  return _internal_additional_backpack_slots();
}
inline void CSOEconGameAccountClient::_internal_set_additional_backpack_slots(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.additional_backpack_slots_ = value;
}
inline void CSOEconGameAccountClient::set_additional_backpack_slots(uint32_t value) {
  _internal_set_additional_backpack_slots(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.additional_backpack_slots)
}

// optional fixed32 trade_ban_expiration = 6;
inline bool CSOEconGameAccountClient::_internal_has_trade_ban_expiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_trade_ban_expiration() const {
  return _internal_has_trade_ban_expiration();
}
inline void CSOEconGameAccountClient::clear_trade_ban_expiration() {
  _impl_.trade_ban_expiration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconGameAccountClient::_internal_trade_ban_expiration() const {
  return _impl_.trade_ban_expiration_;
}
inline uint32_t CSOEconGameAccountClient::trade_ban_expiration() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.trade_ban_expiration)
  return _internal_trade_ban_expiration();
}
inline void CSOEconGameAccountClient::_internal_set_trade_ban_expiration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.trade_ban_expiration_ = value;
}
inline void CSOEconGameAccountClient::set_trade_ban_expiration(uint32_t value) {
  _internal_set_trade_ban_expiration(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.trade_ban_expiration)
}

// optional fixed32 bonus_xp_timestamp_refresh = 12;
inline bool CSOEconGameAccountClient::_internal_has_bonus_xp_timestamp_refresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_bonus_xp_timestamp_refresh() const {
  return _internal_has_bonus_xp_timestamp_refresh();
}
inline void CSOEconGameAccountClient::clear_bonus_xp_timestamp_refresh() {
  _impl_.bonus_xp_timestamp_refresh_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOEconGameAccountClient::_internal_bonus_xp_timestamp_refresh() const {
  return _impl_.bonus_xp_timestamp_refresh_;
}
inline uint32_t CSOEconGameAccountClient::bonus_xp_timestamp_refresh() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.bonus_xp_timestamp_refresh)
  return _internal_bonus_xp_timestamp_refresh();
}
inline void CSOEconGameAccountClient::_internal_set_bonus_xp_timestamp_refresh(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bonus_xp_timestamp_refresh_ = value;
}
inline void CSOEconGameAccountClient::set_bonus_xp_timestamp_refresh(uint32_t value) {
  _internal_set_bonus_xp_timestamp_refresh(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.bonus_xp_timestamp_refresh)
}

// optional uint32 bonus_xp_usedflags = 13;
inline bool CSOEconGameAccountClient::_internal_has_bonus_xp_usedflags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_bonus_xp_usedflags() const {
  return _internal_has_bonus_xp_usedflags();
}
inline void CSOEconGameAccountClient::clear_bonus_xp_usedflags() {
  _impl_.bonus_xp_usedflags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconGameAccountClient::_internal_bonus_xp_usedflags() const {
  return _impl_.bonus_xp_usedflags_;
}
inline uint32_t CSOEconGameAccountClient::bonus_xp_usedflags() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.bonus_xp_usedflags)
  return _internal_bonus_xp_usedflags();
}
inline void CSOEconGameAccountClient::_internal_set_bonus_xp_usedflags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bonus_xp_usedflags_ = value;
}
inline void CSOEconGameAccountClient::set_bonus_xp_usedflags(uint32_t value) {
  _internal_set_bonus_xp_usedflags(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.bonus_xp_usedflags)
}

// optional uint32 elevated_state = 14;
inline bool CSOEconGameAccountClient::_internal_has_elevated_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_elevated_state() const {
  return _internal_has_elevated_state();
}
inline void CSOEconGameAccountClient::clear_elevated_state() {
  _impl_.elevated_state_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CSOEconGameAccountClient::_internal_elevated_state() const {
  return _impl_.elevated_state_;
}
inline uint32_t CSOEconGameAccountClient::elevated_state() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.elevated_state)
  return _internal_elevated_state();
}
inline void CSOEconGameAccountClient::_internal_set_elevated_state(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.elevated_state_ = value;
}
inline void CSOEconGameAccountClient::set_elevated_state(uint32_t value) {
  _internal_set_elevated_state(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.elevated_state)
}

// optional uint32 elevated_timestamp = 15;
inline bool CSOEconGameAccountClient::_internal_has_elevated_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSOEconGameAccountClient::has_elevated_timestamp() const {
  return _internal_has_elevated_timestamp();
}
inline void CSOEconGameAccountClient::clear_elevated_timestamp() {
  _impl_.elevated_timestamp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CSOEconGameAccountClient::_internal_elevated_timestamp() const {
  return _impl_.elevated_timestamp_;
}
inline uint32_t CSOEconGameAccountClient::elevated_timestamp() const {
  // @@protoc_insertion_point(field_get:CSOEconGameAccountClient.elevated_timestamp)
  return _internal_elevated_timestamp();
}
inline void CSOEconGameAccountClient::_internal_set_elevated_timestamp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.elevated_timestamp_ = value;
}
inline void CSOEconGameAccountClient::set_elevated_timestamp(uint32_t value) {
  _internal_set_elevated_timestamp(value);
  // @@protoc_insertion_point(field_set:CSOEconGameAccountClient.elevated_timestamp)
}

// -------------------------------------------------------------------

// CSOItemCriteriaCondition

// optional int32 op = 1;
inline bool CSOItemCriteriaCondition::_internal_has_op() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOItemCriteriaCondition::has_op() const {
  return _internal_has_op();
}
inline void CSOItemCriteriaCondition::clear_op() {
  _impl_.op_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSOItemCriteriaCondition::_internal_op() const {
  return _impl_.op_;
}
inline int32_t CSOItemCriteriaCondition::op() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteriaCondition.op)
  return _internal_op();
}
inline void CSOItemCriteriaCondition::_internal_set_op(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.op_ = value;
}
inline void CSOItemCriteriaCondition::set_op(int32_t value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteriaCondition.op)
}

// optional string field = 2;
inline bool CSOItemCriteriaCondition::_internal_has_field() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOItemCriteriaCondition::has_field() const {
  return _internal_has_field();
}
inline void CSOItemCriteriaCondition::clear_field() {
  _impl_.field_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOItemCriteriaCondition::field() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteriaCondition.field)
  return _internal_field();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemCriteriaCondition::set_field(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.field_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemCriteriaCondition.field)
}
inline std::string* CSOItemCriteriaCondition::mutable_field() {
  std::string* _s = _internal_mutable_field();
  // @@protoc_insertion_point(field_mutable:CSOItemCriteriaCondition.field)
  return _s;
}
inline const std::string& CSOItemCriteriaCondition::_internal_field() const {
  return _impl_.field_.Get();
}
inline void CSOItemCriteriaCondition::_internal_set_field(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.field_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemCriteriaCondition::_internal_mutable_field() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.field_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemCriteriaCondition::release_field() {
  // @@protoc_insertion_point(field_release:CSOItemCriteriaCondition.field)
  if (!_internal_has_field()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.field_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.field_.IsDefault()) {
    _impl_.field_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemCriteriaCondition::set_allocated_field(std::string* field) {
  if (field != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.field_.SetAllocated(field, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.field_.IsDefault()) {
    _impl_.field_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemCriteriaCondition.field)
}

// optional bool required = 3;
inline bool CSOItemCriteriaCondition::_internal_has_required() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOItemCriteriaCondition::has_required() const {
  return _internal_has_required();
}
inline void CSOItemCriteriaCondition::clear_required() {
  _impl_.required_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool CSOItemCriteriaCondition::_internal_required() const {
  return _impl_.required_;
}
inline bool CSOItemCriteriaCondition::required() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteriaCondition.required)
  return _internal_required();
}
inline void CSOItemCriteriaCondition::_internal_set_required(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.required_ = value;
}
inline void CSOItemCriteriaCondition::set_required(bool value) {
  _internal_set_required(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteriaCondition.required)
}

// optional float float_value = 4;
inline bool CSOItemCriteriaCondition::_internal_has_float_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOItemCriteriaCondition::has_float_value() const {
  return _internal_has_float_value();
}
inline void CSOItemCriteriaCondition::clear_float_value() {
  _impl_.float_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CSOItemCriteriaCondition::_internal_float_value() const {
  return _impl_.float_value_;
}
inline float CSOItemCriteriaCondition::float_value() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteriaCondition.float_value)
  return _internal_float_value();
}
inline void CSOItemCriteriaCondition::_internal_set_float_value(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.float_value_ = value;
}
inline void CSOItemCriteriaCondition::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteriaCondition.float_value)
}

// optional string string_value = 5;
inline bool CSOItemCriteriaCondition::_internal_has_string_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOItemCriteriaCondition::has_string_value() const {
  return _internal_has_string_value();
}
inline void CSOItemCriteriaCondition::clear_string_value() {
  _impl_.string_value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSOItemCriteriaCondition::string_value() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteriaCondition.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemCriteriaCondition::set_string_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.string_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemCriteriaCondition.string_value)
}
inline std::string* CSOItemCriteriaCondition::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:CSOItemCriteriaCondition.string_value)
  return _s;
}
inline const std::string& CSOItemCriteriaCondition::_internal_string_value() const {
  return _impl_.string_value_.Get();
}
inline void CSOItemCriteriaCondition::_internal_set_string_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemCriteriaCondition::_internal_mutable_string_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.string_value_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemCriteriaCondition::release_string_value() {
  // @@protoc_insertion_point(field_release:CSOItemCriteriaCondition.string_value)
  if (!_internal_has_string_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.string_value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_value_.IsDefault()) {
    _impl_.string_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemCriteriaCondition::set_allocated_string_value(std::string* string_value) {
  if (string_value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_value_.IsDefault()) {
    _impl_.string_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemCriteriaCondition.string_value)
}

// -------------------------------------------------------------------

// CSOItemCriteria

// optional uint32 item_level = 1;
inline bool CSOItemCriteria::_internal_has_item_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_level() const {
  return _internal_has_item_level();
}
inline void CSOItemCriteria::clear_item_level() {
  _impl_.item_level_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOItemCriteria::_internal_item_level() const {
  return _impl_.item_level_;
}
inline uint32_t CSOItemCriteria::item_level() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_level)
  return _internal_item_level();
}
inline void CSOItemCriteria::_internal_set_item_level(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_level_ = value;
}
inline void CSOItemCriteria::set_item_level(uint32_t value) {
  _internal_set_item_level(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_level)
}

// optional int32 item_quality = 2;
inline bool CSOItemCriteria::_internal_has_item_quality() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_quality() const {
  return _internal_has_item_quality();
}
inline void CSOItemCriteria::clear_item_quality() {
  _impl_.item_quality_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSOItemCriteria::_internal_item_quality() const {
  return _impl_.item_quality_;
}
inline int32_t CSOItemCriteria::item_quality() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_quality)
  return _internal_item_quality();
}
inline void CSOItemCriteria::_internal_set_item_quality(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_quality_ = value;
}
inline void CSOItemCriteria::set_item_quality(int32_t value) {
  _internal_set_item_quality(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_quality)
}

// optional bool item_level_set = 3;
inline bool CSOItemCriteria::_internal_has_item_level_set() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_level_set() const {
  return _internal_has_item_level_set();
}
inline void CSOItemCriteria::clear_item_level_set() {
  _impl_.item_level_set_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool CSOItemCriteria::_internal_item_level_set() const {
  return _impl_.item_level_set_;
}
inline bool CSOItemCriteria::item_level_set() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_level_set)
  return _internal_item_level_set();
}
inline void CSOItemCriteria::_internal_set_item_level_set(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.item_level_set_ = value;
}
inline void CSOItemCriteria::set_item_level_set(bool value) {
  _internal_set_item_level_set(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_level_set)
}

// optional bool item_quality_set = 4;
inline bool CSOItemCriteria::_internal_has_item_quality_set() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_quality_set() const {
  return _internal_has_item_quality_set();
}
inline void CSOItemCriteria::clear_item_quality_set() {
  _impl_.item_quality_set_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CSOItemCriteria::_internal_item_quality_set() const {
  return _impl_.item_quality_set_;
}
inline bool CSOItemCriteria::item_quality_set() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_quality_set)
  return _internal_item_quality_set();
}
inline void CSOItemCriteria::_internal_set_item_quality_set(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.item_quality_set_ = value;
}
inline void CSOItemCriteria::set_item_quality_set(bool value) {
  _internal_set_item_quality_set(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_quality_set)
}

// optional uint32 initial_inventory = 5;
inline bool CSOItemCriteria::_internal_has_initial_inventory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_initial_inventory() const {
  return _internal_has_initial_inventory();
}
inline void CSOItemCriteria::clear_initial_inventory() {
  _impl_.initial_inventory_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOItemCriteria::_internal_initial_inventory() const {
  return _impl_.initial_inventory_;
}
inline uint32_t CSOItemCriteria::initial_inventory() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.initial_inventory)
  return _internal_initial_inventory();
}
inline void CSOItemCriteria::_internal_set_initial_inventory(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.initial_inventory_ = value;
}
inline void CSOItemCriteria::set_initial_inventory(uint32_t value) {
  _internal_set_initial_inventory(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.initial_inventory)
}

// optional uint32 initial_quantity = 6;
inline bool CSOItemCriteria::_internal_has_initial_quantity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_initial_quantity() const {
  return _internal_has_initial_quantity();
}
inline void CSOItemCriteria::clear_initial_quantity() {
  _impl_.initial_quantity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOItemCriteria::_internal_initial_quantity() const {
  return _impl_.initial_quantity_;
}
inline uint32_t CSOItemCriteria::initial_quantity() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.initial_quantity)
  return _internal_initial_quantity();
}
inline void CSOItemCriteria::_internal_set_initial_quantity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.initial_quantity_ = value;
}
inline void CSOItemCriteria::set_initial_quantity(uint32_t value) {
  _internal_set_initial_quantity(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.initial_quantity)
}

// optional bool ignore_enabled_flag = 8;
inline bool CSOItemCriteria::_internal_has_ignore_enabled_flag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_ignore_enabled_flag() const {
  return _internal_has_ignore_enabled_flag();
}
inline void CSOItemCriteria::clear_ignore_enabled_flag() {
  _impl_.ignore_enabled_flag_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CSOItemCriteria::_internal_ignore_enabled_flag() const {
  return _impl_.ignore_enabled_flag_;
}
inline bool CSOItemCriteria::ignore_enabled_flag() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.ignore_enabled_flag)
  return _internal_ignore_enabled_flag();
}
inline void CSOItemCriteria::_internal_set_ignore_enabled_flag(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.ignore_enabled_flag_ = value;
}
inline void CSOItemCriteria::set_ignore_enabled_flag(bool value) {
  _internal_set_ignore_enabled_flag(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.ignore_enabled_flag)
}

// repeated .CSOItemCriteriaCondition conditions = 9;
inline int CSOItemCriteria::_internal_conditions_size() const {
  return _impl_.conditions_.size();
}
inline int CSOItemCriteria::conditions_size() const {
  return _internal_conditions_size();
}
inline void CSOItemCriteria::clear_conditions() {
  _impl_.conditions_.Clear();
}
inline ::CSOItemCriteriaCondition* CSOItemCriteria::mutable_conditions(int index) {
  // @@protoc_insertion_point(field_mutable:CSOItemCriteria.conditions)
  return _impl_.conditions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteriaCondition >*
CSOItemCriteria::mutable_conditions() {
  // @@protoc_insertion_point(field_mutable_list:CSOItemCriteria.conditions)
  return &_impl_.conditions_;
}
inline const ::CSOItemCriteriaCondition& CSOItemCriteria::_internal_conditions(int index) const {
  return _impl_.conditions_.Get(index);
}
inline const ::CSOItemCriteriaCondition& CSOItemCriteria::conditions(int index) const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.conditions)
  return _internal_conditions(index);
}
inline ::CSOItemCriteriaCondition* CSOItemCriteria::_internal_add_conditions() {
  return _impl_.conditions_.Add();
}
inline ::CSOItemCriteriaCondition* CSOItemCriteria::add_conditions() {
  ::CSOItemCriteriaCondition* _add = _internal_add_conditions();
  // @@protoc_insertion_point(field_add:CSOItemCriteria.conditions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteriaCondition >&
CSOItemCriteria::conditions() const {
  // @@protoc_insertion_point(field_list:CSOItemCriteria.conditions)
  return _impl_.conditions_;
}

// optional int32 item_rarity = 10;
inline bool CSOItemCriteria::_internal_has_item_rarity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_rarity() const {
  return _internal_has_item_rarity();
}
inline void CSOItemCriteria::clear_item_rarity() {
  _impl_.item_rarity_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CSOItemCriteria::_internal_item_rarity() const {
  return _impl_.item_rarity_;
}
inline int32_t CSOItemCriteria::item_rarity() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_rarity)
  return _internal_item_rarity();
}
inline void CSOItemCriteria::_internal_set_item_rarity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.item_rarity_ = value;
}
inline void CSOItemCriteria::set_item_rarity(int32_t value) {
  _internal_set_item_rarity(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_rarity)
}

// optional bool item_rarity_set = 11;
inline bool CSOItemCriteria::_internal_has_item_rarity_set() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_item_rarity_set() const {
  return _internal_has_item_rarity_set();
}
inline void CSOItemCriteria::clear_item_rarity_set() {
  _impl_.item_rarity_set_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool CSOItemCriteria::_internal_item_rarity_set() const {
  return _impl_.item_rarity_set_;
}
inline bool CSOItemCriteria::item_rarity_set() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.item_rarity_set)
  return _internal_item_rarity_set();
}
inline void CSOItemCriteria::_internal_set_item_rarity_set(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.item_rarity_set_ = value;
}
inline void CSOItemCriteria::set_item_rarity_set(bool value) {
  _internal_set_item_rarity_set(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.item_rarity_set)
}

// optional bool recent_only = 12;
inline bool CSOItemCriteria::_internal_has_recent_only() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSOItemCriteria::has_recent_only() const {
  return _internal_has_recent_only();
}
inline void CSOItemCriteria::clear_recent_only() {
  _impl_.recent_only_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CSOItemCriteria::_internal_recent_only() const {
  return _impl_.recent_only_;
}
inline bool CSOItemCriteria::recent_only() const {
  // @@protoc_insertion_point(field_get:CSOItemCriteria.recent_only)
  return _internal_recent_only();
}
inline void CSOItemCriteria::_internal_set_recent_only(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.recent_only_ = value;
}
inline void CSOItemCriteria::set_recent_only(bool value) {
  _internal_set_recent_only(value);
  // @@protoc_insertion_point(field_set:CSOItemCriteria.recent_only)
}

// -------------------------------------------------------------------

// CSOItemRecipe

// optional uint32 def_index = 1;
inline bool CSOItemRecipe::_internal_has_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_def_index() const {
  return _internal_has_def_index();
}
inline void CSOItemRecipe::clear_def_index() {
  _impl_.def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CSOItemRecipe::_internal_def_index() const {
  return _impl_.def_index_;
}
inline uint32_t CSOItemRecipe::def_index() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.def_index)
  return _internal_def_index();
}
inline void CSOItemRecipe::_internal_set_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.def_index_ = value;
}
inline void CSOItemRecipe::set_def_index(uint32_t value) {
  _internal_set_def_index(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.def_index)
}

// optional string name = 2;
inline bool CSOItemRecipe::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_name() const {
  return _internal_has_name();
}
inline void CSOItemRecipe::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOItemRecipe::name() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.name)
}
inline std::string* CSOItemRecipe::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.name)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CSOItemRecipe::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_name() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.name)
}

// optional string n_a = 3;
inline bool CSOItemRecipe::_internal_has_n_a() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_n_a() const {
  return _internal_has_n_a();
}
inline void CSOItemRecipe::clear_n_a() {
  _impl_.n_a_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSOItemRecipe::n_a() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.n_a)
  return _internal_n_a();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_n_a(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.n_a_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.n_a)
}
inline std::string* CSOItemRecipe::mutable_n_a() {
  std::string* _s = _internal_mutable_n_a();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.n_a)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_n_a() const {
  return _impl_.n_a_.Get();
}
inline void CSOItemRecipe::_internal_set_n_a(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.n_a_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_n_a() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.n_a_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_n_a() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.n_a)
  if (!_internal_has_n_a()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.n_a_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.n_a_.IsDefault()) {
    _impl_.n_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_n_a(std::string* n_a) {
  if (n_a != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.n_a_.SetAllocated(n_a, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.n_a_.IsDefault()) {
    _impl_.n_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.n_a)
}

// optional string desc_inputs = 4;
inline bool CSOItemRecipe::_internal_has_desc_inputs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_desc_inputs() const {
  return _internal_has_desc_inputs();
}
inline void CSOItemRecipe::clear_desc_inputs() {
  _impl_.desc_inputs_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CSOItemRecipe::desc_inputs() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.desc_inputs)
  return _internal_desc_inputs();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_desc_inputs(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.desc_inputs_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.desc_inputs)
}
inline std::string* CSOItemRecipe::mutable_desc_inputs() {
  std::string* _s = _internal_mutable_desc_inputs();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.desc_inputs)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_desc_inputs() const {
  return _impl_.desc_inputs_.Get();
}
inline void CSOItemRecipe::_internal_set_desc_inputs(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.desc_inputs_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_desc_inputs() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.desc_inputs_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_desc_inputs() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.desc_inputs)
  if (!_internal_has_desc_inputs()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.desc_inputs_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.desc_inputs_.IsDefault()) {
    _impl_.desc_inputs_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_desc_inputs(std::string* desc_inputs) {
  if (desc_inputs != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.desc_inputs_.SetAllocated(desc_inputs, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.desc_inputs_.IsDefault()) {
    _impl_.desc_inputs_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.desc_inputs)
}

// optional string desc_outputs = 5;
inline bool CSOItemRecipe::_internal_has_desc_outputs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_desc_outputs() const {
  return _internal_has_desc_outputs();
}
inline void CSOItemRecipe::clear_desc_outputs() {
  _impl_.desc_outputs_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CSOItemRecipe::desc_outputs() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.desc_outputs)
  return _internal_desc_outputs();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_desc_outputs(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.desc_outputs_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.desc_outputs)
}
inline std::string* CSOItemRecipe::mutable_desc_outputs() {
  std::string* _s = _internal_mutable_desc_outputs();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.desc_outputs)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_desc_outputs() const {
  return _impl_.desc_outputs_.Get();
}
inline void CSOItemRecipe::_internal_set_desc_outputs(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.desc_outputs_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_desc_outputs() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.desc_outputs_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_desc_outputs() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.desc_outputs)
  if (!_internal_has_desc_outputs()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.desc_outputs_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.desc_outputs_.IsDefault()) {
    _impl_.desc_outputs_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_desc_outputs(std::string* desc_outputs) {
  if (desc_outputs != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.desc_outputs_.SetAllocated(desc_outputs, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.desc_outputs_.IsDefault()) {
    _impl_.desc_outputs_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.desc_outputs)
}

// optional string di_a = 6;
inline bool CSOItemRecipe::_internal_has_di_a() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_di_a() const {
  return _internal_has_di_a();
}
inline void CSOItemRecipe::clear_di_a() {
  _impl_.di_a_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CSOItemRecipe::di_a() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.di_a)
  return _internal_di_a();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_di_a(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.di_a_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.di_a)
}
inline std::string* CSOItemRecipe::mutable_di_a() {
  std::string* _s = _internal_mutable_di_a();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.di_a)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_di_a() const {
  return _impl_.di_a_.Get();
}
inline void CSOItemRecipe::_internal_set_di_a(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.di_a_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_di_a() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.di_a_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_di_a() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.di_a)
  if (!_internal_has_di_a()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.di_a_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_a_.IsDefault()) {
    _impl_.di_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_di_a(std::string* di_a) {
  if (di_a != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.di_a_.SetAllocated(di_a, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_a_.IsDefault()) {
    _impl_.di_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.di_a)
}

// optional string di_b = 7;
inline bool CSOItemRecipe::_internal_has_di_b() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_di_b() const {
  return _internal_has_di_b();
}
inline void CSOItemRecipe::clear_di_b() {
  _impl_.di_b_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& CSOItemRecipe::di_b() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.di_b)
  return _internal_di_b();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_di_b(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.di_b_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.di_b)
}
inline std::string* CSOItemRecipe::mutable_di_b() {
  std::string* _s = _internal_mutable_di_b();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.di_b)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_di_b() const {
  return _impl_.di_b_.Get();
}
inline void CSOItemRecipe::_internal_set_di_b(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.di_b_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_di_b() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.di_b_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_di_b() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.di_b)
  if (!_internal_has_di_b()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.di_b_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_b_.IsDefault()) {
    _impl_.di_b_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_di_b(std::string* di_b) {
  if (di_b != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.di_b_.SetAllocated(di_b, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_b_.IsDefault()) {
    _impl_.di_b_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.di_b)
}

// optional string di_c = 8;
inline bool CSOItemRecipe::_internal_has_di_c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_di_c() const {
  return _internal_has_di_c();
}
inline void CSOItemRecipe::clear_di_c() {
  _impl_.di_c_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& CSOItemRecipe::di_c() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.di_c)
  return _internal_di_c();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_di_c(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.di_c_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.di_c)
}
inline std::string* CSOItemRecipe::mutable_di_c() {
  std::string* _s = _internal_mutable_di_c();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.di_c)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_di_c() const {
  return _impl_.di_c_.Get();
}
inline void CSOItemRecipe::_internal_set_di_c(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.di_c_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_di_c() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.di_c_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_di_c() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.di_c)
  if (!_internal_has_di_c()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.di_c_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_c_.IsDefault()) {
    _impl_.di_c_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_di_c(std::string* di_c) {
  if (di_c != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.di_c_.SetAllocated(di_c, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.di_c_.IsDefault()) {
    _impl_.di_c_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.di_c)
}

// optional string do_a = 9;
inline bool CSOItemRecipe::_internal_has_do_a() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_do_a() const {
  return _internal_has_do_a();
}
inline void CSOItemRecipe::clear_do_a() {
  _impl_.do_a_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& CSOItemRecipe::do_a() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.do_a)
  return _internal_do_a();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_do_a(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.do_a_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.do_a)
}
inline std::string* CSOItemRecipe::mutable_do_a() {
  std::string* _s = _internal_mutable_do_a();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.do_a)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_do_a() const {
  return _impl_.do_a_.Get();
}
inline void CSOItemRecipe::_internal_set_do_a(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.do_a_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_do_a() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.do_a_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_do_a() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.do_a)
  if (!_internal_has_do_a()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.do_a_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_a_.IsDefault()) {
    _impl_.do_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_do_a(std::string* do_a) {
  if (do_a != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.do_a_.SetAllocated(do_a, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_a_.IsDefault()) {
    _impl_.do_a_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.do_a)
}

// optional string do_b = 10;
inline bool CSOItemRecipe::_internal_has_do_b() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_do_b() const {
  return _internal_has_do_b();
}
inline void CSOItemRecipe::clear_do_b() {
  _impl_.do_b_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& CSOItemRecipe::do_b() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.do_b)
  return _internal_do_b();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_do_b(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.do_b_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.do_b)
}
inline std::string* CSOItemRecipe::mutable_do_b() {
  std::string* _s = _internal_mutable_do_b();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.do_b)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_do_b() const {
  return _impl_.do_b_.Get();
}
inline void CSOItemRecipe::_internal_set_do_b(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.do_b_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_do_b() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.do_b_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_do_b() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.do_b)
  if (!_internal_has_do_b()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.do_b_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_b_.IsDefault()) {
    _impl_.do_b_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_do_b(std::string* do_b) {
  if (do_b != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.do_b_.SetAllocated(do_b, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_b_.IsDefault()) {
    _impl_.do_b_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.do_b)
}

// optional string do_c = 11;
inline bool CSOItemRecipe::_internal_has_do_c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_do_c() const {
  return _internal_has_do_c();
}
inline void CSOItemRecipe::clear_do_c() {
  _impl_.do_c_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& CSOItemRecipe::do_c() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.do_c)
  return _internal_do_c();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOItemRecipe::set_do_c(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.do_c_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOItemRecipe.do_c)
}
inline std::string* CSOItemRecipe::mutable_do_c() {
  std::string* _s = _internal_mutable_do_c();
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.do_c)
  return _s;
}
inline const std::string& CSOItemRecipe::_internal_do_c() const {
  return _impl_.do_c_.Get();
}
inline void CSOItemRecipe::_internal_set_do_c(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.do_c_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::_internal_mutable_do_c() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.do_c_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOItemRecipe::release_do_c() {
  // @@protoc_insertion_point(field_release:CSOItemRecipe.do_c)
  if (!_internal_has_do_c()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.do_c_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_c_.IsDefault()) {
    _impl_.do_c_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOItemRecipe::set_allocated_do_c(std::string* do_c) {
  if (do_c != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.do_c_.SetAllocated(do_c, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.do_c_.IsDefault()) {
    _impl_.do_c_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOItemRecipe.do_c)
}

// optional bool requires_all_same_class = 12;
inline bool CSOItemRecipe::_internal_has_requires_all_same_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_requires_all_same_class() const {
  return _internal_has_requires_all_same_class();
}
inline void CSOItemRecipe::clear_requires_all_same_class() {
  _impl_.requires_all_same_class_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool CSOItemRecipe::_internal_requires_all_same_class() const {
  return _impl_.requires_all_same_class_;
}
inline bool CSOItemRecipe::requires_all_same_class() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.requires_all_same_class)
  return _internal_requires_all_same_class();
}
inline void CSOItemRecipe::_internal_set_requires_all_same_class(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.requires_all_same_class_ = value;
}
inline void CSOItemRecipe::set_requires_all_same_class(bool value) {
  _internal_set_requires_all_same_class(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.requires_all_same_class)
}

// optional bool requires_all_same_slot = 13;
inline bool CSOItemRecipe::_internal_has_requires_all_same_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_requires_all_same_slot() const {
  return _internal_has_requires_all_same_slot();
}
inline void CSOItemRecipe::clear_requires_all_same_slot() {
  _impl_.requires_all_same_slot_ = false;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool CSOItemRecipe::_internal_requires_all_same_slot() const {
  return _impl_.requires_all_same_slot_;
}
inline bool CSOItemRecipe::requires_all_same_slot() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.requires_all_same_slot)
  return _internal_requires_all_same_slot();
}
inline void CSOItemRecipe::_internal_set_requires_all_same_slot(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.requires_all_same_slot_ = value;
}
inline void CSOItemRecipe::set_requires_all_same_slot(bool value) {
  _internal_set_requires_all_same_slot(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.requires_all_same_slot)
}

// optional int32 class_usage_for_output = 14;
inline bool CSOItemRecipe::_internal_has_class_usage_for_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_class_usage_for_output() const {
  return _internal_has_class_usage_for_output();
}
inline void CSOItemRecipe::clear_class_usage_for_output() {
  _impl_.class_usage_for_output_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CSOItemRecipe::_internal_class_usage_for_output() const {
  return _impl_.class_usage_for_output_;
}
inline int32_t CSOItemRecipe::class_usage_for_output() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.class_usage_for_output)
  return _internal_class_usage_for_output();
}
inline void CSOItemRecipe::_internal_set_class_usage_for_output(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.class_usage_for_output_ = value;
}
inline void CSOItemRecipe::set_class_usage_for_output(int32_t value) {
  _internal_set_class_usage_for_output(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.class_usage_for_output)
}

// optional int32 slot_usage_for_output = 15;
inline bool CSOItemRecipe::_internal_has_slot_usage_for_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_slot_usage_for_output() const {
  return _internal_has_slot_usage_for_output();
}
inline void CSOItemRecipe::clear_slot_usage_for_output() {
  _impl_.slot_usage_for_output_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t CSOItemRecipe::_internal_slot_usage_for_output() const {
  return _impl_.slot_usage_for_output_;
}
inline int32_t CSOItemRecipe::slot_usage_for_output() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.slot_usage_for_output)
  return _internal_slot_usage_for_output();
}
inline void CSOItemRecipe::_internal_set_slot_usage_for_output(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.slot_usage_for_output_ = value;
}
inline void CSOItemRecipe::set_slot_usage_for_output(int32_t value) {
  _internal_set_slot_usage_for_output(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.slot_usage_for_output)
}

// optional int32 set_for_output = 16;
inline bool CSOItemRecipe::_internal_has_set_for_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSOItemRecipe::has_set_for_output() const {
  return _internal_has_set_for_output();
}
inline void CSOItemRecipe::clear_set_for_output() {
  _impl_.set_for_output_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t CSOItemRecipe::_internal_set_for_output() const {
  return _impl_.set_for_output_;
}
inline int32_t CSOItemRecipe::set_for_output() const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.set_for_output)
  return _internal_set_for_output();
}
inline void CSOItemRecipe::_internal_set_set_for_output(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.set_for_output_ = value;
}
inline void CSOItemRecipe::set_set_for_output(int32_t value) {
  _internal_set_set_for_output(value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.set_for_output)
}

// repeated .CSOItemCriteria input_items_criteria = 20;
inline int CSOItemRecipe::_internal_input_items_criteria_size() const {
  return _impl_.input_items_criteria_.size();
}
inline int CSOItemRecipe::input_items_criteria_size() const {
  return _internal_input_items_criteria_size();
}
inline void CSOItemRecipe::clear_input_items_criteria() {
  _impl_.input_items_criteria_.Clear();
}
inline ::CSOItemCriteria* CSOItemRecipe::mutable_input_items_criteria(int index) {
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.input_items_criteria)
  return _impl_.input_items_criteria_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >*
CSOItemRecipe::mutable_input_items_criteria() {
  // @@protoc_insertion_point(field_mutable_list:CSOItemRecipe.input_items_criteria)
  return &_impl_.input_items_criteria_;
}
inline const ::CSOItemCriteria& CSOItemRecipe::_internal_input_items_criteria(int index) const {
  return _impl_.input_items_criteria_.Get(index);
}
inline const ::CSOItemCriteria& CSOItemRecipe::input_items_criteria(int index) const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.input_items_criteria)
  return _internal_input_items_criteria(index);
}
inline ::CSOItemCriteria* CSOItemRecipe::_internal_add_input_items_criteria() {
  return _impl_.input_items_criteria_.Add();
}
inline ::CSOItemCriteria* CSOItemRecipe::add_input_items_criteria() {
  ::CSOItemCriteria* _add = _internal_add_input_items_criteria();
  // @@protoc_insertion_point(field_add:CSOItemRecipe.input_items_criteria)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >&
CSOItemRecipe::input_items_criteria() const {
  // @@protoc_insertion_point(field_list:CSOItemRecipe.input_items_criteria)
  return _impl_.input_items_criteria_;
}

// repeated .CSOItemCriteria output_items_criteria = 21;
inline int CSOItemRecipe::_internal_output_items_criteria_size() const {
  return _impl_.output_items_criteria_.size();
}
inline int CSOItemRecipe::output_items_criteria_size() const {
  return _internal_output_items_criteria_size();
}
inline void CSOItemRecipe::clear_output_items_criteria() {
  _impl_.output_items_criteria_.Clear();
}
inline ::CSOItemCriteria* CSOItemRecipe::mutable_output_items_criteria(int index) {
  // @@protoc_insertion_point(field_mutable:CSOItemRecipe.output_items_criteria)
  return _impl_.output_items_criteria_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >*
CSOItemRecipe::mutable_output_items_criteria() {
  // @@protoc_insertion_point(field_mutable_list:CSOItemRecipe.output_items_criteria)
  return &_impl_.output_items_criteria_;
}
inline const ::CSOItemCriteria& CSOItemRecipe::_internal_output_items_criteria(int index) const {
  return _impl_.output_items_criteria_.Get(index);
}
inline const ::CSOItemCriteria& CSOItemRecipe::output_items_criteria(int index) const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.output_items_criteria)
  return _internal_output_items_criteria(index);
}
inline ::CSOItemCriteria* CSOItemRecipe::_internal_add_output_items_criteria() {
  return _impl_.output_items_criteria_.Add();
}
inline ::CSOItemCriteria* CSOItemRecipe::add_output_items_criteria() {
  ::CSOItemCriteria* _add = _internal_add_output_items_criteria();
  // @@protoc_insertion_point(field_add:CSOItemRecipe.output_items_criteria)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOItemCriteria >&
CSOItemRecipe::output_items_criteria() const {
  // @@protoc_insertion_point(field_list:CSOItemRecipe.output_items_criteria)
  return _impl_.output_items_criteria_;
}

// repeated uint32 input_item_dupe_counts = 22;
inline int CSOItemRecipe::_internal_input_item_dupe_counts_size() const {
  return _impl_.input_item_dupe_counts_.size();
}
inline int CSOItemRecipe::input_item_dupe_counts_size() const {
  return _internal_input_item_dupe_counts_size();
}
inline void CSOItemRecipe::clear_input_item_dupe_counts() {
  _impl_.input_item_dupe_counts_.Clear();
}
inline uint32_t CSOItemRecipe::_internal_input_item_dupe_counts(int index) const {
  return _impl_.input_item_dupe_counts_.Get(index);
}
inline uint32_t CSOItemRecipe::input_item_dupe_counts(int index) const {
  // @@protoc_insertion_point(field_get:CSOItemRecipe.input_item_dupe_counts)
  return _internal_input_item_dupe_counts(index);
}
inline void CSOItemRecipe::set_input_item_dupe_counts(int index, uint32_t value) {
  _impl_.input_item_dupe_counts_.Set(index, value);
  // @@protoc_insertion_point(field_set:CSOItemRecipe.input_item_dupe_counts)
}
inline void CSOItemRecipe::_internal_add_input_item_dupe_counts(uint32_t value) {
  _impl_.input_item_dupe_counts_.Add(value);
}
inline void CSOItemRecipe::add_input_item_dupe_counts(uint32_t value) {
  _internal_add_input_item_dupe_counts(value);
  // @@protoc_insertion_point(field_add:CSOItemRecipe.input_item_dupe_counts)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CSOItemRecipe::_internal_input_item_dupe_counts() const {
  return _impl_.input_item_dupe_counts_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CSOItemRecipe::input_item_dupe_counts() const {
  // @@protoc_insertion_point(field_list:CSOItemRecipe.input_item_dupe_counts)
  return _internal_input_item_dupe_counts();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CSOItemRecipe::_internal_mutable_input_item_dupe_counts() {
  return &_impl_.input_item_dupe_counts_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CSOItemRecipe::mutable_input_item_dupe_counts() {
  // @@protoc_insertion_point(field_mutable_list:CSOItemRecipe.input_item_dupe_counts)
  return _internal_mutable_input_item_dupe_counts();
}

// -------------------------------------------------------------------

// CMsgDevNewItemRequest

// optional fixed64 receiver = 1;
inline bool CMsgDevNewItemRequest::_internal_has_receiver() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgDevNewItemRequest::has_receiver() const {
  return _internal_has_receiver();
}
inline void CMsgDevNewItemRequest::clear_receiver() {
  _impl_.receiver_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgDevNewItemRequest::_internal_receiver() const {
  return _impl_.receiver_;
}
inline uint64_t CMsgDevNewItemRequest::receiver() const {
  // @@protoc_insertion_point(field_get:CMsgDevNewItemRequest.receiver)
  return _internal_receiver();
}
inline void CMsgDevNewItemRequest::_internal_set_receiver(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.receiver_ = value;
}
inline void CMsgDevNewItemRequest::set_receiver(uint64_t value) {
  _internal_set_receiver(value);
  // @@protoc_insertion_point(field_set:CMsgDevNewItemRequest.receiver)
}

// optional .CSOItemCriteria criteria = 2;
inline bool CMsgDevNewItemRequest::_internal_has_criteria() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.criteria_ != nullptr);
  return value;
}
inline bool CMsgDevNewItemRequest::has_criteria() const {
  return _internal_has_criteria();
}
inline void CMsgDevNewItemRequest::clear_criteria() {
  if (_impl_.criteria_ != nullptr) _impl_.criteria_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CSOItemCriteria& CMsgDevNewItemRequest::_internal_criteria() const {
  const ::CSOItemCriteria* p = _impl_.criteria_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSOItemCriteria&>(
      ::_CSOItemCriteria_default_instance_);
}
inline const ::CSOItemCriteria& CMsgDevNewItemRequest::criteria() const {
  // @@protoc_insertion_point(field_get:CMsgDevNewItemRequest.criteria)
  return _internal_criteria();
}
inline void CMsgDevNewItemRequest::unsafe_arena_set_allocated_criteria(
    ::CSOItemCriteria* criteria) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.criteria_);
  }
  _impl_.criteria_ = criteria;
  if (criteria) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgDevNewItemRequest.criteria)
}
inline ::CSOItemCriteria* CMsgDevNewItemRequest::release_criteria() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CSOItemCriteria* temp = _impl_.criteria_;
  _impl_.criteria_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSOItemCriteria* CMsgDevNewItemRequest::unsafe_arena_release_criteria() {
  // @@protoc_insertion_point(field_release:CMsgDevNewItemRequest.criteria)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CSOItemCriteria* temp = _impl_.criteria_;
  _impl_.criteria_ = nullptr;
  return temp;
}
inline ::CSOItemCriteria* CMsgDevNewItemRequest::_internal_mutable_criteria() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.criteria_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSOItemCriteria>(GetArenaForAllocation());
    _impl_.criteria_ = p;
  }
  return _impl_.criteria_;
}
inline ::CSOItemCriteria* CMsgDevNewItemRequest::mutable_criteria() {
  ::CSOItemCriteria* _msg = _internal_mutable_criteria();
  // @@protoc_insertion_point(field_mutable:CMsgDevNewItemRequest.criteria)
  return _msg;
}
inline void CMsgDevNewItemRequest::set_allocated_criteria(::CSOItemCriteria* criteria) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.criteria_;
  }
  if (criteria) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(criteria);
    if (message_arena != submessage_arena) {
      criteria = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, criteria, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.criteria_ = criteria;
  // @@protoc_insertion_point(field_set_allocated:CMsgDevNewItemRequest.criteria)
}

// -------------------------------------------------------------------

// CMsgIncrementKillCountAttribute

// optional fixed32 killer_account_id = 1;
inline bool CMsgIncrementKillCountAttribute::_internal_has_killer_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgIncrementKillCountAttribute::has_killer_account_id() const {
  return _internal_has_killer_account_id();
}
inline void CMsgIncrementKillCountAttribute::clear_killer_account_id() {
  _impl_.killer_account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgIncrementKillCountAttribute::_internal_killer_account_id() const {
  return _impl_.killer_account_id_;
}
inline uint32_t CMsgIncrementKillCountAttribute::killer_account_id() const {
  // @@protoc_insertion_point(field_get:CMsgIncrementKillCountAttribute.killer_account_id)
  return _internal_killer_account_id();
}
inline void CMsgIncrementKillCountAttribute::_internal_set_killer_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.killer_account_id_ = value;
}
inline void CMsgIncrementKillCountAttribute::set_killer_account_id(uint32_t value) {
  _internal_set_killer_account_id(value);
  // @@protoc_insertion_point(field_set:CMsgIncrementKillCountAttribute.killer_account_id)
}

// optional fixed32 victim_account_id = 2;
inline bool CMsgIncrementKillCountAttribute::_internal_has_victim_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgIncrementKillCountAttribute::has_victim_account_id() const {
  return _internal_has_victim_account_id();
}
inline void CMsgIncrementKillCountAttribute::clear_victim_account_id() {
  _impl_.victim_account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgIncrementKillCountAttribute::_internal_victim_account_id() const {
  return _impl_.victim_account_id_;
}
inline uint32_t CMsgIncrementKillCountAttribute::victim_account_id() const {
  // @@protoc_insertion_point(field_get:CMsgIncrementKillCountAttribute.victim_account_id)
  return _internal_victim_account_id();
}
inline void CMsgIncrementKillCountAttribute::_internal_set_victim_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.victim_account_id_ = value;
}
inline void CMsgIncrementKillCountAttribute::set_victim_account_id(uint32_t value) {
  _internal_set_victim_account_id(value);
  // @@protoc_insertion_point(field_set:CMsgIncrementKillCountAttribute.victim_account_id)
}

// optional uint64 item_id = 3;
inline bool CMsgIncrementKillCountAttribute::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgIncrementKillCountAttribute::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgIncrementKillCountAttribute::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgIncrementKillCountAttribute::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgIncrementKillCountAttribute::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgIncrementKillCountAttribute.item_id)
  return _internal_item_id();
}
inline void CMsgIncrementKillCountAttribute::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_id_ = value;
}
inline void CMsgIncrementKillCountAttribute::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgIncrementKillCountAttribute.item_id)
}

// optional uint32 event_type = 4;
inline bool CMsgIncrementKillCountAttribute::_internal_has_event_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgIncrementKillCountAttribute::has_event_type() const {
  return _internal_has_event_type();
}
inline void CMsgIncrementKillCountAttribute::clear_event_type() {
  _impl_.event_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgIncrementKillCountAttribute::_internal_event_type() const {
  return _impl_.event_type_;
}
inline uint32_t CMsgIncrementKillCountAttribute::event_type() const {
  // @@protoc_insertion_point(field_get:CMsgIncrementKillCountAttribute.event_type)
  return _internal_event_type();
}
inline void CMsgIncrementKillCountAttribute::_internal_set_event_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.event_type_ = value;
}
inline void CMsgIncrementKillCountAttribute::set_event_type(uint32_t value) {
  _internal_set_event_type(value);
  // @@protoc_insertion_point(field_set:CMsgIncrementKillCountAttribute.event_type)
}

// optional uint32 amount = 5;
inline bool CMsgIncrementKillCountAttribute::_internal_has_amount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgIncrementKillCountAttribute::has_amount() const {
  return _internal_has_amount();
}
inline void CMsgIncrementKillCountAttribute::clear_amount() {
  _impl_.amount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgIncrementKillCountAttribute::_internal_amount() const {
  return _impl_.amount_;
}
inline uint32_t CMsgIncrementKillCountAttribute::amount() const {
  // @@protoc_insertion_point(field_get:CMsgIncrementKillCountAttribute.amount)
  return _internal_amount();
}
inline void CMsgIncrementKillCountAttribute::_internal_set_amount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.amount_ = value;
}
inline void CMsgIncrementKillCountAttribute::set_amount(uint32_t value) {
  _internal_set_amount(value);
  // @@protoc_insertion_point(field_set:CMsgIncrementKillCountAttribute.amount)
}

// -------------------------------------------------------------------

// CMsgApplySticker

// optional uint64 sticker_item_id = 1;
inline bool CMsgApplySticker::_internal_has_sticker_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_item_id() const {
  return _internal_has_sticker_item_id();
}
inline void CMsgApplySticker::clear_sticker_item_id() {
  _impl_.sticker_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgApplySticker::_internal_sticker_item_id() const {
  return _impl_.sticker_item_id_;
}
inline uint64_t CMsgApplySticker::sticker_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_item_id)
  return _internal_sticker_item_id();
}
inline void CMsgApplySticker::_internal_set_sticker_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sticker_item_id_ = value;
}
inline void CMsgApplySticker::set_sticker_item_id(uint64_t value) {
  _internal_set_sticker_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_item_id)
}

// optional uint64 item_item_id = 2;
inline bool CMsgApplySticker::_internal_has_item_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_item_item_id() const {
  return _internal_has_item_item_id();
}
inline void CMsgApplySticker::clear_item_item_id() {
  _impl_.item_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgApplySticker::_internal_item_item_id() const {
  return _impl_.item_item_id_;
}
inline uint64_t CMsgApplySticker::item_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.item_item_id)
  return _internal_item_item_id();
}
inline void CMsgApplySticker::_internal_set_item_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_item_id_ = value;
}
inline void CMsgApplySticker::set_item_item_id(uint64_t value) {
  _internal_set_item_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.item_item_id)
}

// optional uint32 sticker_slot = 3;
inline bool CMsgApplySticker::_internal_has_sticker_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_slot() const {
  return _internal_has_sticker_slot();
}
inline void CMsgApplySticker::clear_sticker_slot() {
  _impl_.sticker_slot_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgApplySticker::_internal_sticker_slot() const {
  return _impl_.sticker_slot_;
}
inline uint32_t CMsgApplySticker::sticker_slot() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_slot)
  return _internal_sticker_slot();
}
inline void CMsgApplySticker::_internal_set_sticker_slot(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sticker_slot_ = value;
}
inline void CMsgApplySticker::set_sticker_slot(uint32_t value) {
  _internal_set_sticker_slot(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_slot)
}

// optional uint32 baseitem_defidx = 4;
inline bool CMsgApplySticker::_internal_has_baseitem_defidx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_baseitem_defidx() const {
  return _internal_has_baseitem_defidx();
}
inline void CMsgApplySticker::clear_baseitem_defidx() {
  _impl_.baseitem_defidx_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgApplySticker::_internal_baseitem_defidx() const {
  return _impl_.baseitem_defidx_;
}
inline uint32_t CMsgApplySticker::baseitem_defidx() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.baseitem_defidx)
  return _internal_baseitem_defidx();
}
inline void CMsgApplySticker::_internal_set_baseitem_defidx(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.baseitem_defidx_ = value;
}
inline void CMsgApplySticker::set_baseitem_defidx(uint32_t value) {
  _internal_set_baseitem_defidx(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.baseitem_defidx)
}

// optional float sticker_wear = 5;
inline bool CMsgApplySticker::_internal_has_sticker_wear() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_wear() const {
  return _internal_has_sticker_wear();
}
inline void CMsgApplySticker::clear_sticker_wear() {
  _impl_.sticker_wear_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgApplySticker::_internal_sticker_wear() const {
  return _impl_.sticker_wear_;
}
inline float CMsgApplySticker::sticker_wear() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_wear)
  return _internal_sticker_wear();
}
inline void CMsgApplySticker::_internal_set_sticker_wear(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.sticker_wear_ = value;
}
inline void CMsgApplySticker::set_sticker_wear(float value) {
  _internal_set_sticker_wear(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_wear)
}

// optional float sticker_rotation = 6;
inline bool CMsgApplySticker::_internal_has_sticker_rotation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_rotation() const {
  return _internal_has_sticker_rotation();
}
inline void CMsgApplySticker::clear_sticker_rotation() {
  _impl_.sticker_rotation_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CMsgApplySticker::_internal_sticker_rotation() const {
  return _impl_.sticker_rotation_;
}
inline float CMsgApplySticker::sticker_rotation() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_rotation)
  return _internal_sticker_rotation();
}
inline void CMsgApplySticker::_internal_set_sticker_rotation(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.sticker_rotation_ = value;
}
inline void CMsgApplySticker::set_sticker_rotation(float value) {
  _internal_set_sticker_rotation(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_rotation)
}

// optional float sticker_scale = 7;
inline bool CMsgApplySticker::_internal_has_sticker_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_scale() const {
  return _internal_has_sticker_scale();
}
inline void CMsgApplySticker::clear_sticker_scale() {
  _impl_.sticker_scale_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CMsgApplySticker::_internal_sticker_scale() const {
  return _impl_.sticker_scale_;
}
inline float CMsgApplySticker::sticker_scale() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_scale)
  return _internal_sticker_scale();
}
inline void CMsgApplySticker::_internal_set_sticker_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.sticker_scale_ = value;
}
inline void CMsgApplySticker::set_sticker_scale(float value) {
  _internal_set_sticker_scale(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_scale)
}

// optional float sticker_offset_x = 8;
inline bool CMsgApplySticker::_internal_has_sticker_offset_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_offset_x() const {
  return _internal_has_sticker_offset_x();
}
inline void CMsgApplySticker::clear_sticker_offset_x() {
  _impl_.sticker_offset_x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float CMsgApplySticker::_internal_sticker_offset_x() const {
  return _impl_.sticker_offset_x_;
}
inline float CMsgApplySticker::sticker_offset_x() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_offset_x)
  return _internal_sticker_offset_x();
}
inline void CMsgApplySticker::_internal_set_sticker_offset_x(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.sticker_offset_x_ = value;
}
inline void CMsgApplySticker::set_sticker_offset_x(float value) {
  _internal_set_sticker_offset_x(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_offset_x)
}

// optional float sticker_offset_y = 9;
inline bool CMsgApplySticker::_internal_has_sticker_offset_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_offset_y() const {
  return _internal_has_sticker_offset_y();
}
inline void CMsgApplySticker::clear_sticker_offset_y() {
  _impl_.sticker_offset_y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float CMsgApplySticker::_internal_sticker_offset_y() const {
  return _impl_.sticker_offset_y_;
}
inline float CMsgApplySticker::sticker_offset_y() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_offset_y)
  return _internal_sticker_offset_y();
}
inline void CMsgApplySticker::_internal_set_sticker_offset_y(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.sticker_offset_y_ = value;
}
inline void CMsgApplySticker::set_sticker_offset_y(float value) {
  _internal_set_sticker_offset_y(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_offset_y)
}

// optional float sticker_offset_z = 10;
inline bool CMsgApplySticker::_internal_has_sticker_offset_z() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_offset_z() const {
  return _internal_has_sticker_offset_z();
}
inline void CMsgApplySticker::clear_sticker_offset_z() {
  _impl_.sticker_offset_z_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float CMsgApplySticker::_internal_sticker_offset_z() const {
  return _impl_.sticker_offset_z_;
}
inline float CMsgApplySticker::sticker_offset_z() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_offset_z)
  return _internal_sticker_offset_z();
}
inline void CMsgApplySticker::_internal_set_sticker_offset_z(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.sticker_offset_z_ = value;
}
inline void CMsgApplySticker::set_sticker_offset_z(float value) {
  _internal_set_sticker_offset_z(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_offset_z)
}

// optional float sticker_wear_target = 11;
inline bool CMsgApplySticker::_internal_has_sticker_wear_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgApplySticker::has_sticker_wear_target() const {
  return _internal_has_sticker_wear_target();
}
inline void CMsgApplySticker::clear_sticker_wear_target() {
  _impl_.sticker_wear_target_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float CMsgApplySticker::_internal_sticker_wear_target() const {
  return _impl_.sticker_wear_target_;
}
inline float CMsgApplySticker::sticker_wear_target() const {
  // @@protoc_insertion_point(field_get:CMsgApplySticker.sticker_wear_target)
  return _internal_sticker_wear_target();
}
inline void CMsgApplySticker::_internal_set_sticker_wear_target(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.sticker_wear_target_ = value;
}
inline void CMsgApplySticker::set_sticker_wear_target(float value) {
  _internal_set_sticker_wear_target(value);
  // @@protoc_insertion_point(field_set:CMsgApplySticker.sticker_wear_target)
}

// -------------------------------------------------------------------

// CMsgModifyItemAttribute

// optional uint64 item_id = 1;
inline bool CMsgModifyItemAttribute::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgModifyItemAttribute::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgModifyItemAttribute::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgModifyItemAttribute::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgModifyItemAttribute::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgModifyItemAttribute.item_id)
  return _internal_item_id();
}
inline void CMsgModifyItemAttribute::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_id_ = value;
}
inline void CMsgModifyItemAttribute::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgModifyItemAttribute.item_id)
}

// optional uint32 attr_defidx = 2;
inline bool CMsgModifyItemAttribute::_internal_has_attr_defidx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgModifyItemAttribute::has_attr_defidx() const {
  return _internal_has_attr_defidx();
}
inline void CMsgModifyItemAttribute::clear_attr_defidx() {
  _impl_.attr_defidx_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgModifyItemAttribute::_internal_attr_defidx() const {
  return _impl_.attr_defidx_;
}
inline uint32_t CMsgModifyItemAttribute::attr_defidx() const {
  // @@protoc_insertion_point(field_get:CMsgModifyItemAttribute.attr_defidx)
  return _internal_attr_defidx();
}
inline void CMsgModifyItemAttribute::_internal_set_attr_defidx(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.attr_defidx_ = value;
}
inline void CMsgModifyItemAttribute::set_attr_defidx(uint32_t value) {
  _internal_set_attr_defidx(value);
  // @@protoc_insertion_point(field_set:CMsgModifyItemAttribute.attr_defidx)
}

// optional uint32 attr_value = 3;
inline bool CMsgModifyItemAttribute::_internal_has_attr_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgModifyItemAttribute::has_attr_value() const {
  return _internal_has_attr_value();
}
inline void CMsgModifyItemAttribute::clear_attr_value() {
  _impl_.attr_value_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgModifyItemAttribute::_internal_attr_value() const {
  return _impl_.attr_value_;
}
inline uint32_t CMsgModifyItemAttribute::attr_value() const {
  // @@protoc_insertion_point(field_get:CMsgModifyItemAttribute.attr_value)
  return _internal_attr_value();
}
inline void CMsgModifyItemAttribute::_internal_set_attr_value(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.attr_value_ = value;
}
inline void CMsgModifyItemAttribute::set_attr_value(uint32_t value) {
  _internal_set_attr_value(value);
  // @@protoc_insertion_point(field_set:CMsgModifyItemAttribute.attr_value)
}

// -------------------------------------------------------------------

// CMsgApplyStatTrakSwap

// optional uint64 tool_item_id = 1;
inline bool CMsgApplyStatTrakSwap::_internal_has_tool_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgApplyStatTrakSwap::has_tool_item_id() const {
  return _internal_has_tool_item_id();
}
inline void CMsgApplyStatTrakSwap::clear_tool_item_id() {
  _impl_.tool_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgApplyStatTrakSwap::_internal_tool_item_id() const {
  return _impl_.tool_item_id_;
}
inline uint64_t CMsgApplyStatTrakSwap::tool_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyStatTrakSwap.tool_item_id)
  return _internal_tool_item_id();
}
inline void CMsgApplyStatTrakSwap::_internal_set_tool_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.tool_item_id_ = value;
}
inline void CMsgApplyStatTrakSwap::set_tool_item_id(uint64_t value) {
  _internal_set_tool_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyStatTrakSwap.tool_item_id)
}

// optional uint64 item_1_item_id = 2;
inline bool CMsgApplyStatTrakSwap::_internal_has_item_1_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgApplyStatTrakSwap::has_item_1_item_id() const {
  return _internal_has_item_1_item_id();
}
inline void CMsgApplyStatTrakSwap::clear_item_1_item_id() {
  _impl_.item_1_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgApplyStatTrakSwap::_internal_item_1_item_id() const {
  return _impl_.item_1_item_id_;
}
inline uint64_t CMsgApplyStatTrakSwap::item_1_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyStatTrakSwap.item_1_item_id)
  return _internal_item_1_item_id();
}
inline void CMsgApplyStatTrakSwap::_internal_set_item_1_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_1_item_id_ = value;
}
inline void CMsgApplyStatTrakSwap::set_item_1_item_id(uint64_t value) {
  _internal_set_item_1_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyStatTrakSwap.item_1_item_id)
}

// optional uint64 item_2_item_id = 3;
inline bool CMsgApplyStatTrakSwap::_internal_has_item_2_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgApplyStatTrakSwap::has_item_2_item_id() const {
  return _internal_has_item_2_item_id();
}
inline void CMsgApplyStatTrakSwap::clear_item_2_item_id() {
  _impl_.item_2_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgApplyStatTrakSwap::_internal_item_2_item_id() const {
  return _impl_.item_2_item_id_;
}
inline uint64_t CMsgApplyStatTrakSwap::item_2_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyStatTrakSwap.item_2_item_id)
  return _internal_item_2_item_id();
}
inline void CMsgApplyStatTrakSwap::_internal_set_item_2_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_2_item_id_ = value;
}
inline void CMsgApplyStatTrakSwap::set_item_2_item_id(uint64_t value) {
  _internal_set_item_2_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyStatTrakSwap.item_2_item_id)
}

// -------------------------------------------------------------------

// CMsgApplyStrangePart

// optional uint64 strange_part_item_id = 1;
inline bool CMsgApplyStrangePart::_internal_has_strange_part_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgApplyStrangePart::has_strange_part_item_id() const {
  return _internal_has_strange_part_item_id();
}
inline void CMsgApplyStrangePart::clear_strange_part_item_id() {
  _impl_.strange_part_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgApplyStrangePart::_internal_strange_part_item_id() const {
  return _impl_.strange_part_item_id_;
}
inline uint64_t CMsgApplyStrangePart::strange_part_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyStrangePart.strange_part_item_id)
  return _internal_strange_part_item_id();
}
inline void CMsgApplyStrangePart::_internal_set_strange_part_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.strange_part_item_id_ = value;
}
inline void CMsgApplyStrangePart::set_strange_part_item_id(uint64_t value) {
  _internal_set_strange_part_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyStrangePart.strange_part_item_id)
}

// optional uint64 item_item_id = 2;
inline bool CMsgApplyStrangePart::_internal_has_item_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgApplyStrangePart::has_item_item_id() const {
  return _internal_has_item_item_id();
}
inline void CMsgApplyStrangePart::clear_item_item_id() {
  _impl_.item_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgApplyStrangePart::_internal_item_item_id() const {
  return _impl_.item_item_id_;
}
inline uint64_t CMsgApplyStrangePart::item_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyStrangePart.item_item_id)
  return _internal_item_item_id();
}
inline void CMsgApplyStrangePart::_internal_set_item_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_item_id_ = value;
}
inline void CMsgApplyStrangePart::set_item_item_id(uint64_t value) {
  _internal_set_item_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyStrangePart.item_item_id)
}

// -------------------------------------------------------------------

// CMsgApplyPennantUpgrade

// optional uint64 upgrade_item_id = 1;
inline bool CMsgApplyPennantUpgrade::_internal_has_upgrade_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgApplyPennantUpgrade::has_upgrade_item_id() const {
  return _internal_has_upgrade_item_id();
}
inline void CMsgApplyPennantUpgrade::clear_upgrade_item_id() {
  _impl_.upgrade_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgApplyPennantUpgrade::_internal_upgrade_item_id() const {
  return _impl_.upgrade_item_id_;
}
inline uint64_t CMsgApplyPennantUpgrade::upgrade_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyPennantUpgrade.upgrade_item_id)
  return _internal_upgrade_item_id();
}
inline void CMsgApplyPennantUpgrade::_internal_set_upgrade_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.upgrade_item_id_ = value;
}
inline void CMsgApplyPennantUpgrade::set_upgrade_item_id(uint64_t value) {
  _internal_set_upgrade_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyPennantUpgrade.upgrade_item_id)
}

// optional uint64 pennant_item_id = 2;
inline bool CMsgApplyPennantUpgrade::_internal_has_pennant_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgApplyPennantUpgrade::has_pennant_item_id() const {
  return _internal_has_pennant_item_id();
}
inline void CMsgApplyPennantUpgrade::clear_pennant_item_id() {
  _impl_.pennant_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgApplyPennantUpgrade::_internal_pennant_item_id() const {
  return _impl_.pennant_item_id_;
}
inline uint64_t CMsgApplyPennantUpgrade::pennant_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyPennantUpgrade.pennant_item_id)
  return _internal_pennant_item_id();
}
inline void CMsgApplyPennantUpgrade::_internal_set_pennant_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pennant_item_id_ = value;
}
inline void CMsgApplyPennantUpgrade::set_pennant_item_id(uint64_t value) {
  _internal_set_pennant_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyPennantUpgrade.pennant_item_id)
}

// -------------------------------------------------------------------

// CMsgApplyEggEssence

// optional uint64 essence_item_id = 1;
inline bool CMsgApplyEggEssence::_internal_has_essence_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgApplyEggEssence::has_essence_item_id() const {
  return _internal_has_essence_item_id();
}
inline void CMsgApplyEggEssence::clear_essence_item_id() {
  _impl_.essence_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgApplyEggEssence::_internal_essence_item_id() const {
  return _impl_.essence_item_id_;
}
inline uint64_t CMsgApplyEggEssence::essence_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyEggEssence.essence_item_id)
  return _internal_essence_item_id();
}
inline void CMsgApplyEggEssence::_internal_set_essence_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.essence_item_id_ = value;
}
inline void CMsgApplyEggEssence::set_essence_item_id(uint64_t value) {
  _internal_set_essence_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyEggEssence.essence_item_id)
}

// optional uint64 egg_item_id = 2;
inline bool CMsgApplyEggEssence::_internal_has_egg_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgApplyEggEssence::has_egg_item_id() const {
  return _internal_has_egg_item_id();
}
inline void CMsgApplyEggEssence::clear_egg_item_id() {
  _impl_.egg_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgApplyEggEssence::_internal_egg_item_id() const {
  return _impl_.egg_item_id_;
}
inline uint64_t CMsgApplyEggEssence::egg_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgApplyEggEssence.egg_item_id)
  return _internal_egg_item_id();
}
inline void CMsgApplyEggEssence::_internal_set_egg_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.egg_item_id_ = value;
}
inline void CMsgApplyEggEssence::set_egg_item_id(uint64_t value) {
  _internal_set_egg_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgApplyEggEssence.egg_item_id)
}

// -------------------------------------------------------------------

// CSOEconItemAttribute

// optional uint32 def_index = 1;
inline bool CSOEconItemAttribute::_internal_has_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItemAttribute::has_def_index() const {
  return _internal_has_def_index();
}
inline void CSOEconItemAttribute::clear_def_index() {
  _impl_.def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconItemAttribute::_internal_def_index() const {
  return _impl_.def_index_;
}
inline uint32_t CSOEconItemAttribute::def_index() const {
  // @@protoc_insertion_point(field_get:CSOEconItemAttribute.def_index)
  return _internal_def_index();
}
inline void CSOEconItemAttribute::_internal_set_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.def_index_ = value;
}
inline void CSOEconItemAttribute::set_def_index(uint32_t value) {
  _internal_set_def_index(value);
  // @@protoc_insertion_point(field_set:CSOEconItemAttribute.def_index)
}

// optional uint32 value = 2;
inline bool CSOEconItemAttribute::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconItemAttribute::has_value() const {
  return _internal_has_value();
}
inline void CSOEconItemAttribute::clear_value() {
  _impl_.value_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOEconItemAttribute::_internal_value() const {
  return _impl_.value_;
}
inline uint32_t CSOEconItemAttribute::value() const {
  // @@protoc_insertion_point(field_get:CSOEconItemAttribute.value)
  return _internal_value();
}
inline void CSOEconItemAttribute::_internal_set_value(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.value_ = value;
}
inline void CSOEconItemAttribute::set_value(uint32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:CSOEconItemAttribute.value)
}

// optional bytes value_bytes = 3;
inline bool CSOEconItemAttribute::_internal_has_value_bytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItemAttribute::has_value_bytes() const {
  return _internal_has_value_bytes();
}
inline void CSOEconItemAttribute::clear_value_bytes() {
  _impl_.value_bytes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOEconItemAttribute::value_bytes() const {
  // @@protoc_insertion_point(field_get:CSOEconItemAttribute.value_bytes)
  return _internal_value_bytes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOEconItemAttribute::set_value_bytes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.value_bytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOEconItemAttribute.value_bytes)
}
inline std::string* CSOEconItemAttribute::mutable_value_bytes() {
  std::string* _s = _internal_mutable_value_bytes();
  // @@protoc_insertion_point(field_mutable:CSOEconItemAttribute.value_bytes)
  return _s;
}
inline const std::string& CSOEconItemAttribute::_internal_value_bytes() const {
  return _impl_.value_bytes_.Get();
}
inline void CSOEconItemAttribute::_internal_set_value_bytes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_bytes_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOEconItemAttribute::_internal_mutable_value_bytes() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.value_bytes_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOEconItemAttribute::release_value_bytes() {
  // @@protoc_insertion_point(field_release:CSOEconItemAttribute.value_bytes)
  if (!_internal_has_value_bytes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.value_bytes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_bytes_.IsDefault()) {
    _impl_.value_bytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOEconItemAttribute::set_allocated_value_bytes(std::string* value_bytes) {
  if (value_bytes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.value_bytes_.SetAllocated(value_bytes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_bytes_.IsDefault()) {
    _impl_.value_bytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOEconItemAttribute.value_bytes)
}

// -------------------------------------------------------------------

// CSOEconItemEquipped

// optional uint32 new_class = 1;
inline bool CSOEconItemEquipped::_internal_has_new_class() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItemEquipped::has_new_class() const {
  return _internal_has_new_class();
}
inline void CSOEconItemEquipped::clear_new_class() {
  _impl_.new_class_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconItemEquipped::_internal_new_class() const {
  return _impl_.new_class_;
}
inline uint32_t CSOEconItemEquipped::new_class() const {
  // @@protoc_insertion_point(field_get:CSOEconItemEquipped.new_class)
  return _internal_new_class();
}
inline void CSOEconItemEquipped::_internal_set_new_class(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.new_class_ = value;
}
inline void CSOEconItemEquipped::set_new_class(uint32_t value) {
  _internal_set_new_class(value);
  // @@protoc_insertion_point(field_set:CSOEconItemEquipped.new_class)
}

// optional uint32 new_slot = 2;
inline bool CSOEconItemEquipped::_internal_has_new_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItemEquipped::has_new_slot() const {
  return _internal_has_new_slot();
}
inline void CSOEconItemEquipped::clear_new_slot() {
  _impl_.new_slot_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconItemEquipped::_internal_new_slot() const {
  return _impl_.new_slot_;
}
inline uint32_t CSOEconItemEquipped::new_slot() const {
  // @@protoc_insertion_point(field_get:CSOEconItemEquipped.new_slot)
  return _internal_new_slot();
}
inline void CSOEconItemEquipped::_internal_set_new_slot(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.new_slot_ = value;
}
inline void CSOEconItemEquipped::set_new_slot(uint32_t value) {
  _internal_set_new_slot(value);
  // @@protoc_insertion_point(field_set:CSOEconItemEquipped.new_slot)
}

// -------------------------------------------------------------------

// CSOEconItem

// optional uint64 id = 1;
inline bool CSOEconItem::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconItem::has_id() const {
  return _internal_has_id();
}
inline void CSOEconItem::clear_id() {
  _impl_.id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CSOEconItem::_internal_id() const {
  return _impl_.id_;
}
inline uint64_t CSOEconItem::id() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.id)
  return _internal_id();
}
inline void CSOEconItem::_internal_set_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.id_ = value;
}
inline void CSOEconItem::set_id(uint64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.id)
}

// optional uint32 account_id = 2;
inline bool CSOEconItem::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOEconItem::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconItem::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CSOEconItem::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconItem::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.account_id)
  return _internal_account_id();
}
inline void CSOEconItem::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.account_id_ = value;
}
inline void CSOEconItem::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.account_id)
}

// optional uint32 inventory = 3;
inline bool CSOEconItem::_internal_has_inventory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSOEconItem::has_inventory() const {
  return _internal_has_inventory();
}
inline void CSOEconItem::clear_inventory() {
  _impl_.inventory_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CSOEconItem::_internal_inventory() const {
  return _impl_.inventory_;
}
inline uint32_t CSOEconItem::inventory() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.inventory)
  return _internal_inventory();
}
inline void CSOEconItem::_internal_set_inventory(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.inventory_ = value;
}
inline void CSOEconItem::set_inventory(uint32_t value) {
  _internal_set_inventory(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.inventory)
}

// optional uint32 def_index = 4;
inline bool CSOEconItem::_internal_has_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSOEconItem::has_def_index() const {
  return _internal_has_def_index();
}
inline void CSOEconItem::clear_def_index() {
  _impl_.def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CSOEconItem::_internal_def_index() const {
  return _impl_.def_index_;
}
inline uint32_t CSOEconItem::def_index() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.def_index)
  return _internal_def_index();
}
inline void CSOEconItem::_internal_set_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.def_index_ = value;
}
inline void CSOEconItem::set_def_index(uint32_t value) {
  _internal_set_def_index(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.def_index)
}

// optional uint32 quantity = 5;
inline bool CSOEconItem::_internal_has_quantity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSOEconItem::has_quantity() const {
  return _internal_has_quantity();
}
inline void CSOEconItem::clear_quantity() {
  _impl_.quantity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CSOEconItem::_internal_quantity() const {
  return _impl_.quantity_;
}
inline uint32_t CSOEconItem::quantity() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.quantity)
  return _internal_quantity();
}
inline void CSOEconItem::_internal_set_quantity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.quantity_ = value;
}
inline void CSOEconItem::set_quantity(uint32_t value) {
  _internal_set_quantity(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.quantity)
}

// optional uint32 level = 6;
inline bool CSOEconItem::_internal_has_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSOEconItem::has_level() const {
  return _internal_has_level();
}
inline void CSOEconItem::clear_level() {
  _impl_.level_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CSOEconItem::_internal_level() const {
  return _impl_.level_;
}
inline uint32_t CSOEconItem::level() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.level)
  return _internal_level();
}
inline void CSOEconItem::_internal_set_level(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.level_ = value;
}
inline void CSOEconItem::set_level(uint32_t value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.level)
}

// optional uint32 quality = 7;
inline bool CSOEconItem::_internal_has_quality() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSOEconItem::has_quality() const {
  return _internal_has_quality();
}
inline void CSOEconItem::clear_quality() {
  _impl_.quality_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CSOEconItem::_internal_quality() const {
  return _impl_.quality_;
}
inline uint32_t CSOEconItem::quality() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.quality)
  return _internal_quality();
}
inline void CSOEconItem::_internal_set_quality(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.quality_ = value;
}
inline void CSOEconItem::set_quality(uint32_t value) {
  _internal_set_quality(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.quality)
}

// optional uint32 flags = 8 [default = 0];
inline bool CSOEconItem::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSOEconItem::has_flags() const {
  return _internal_has_flags();
}
inline void CSOEconItem::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CSOEconItem::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t CSOEconItem::flags() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.flags)
  return _internal_flags();
}
inline void CSOEconItem::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.flags_ = value;
}
inline void CSOEconItem::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.flags)
}

// optional uint32 origin = 9;
inline bool CSOEconItem::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSOEconItem::has_origin() const {
  return _internal_has_origin();
}
inline void CSOEconItem::clear_origin() {
  _impl_.origin_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CSOEconItem::_internal_origin() const {
  return _impl_.origin_;
}
inline uint32_t CSOEconItem::origin() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.origin)
  return _internal_origin();
}
inline void CSOEconItem::_internal_set_origin(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.origin_ = value;
}
inline void CSOEconItem::set_origin(uint32_t value) {
  _internal_set_origin(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.origin)
}

// optional string custom_name = 10;
inline bool CSOEconItem::_internal_has_custom_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItem::has_custom_name() const {
  return _internal_has_custom_name();
}
inline void CSOEconItem::clear_custom_name() {
  _impl_.custom_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOEconItem::custom_name() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.custom_name)
  return _internal_custom_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOEconItem::set_custom_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.custom_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOEconItem.custom_name)
}
inline std::string* CSOEconItem::mutable_custom_name() {
  std::string* _s = _internal_mutable_custom_name();
  // @@protoc_insertion_point(field_mutable:CSOEconItem.custom_name)
  return _s;
}
inline const std::string& CSOEconItem::_internal_custom_name() const {
  return _impl_.custom_name_.Get();
}
inline void CSOEconItem::_internal_set_custom_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.custom_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOEconItem::_internal_mutable_custom_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.custom_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOEconItem::release_custom_name() {
  // @@protoc_insertion_point(field_release:CSOEconItem.custom_name)
  if (!_internal_has_custom_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.custom_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.custom_name_.IsDefault()) {
    _impl_.custom_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOEconItem::set_allocated_custom_name(std::string* custom_name) {
  if (custom_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.custom_name_.SetAllocated(custom_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.custom_name_.IsDefault()) {
    _impl_.custom_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOEconItem.custom_name)
}

// optional string custom_desc = 11;
inline bool CSOEconItem::_internal_has_custom_desc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItem::has_custom_desc() const {
  return _internal_has_custom_desc();
}
inline void CSOEconItem::clear_custom_desc() {
  _impl_.custom_desc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSOEconItem::custom_desc() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.custom_desc)
  return _internal_custom_desc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOEconItem::set_custom_desc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.custom_desc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOEconItem.custom_desc)
}
inline std::string* CSOEconItem::mutable_custom_desc() {
  std::string* _s = _internal_mutable_custom_desc();
  // @@protoc_insertion_point(field_mutable:CSOEconItem.custom_desc)
  return _s;
}
inline const std::string& CSOEconItem::_internal_custom_desc() const {
  return _impl_.custom_desc_.Get();
}
inline void CSOEconItem::_internal_set_custom_desc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.custom_desc_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOEconItem::_internal_mutable_custom_desc() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.custom_desc_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOEconItem::release_custom_desc() {
  // @@protoc_insertion_point(field_release:CSOEconItem.custom_desc)
  if (!_internal_has_custom_desc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.custom_desc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.custom_desc_.IsDefault()) {
    _impl_.custom_desc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOEconItem::set_allocated_custom_desc(std::string* custom_desc) {
  if (custom_desc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.custom_desc_.SetAllocated(custom_desc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.custom_desc_.IsDefault()) {
    _impl_.custom_desc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOEconItem.custom_desc)
}

// repeated .CSOEconItemAttribute attribute = 12;
inline int CSOEconItem::_internal_attribute_size() const {
  return _impl_.attribute_.size();
}
inline int CSOEconItem::attribute_size() const {
  return _internal_attribute_size();
}
inline void CSOEconItem::clear_attribute() {
  _impl_.attribute_.Clear();
}
inline ::CSOEconItemAttribute* CSOEconItem::mutable_attribute(int index) {
  // @@protoc_insertion_point(field_mutable:CSOEconItem.attribute)
  return _impl_.attribute_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemAttribute >*
CSOEconItem::mutable_attribute() {
  // @@protoc_insertion_point(field_mutable_list:CSOEconItem.attribute)
  return &_impl_.attribute_;
}
inline const ::CSOEconItemAttribute& CSOEconItem::_internal_attribute(int index) const {
  return _impl_.attribute_.Get(index);
}
inline const ::CSOEconItemAttribute& CSOEconItem::attribute(int index) const {
  // @@protoc_insertion_point(field_get:CSOEconItem.attribute)
  return _internal_attribute(index);
}
inline ::CSOEconItemAttribute* CSOEconItem::_internal_add_attribute() {
  return _impl_.attribute_.Add();
}
inline ::CSOEconItemAttribute* CSOEconItem::add_attribute() {
  ::CSOEconItemAttribute* _add = _internal_add_attribute();
  // @@protoc_insertion_point(field_add:CSOEconItem.attribute)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemAttribute >&
CSOEconItem::attribute() const {
  // @@protoc_insertion_point(field_list:CSOEconItem.attribute)
  return _impl_.attribute_;
}

// optional .CSOEconItem interior_item = 13;
inline bool CSOEconItem::_internal_has_interior_item() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.interior_item_ != nullptr);
  return value;
}
inline bool CSOEconItem::has_interior_item() const {
  return _internal_has_interior_item();
}
inline void CSOEconItem::clear_interior_item() {
  if (_impl_.interior_item_ != nullptr) _impl_.interior_item_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::CSOEconItem& CSOEconItem::_internal_interior_item() const {
  const ::CSOEconItem* p = _impl_.interior_item_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSOEconItem&>(
      ::_CSOEconItem_default_instance_);
}
inline const ::CSOEconItem& CSOEconItem::interior_item() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.interior_item)
  return _internal_interior_item();
}
inline void CSOEconItem::unsafe_arena_set_allocated_interior_item(
    ::CSOEconItem* interior_item) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interior_item_);
  }
  _impl_.interior_item_ = interior_item;
  if (interior_item) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSOEconItem.interior_item)
}
inline ::CSOEconItem* CSOEconItem::release_interior_item() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CSOEconItem* temp = _impl_.interior_item_;
  _impl_.interior_item_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSOEconItem* CSOEconItem::unsafe_arena_release_interior_item() {
  // @@protoc_insertion_point(field_release:CSOEconItem.interior_item)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CSOEconItem* temp = _impl_.interior_item_;
  _impl_.interior_item_ = nullptr;
  return temp;
}
inline ::CSOEconItem* CSOEconItem::_internal_mutable_interior_item() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.interior_item_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSOEconItem>(GetArenaForAllocation());
    _impl_.interior_item_ = p;
  }
  return _impl_.interior_item_;
}
inline ::CSOEconItem* CSOEconItem::mutable_interior_item() {
  ::CSOEconItem* _msg = _internal_mutable_interior_item();
  // @@protoc_insertion_point(field_mutable:CSOEconItem.interior_item)
  return _msg;
}
inline void CSOEconItem::set_allocated_interior_item(::CSOEconItem* interior_item) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.interior_item_;
  }
  if (interior_item) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interior_item);
    if (message_arena != submessage_arena) {
      interior_item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interior_item, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.interior_item_ = interior_item;
  // @@protoc_insertion_point(field_set_allocated:CSOEconItem.interior_item)
}

// optional bool in_use = 14 [default = false];
inline bool CSOEconItem::_internal_has_in_use() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSOEconItem::has_in_use() const {
  return _internal_has_in_use();
}
inline void CSOEconItem::clear_in_use() {
  _impl_.in_use_ = false;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool CSOEconItem::_internal_in_use() const {
  return _impl_.in_use_;
}
inline bool CSOEconItem::in_use() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.in_use)
  return _internal_in_use();
}
inline void CSOEconItem::_internal_set_in_use(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.in_use_ = value;
}
inline void CSOEconItem::set_in_use(bool value) {
  _internal_set_in_use(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.in_use)
}

// optional uint32 style = 15 [default = 0];
inline bool CSOEconItem::_internal_has_style() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSOEconItem::has_style() const {
  return _internal_has_style();
}
inline void CSOEconItem::clear_style() {
  _impl_.style_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CSOEconItem::_internal_style() const {
  return _impl_.style_;
}
inline uint32_t CSOEconItem::style() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.style)
  return _internal_style();
}
inline void CSOEconItem::_internal_set_style(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.style_ = value;
}
inline void CSOEconItem::set_style(uint32_t value) {
  _internal_set_style(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.style)
}

// optional uint64 original_id = 16 [default = 0];
inline bool CSOEconItem::_internal_has_original_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSOEconItem::has_original_id() const {
  return _internal_has_original_id();
}
inline void CSOEconItem::clear_original_id() {
  _impl_.original_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t CSOEconItem::_internal_original_id() const {
  return _impl_.original_id_;
}
inline uint64_t CSOEconItem::original_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.original_id)
  return _internal_original_id();
}
inline void CSOEconItem::_internal_set_original_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.original_id_ = value;
}
inline void CSOEconItem::set_original_id(uint64_t value) {
  _internal_set_original_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.original_id)
}

// repeated .CSOEconItemEquipped equipped_state = 18;
inline int CSOEconItem::_internal_equipped_state_size() const {
  return _impl_.equipped_state_.size();
}
inline int CSOEconItem::equipped_state_size() const {
  return _internal_equipped_state_size();
}
inline void CSOEconItem::clear_equipped_state() {
  _impl_.equipped_state_.Clear();
}
inline ::CSOEconItemEquipped* CSOEconItem::mutable_equipped_state(int index) {
  // @@protoc_insertion_point(field_mutable:CSOEconItem.equipped_state)
  return _impl_.equipped_state_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemEquipped >*
CSOEconItem::mutable_equipped_state() {
  // @@protoc_insertion_point(field_mutable_list:CSOEconItem.equipped_state)
  return &_impl_.equipped_state_;
}
inline const ::CSOEconItemEquipped& CSOEconItem::_internal_equipped_state(int index) const {
  return _impl_.equipped_state_.Get(index);
}
inline const ::CSOEconItemEquipped& CSOEconItem::equipped_state(int index) const {
  // @@protoc_insertion_point(field_get:CSOEconItem.equipped_state)
  return _internal_equipped_state(index);
}
inline ::CSOEconItemEquipped* CSOEconItem::_internal_add_equipped_state() {
  return _impl_.equipped_state_.Add();
}
inline ::CSOEconItemEquipped* CSOEconItem::add_equipped_state() {
  ::CSOEconItemEquipped* _add = _internal_add_equipped_state();
  // @@protoc_insertion_point(field_add:CSOEconItem.equipped_state)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSOEconItemEquipped >&
CSOEconItem::equipped_state() const {
  // @@protoc_insertion_point(field_list:CSOEconItem.equipped_state)
  return _impl_.equipped_state_;
}

// optional uint32 rarity = 19;
inline bool CSOEconItem::_internal_has_rarity() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSOEconItem::has_rarity() const {
  return _internal_has_rarity();
}
inline void CSOEconItem::clear_rarity() {
  _impl_.rarity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CSOEconItem::_internal_rarity() const {
  return _impl_.rarity_;
}
inline uint32_t CSOEconItem::rarity() const {
  // @@protoc_insertion_point(field_get:CSOEconItem.rarity)
  return _internal_rarity();
}
inline void CSOEconItem::_internal_set_rarity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.rarity_ = value;
}
inline void CSOEconItem::set_rarity(uint32_t value) {
  _internal_set_rarity(value);
  // @@protoc_insertion_point(field_set:CSOEconItem.rarity)
}

// -------------------------------------------------------------------

// CMsgSortItems

// optional uint32 sort_type = 1;
inline bool CMsgSortItems::_internal_has_sort_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSortItems::has_sort_type() const {
  return _internal_has_sort_type();
}
inline void CMsgSortItems::clear_sort_type() {
  _impl_.sort_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSortItems::_internal_sort_type() const {
  return _impl_.sort_type_;
}
inline uint32_t CMsgSortItems::sort_type() const {
  // @@protoc_insertion_point(field_get:CMsgSortItems.sort_type)
  return _internal_sort_type();
}
inline void CMsgSortItems::_internal_set_sort_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sort_type_ = value;
}
inline void CMsgSortItems::set_sort_type(uint32_t value) {
  _internal_set_sort_type(value);
  // @@protoc_insertion_point(field_set:CMsgSortItems.sort_type)
}

// -------------------------------------------------------------------

// CSOEconClaimCode

// optional uint32 account_id = 1;
inline bool CSOEconClaimCode::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconClaimCode::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconClaimCode::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconClaimCode::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconClaimCode::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconClaimCode.account_id)
  return _internal_account_id();
}
inline void CSOEconClaimCode::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.account_id_ = value;
}
inline void CSOEconClaimCode::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconClaimCode.account_id)
}

// optional uint32 code_type = 2;
inline bool CSOEconClaimCode::_internal_has_code_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconClaimCode::has_code_type() const {
  return _internal_has_code_type();
}
inline void CSOEconClaimCode::clear_code_type() {
  _impl_.code_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOEconClaimCode::_internal_code_type() const {
  return _impl_.code_type_;
}
inline uint32_t CSOEconClaimCode::code_type() const {
  // @@protoc_insertion_point(field_get:CSOEconClaimCode.code_type)
  return _internal_code_type();
}
inline void CSOEconClaimCode::_internal_set_code_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.code_type_ = value;
}
inline void CSOEconClaimCode::set_code_type(uint32_t value) {
  _internal_set_code_type(value);
  // @@protoc_insertion_point(field_set:CSOEconClaimCode.code_type)
}

// optional uint32 time_acquired = 3;
inline bool CSOEconClaimCode::_internal_has_time_acquired() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconClaimCode::has_time_acquired() const {
  return _internal_has_time_acquired();
}
inline void CSOEconClaimCode::clear_time_acquired() {
  _impl_.time_acquired_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconClaimCode::_internal_time_acquired() const {
  return _impl_.time_acquired_;
}
inline uint32_t CSOEconClaimCode::time_acquired() const {
  // @@protoc_insertion_point(field_get:CSOEconClaimCode.time_acquired)
  return _internal_time_acquired();
}
inline void CSOEconClaimCode::_internal_set_time_acquired(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.time_acquired_ = value;
}
inline void CSOEconClaimCode::set_time_acquired(uint32_t value) {
  _internal_set_time_acquired(value);
  // @@protoc_insertion_point(field_set:CSOEconClaimCode.time_acquired)
}

// optional string code = 4;
inline bool CSOEconClaimCode::_internal_has_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconClaimCode::has_code() const {
  return _internal_has_code();
}
inline void CSOEconClaimCode::clear_code() {
  _impl_.code_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSOEconClaimCode::code() const {
  // @@protoc_insertion_point(field_get:CSOEconClaimCode.code)
  return _internal_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSOEconClaimCode::set_code(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSOEconClaimCode.code)
}
inline std::string* CSOEconClaimCode::mutable_code() {
  std::string* _s = _internal_mutable_code();
  // @@protoc_insertion_point(field_mutable:CSOEconClaimCode.code)
  return _s;
}
inline const std::string& CSOEconClaimCode::_internal_code() const {
  return _impl_.code_.Get();
}
inline void CSOEconClaimCode::_internal_set_code(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.code_.Set(value, GetArenaForAllocation());
}
inline std::string* CSOEconClaimCode::_internal_mutable_code() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.code_.Mutable(GetArenaForAllocation());
}
inline std::string* CSOEconClaimCode::release_code() {
  // @@protoc_insertion_point(field_release:CSOEconClaimCode.code)
  if (!_internal_has_code()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.code_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.code_.IsDefault()) {
    _impl_.code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSOEconClaimCode::set_allocated_code(std::string* code) {
  if (code != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.code_.SetAllocated(code, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.code_.IsDefault()) {
    _impl_.code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSOEconClaimCode.code)
}

// -------------------------------------------------------------------

// CMsgStoreGetUserData

// optional fixed32 price_sheet_version = 1;
inline bool CMsgStoreGetUserData::_internal_has_price_sheet_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgStoreGetUserData::has_price_sheet_version() const {
  return _internal_has_price_sheet_version();
}
inline void CMsgStoreGetUserData::clear_price_sheet_version() {
  _impl_.price_sheet_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgStoreGetUserData::_internal_price_sheet_version() const {
  return _impl_.price_sheet_version_;
}
inline uint32_t CMsgStoreGetUserData::price_sheet_version() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserData.price_sheet_version)
  return _internal_price_sheet_version();
}
inline void CMsgStoreGetUserData::_internal_set_price_sheet_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.price_sheet_version_ = value;
}
inline void CMsgStoreGetUserData::set_price_sheet_version(uint32_t value) {
  _internal_set_price_sheet_version(value);
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserData.price_sheet_version)
}

// optional int32 currency = 2;
inline bool CMsgStoreGetUserData::_internal_has_currency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgStoreGetUserData::has_currency() const {
  return _internal_has_currency();
}
inline void CMsgStoreGetUserData::clear_currency() {
  _impl_.currency_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgStoreGetUserData::_internal_currency() const {
  return _impl_.currency_;
}
inline int32_t CMsgStoreGetUserData::currency() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserData.currency)
  return _internal_currency();
}
inline void CMsgStoreGetUserData::_internal_set_currency(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.currency_ = value;
}
inline void CMsgStoreGetUserData::set_currency(int32_t value) {
  _internal_set_currency(value);
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserData.currency)
}

// -------------------------------------------------------------------

// CMsgStoreGetUserDataResponse

// optional int32 result = 1;
inline bool CMsgStoreGetUserDataResponse::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgStoreGetUserDataResponse::has_result() const {
  return _internal_has_result();
}
inline void CMsgStoreGetUserDataResponse::clear_result() {
  _impl_.result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgStoreGetUserDataResponse::_internal_result() const {
  return _impl_.result_;
}
inline int32_t CMsgStoreGetUserDataResponse::result() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserDataResponse.result)
  return _internal_result();
}
inline void CMsgStoreGetUserDataResponse::_internal_set_result(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.result_ = value;
}
inline void CMsgStoreGetUserDataResponse::set_result(int32_t value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserDataResponse.result)
}

// optional int32 currency_deprecated = 2;
inline bool CMsgStoreGetUserDataResponse::_internal_has_currency_deprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgStoreGetUserDataResponse::has_currency_deprecated() const {
  return _internal_has_currency_deprecated();
}
inline void CMsgStoreGetUserDataResponse::clear_currency_deprecated() {
  _impl_.currency_deprecated_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgStoreGetUserDataResponse::_internal_currency_deprecated() const {
  return _impl_.currency_deprecated_;
}
inline int32_t CMsgStoreGetUserDataResponse::currency_deprecated() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserDataResponse.currency_deprecated)
  return _internal_currency_deprecated();
}
inline void CMsgStoreGetUserDataResponse::_internal_set_currency_deprecated(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.currency_deprecated_ = value;
}
inline void CMsgStoreGetUserDataResponse::set_currency_deprecated(int32_t value) {
  _internal_set_currency_deprecated(value);
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserDataResponse.currency_deprecated)
}

// optional string country_deprecated = 3;
inline bool CMsgStoreGetUserDataResponse::_internal_has_country_deprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgStoreGetUserDataResponse::has_country_deprecated() const {
  return _internal_has_country_deprecated();
}
inline void CMsgStoreGetUserDataResponse::clear_country_deprecated() {
  _impl_.country_deprecated_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgStoreGetUserDataResponse::country_deprecated() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserDataResponse.country_deprecated)
  return _internal_country_deprecated();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgStoreGetUserDataResponse::set_country_deprecated(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.country_deprecated_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserDataResponse.country_deprecated)
}
inline std::string* CMsgStoreGetUserDataResponse::mutable_country_deprecated() {
  std::string* _s = _internal_mutable_country_deprecated();
  // @@protoc_insertion_point(field_mutable:CMsgStoreGetUserDataResponse.country_deprecated)
  return _s;
}
inline const std::string& CMsgStoreGetUserDataResponse::_internal_country_deprecated() const {
  return _impl_.country_deprecated_.Get();
}
inline void CMsgStoreGetUserDataResponse::_internal_set_country_deprecated(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.country_deprecated_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgStoreGetUserDataResponse::_internal_mutable_country_deprecated() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.country_deprecated_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgStoreGetUserDataResponse::release_country_deprecated() {
  // @@protoc_insertion_point(field_release:CMsgStoreGetUserDataResponse.country_deprecated)
  if (!_internal_has_country_deprecated()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.country_deprecated_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_deprecated_.IsDefault()) {
    _impl_.country_deprecated_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgStoreGetUserDataResponse::set_allocated_country_deprecated(std::string* country_deprecated) {
  if (country_deprecated != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.country_deprecated_.SetAllocated(country_deprecated, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.country_deprecated_.IsDefault()) {
    _impl_.country_deprecated_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgStoreGetUserDataResponse.country_deprecated)
}

// optional fixed32 price_sheet_version = 4;
inline bool CMsgStoreGetUserDataResponse::_internal_has_price_sheet_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgStoreGetUserDataResponse::has_price_sheet_version() const {
  return _internal_has_price_sheet_version();
}
inline void CMsgStoreGetUserDataResponse::clear_price_sheet_version() {
  _impl_.price_sheet_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgStoreGetUserDataResponse::_internal_price_sheet_version() const {
  return _impl_.price_sheet_version_;
}
inline uint32_t CMsgStoreGetUserDataResponse::price_sheet_version() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserDataResponse.price_sheet_version)
  return _internal_price_sheet_version();
}
inline void CMsgStoreGetUserDataResponse::_internal_set_price_sheet_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.price_sheet_version_ = value;
}
inline void CMsgStoreGetUserDataResponse::set_price_sheet_version(uint32_t value) {
  _internal_set_price_sheet_version(value);
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserDataResponse.price_sheet_version)
}

// optional bytes price_sheet = 8;
inline bool CMsgStoreGetUserDataResponse::_internal_has_price_sheet() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgStoreGetUserDataResponse::has_price_sheet() const {
  return _internal_has_price_sheet();
}
inline void CMsgStoreGetUserDataResponse::clear_price_sheet() {
  _impl_.price_sheet_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgStoreGetUserDataResponse::price_sheet() const {
  // @@protoc_insertion_point(field_get:CMsgStoreGetUserDataResponse.price_sheet)
  return _internal_price_sheet();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgStoreGetUserDataResponse::set_price_sheet(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.price_sheet_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgStoreGetUserDataResponse.price_sheet)
}
inline std::string* CMsgStoreGetUserDataResponse::mutable_price_sheet() {
  std::string* _s = _internal_mutable_price_sheet();
  // @@protoc_insertion_point(field_mutable:CMsgStoreGetUserDataResponse.price_sheet)
  return _s;
}
inline const std::string& CMsgStoreGetUserDataResponse::_internal_price_sheet() const {
  return _impl_.price_sheet_.Get();
}
inline void CMsgStoreGetUserDataResponse::_internal_set_price_sheet(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.price_sheet_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgStoreGetUserDataResponse::_internal_mutable_price_sheet() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.price_sheet_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgStoreGetUserDataResponse::release_price_sheet() {
  // @@protoc_insertion_point(field_release:CMsgStoreGetUserDataResponse.price_sheet)
  if (!_internal_has_price_sheet()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.price_sheet_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.price_sheet_.IsDefault()) {
    _impl_.price_sheet_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgStoreGetUserDataResponse::set_allocated_price_sheet(std::string* price_sheet) {
  if (price_sheet != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.price_sheet_.SetAllocated(price_sheet, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.price_sheet_.IsDefault()) {
    _impl_.price_sheet_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgStoreGetUserDataResponse.price_sheet)
}

// -------------------------------------------------------------------

// CMsgUpdateItemSchema

// optional bytes items_game = 1;
inline bool CMsgUpdateItemSchema::_internal_has_items_game() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgUpdateItemSchema::has_items_game() const {
  return _internal_has_items_game();
}
inline void CMsgUpdateItemSchema::clear_items_game() {
  _impl_.items_game_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgUpdateItemSchema::items_game() const {
  // @@protoc_insertion_point(field_get:CMsgUpdateItemSchema.items_game)
  return _internal_items_game();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgUpdateItemSchema::set_items_game(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.items_game_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgUpdateItemSchema.items_game)
}
inline std::string* CMsgUpdateItemSchema::mutable_items_game() {
  std::string* _s = _internal_mutable_items_game();
  // @@protoc_insertion_point(field_mutable:CMsgUpdateItemSchema.items_game)
  return _s;
}
inline const std::string& CMsgUpdateItemSchema::_internal_items_game() const {
  return _impl_.items_game_.Get();
}
inline void CMsgUpdateItemSchema::_internal_set_items_game(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.items_game_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgUpdateItemSchema::_internal_mutable_items_game() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.items_game_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgUpdateItemSchema::release_items_game() {
  // @@protoc_insertion_point(field_release:CMsgUpdateItemSchema.items_game)
  if (!_internal_has_items_game()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.items_game_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.items_game_.IsDefault()) {
    _impl_.items_game_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgUpdateItemSchema::set_allocated_items_game(std::string* items_game) {
  if (items_game != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.items_game_.SetAllocated(items_game, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.items_game_.IsDefault()) {
    _impl_.items_game_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgUpdateItemSchema.items_game)
}

// optional fixed32 item_schema_version = 2;
inline bool CMsgUpdateItemSchema::_internal_has_item_schema_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgUpdateItemSchema::has_item_schema_version() const {
  return _internal_has_item_schema_version();
}
inline void CMsgUpdateItemSchema::clear_item_schema_version() {
  _impl_.item_schema_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgUpdateItemSchema::_internal_item_schema_version() const {
  return _impl_.item_schema_version_;
}
inline uint32_t CMsgUpdateItemSchema::item_schema_version() const {
  // @@protoc_insertion_point(field_get:CMsgUpdateItemSchema.item_schema_version)
  return _internal_item_schema_version();
}
inline void CMsgUpdateItemSchema::_internal_set_item_schema_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_schema_version_ = value;
}
inline void CMsgUpdateItemSchema::set_item_schema_version(uint32_t value) {
  _internal_set_item_schema_version(value);
  // @@protoc_insertion_point(field_set:CMsgUpdateItemSchema.item_schema_version)
}

// optional string items_game_url = 4;
inline bool CMsgUpdateItemSchema::_internal_has_items_game_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgUpdateItemSchema::has_items_game_url() const {
  return _internal_has_items_game_url();
}
inline void CMsgUpdateItemSchema::clear_items_game_url() {
  _impl_.items_game_url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgUpdateItemSchema::items_game_url() const {
  // @@protoc_insertion_point(field_get:CMsgUpdateItemSchema.items_game_url)
  return _internal_items_game_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgUpdateItemSchema::set_items_game_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.items_game_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgUpdateItemSchema.items_game_url)
}
inline std::string* CMsgUpdateItemSchema::mutable_items_game_url() {
  std::string* _s = _internal_mutable_items_game_url();
  // @@protoc_insertion_point(field_mutable:CMsgUpdateItemSchema.items_game_url)
  return _s;
}
inline const std::string& CMsgUpdateItemSchema::_internal_items_game_url() const {
  return _impl_.items_game_url_.Get();
}
inline void CMsgUpdateItemSchema::_internal_set_items_game_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.items_game_url_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgUpdateItemSchema::_internal_mutable_items_game_url() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.items_game_url_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgUpdateItemSchema::release_items_game_url() {
  // @@protoc_insertion_point(field_release:CMsgUpdateItemSchema.items_game_url)
  if (!_internal_has_items_game_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.items_game_url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.items_game_url_.IsDefault()) {
    _impl_.items_game_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgUpdateItemSchema::set_allocated_items_game_url(std::string* items_game_url) {
  if (items_game_url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.items_game_url_.SetAllocated(items_game_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.items_game_url_.IsDefault()) {
    _impl_.items_game_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgUpdateItemSchema.items_game_url)
}

// -------------------------------------------------------------------

// CMsgGCError

// optional string error_text = 1;
inline bool CMsgGCError::_internal_has_error_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCError::has_error_text() const {
  return _internal_has_error_text();
}
inline void CMsgGCError::clear_error_text() {
  _impl_.error_text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCError::error_text() const {
  // @@protoc_insertion_point(field_get:CMsgGCError.error_text)
  return _internal_error_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCError::set_error_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.error_text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCError.error_text)
}
inline std::string* CMsgGCError::mutable_error_text() {
  std::string* _s = _internal_mutable_error_text();
  // @@protoc_insertion_point(field_mutable:CMsgGCError.error_text)
  return _s;
}
inline const std::string& CMsgGCError::_internal_error_text() const {
  return _impl_.error_text_.Get();
}
inline void CMsgGCError::_internal_set_error_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.error_text_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCError::_internal_mutable_error_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.error_text_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCError::release_error_text() {
  // @@protoc_insertion_point(field_release:CMsgGCError.error_text)
  if (!_internal_has_error_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.error_text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_text_.IsDefault()) {
    _impl_.error_text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCError::set_allocated_error_text(std::string* error_text) {
  if (error_text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.error_text_.SetAllocated(error_text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_text_.IsDefault()) {
    _impl_.error_text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCError.error_text)
}

// -------------------------------------------------------------------

// CMsgRequestInventoryRefresh

// -------------------------------------------------------------------

// CMsgConVarValue

// optional string name = 1;
inline bool CMsgConVarValue::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgConVarValue::has_name() const {
  return _internal_has_name();
}
inline void CMsgConVarValue::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgConVarValue::name() const {
  // @@protoc_insertion_point(field_get:CMsgConVarValue.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgConVarValue::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgConVarValue.name)
}
inline std::string* CMsgConVarValue::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CMsgConVarValue.name)
  return _s;
}
inline const std::string& CMsgConVarValue::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CMsgConVarValue::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgConVarValue::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgConVarValue::release_name() {
  // @@protoc_insertion_point(field_release:CMsgConVarValue.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgConVarValue::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgConVarValue.name)
}

// optional string value = 2;
inline bool CMsgConVarValue::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgConVarValue::has_value() const {
  return _internal_has_value();
}
inline void CMsgConVarValue::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgConVarValue::value() const {
  // @@protoc_insertion_point(field_get:CMsgConVarValue.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgConVarValue::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgConVarValue.value)
}
inline std::string* CMsgConVarValue::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:CMsgConVarValue.value)
  return _s;
}
inline const std::string& CMsgConVarValue::_internal_value() const {
  return _impl_.value_.Get();
}
inline void CMsgConVarValue::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgConVarValue::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgConVarValue::release_value() {
  // @@protoc_insertion_point(field_release:CMsgConVarValue.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgConVarValue::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgConVarValue.value)
}

// -------------------------------------------------------------------

// CMsgReplicateConVars

// repeated .CMsgConVarValue convars = 1;
inline int CMsgReplicateConVars::_internal_convars_size() const {
  return _impl_.convars_.size();
}
inline int CMsgReplicateConVars::convars_size() const {
  return _internal_convars_size();
}
inline void CMsgReplicateConVars::clear_convars() {
  _impl_.convars_.Clear();
}
inline ::CMsgConVarValue* CMsgReplicateConVars::mutable_convars(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgReplicateConVars.convars)
  return _impl_.convars_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgConVarValue >*
CMsgReplicateConVars::mutable_convars() {
  // @@protoc_insertion_point(field_mutable_list:CMsgReplicateConVars.convars)
  return &_impl_.convars_;
}
inline const ::CMsgConVarValue& CMsgReplicateConVars::_internal_convars(int index) const {
  return _impl_.convars_.Get(index);
}
inline const ::CMsgConVarValue& CMsgReplicateConVars::convars(int index) const {
  // @@protoc_insertion_point(field_get:CMsgReplicateConVars.convars)
  return _internal_convars(index);
}
inline ::CMsgConVarValue* CMsgReplicateConVars::_internal_add_convars() {
  return _impl_.convars_.Add();
}
inline ::CMsgConVarValue* CMsgReplicateConVars::add_convars() {
  ::CMsgConVarValue* _add = _internal_add_convars();
  // @@protoc_insertion_point(field_add:CMsgReplicateConVars.convars)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgConVarValue >&
CMsgReplicateConVars::convars() const {
  // @@protoc_insertion_point(field_list:CMsgReplicateConVars.convars)
  return _impl_.convars_;
}

// -------------------------------------------------------------------

// CMsgUseItem

// optional uint64 item_id = 1;
inline bool CMsgUseItem::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgUseItem::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgUseItem::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgUseItem::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgUseItem::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgUseItem.item_id)
  return _internal_item_id();
}
inline void CMsgUseItem::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_id_ = value;
}
inline void CMsgUseItem::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgUseItem.item_id)
}

// optional fixed64 target_steam_id = 2;
inline bool CMsgUseItem::_internal_has_target_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgUseItem::has_target_steam_id() const {
  return _internal_has_target_steam_id();
}
inline void CMsgUseItem::clear_target_steam_id() {
  _impl_.target_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgUseItem::_internal_target_steam_id() const {
  return _impl_.target_steam_id_;
}
inline uint64_t CMsgUseItem::target_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgUseItem.target_steam_id)
  return _internal_target_steam_id();
}
inline void CMsgUseItem::_internal_set_target_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.target_steam_id_ = value;
}
inline void CMsgUseItem::set_target_steam_id(uint64_t value) {
  _internal_set_target_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgUseItem.target_steam_id)
}

// repeated uint32 gift__potential_targets = 3;
inline int CMsgUseItem::_internal_gift__potential_targets_size() const {
  return _impl_.gift__potential_targets_.size();
}
inline int CMsgUseItem::gift__potential_targets_size() const {
  return _internal_gift__potential_targets_size();
}
inline void CMsgUseItem::clear_gift__potential_targets() {
  _impl_.gift__potential_targets_.Clear();
}
inline uint32_t CMsgUseItem::_internal_gift__potential_targets(int index) const {
  return _impl_.gift__potential_targets_.Get(index);
}
inline uint32_t CMsgUseItem::gift__potential_targets(int index) const {
  // @@protoc_insertion_point(field_get:CMsgUseItem.gift__potential_targets)
  return _internal_gift__potential_targets(index);
}
inline void CMsgUseItem::set_gift__potential_targets(int index, uint32_t value) {
  _impl_.gift__potential_targets_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgUseItem.gift__potential_targets)
}
inline void CMsgUseItem::_internal_add_gift__potential_targets(uint32_t value) {
  _impl_.gift__potential_targets_.Add(value);
}
inline void CMsgUseItem::add_gift__potential_targets(uint32_t value) {
  _internal_add_gift__potential_targets(value);
  // @@protoc_insertion_point(field_add:CMsgUseItem.gift__potential_targets)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgUseItem::_internal_gift__potential_targets() const {
  return _impl_.gift__potential_targets_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgUseItem::gift__potential_targets() const {
  // @@protoc_insertion_point(field_list:CMsgUseItem.gift__potential_targets)
  return _internal_gift__potential_targets();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgUseItem::_internal_mutable_gift__potential_targets() {
  return &_impl_.gift__potential_targets_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgUseItem::mutable_gift__potential_targets() {
  // @@protoc_insertion_point(field_mutable_list:CMsgUseItem.gift__potential_targets)
  return _internal_mutable_gift__potential_targets();
}

// optional uint32 duel__class_lock = 4;
inline bool CMsgUseItem::_internal_has_duel__class_lock() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgUseItem::has_duel__class_lock() const {
  return _internal_has_duel__class_lock();
}
inline void CMsgUseItem::clear_duel__class_lock() {
  _impl_.duel__class_lock_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgUseItem::_internal_duel__class_lock() const {
  return _impl_.duel__class_lock_;
}
inline uint32_t CMsgUseItem::duel__class_lock() const {
  // @@protoc_insertion_point(field_get:CMsgUseItem.duel__class_lock)
  return _internal_duel__class_lock();
}
inline void CMsgUseItem::_internal_set_duel__class_lock(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.duel__class_lock_ = value;
}
inline void CMsgUseItem::set_duel__class_lock(uint32_t value) {
  _internal_set_duel__class_lock(value);
  // @@protoc_insertion_point(field_set:CMsgUseItem.duel__class_lock)
}

// optional fixed64 initiator_steam_id = 5;
inline bool CMsgUseItem::_internal_has_initiator_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgUseItem::has_initiator_steam_id() const {
  return _internal_has_initiator_steam_id();
}
inline void CMsgUseItem::clear_initiator_steam_id() {
  _impl_.initiator_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgUseItem::_internal_initiator_steam_id() const {
  return _impl_.initiator_steam_id_;
}
inline uint64_t CMsgUseItem::initiator_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgUseItem.initiator_steam_id)
  return _internal_initiator_steam_id();
}
inline void CMsgUseItem::_internal_set_initiator_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.initiator_steam_id_ = value;
}
inline void CMsgUseItem::set_initiator_steam_id(uint64_t value) {
  _internal_set_initiator_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgUseItem.initiator_steam_id)
}

// -------------------------------------------------------------------

// CMsgReplayUploadedToYouTube

// optional string youtube_url = 1;
inline bool CMsgReplayUploadedToYouTube::_internal_has_youtube_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgReplayUploadedToYouTube::has_youtube_url() const {
  return _internal_has_youtube_url();
}
inline void CMsgReplayUploadedToYouTube::clear_youtube_url() {
  _impl_.youtube_url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgReplayUploadedToYouTube::youtube_url() const {
  // @@protoc_insertion_point(field_get:CMsgReplayUploadedToYouTube.youtube_url)
  return _internal_youtube_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgReplayUploadedToYouTube::set_youtube_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.youtube_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgReplayUploadedToYouTube.youtube_url)
}
inline std::string* CMsgReplayUploadedToYouTube::mutable_youtube_url() {
  std::string* _s = _internal_mutable_youtube_url();
  // @@protoc_insertion_point(field_mutable:CMsgReplayUploadedToYouTube.youtube_url)
  return _s;
}
inline const std::string& CMsgReplayUploadedToYouTube::_internal_youtube_url() const {
  return _impl_.youtube_url_.Get();
}
inline void CMsgReplayUploadedToYouTube::_internal_set_youtube_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.youtube_url_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgReplayUploadedToYouTube::_internal_mutable_youtube_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.youtube_url_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgReplayUploadedToYouTube::release_youtube_url() {
  // @@protoc_insertion_point(field_release:CMsgReplayUploadedToYouTube.youtube_url)
  if (!_internal_has_youtube_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.youtube_url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.youtube_url_.IsDefault()) {
    _impl_.youtube_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgReplayUploadedToYouTube::set_allocated_youtube_url(std::string* youtube_url) {
  if (youtube_url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.youtube_url_.SetAllocated(youtube_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.youtube_url_.IsDefault()) {
    _impl_.youtube_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgReplayUploadedToYouTube.youtube_url)
}

// optional string youtube_account_name = 2;
inline bool CMsgReplayUploadedToYouTube::_internal_has_youtube_account_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgReplayUploadedToYouTube::has_youtube_account_name() const {
  return _internal_has_youtube_account_name();
}
inline void CMsgReplayUploadedToYouTube::clear_youtube_account_name() {
  _impl_.youtube_account_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgReplayUploadedToYouTube::youtube_account_name() const {
  // @@protoc_insertion_point(field_get:CMsgReplayUploadedToYouTube.youtube_account_name)
  return _internal_youtube_account_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgReplayUploadedToYouTube::set_youtube_account_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.youtube_account_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgReplayUploadedToYouTube.youtube_account_name)
}
inline std::string* CMsgReplayUploadedToYouTube::mutable_youtube_account_name() {
  std::string* _s = _internal_mutable_youtube_account_name();
  // @@protoc_insertion_point(field_mutable:CMsgReplayUploadedToYouTube.youtube_account_name)
  return _s;
}
inline const std::string& CMsgReplayUploadedToYouTube::_internal_youtube_account_name() const {
  return _impl_.youtube_account_name_.Get();
}
inline void CMsgReplayUploadedToYouTube::_internal_set_youtube_account_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.youtube_account_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgReplayUploadedToYouTube::_internal_mutable_youtube_account_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.youtube_account_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgReplayUploadedToYouTube::release_youtube_account_name() {
  // @@protoc_insertion_point(field_release:CMsgReplayUploadedToYouTube.youtube_account_name)
  if (!_internal_has_youtube_account_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.youtube_account_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.youtube_account_name_.IsDefault()) {
    _impl_.youtube_account_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgReplayUploadedToYouTube::set_allocated_youtube_account_name(std::string* youtube_account_name) {
  if (youtube_account_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.youtube_account_name_.SetAllocated(youtube_account_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.youtube_account_name_.IsDefault()) {
    _impl_.youtube_account_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgReplayUploadedToYouTube.youtube_account_name)
}

// optional uint64 session_id = 3;
inline bool CMsgReplayUploadedToYouTube::_internal_has_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgReplayUploadedToYouTube::has_session_id() const {
  return _internal_has_session_id();
}
inline void CMsgReplayUploadedToYouTube::clear_session_id() {
  _impl_.session_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgReplayUploadedToYouTube::_internal_session_id() const {
  return _impl_.session_id_;
}
inline uint64_t CMsgReplayUploadedToYouTube::session_id() const {
  // @@protoc_insertion_point(field_get:CMsgReplayUploadedToYouTube.session_id)
  return _internal_session_id();
}
inline void CMsgReplayUploadedToYouTube::_internal_set_session_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.session_id_ = value;
}
inline void CMsgReplayUploadedToYouTube::set_session_id(uint64_t value) {
  _internal_set_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgReplayUploadedToYouTube.session_id)
}

// -------------------------------------------------------------------

// CMsgConsumableExhausted

// optional int32 item_def_id = 1;
inline bool CMsgConsumableExhausted::_internal_has_item_def_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgConsumableExhausted::has_item_def_id() const {
  return _internal_has_item_def_id();
}
inline void CMsgConsumableExhausted::clear_item_def_id() {
  _impl_.item_def_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CMsgConsumableExhausted::_internal_item_def_id() const {
  return _impl_.item_def_id_;
}
inline int32_t CMsgConsumableExhausted::item_def_id() const {
  // @@protoc_insertion_point(field_get:CMsgConsumableExhausted.item_def_id)
  return _internal_item_def_id();
}
inline void CMsgConsumableExhausted::_internal_set_item_def_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_def_id_ = value;
}
inline void CMsgConsumableExhausted::set_item_def_id(int32_t value) {
  _internal_set_item_def_id(value);
  // @@protoc_insertion_point(field_set:CMsgConsumableExhausted.item_def_id)
}

// -------------------------------------------------------------------

// CMsgItemAcknowledged__DEPRECATED

// optional uint32 account_id = 1;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_account_id() const {
  return _internal_has_account_id();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::account_id() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.account_id)
  return _internal_account_id();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.account_id_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.account_id)
}

// optional uint32 inventory = 2;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_inventory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_inventory() const {
  return _internal_has_inventory();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_inventory() {
  _impl_.inventory_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_inventory() const {
  return _impl_.inventory_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::inventory() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.inventory)
  return _internal_inventory();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_inventory(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.inventory_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_inventory(uint32_t value) {
  _internal_set_inventory(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.inventory)
}

// optional uint32 def_index = 3;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_def_index() const {
  return _internal_has_def_index();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_def_index() {
  _impl_.def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_def_index() const {
  return _impl_.def_index_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::def_index() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.def_index)
  return _internal_def_index();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.def_index_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_def_index(uint32_t value) {
  _internal_set_def_index(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.def_index)
}

// optional uint32 quality = 4;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_quality() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_quality() const {
  return _internal_has_quality();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_quality() {
  _impl_.quality_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_quality() const {
  return _impl_.quality_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::quality() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.quality)
  return _internal_quality();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_quality(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.quality_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_quality(uint32_t value) {
  _internal_set_quality(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.quality)
}

// optional uint32 rarity = 5;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_rarity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_rarity() const {
  return _internal_has_rarity();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_rarity() {
  _impl_.rarity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_rarity() const {
  return _impl_.rarity_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::rarity() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.rarity)
  return _internal_rarity();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_rarity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.rarity_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_rarity(uint32_t value) {
  _internal_set_rarity(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.rarity)
}

// optional uint32 origin = 6;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_origin() const {
  return _internal_has_origin();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_origin() {
  _impl_.origin_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::_internal_origin() const {
  return _impl_.origin_;
}
inline uint32_t CMsgItemAcknowledged__DEPRECATED::origin() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.origin)
  return _internal_origin();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_origin(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.origin_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_origin(uint32_t value) {
  _internal_set_origin(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.origin)
}

// optional uint64 item_id = 7;
inline bool CMsgItemAcknowledged__DEPRECATED::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgItemAcknowledged__DEPRECATED::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgItemAcknowledged__DEPRECATED::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint64_t CMsgItemAcknowledged__DEPRECATED::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgItemAcknowledged__DEPRECATED::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgItemAcknowledged__DEPRECATED.item_id)
  return _internal_item_id();
}
inline void CMsgItemAcknowledged__DEPRECATED::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.item_id_ = value;
}
inline void CMsgItemAcknowledged__DEPRECATED::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgItemAcknowledged__DEPRECATED.item_id)
}

// -------------------------------------------------------------------

// CMsgSetItemPositions_ItemPosition

// optional uint32 legacy_item_id = 1;
inline bool CMsgSetItemPositions_ItemPosition::_internal_has_legacy_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSetItemPositions_ItemPosition::has_legacy_item_id() const {
  return _internal_has_legacy_item_id();
}
inline void CMsgSetItemPositions_ItemPosition::clear_legacy_item_id() {
  _impl_.legacy_item_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSetItemPositions_ItemPosition::_internal_legacy_item_id() const {
  return _impl_.legacy_item_id_;
}
inline uint32_t CMsgSetItemPositions_ItemPosition::legacy_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgSetItemPositions.ItemPosition.legacy_item_id)
  return _internal_legacy_item_id();
}
inline void CMsgSetItemPositions_ItemPosition::_internal_set_legacy_item_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.legacy_item_id_ = value;
}
inline void CMsgSetItemPositions_ItemPosition::set_legacy_item_id(uint32_t value) {
  _internal_set_legacy_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgSetItemPositions.ItemPosition.legacy_item_id)
}

// optional uint32 position = 2;
inline bool CMsgSetItemPositions_ItemPosition::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSetItemPositions_ItemPosition::has_position() const {
  return _internal_has_position();
}
inline void CMsgSetItemPositions_ItemPosition::clear_position() {
  _impl_.position_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSetItemPositions_ItemPosition::_internal_position() const {
  return _impl_.position_;
}
inline uint32_t CMsgSetItemPositions_ItemPosition::position() const {
  // @@protoc_insertion_point(field_get:CMsgSetItemPositions.ItemPosition.position)
  return _internal_position();
}
inline void CMsgSetItemPositions_ItemPosition::_internal_set_position(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.position_ = value;
}
inline void CMsgSetItemPositions_ItemPosition::set_position(uint32_t value) {
  _internal_set_position(value);
  // @@protoc_insertion_point(field_set:CMsgSetItemPositions.ItemPosition.position)
}

// optional uint64 item_id = 3;
inline bool CMsgSetItemPositions_ItemPosition::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSetItemPositions_ItemPosition::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgSetItemPositions_ItemPosition::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgSetItemPositions_ItemPosition::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgSetItemPositions_ItemPosition::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgSetItemPositions.ItemPosition.item_id)
  return _internal_item_id();
}
inline void CMsgSetItemPositions_ItemPosition::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_id_ = value;
}
inline void CMsgSetItemPositions_ItemPosition::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgSetItemPositions.ItemPosition.item_id)
}

// -------------------------------------------------------------------

// CMsgSetItemPositions

// repeated .CMsgSetItemPositions.ItemPosition item_positions = 1;
inline int CMsgSetItemPositions::_internal_item_positions_size() const {
  return _impl_.item_positions_.size();
}
inline int CMsgSetItemPositions::item_positions_size() const {
  return _internal_item_positions_size();
}
inline void CMsgSetItemPositions::clear_item_positions() {
  _impl_.item_positions_.Clear();
}
inline ::CMsgSetItemPositions_ItemPosition* CMsgSetItemPositions::mutable_item_positions(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSetItemPositions.item_positions)
  return _impl_.item_positions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSetItemPositions_ItemPosition >*
CMsgSetItemPositions::mutable_item_positions() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSetItemPositions.item_positions)
  return &_impl_.item_positions_;
}
inline const ::CMsgSetItemPositions_ItemPosition& CMsgSetItemPositions::_internal_item_positions(int index) const {
  return _impl_.item_positions_.Get(index);
}
inline const ::CMsgSetItemPositions_ItemPosition& CMsgSetItemPositions::item_positions(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSetItemPositions.item_positions)
  return _internal_item_positions(index);
}
inline ::CMsgSetItemPositions_ItemPosition* CMsgSetItemPositions::_internal_add_item_positions() {
  return _impl_.item_positions_.Add();
}
inline ::CMsgSetItemPositions_ItemPosition* CMsgSetItemPositions::add_item_positions() {
  ::CMsgSetItemPositions_ItemPosition* _add = _internal_add_item_positions();
  // @@protoc_insertion_point(field_add:CMsgSetItemPositions.item_positions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSetItemPositions_ItemPosition >&
CMsgSetItemPositions::item_positions() const {
  // @@protoc_insertion_point(field_list:CMsgSetItemPositions.item_positions)
  return _impl_.item_positions_;
}

// -------------------------------------------------------------------

// CMsgGCReportAbuse

// optional fixed64 target_steam_id = 1;
inline bool CMsgGCReportAbuse::_internal_has_target_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_target_steam_id() const {
  return _internal_has_target_steam_id();
}
inline void CMsgGCReportAbuse::clear_target_steam_id() {
  _impl_.target_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgGCReportAbuse::_internal_target_steam_id() const {
  return _impl_.target_steam_id_;
}
inline uint64_t CMsgGCReportAbuse::target_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.target_steam_id)
  return _internal_target_steam_id();
}
inline void CMsgGCReportAbuse::_internal_set_target_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.target_steam_id_ = value;
}
inline void CMsgGCReportAbuse::set_target_steam_id(uint64_t value) {
  _internal_set_target_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.target_steam_id)
}

// optional string description = 4;
inline bool CMsgGCReportAbuse::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_description() const {
  return _internal_has_description();
}
inline void CMsgGCReportAbuse::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCReportAbuse::description() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCReportAbuse::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.description)
}
inline std::string* CMsgGCReportAbuse::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:CMsgGCReportAbuse.description)
  return _s;
}
inline const std::string& CMsgGCReportAbuse::_internal_description() const {
  return _impl_.description_.Get();
}
inline void CMsgGCReportAbuse::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCReportAbuse::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCReportAbuse::release_description() {
  // @@protoc_insertion_point(field_release:CMsgGCReportAbuse.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCReportAbuse::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCReportAbuse.description)
}

// optional uint64 gid = 5;
inline bool CMsgGCReportAbuse::_internal_has_gid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_gid() const {
  return _internal_has_gid();
}
inline void CMsgGCReportAbuse::clear_gid() {
  _impl_.gid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgGCReportAbuse::_internal_gid() const {
  return _impl_.gid_;
}
inline uint64_t CMsgGCReportAbuse::gid() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.gid)
  return _internal_gid();
}
inline void CMsgGCReportAbuse::_internal_set_gid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.gid_ = value;
}
inline void CMsgGCReportAbuse::set_gid(uint64_t value) {
  _internal_set_gid(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.gid)
}

// optional uint32 abuse_type = 2;
inline bool CMsgGCReportAbuse::_internal_has_abuse_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_abuse_type() const {
  return _internal_has_abuse_type();
}
inline void CMsgGCReportAbuse::clear_abuse_type() {
  _impl_.abuse_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgGCReportAbuse::_internal_abuse_type() const {
  return _impl_.abuse_type_;
}
inline uint32_t CMsgGCReportAbuse::abuse_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.abuse_type)
  return _internal_abuse_type();
}
inline void CMsgGCReportAbuse::_internal_set_abuse_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.abuse_type_ = value;
}
inline void CMsgGCReportAbuse::set_abuse_type(uint32_t value) {
  _internal_set_abuse_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.abuse_type)
}

// optional uint32 content_type = 3;
inline bool CMsgGCReportAbuse::_internal_has_content_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_content_type() const {
  return _internal_has_content_type();
}
inline void CMsgGCReportAbuse::clear_content_type() {
  _impl_.content_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgGCReportAbuse::_internal_content_type() const {
  return _impl_.content_type_;
}
inline uint32_t CMsgGCReportAbuse::content_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.content_type)
  return _internal_content_type();
}
inline void CMsgGCReportAbuse::_internal_set_content_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.content_type_ = value;
}
inline void CMsgGCReportAbuse::set_content_type(uint32_t value) {
  _internal_set_content_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.content_type)
}

// optional fixed32 target_game_server_ip = 6;
inline bool CMsgGCReportAbuse::_internal_has_target_game_server_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_target_game_server_ip() const {
  return _internal_has_target_game_server_ip();
}
inline void CMsgGCReportAbuse::clear_target_game_server_ip() {
  _impl_.target_game_server_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgGCReportAbuse::_internal_target_game_server_ip() const {
  return _impl_.target_game_server_ip_;
}
inline uint32_t CMsgGCReportAbuse::target_game_server_ip() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.target_game_server_ip)
  return _internal_target_game_server_ip();
}
inline void CMsgGCReportAbuse::_internal_set_target_game_server_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.target_game_server_ip_ = value;
}
inline void CMsgGCReportAbuse::set_target_game_server_ip(uint32_t value) {
  _internal_set_target_game_server_ip(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.target_game_server_ip)
}

// optional uint32 target_game_server_port = 7;
inline bool CMsgGCReportAbuse::_internal_has_target_game_server_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgGCReportAbuse::has_target_game_server_port() const {
  return _internal_has_target_game_server_port();
}
inline void CMsgGCReportAbuse::clear_target_game_server_port() {
  _impl_.target_game_server_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgGCReportAbuse::_internal_target_game_server_port() const {
  return _impl_.target_game_server_port_;
}
inline uint32_t CMsgGCReportAbuse::target_game_server_port() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuse.target_game_server_port)
  return _internal_target_game_server_port();
}
inline void CMsgGCReportAbuse::_internal_set_target_game_server_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.target_game_server_port_ = value;
}
inline void CMsgGCReportAbuse::set_target_game_server_port(uint32_t value) {
  _internal_set_target_game_server_port(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuse.target_game_server_port)
}

// -------------------------------------------------------------------

// CMsgGCReportAbuseResponse

// optional fixed64 target_steam_id = 1;
inline bool CMsgGCReportAbuseResponse::_internal_has_target_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCReportAbuseResponse::has_target_steam_id() const {
  return _internal_has_target_steam_id();
}
inline void CMsgGCReportAbuseResponse::clear_target_steam_id() {
  _impl_.target_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgGCReportAbuseResponse::_internal_target_steam_id() const {
  return _impl_.target_steam_id_;
}
inline uint64_t CMsgGCReportAbuseResponse::target_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuseResponse.target_steam_id)
  return _internal_target_steam_id();
}
inline void CMsgGCReportAbuseResponse::_internal_set_target_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.target_steam_id_ = value;
}
inline void CMsgGCReportAbuseResponse::set_target_steam_id(uint64_t value) {
  _internal_set_target_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuseResponse.target_steam_id)
}

// optional uint32 result = 2;
inline bool CMsgGCReportAbuseResponse::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCReportAbuseResponse::has_result() const {
  return _internal_has_result();
}
inline void CMsgGCReportAbuseResponse::clear_result() {
  _impl_.result_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgGCReportAbuseResponse::_internal_result() const {
  return _impl_.result_;
}
inline uint32_t CMsgGCReportAbuseResponse::result() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuseResponse.result)
  return _internal_result();
}
inline void CMsgGCReportAbuseResponse::_internal_set_result(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.result_ = value;
}
inline void CMsgGCReportAbuseResponse::set_result(uint32_t value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuseResponse.result)
}

// optional string error_message = 3;
inline bool CMsgGCReportAbuseResponse::_internal_has_error_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCReportAbuseResponse::has_error_message() const {
  return _internal_has_error_message();
}
inline void CMsgGCReportAbuseResponse::clear_error_message() {
  _impl_.error_message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCReportAbuseResponse::error_message() const {
  // @@protoc_insertion_point(field_get:CMsgGCReportAbuseResponse.error_message)
  return _internal_error_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCReportAbuseResponse::set_error_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.error_message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCReportAbuseResponse.error_message)
}
inline std::string* CMsgGCReportAbuseResponse::mutable_error_message() {
  std::string* _s = _internal_mutable_error_message();
  // @@protoc_insertion_point(field_mutable:CMsgGCReportAbuseResponse.error_message)
  return _s;
}
inline const std::string& CMsgGCReportAbuseResponse::_internal_error_message() const {
  return _impl_.error_message_.Get();
}
inline void CMsgGCReportAbuseResponse::_internal_set_error_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.error_message_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCReportAbuseResponse::_internal_mutable_error_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.error_message_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCReportAbuseResponse::release_error_message() {
  // @@protoc_insertion_point(field_release:CMsgGCReportAbuseResponse.error_message)
  if (!_internal_has_error_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.error_message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_message_.IsDefault()) {
    _impl_.error_message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCReportAbuseResponse::set_allocated_error_message(std::string* error_message) {
  if (error_message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.error_message_.SetAllocated(error_message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_message_.IsDefault()) {
    _impl_.error_message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCReportAbuseResponse.error_message)
}

// -------------------------------------------------------------------

// CMsgGCNameItemNotification

// optional fixed64 player_steamid = 1;
inline bool CMsgGCNameItemNotification::_internal_has_player_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCNameItemNotification::has_player_steamid() const {
  return _internal_has_player_steamid();
}
inline void CMsgGCNameItemNotification::clear_player_steamid() {
  _impl_.player_steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgGCNameItemNotification::_internal_player_steamid() const {
  return _impl_.player_steamid_;
}
inline uint64_t CMsgGCNameItemNotification::player_steamid() const {
  // @@protoc_insertion_point(field_get:CMsgGCNameItemNotification.player_steamid)
  return _internal_player_steamid();
}
inline void CMsgGCNameItemNotification::_internal_set_player_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.player_steamid_ = value;
}
inline void CMsgGCNameItemNotification::set_player_steamid(uint64_t value) {
  _internal_set_player_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgGCNameItemNotification.player_steamid)
}

// optional uint32 item_def_index = 2;
inline bool CMsgGCNameItemNotification::_internal_has_item_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCNameItemNotification::has_item_def_index() const {
  return _internal_has_item_def_index();
}
inline void CMsgGCNameItemNotification::clear_item_def_index() {
  _impl_.item_def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgGCNameItemNotification::_internal_item_def_index() const {
  return _impl_.item_def_index_;
}
inline uint32_t CMsgGCNameItemNotification::item_def_index() const {
  // @@protoc_insertion_point(field_get:CMsgGCNameItemNotification.item_def_index)
  return _internal_item_def_index();
}
inline void CMsgGCNameItemNotification::_internal_set_item_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_def_index_ = value;
}
inline void CMsgGCNameItemNotification::set_item_def_index(uint32_t value) {
  _internal_set_item_def_index(value);
  // @@protoc_insertion_point(field_set:CMsgGCNameItemNotification.item_def_index)
}

// optional string item_name_custom = 3;
inline bool CMsgGCNameItemNotification::_internal_has_item_name_custom() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCNameItemNotification::has_item_name_custom() const {
  return _internal_has_item_name_custom();
}
inline void CMsgGCNameItemNotification::clear_item_name_custom() {
  _impl_.item_name_custom_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCNameItemNotification::item_name_custom() const {
  // @@protoc_insertion_point(field_get:CMsgGCNameItemNotification.item_name_custom)
  return _internal_item_name_custom();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCNameItemNotification::set_item_name_custom(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.item_name_custom_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCNameItemNotification.item_name_custom)
}
inline std::string* CMsgGCNameItemNotification::mutable_item_name_custom() {
  std::string* _s = _internal_mutable_item_name_custom();
  // @@protoc_insertion_point(field_mutable:CMsgGCNameItemNotification.item_name_custom)
  return _s;
}
inline const std::string& CMsgGCNameItemNotification::_internal_item_name_custom() const {
  return _impl_.item_name_custom_.Get();
}
inline void CMsgGCNameItemNotification::_internal_set_item_name_custom(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_name_custom_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCNameItemNotification::_internal_mutable_item_name_custom() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.item_name_custom_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCNameItemNotification::release_item_name_custom() {
  // @@protoc_insertion_point(field_release:CMsgGCNameItemNotification.item_name_custom)
  if (!_internal_has_item_name_custom()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.item_name_custom_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.item_name_custom_.IsDefault()) {
    _impl_.item_name_custom_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCNameItemNotification::set_allocated_item_name_custom(std::string* item_name_custom) {
  if (item_name_custom != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.item_name_custom_.SetAllocated(item_name_custom, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.item_name_custom_.IsDefault()) {
    _impl_.item_name_custom_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCNameItemNotification.item_name_custom)
}

// -------------------------------------------------------------------

// CMsgGCClientDisplayNotification

// optional string notification_title_localization_key = 1;
inline bool CMsgGCClientDisplayNotification::_internal_has_notification_title_localization_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCClientDisplayNotification::has_notification_title_localization_key() const {
  return _internal_has_notification_title_localization_key();
}
inline void CMsgGCClientDisplayNotification::clear_notification_title_localization_key() {
  _impl_.notification_title_localization_key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCClientDisplayNotification::notification_title_localization_key() const {
  // @@protoc_insertion_point(field_get:CMsgGCClientDisplayNotification.notification_title_localization_key)
  return _internal_notification_title_localization_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCClientDisplayNotification::set_notification_title_localization_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.notification_title_localization_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.notification_title_localization_key)
}
inline std::string* CMsgGCClientDisplayNotification::mutable_notification_title_localization_key() {
  std::string* _s = _internal_mutable_notification_title_localization_key();
  // @@protoc_insertion_point(field_mutable:CMsgGCClientDisplayNotification.notification_title_localization_key)
  return _s;
}
inline const std::string& CMsgGCClientDisplayNotification::_internal_notification_title_localization_key() const {
  return _impl_.notification_title_localization_key_.Get();
}
inline void CMsgGCClientDisplayNotification::_internal_set_notification_title_localization_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.notification_title_localization_key_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCClientDisplayNotification::_internal_mutable_notification_title_localization_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.notification_title_localization_key_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCClientDisplayNotification::release_notification_title_localization_key() {
  // @@protoc_insertion_point(field_release:CMsgGCClientDisplayNotification.notification_title_localization_key)
  if (!_internal_has_notification_title_localization_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.notification_title_localization_key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.notification_title_localization_key_.IsDefault()) {
    _impl_.notification_title_localization_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCClientDisplayNotification::set_allocated_notification_title_localization_key(std::string* notification_title_localization_key) {
  if (notification_title_localization_key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.notification_title_localization_key_.SetAllocated(notification_title_localization_key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.notification_title_localization_key_.IsDefault()) {
    _impl_.notification_title_localization_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCClientDisplayNotification.notification_title_localization_key)
}

// optional string notification_body_localization_key = 2;
inline bool CMsgGCClientDisplayNotification::_internal_has_notification_body_localization_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCClientDisplayNotification::has_notification_body_localization_key() const {
  return _internal_has_notification_body_localization_key();
}
inline void CMsgGCClientDisplayNotification::clear_notification_body_localization_key() {
  _impl_.notification_body_localization_key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgGCClientDisplayNotification::notification_body_localization_key() const {
  // @@protoc_insertion_point(field_get:CMsgGCClientDisplayNotification.notification_body_localization_key)
  return _internal_notification_body_localization_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCClientDisplayNotification::set_notification_body_localization_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.notification_body_localization_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.notification_body_localization_key)
}
inline std::string* CMsgGCClientDisplayNotification::mutable_notification_body_localization_key() {
  std::string* _s = _internal_mutable_notification_body_localization_key();
  // @@protoc_insertion_point(field_mutable:CMsgGCClientDisplayNotification.notification_body_localization_key)
  return _s;
}
inline const std::string& CMsgGCClientDisplayNotification::_internal_notification_body_localization_key() const {
  return _impl_.notification_body_localization_key_.Get();
}
inline void CMsgGCClientDisplayNotification::_internal_set_notification_body_localization_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.notification_body_localization_key_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCClientDisplayNotification::_internal_mutable_notification_body_localization_key() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.notification_body_localization_key_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCClientDisplayNotification::release_notification_body_localization_key() {
  // @@protoc_insertion_point(field_release:CMsgGCClientDisplayNotification.notification_body_localization_key)
  if (!_internal_has_notification_body_localization_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.notification_body_localization_key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.notification_body_localization_key_.IsDefault()) {
    _impl_.notification_body_localization_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCClientDisplayNotification::set_allocated_notification_body_localization_key(std::string* notification_body_localization_key) {
  if (notification_body_localization_key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.notification_body_localization_key_.SetAllocated(notification_body_localization_key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.notification_body_localization_key_.IsDefault()) {
    _impl_.notification_body_localization_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCClientDisplayNotification.notification_body_localization_key)
}

// repeated string body_substring_keys = 3;
inline int CMsgGCClientDisplayNotification::_internal_body_substring_keys_size() const {
  return _impl_.body_substring_keys_.size();
}
inline int CMsgGCClientDisplayNotification::body_substring_keys_size() const {
  return _internal_body_substring_keys_size();
}
inline void CMsgGCClientDisplayNotification::clear_body_substring_keys() {
  _impl_.body_substring_keys_.Clear();
}
inline std::string* CMsgGCClientDisplayNotification::add_body_substring_keys() {
  std::string* _s = _internal_add_body_substring_keys();
  // @@protoc_insertion_point(field_add_mutable:CMsgGCClientDisplayNotification.body_substring_keys)
  return _s;
}
inline const std::string& CMsgGCClientDisplayNotification::_internal_body_substring_keys(int index) const {
  return _impl_.body_substring_keys_.Get(index);
}
inline const std::string& CMsgGCClientDisplayNotification::body_substring_keys(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCClientDisplayNotification.body_substring_keys)
  return _internal_body_substring_keys(index);
}
inline std::string* CMsgGCClientDisplayNotification::mutable_body_substring_keys(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgGCClientDisplayNotification.body_substring_keys)
  return _impl_.body_substring_keys_.Mutable(index);
}
inline void CMsgGCClientDisplayNotification::set_body_substring_keys(int index, const std::string& value) {
  _impl_.body_substring_keys_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_keys(int index, std::string&& value) {
  _impl_.body_substring_keys_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_keys(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.body_substring_keys_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_keys(int index, const char* value, size_t size) {
  _impl_.body_substring_keys_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline std::string* CMsgGCClientDisplayNotification::_internal_add_body_substring_keys() {
  return _impl_.body_substring_keys_.Add();
}
inline void CMsgGCClientDisplayNotification::add_body_substring_keys(const std::string& value) {
  _impl_.body_substring_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_keys(std::string&& value) {
  _impl_.body_substring_keys_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_keys(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.body_substring_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_keys(const char* value, size_t size) {
  _impl_.body_substring_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CMsgGCClientDisplayNotification.body_substring_keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CMsgGCClientDisplayNotification::body_substring_keys() const {
  // @@protoc_insertion_point(field_list:CMsgGCClientDisplayNotification.body_substring_keys)
  return _impl_.body_substring_keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CMsgGCClientDisplayNotification::mutable_body_substring_keys() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCClientDisplayNotification.body_substring_keys)
  return &_impl_.body_substring_keys_;
}

// repeated string body_substring_values = 4;
inline int CMsgGCClientDisplayNotification::_internal_body_substring_values_size() const {
  return _impl_.body_substring_values_.size();
}
inline int CMsgGCClientDisplayNotification::body_substring_values_size() const {
  return _internal_body_substring_values_size();
}
inline void CMsgGCClientDisplayNotification::clear_body_substring_values() {
  _impl_.body_substring_values_.Clear();
}
inline std::string* CMsgGCClientDisplayNotification::add_body_substring_values() {
  std::string* _s = _internal_add_body_substring_values();
  // @@protoc_insertion_point(field_add_mutable:CMsgGCClientDisplayNotification.body_substring_values)
  return _s;
}
inline const std::string& CMsgGCClientDisplayNotification::_internal_body_substring_values(int index) const {
  return _impl_.body_substring_values_.Get(index);
}
inline const std::string& CMsgGCClientDisplayNotification::body_substring_values(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCClientDisplayNotification.body_substring_values)
  return _internal_body_substring_values(index);
}
inline std::string* CMsgGCClientDisplayNotification::mutable_body_substring_values(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgGCClientDisplayNotification.body_substring_values)
  return _impl_.body_substring_values_.Mutable(index);
}
inline void CMsgGCClientDisplayNotification::set_body_substring_values(int index, const std::string& value) {
  _impl_.body_substring_values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_values(int index, std::string&& value) {
  _impl_.body_substring_values_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_values(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.body_substring_values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::set_body_substring_values(int index, const char* value, size_t size) {
  _impl_.body_substring_values_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CMsgGCClientDisplayNotification.body_substring_values)
}
inline std::string* CMsgGCClientDisplayNotification::_internal_add_body_substring_values() {
  return _impl_.body_substring_values_.Add();
}
inline void CMsgGCClientDisplayNotification::add_body_substring_values(const std::string& value) {
  _impl_.body_substring_values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_values(std::string&& value) {
  _impl_.body_substring_values_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_values(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.body_substring_values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CMsgGCClientDisplayNotification.body_substring_values)
}
inline void CMsgGCClientDisplayNotification::add_body_substring_values(const char* value, size_t size) {
  _impl_.body_substring_values_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CMsgGCClientDisplayNotification.body_substring_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CMsgGCClientDisplayNotification::body_substring_values() const {
  // @@protoc_insertion_point(field_list:CMsgGCClientDisplayNotification.body_substring_values)
  return _impl_.body_substring_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CMsgGCClientDisplayNotification::mutable_body_substring_values() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCClientDisplayNotification.body_substring_values)
  return &_impl_.body_substring_values_;
}

// -------------------------------------------------------------------

// CMsgGCShowItemsPickedUp

// optional fixed64 player_steamid = 1;
inline bool CMsgGCShowItemsPickedUp::_internal_has_player_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCShowItemsPickedUp::has_player_steamid() const {
  return _internal_has_player_steamid();
}
inline void CMsgGCShowItemsPickedUp::clear_player_steamid() {
  _impl_.player_steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCShowItemsPickedUp::_internal_player_steamid() const {
  return _impl_.player_steamid_;
}
inline uint64_t CMsgGCShowItemsPickedUp::player_steamid() const {
  // @@protoc_insertion_point(field_get:CMsgGCShowItemsPickedUp.player_steamid)
  return _internal_player_steamid();
}
inline void CMsgGCShowItemsPickedUp::_internal_set_player_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.player_steamid_ = value;
}
inline void CMsgGCShowItemsPickedUp::set_player_steamid(uint64_t value) {
  _internal_set_player_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgGCShowItemsPickedUp.player_steamid)
}

// -------------------------------------------------------------------

// CMsgGCIncrementKillCountResponse

// optional uint32 killer_account_id = 1 [(.key_field) = true];
inline bool CMsgGCIncrementKillCountResponse::_internal_has_killer_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCIncrementKillCountResponse::has_killer_account_id() const {
  return _internal_has_killer_account_id();
}
inline void CMsgGCIncrementKillCountResponse::clear_killer_account_id() {
  _impl_.killer_account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCIncrementKillCountResponse::_internal_killer_account_id() const {
  return _impl_.killer_account_id_;
}
inline uint32_t CMsgGCIncrementKillCountResponse::killer_account_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCIncrementKillCountResponse.killer_account_id)
  return _internal_killer_account_id();
}
inline void CMsgGCIncrementKillCountResponse::_internal_set_killer_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.killer_account_id_ = value;
}
inline void CMsgGCIncrementKillCountResponse::set_killer_account_id(uint32_t value) {
  _internal_set_killer_account_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCIncrementKillCountResponse.killer_account_id)
}

// optional uint32 num_kills = 2;
inline bool CMsgGCIncrementKillCountResponse::_internal_has_num_kills() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCIncrementKillCountResponse::has_num_kills() const {
  return _internal_has_num_kills();
}
inline void CMsgGCIncrementKillCountResponse::clear_num_kills() {
  _impl_.num_kills_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGCIncrementKillCountResponse::_internal_num_kills() const {
  return _impl_.num_kills_;
}
inline uint32_t CMsgGCIncrementKillCountResponse::num_kills() const {
  // @@protoc_insertion_point(field_get:CMsgGCIncrementKillCountResponse.num_kills)
  return _internal_num_kills();
}
inline void CMsgGCIncrementKillCountResponse::_internal_set_num_kills(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.num_kills_ = value;
}
inline void CMsgGCIncrementKillCountResponse::set_num_kills(uint32_t value) {
  _internal_set_num_kills(value);
  // @@protoc_insertion_point(field_set:CMsgGCIncrementKillCountResponse.num_kills)
}

// optional uint32 item_def = 3;
inline bool CMsgGCIncrementKillCountResponse::_internal_has_item_def() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCIncrementKillCountResponse::has_item_def() const {
  return _internal_has_item_def();
}
inline void CMsgGCIncrementKillCountResponse::clear_item_def() {
  _impl_.item_def_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgGCIncrementKillCountResponse::_internal_item_def() const {
  return _impl_.item_def_;
}
inline uint32_t CMsgGCIncrementKillCountResponse::item_def() const {
  // @@protoc_insertion_point(field_get:CMsgGCIncrementKillCountResponse.item_def)
  return _internal_item_def();
}
inline void CMsgGCIncrementKillCountResponse::_internal_set_item_def(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_def_ = value;
}
inline void CMsgGCIncrementKillCountResponse::set_item_def(uint32_t value) {
  _internal_set_item_def(value);
  // @@protoc_insertion_point(field_set:CMsgGCIncrementKillCountResponse.item_def)
}

// optional uint32 level_type = 4;
inline bool CMsgGCIncrementKillCountResponse::_internal_has_level_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgGCIncrementKillCountResponse::has_level_type() const {
  return _internal_has_level_type();
}
inline void CMsgGCIncrementKillCountResponse::clear_level_type() {
  _impl_.level_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgGCIncrementKillCountResponse::_internal_level_type() const {
  return _impl_.level_type_;
}
inline uint32_t CMsgGCIncrementKillCountResponse::level_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCIncrementKillCountResponse.level_type)
  return _internal_level_type();
}
inline void CMsgGCIncrementKillCountResponse::_internal_set_level_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.level_type_ = value;
}
inline void CMsgGCIncrementKillCountResponse::set_level_type(uint32_t value) {
  _internal_set_level_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCIncrementKillCountResponse.level_type)
}

// -------------------------------------------------------------------

// CSOEconItemDropRateBonus

// optional uint32 account_id = 1;
inline bool CSOEconItemDropRateBonus::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconItemDropRateBonus::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconItemDropRateBonus::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconItemDropRateBonus::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.account_id)
  return _internal_account_id();
}
inline void CSOEconItemDropRateBonus::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.account_id_ = value;
}
inline void CSOEconItemDropRateBonus::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.account_id)
}

// optional fixed32 expiration_date = 2;
inline bool CSOEconItemDropRateBonus::_internal_has_expiration_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_expiration_date() const {
  return _internal_has_expiration_date();
}
inline void CSOEconItemDropRateBonus::clear_expiration_date() {
  _impl_.expiration_date_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconItemDropRateBonus::_internal_expiration_date() const {
  return _impl_.expiration_date_;
}
inline uint32_t CSOEconItemDropRateBonus::expiration_date() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.expiration_date)
  return _internal_expiration_date();
}
inline void CSOEconItemDropRateBonus::_internal_set_expiration_date(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.expiration_date_ = value;
}
inline void CSOEconItemDropRateBonus::set_expiration_date(uint32_t value) {
  _internal_set_expiration_date(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.expiration_date)
}

// optional float bonus = 3;
inline bool CSOEconItemDropRateBonus::_internal_has_bonus() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_bonus() const {
  return _internal_has_bonus();
}
inline void CSOEconItemDropRateBonus::clear_bonus() {
  _impl_.bonus_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CSOEconItemDropRateBonus::_internal_bonus() const {
  return _impl_.bonus_;
}
inline float CSOEconItemDropRateBonus::bonus() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.bonus)
  return _internal_bonus();
}
inline void CSOEconItemDropRateBonus::_internal_set_bonus(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bonus_ = value;
}
inline void CSOEconItemDropRateBonus::set_bonus(float value) {
  _internal_set_bonus(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.bonus)
}

// optional uint32 bonus_count = 4;
inline bool CSOEconItemDropRateBonus::_internal_has_bonus_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_bonus_count() const {
  return _internal_has_bonus_count();
}
inline void CSOEconItemDropRateBonus::clear_bonus_count() {
  _impl_.bonus_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconItemDropRateBonus::_internal_bonus_count() const {
  return _impl_.bonus_count_;
}
inline uint32_t CSOEconItemDropRateBonus::bonus_count() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.bonus_count)
  return _internal_bonus_count();
}
inline void CSOEconItemDropRateBonus::_internal_set_bonus_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bonus_count_ = value;
}
inline void CSOEconItemDropRateBonus::set_bonus_count(uint32_t value) {
  _internal_set_bonus_count(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.bonus_count)
}

// optional uint64 item_id = 5;
inline bool CSOEconItemDropRateBonus::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_item_id() const {
  return _internal_has_item_id();
}
inline void CSOEconItemDropRateBonus::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CSOEconItemDropRateBonus::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CSOEconItemDropRateBonus::item_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.item_id)
  return _internal_item_id();
}
inline void CSOEconItemDropRateBonus::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.item_id_ = value;
}
inline void CSOEconItemDropRateBonus::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.item_id)
}

// optional uint32 def_index = 6;
inline bool CSOEconItemDropRateBonus::_internal_has_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSOEconItemDropRateBonus::has_def_index() const {
  return _internal_has_def_index();
}
inline void CSOEconItemDropRateBonus::clear_def_index() {
  _impl_.def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CSOEconItemDropRateBonus::_internal_def_index() const {
  return _impl_.def_index_;
}
inline uint32_t CSOEconItemDropRateBonus::def_index() const {
  // @@protoc_insertion_point(field_get:CSOEconItemDropRateBonus.def_index)
  return _internal_def_index();
}
inline void CSOEconItemDropRateBonus::_internal_set_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.def_index_ = value;
}
inline void CSOEconItemDropRateBonus::set_def_index(uint32_t value) {
  _internal_set_def_index(value);
  // @@protoc_insertion_point(field_set:CSOEconItemDropRateBonus.def_index)
}

// -------------------------------------------------------------------

// CSOEconItemLeagueViewPass

// optional uint32 account_id = 1 [(.key_field) = true];
inline bool CSOEconItemLeagueViewPass::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItemLeagueViewPass::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconItemLeagueViewPass::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconItemLeagueViewPass::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconItemLeagueViewPass::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemLeagueViewPass.account_id)
  return _internal_account_id();
}
inline void CSOEconItemLeagueViewPass::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.account_id_ = value;
}
inline void CSOEconItemLeagueViewPass::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemLeagueViewPass.account_id)
}

// optional uint32 league_id = 2 [(.key_field) = true];
inline bool CSOEconItemLeagueViewPass::_internal_has_league_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItemLeagueViewPass::has_league_id() const {
  return _internal_has_league_id();
}
inline void CSOEconItemLeagueViewPass::clear_league_id() {
  _impl_.league_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconItemLeagueViewPass::_internal_league_id() const {
  return _impl_.league_id_;
}
inline uint32_t CSOEconItemLeagueViewPass::league_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemLeagueViewPass.league_id)
  return _internal_league_id();
}
inline void CSOEconItemLeagueViewPass::_internal_set_league_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.league_id_ = value;
}
inline void CSOEconItemLeagueViewPass::set_league_id(uint32_t value) {
  _internal_set_league_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemLeagueViewPass.league_id)
}

// optional uint32 admin = 3;
inline bool CSOEconItemLeagueViewPass::_internal_has_admin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconItemLeagueViewPass::has_admin() const {
  return _internal_has_admin();
}
inline void CSOEconItemLeagueViewPass::clear_admin() {
  _impl_.admin_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOEconItemLeagueViewPass::_internal_admin() const {
  return _impl_.admin_;
}
inline uint32_t CSOEconItemLeagueViewPass::admin() const {
  // @@protoc_insertion_point(field_get:CSOEconItemLeagueViewPass.admin)
  return _internal_admin();
}
inline void CSOEconItemLeagueViewPass::_internal_set_admin(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.admin_ = value;
}
inline void CSOEconItemLeagueViewPass::set_admin(uint32_t value) {
  _internal_set_admin(value);
  // @@protoc_insertion_point(field_set:CSOEconItemLeagueViewPass.admin)
}

// optional uint32 itemindex = 4;
inline bool CSOEconItemLeagueViewPass::_internal_has_itemindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconItemLeagueViewPass::has_itemindex() const {
  return _internal_has_itemindex();
}
inline void CSOEconItemLeagueViewPass::clear_itemindex() {
  _impl_.itemindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconItemLeagueViewPass::_internal_itemindex() const {
  return _impl_.itemindex_;
}
inline uint32_t CSOEconItemLeagueViewPass::itemindex() const {
  // @@protoc_insertion_point(field_get:CSOEconItemLeagueViewPass.itemindex)
  return _internal_itemindex();
}
inline void CSOEconItemLeagueViewPass::_internal_set_itemindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.itemindex_ = value;
}
inline void CSOEconItemLeagueViewPass::set_itemindex(uint32_t value) {
  _internal_set_itemindex(value);
  // @@protoc_insertion_point(field_set:CSOEconItemLeagueViewPass.itemindex)
}

// -------------------------------------------------------------------

// CSOEconItemEventTicket

// optional uint32 account_id = 1;
inline bool CSOEconItemEventTicket::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconItemEventTicket::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconItemEventTicket::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconItemEventTicket::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconItemEventTicket::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemEventTicket.account_id)
  return _internal_account_id();
}
inline void CSOEconItemEventTicket::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.account_id_ = value;
}
inline void CSOEconItemEventTicket::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemEventTicket.account_id)
}

// optional uint32 event_id = 2;
inline bool CSOEconItemEventTicket::_internal_has_event_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconItemEventTicket::has_event_id() const {
  return _internal_has_event_id();
}
inline void CSOEconItemEventTicket::clear_event_id() {
  _impl_.event_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconItemEventTicket::_internal_event_id() const {
  return _impl_.event_id_;
}
inline uint32_t CSOEconItemEventTicket::event_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemEventTicket.event_id)
  return _internal_event_id();
}
inline void CSOEconItemEventTicket::_internal_set_event_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.event_id_ = value;
}
inline void CSOEconItemEventTicket::set_event_id(uint32_t value) {
  _internal_set_event_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemEventTicket.event_id)
}

// optional uint64 item_id = 3;
inline bool CSOEconItemEventTicket::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconItemEventTicket::has_item_id() const {
  return _internal_has_item_id();
}
inline void CSOEconItemEventTicket::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CSOEconItemEventTicket::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CSOEconItemEventTicket::item_id() const {
  // @@protoc_insertion_point(field_get:CSOEconItemEventTicket.item_id)
  return _internal_item_id();
}
inline void CSOEconItemEventTicket::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_id_ = value;
}
inline void CSOEconItemEventTicket::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CSOEconItemEventTicket.item_id)
}

// -------------------------------------------------------------------

// CMsgGCItemPreviewItemBoughtNotification

// optional uint32 item_def_index = 1;
inline bool CMsgGCItemPreviewItemBoughtNotification::_internal_has_item_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCItemPreviewItemBoughtNotification::has_item_def_index() const {
  return _internal_has_item_def_index();
}
inline void CMsgGCItemPreviewItemBoughtNotification::clear_item_def_index() {
  _impl_.item_def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCItemPreviewItemBoughtNotification::_internal_item_def_index() const {
  return _impl_.item_def_index_;
}
inline uint32_t CMsgGCItemPreviewItemBoughtNotification::item_def_index() const {
  // @@protoc_insertion_point(field_get:CMsgGCItemPreviewItemBoughtNotification.item_def_index)
  return _internal_item_def_index();
}
inline void CMsgGCItemPreviewItemBoughtNotification::_internal_set_item_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.item_def_index_ = value;
}
inline void CMsgGCItemPreviewItemBoughtNotification::set_item_def_index(uint32_t value) {
  _internal_set_item_def_index(value);
  // @@protoc_insertion_point(field_set:CMsgGCItemPreviewItemBoughtNotification.item_def_index)
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseCancel

// optional uint64 txn_id = 1;
inline bool CMsgGCStorePurchaseCancel::_internal_has_txn_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseCancel::has_txn_id() const {
  return _internal_has_txn_id();
}
inline void CMsgGCStorePurchaseCancel::clear_txn_id() {
  _impl_.txn_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCStorePurchaseCancel::_internal_txn_id() const {
  return _impl_.txn_id_;
}
inline uint64_t CMsgGCStorePurchaseCancel::txn_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseCancel.txn_id)
  return _internal_txn_id();
}
inline void CMsgGCStorePurchaseCancel::_internal_set_txn_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.txn_id_ = value;
}
inline void CMsgGCStorePurchaseCancel::set_txn_id(uint64_t value) {
  _internal_set_txn_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseCancel.txn_id)
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseCancelResponse

// optional uint32 result = 1;
inline bool CMsgGCStorePurchaseCancelResponse::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseCancelResponse::has_result() const {
  return _internal_has_result();
}
inline void CMsgGCStorePurchaseCancelResponse::clear_result() {
  _impl_.result_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCStorePurchaseCancelResponse::_internal_result() const {
  return _impl_.result_;
}
inline uint32_t CMsgGCStorePurchaseCancelResponse::result() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseCancelResponse.result)
  return _internal_result();
}
inline void CMsgGCStorePurchaseCancelResponse::_internal_set_result(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.result_ = value;
}
inline void CMsgGCStorePurchaseCancelResponse::set_result(uint32_t value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseCancelResponse.result)
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseFinalize

// optional uint64 txn_id = 1;
inline bool CMsgGCStorePurchaseFinalize::_internal_has_txn_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseFinalize::has_txn_id() const {
  return _internal_has_txn_id();
}
inline void CMsgGCStorePurchaseFinalize::clear_txn_id() {
  _impl_.txn_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCStorePurchaseFinalize::_internal_txn_id() const {
  return _impl_.txn_id_;
}
inline uint64_t CMsgGCStorePurchaseFinalize::txn_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseFinalize.txn_id)
  return _internal_txn_id();
}
inline void CMsgGCStorePurchaseFinalize::_internal_set_txn_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.txn_id_ = value;
}
inline void CMsgGCStorePurchaseFinalize::set_txn_id(uint64_t value) {
  _internal_set_txn_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseFinalize.txn_id)
}

// -------------------------------------------------------------------

// CMsgGCStorePurchaseFinalizeResponse

// optional uint32 result = 1;
inline bool CMsgGCStorePurchaseFinalizeResponse::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCStorePurchaseFinalizeResponse::has_result() const {
  return _internal_has_result();
}
inline void CMsgGCStorePurchaseFinalizeResponse::clear_result() {
  _impl_.result_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCStorePurchaseFinalizeResponse::_internal_result() const {
  return _impl_.result_;
}
inline uint32_t CMsgGCStorePurchaseFinalizeResponse::result() const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseFinalizeResponse.result)
  return _internal_result();
}
inline void CMsgGCStorePurchaseFinalizeResponse::_internal_set_result(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.result_ = value;
}
inline void CMsgGCStorePurchaseFinalizeResponse::set_result(uint32_t value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseFinalizeResponse.result)
}

// repeated uint64 item_ids = 2;
inline int CMsgGCStorePurchaseFinalizeResponse::_internal_item_ids_size() const {
  return _impl_.item_ids_.size();
}
inline int CMsgGCStorePurchaseFinalizeResponse::item_ids_size() const {
  return _internal_item_ids_size();
}
inline void CMsgGCStorePurchaseFinalizeResponse::clear_item_ids() {
  _impl_.item_ids_.Clear();
}
inline uint64_t CMsgGCStorePurchaseFinalizeResponse::_internal_item_ids(int index) const {
  return _impl_.item_ids_.Get(index);
}
inline uint64_t CMsgGCStorePurchaseFinalizeResponse::item_ids(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCStorePurchaseFinalizeResponse.item_ids)
  return _internal_item_ids(index);
}
inline void CMsgGCStorePurchaseFinalizeResponse::set_item_ids(int index, uint64_t value) {
  _impl_.item_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgGCStorePurchaseFinalizeResponse.item_ids)
}
inline void CMsgGCStorePurchaseFinalizeResponse::_internal_add_item_ids(uint64_t value) {
  _impl_.item_ids_.Add(value);
}
inline void CMsgGCStorePurchaseFinalizeResponse::add_item_ids(uint64_t value) {
  _internal_add_item_ids(value);
  // @@protoc_insertion_point(field_add:CMsgGCStorePurchaseFinalizeResponse.item_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCStorePurchaseFinalizeResponse::_internal_item_ids() const {
  return _impl_.item_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCStorePurchaseFinalizeResponse::item_ids() const {
  // @@protoc_insertion_point(field_list:CMsgGCStorePurchaseFinalizeResponse.item_ids)
  return _internal_item_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCStorePurchaseFinalizeResponse::_internal_mutable_item_ids() {
  return &_impl_.item_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCStorePurchaseFinalizeResponse::mutable_item_ids() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCStorePurchaseFinalizeResponse.item_ids)
  return _internal_mutable_item_ids();
}

// -------------------------------------------------------------------

// CMsgGCBannedWordListRequest

// optional uint32 ban_list_group_id = 1;
inline bool CMsgGCBannedWordListRequest::_internal_has_ban_list_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCBannedWordListRequest::has_ban_list_group_id() const {
  return _internal_has_ban_list_group_id();
}
inline void CMsgGCBannedWordListRequest::clear_ban_list_group_id() {
  _impl_.ban_list_group_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCBannedWordListRequest::_internal_ban_list_group_id() const {
  return _impl_.ban_list_group_id_;
}
inline uint32_t CMsgGCBannedWordListRequest::ban_list_group_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWordListRequest.ban_list_group_id)
  return _internal_ban_list_group_id();
}
inline void CMsgGCBannedWordListRequest::_internal_set_ban_list_group_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ban_list_group_id_ = value;
}
inline void CMsgGCBannedWordListRequest::set_ban_list_group_id(uint32_t value) {
  _internal_set_ban_list_group_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCBannedWordListRequest.ban_list_group_id)
}

// optional uint32 word_id = 2;
inline bool CMsgGCBannedWordListRequest::_internal_has_word_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCBannedWordListRequest::has_word_id() const {
  return _internal_has_word_id();
}
inline void CMsgGCBannedWordListRequest::clear_word_id() {
  _impl_.word_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGCBannedWordListRequest::_internal_word_id() const {
  return _impl_.word_id_;
}
inline uint32_t CMsgGCBannedWordListRequest::word_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWordListRequest.word_id)
  return _internal_word_id();
}
inline void CMsgGCBannedWordListRequest::_internal_set_word_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.word_id_ = value;
}
inline void CMsgGCBannedWordListRequest::set_word_id(uint32_t value) {
  _internal_set_word_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCBannedWordListRequest.word_id)
}

// -------------------------------------------------------------------

// CMsgGCRequestAnnouncements

// -------------------------------------------------------------------

// CMsgGCRequestAnnouncementsResponse

// optional string announcement_title = 1;
inline bool CMsgGCRequestAnnouncementsResponse::_internal_has_announcement_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCRequestAnnouncementsResponse::has_announcement_title() const {
  return _internal_has_announcement_title();
}
inline void CMsgGCRequestAnnouncementsResponse::clear_announcement_title() {
  _impl_.announcement_title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::announcement_title() const {
  // @@protoc_insertion_point(field_get:CMsgGCRequestAnnouncementsResponse.announcement_title)
  return _internal_announcement_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCRequestAnnouncementsResponse::set_announcement_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.announcement_title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCRequestAnnouncementsResponse.announcement_title)
}
inline std::string* CMsgGCRequestAnnouncementsResponse::mutable_announcement_title() {
  std::string* _s = _internal_mutable_announcement_title();
  // @@protoc_insertion_point(field_mutable:CMsgGCRequestAnnouncementsResponse.announcement_title)
  return _s;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::_internal_announcement_title() const {
  return _impl_.announcement_title_.Get();
}
inline void CMsgGCRequestAnnouncementsResponse::_internal_set_announcement_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.announcement_title_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::_internal_mutable_announcement_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.announcement_title_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::release_announcement_title() {
  // @@protoc_insertion_point(field_release:CMsgGCRequestAnnouncementsResponse.announcement_title)
  if (!_internal_has_announcement_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.announcement_title_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.announcement_title_.IsDefault()) {
    _impl_.announcement_title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCRequestAnnouncementsResponse::set_allocated_announcement_title(std::string* announcement_title) {
  if (announcement_title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.announcement_title_.SetAllocated(announcement_title, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.announcement_title_.IsDefault()) {
    _impl_.announcement_title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCRequestAnnouncementsResponse.announcement_title)
}

// optional string announcement = 2;
inline bool CMsgGCRequestAnnouncementsResponse::_internal_has_announcement() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCRequestAnnouncementsResponse::has_announcement() const {
  return _internal_has_announcement();
}
inline void CMsgGCRequestAnnouncementsResponse::clear_announcement() {
  _impl_.announcement_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::announcement() const {
  // @@protoc_insertion_point(field_get:CMsgGCRequestAnnouncementsResponse.announcement)
  return _internal_announcement();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCRequestAnnouncementsResponse::set_announcement(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.announcement_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCRequestAnnouncementsResponse.announcement)
}
inline std::string* CMsgGCRequestAnnouncementsResponse::mutable_announcement() {
  std::string* _s = _internal_mutable_announcement();
  // @@protoc_insertion_point(field_mutable:CMsgGCRequestAnnouncementsResponse.announcement)
  return _s;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::_internal_announcement() const {
  return _impl_.announcement_.Get();
}
inline void CMsgGCRequestAnnouncementsResponse::_internal_set_announcement(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.announcement_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::_internal_mutable_announcement() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.announcement_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::release_announcement() {
  // @@protoc_insertion_point(field_release:CMsgGCRequestAnnouncementsResponse.announcement)
  if (!_internal_has_announcement()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.announcement_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.announcement_.IsDefault()) {
    _impl_.announcement_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCRequestAnnouncementsResponse::set_allocated_announcement(std::string* announcement) {
  if (announcement != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.announcement_.SetAllocated(announcement, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.announcement_.IsDefault()) {
    _impl_.announcement_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCRequestAnnouncementsResponse.announcement)
}

// optional string nextmatch_title = 3;
inline bool CMsgGCRequestAnnouncementsResponse::_internal_has_nextmatch_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCRequestAnnouncementsResponse::has_nextmatch_title() const {
  return _internal_has_nextmatch_title();
}
inline void CMsgGCRequestAnnouncementsResponse::clear_nextmatch_title() {
  _impl_.nextmatch_title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::nextmatch_title() const {
  // @@protoc_insertion_point(field_get:CMsgGCRequestAnnouncementsResponse.nextmatch_title)
  return _internal_nextmatch_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCRequestAnnouncementsResponse::set_nextmatch_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.nextmatch_title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCRequestAnnouncementsResponse.nextmatch_title)
}
inline std::string* CMsgGCRequestAnnouncementsResponse::mutable_nextmatch_title() {
  std::string* _s = _internal_mutable_nextmatch_title();
  // @@protoc_insertion_point(field_mutable:CMsgGCRequestAnnouncementsResponse.nextmatch_title)
  return _s;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::_internal_nextmatch_title() const {
  return _impl_.nextmatch_title_.Get();
}
inline void CMsgGCRequestAnnouncementsResponse::_internal_set_nextmatch_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.nextmatch_title_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::_internal_mutable_nextmatch_title() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.nextmatch_title_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::release_nextmatch_title() {
  // @@protoc_insertion_point(field_release:CMsgGCRequestAnnouncementsResponse.nextmatch_title)
  if (!_internal_has_nextmatch_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.nextmatch_title_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.nextmatch_title_.IsDefault()) {
    _impl_.nextmatch_title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCRequestAnnouncementsResponse::set_allocated_nextmatch_title(std::string* nextmatch_title) {
  if (nextmatch_title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.nextmatch_title_.SetAllocated(nextmatch_title, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.nextmatch_title_.IsDefault()) {
    _impl_.nextmatch_title_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCRequestAnnouncementsResponse.nextmatch_title)
}

// optional string nextmatch = 4;
inline bool CMsgGCRequestAnnouncementsResponse::_internal_has_nextmatch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgGCRequestAnnouncementsResponse::has_nextmatch() const {
  return _internal_has_nextmatch();
}
inline void CMsgGCRequestAnnouncementsResponse::clear_nextmatch() {
  _impl_.nextmatch_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::nextmatch() const {
  // @@protoc_insertion_point(field_get:CMsgGCRequestAnnouncementsResponse.nextmatch)
  return _internal_nextmatch();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCRequestAnnouncementsResponse::set_nextmatch(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.nextmatch_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCRequestAnnouncementsResponse.nextmatch)
}
inline std::string* CMsgGCRequestAnnouncementsResponse::mutable_nextmatch() {
  std::string* _s = _internal_mutable_nextmatch();
  // @@protoc_insertion_point(field_mutable:CMsgGCRequestAnnouncementsResponse.nextmatch)
  return _s;
}
inline const std::string& CMsgGCRequestAnnouncementsResponse::_internal_nextmatch() const {
  return _impl_.nextmatch_.Get();
}
inline void CMsgGCRequestAnnouncementsResponse::_internal_set_nextmatch(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.nextmatch_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::_internal_mutable_nextmatch() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.nextmatch_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCRequestAnnouncementsResponse::release_nextmatch() {
  // @@protoc_insertion_point(field_release:CMsgGCRequestAnnouncementsResponse.nextmatch)
  if (!_internal_has_nextmatch()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.nextmatch_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.nextmatch_.IsDefault()) {
    _impl_.nextmatch_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCRequestAnnouncementsResponse::set_allocated_nextmatch(std::string* nextmatch) {
  if (nextmatch != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.nextmatch_.SetAllocated(nextmatch, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.nextmatch_.IsDefault()) {
    _impl_.nextmatch_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCRequestAnnouncementsResponse.nextmatch)
}

// -------------------------------------------------------------------

// CMsgGCBannedWord

// optional uint32 word_id = 1;
inline bool CMsgGCBannedWord::_internal_has_word_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCBannedWord::has_word_id() const {
  return _internal_has_word_id();
}
inline void CMsgGCBannedWord::clear_word_id() {
  _impl_.word_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGCBannedWord::_internal_word_id() const {
  return _impl_.word_id_;
}
inline uint32_t CMsgGCBannedWord::word_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWord.word_id)
  return _internal_word_id();
}
inline void CMsgGCBannedWord::_internal_set_word_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.word_id_ = value;
}
inline void CMsgGCBannedWord::set_word_id(uint32_t value) {
  _internal_set_word_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCBannedWord.word_id)
}

// optional .GC_BannedWordType word_type = 2 [default = GC_BANNED_WORD_DISABLE_WORD];
inline bool CMsgGCBannedWord::_internal_has_word_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCBannedWord::has_word_type() const {
  return _internal_has_word_type();
}
inline void CMsgGCBannedWord::clear_word_type() {
  _impl_.word_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::GC_BannedWordType CMsgGCBannedWord::_internal_word_type() const {
  return static_cast< ::GC_BannedWordType >(_impl_.word_type_);
}
inline ::GC_BannedWordType CMsgGCBannedWord::word_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWord.word_type)
  return _internal_word_type();
}
inline void CMsgGCBannedWord::_internal_set_word_type(::GC_BannedWordType value) {
  assert(::GC_BannedWordType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.word_type_ = value;
}
inline void CMsgGCBannedWord::set_word_type(::GC_BannedWordType value) {
  _internal_set_word_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCBannedWord.word_type)
}

// optional string word = 3;
inline bool CMsgGCBannedWord::_internal_has_word() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCBannedWord::has_word() const {
  return _internal_has_word();
}
inline void CMsgGCBannedWord::clear_word() {
  _impl_.word_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCBannedWord::word() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWord.word)
  return _internal_word();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCBannedWord::set_word(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.word_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCBannedWord.word)
}
inline std::string* CMsgGCBannedWord::mutable_word() {
  std::string* _s = _internal_mutable_word();
  // @@protoc_insertion_point(field_mutable:CMsgGCBannedWord.word)
  return _s;
}
inline const std::string& CMsgGCBannedWord::_internal_word() const {
  return _impl_.word_.Get();
}
inline void CMsgGCBannedWord::_internal_set_word(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.word_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCBannedWord::_internal_mutable_word() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.word_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCBannedWord::release_word() {
  // @@protoc_insertion_point(field_release:CMsgGCBannedWord.word)
  if (!_internal_has_word()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.word_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.word_.IsDefault()) {
    _impl_.word_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCBannedWord::set_allocated_word(std::string* word) {
  if (word != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.word_.SetAllocated(word, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.word_.IsDefault()) {
    _impl_.word_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCBannedWord.word)
}

// -------------------------------------------------------------------

// CMsgGCBannedWordListResponse

// optional uint32 ban_list_group_id = 1;
inline bool CMsgGCBannedWordListResponse::_internal_has_ban_list_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCBannedWordListResponse::has_ban_list_group_id() const {
  return _internal_has_ban_list_group_id();
}
inline void CMsgGCBannedWordListResponse::clear_ban_list_group_id() {
  _impl_.ban_list_group_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCBannedWordListResponse::_internal_ban_list_group_id() const {
  return _impl_.ban_list_group_id_;
}
inline uint32_t CMsgGCBannedWordListResponse::ban_list_group_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWordListResponse.ban_list_group_id)
  return _internal_ban_list_group_id();
}
inline void CMsgGCBannedWordListResponse::_internal_set_ban_list_group_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ban_list_group_id_ = value;
}
inline void CMsgGCBannedWordListResponse::set_ban_list_group_id(uint32_t value) {
  _internal_set_ban_list_group_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCBannedWordListResponse.ban_list_group_id)
}

// repeated .CMsgGCBannedWord word_list = 2;
inline int CMsgGCBannedWordListResponse::_internal_word_list_size() const {
  return _impl_.word_list_.size();
}
inline int CMsgGCBannedWordListResponse::word_list_size() const {
  return _internal_word_list_size();
}
inline void CMsgGCBannedWordListResponse::clear_word_list() {
  _impl_.word_list_.Clear();
}
inline ::CMsgGCBannedWord* CMsgGCBannedWordListResponse::mutable_word_list(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgGCBannedWordListResponse.word_list)
  return _impl_.word_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgGCBannedWord >*
CMsgGCBannedWordListResponse::mutable_word_list() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCBannedWordListResponse.word_list)
  return &_impl_.word_list_;
}
inline const ::CMsgGCBannedWord& CMsgGCBannedWordListResponse::_internal_word_list(int index) const {
  return _impl_.word_list_.Get(index);
}
inline const ::CMsgGCBannedWord& CMsgGCBannedWordListResponse::word_list(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCBannedWordListResponse.word_list)
  return _internal_word_list(index);
}
inline ::CMsgGCBannedWord* CMsgGCBannedWordListResponse::_internal_add_word_list() {
  return _impl_.word_list_.Add();
}
inline ::CMsgGCBannedWord* CMsgGCBannedWordListResponse::add_word_list() {
  ::CMsgGCBannedWord* _add = _internal_add_word_list();
  // @@protoc_insertion_point(field_add:CMsgGCBannedWordListResponse.word_list)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgGCBannedWord >&
CMsgGCBannedWordListResponse::word_list() const {
  // @@protoc_insertion_point(field_list:CMsgGCBannedWordListResponse.word_list)
  return _impl_.word_list_;
}

// -------------------------------------------------------------------

// CMsgGCToGCBannedWordListBroadcast

// optional .CMsgGCBannedWordListResponse broadcast = 1;
inline bool CMsgGCToGCBannedWordListBroadcast::_internal_has_broadcast() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.broadcast_ != nullptr);
  return value;
}
inline bool CMsgGCToGCBannedWordListBroadcast::has_broadcast() const {
  return _internal_has_broadcast();
}
inline void CMsgGCToGCBannedWordListBroadcast::clear_broadcast() {
  if (_impl_.broadcast_ != nullptr) _impl_.broadcast_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgGCBannedWordListResponse& CMsgGCToGCBannedWordListBroadcast::_internal_broadcast() const {
  const ::CMsgGCBannedWordListResponse* p = _impl_.broadcast_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgGCBannedWordListResponse&>(
      ::_CMsgGCBannedWordListResponse_default_instance_);
}
inline const ::CMsgGCBannedWordListResponse& CMsgGCToGCBannedWordListBroadcast::broadcast() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCBannedWordListBroadcast.broadcast)
  return _internal_broadcast();
}
inline void CMsgGCToGCBannedWordListBroadcast::unsafe_arena_set_allocated_broadcast(
    ::CMsgGCBannedWordListResponse* broadcast) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.broadcast_);
  }
  _impl_.broadcast_ = broadcast;
  if (broadcast) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgGCToGCBannedWordListBroadcast.broadcast)
}
inline ::CMsgGCBannedWordListResponse* CMsgGCToGCBannedWordListBroadcast::release_broadcast() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgGCBannedWordListResponse* temp = _impl_.broadcast_;
  _impl_.broadcast_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgGCBannedWordListResponse* CMsgGCToGCBannedWordListBroadcast::unsafe_arena_release_broadcast() {
  // @@protoc_insertion_point(field_release:CMsgGCToGCBannedWordListBroadcast.broadcast)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgGCBannedWordListResponse* temp = _impl_.broadcast_;
  _impl_.broadcast_ = nullptr;
  return temp;
}
inline ::CMsgGCBannedWordListResponse* CMsgGCToGCBannedWordListBroadcast::_internal_mutable_broadcast() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.broadcast_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgGCBannedWordListResponse>(GetArenaForAllocation());
    _impl_.broadcast_ = p;
  }
  return _impl_.broadcast_;
}
inline ::CMsgGCBannedWordListResponse* CMsgGCToGCBannedWordListBroadcast::mutable_broadcast() {
  ::CMsgGCBannedWordListResponse* _msg = _internal_mutable_broadcast();
  // @@protoc_insertion_point(field_mutable:CMsgGCToGCBannedWordListBroadcast.broadcast)
  return _msg;
}
inline void CMsgGCToGCBannedWordListBroadcast::set_allocated_broadcast(::CMsgGCBannedWordListResponse* broadcast) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.broadcast_;
  }
  if (broadcast) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(broadcast);
    if (message_arena != submessage_arena) {
      broadcast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, broadcast, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.broadcast_ = broadcast;
  // @@protoc_insertion_point(field_set_allocated:CMsgGCToGCBannedWordListBroadcast.broadcast)
}

// -------------------------------------------------------------------

// CMsgGCToGCBannedWordListUpdated

// optional uint32 group_id = 1;
inline bool CMsgGCToGCBannedWordListUpdated::_internal_has_group_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCBannedWordListUpdated::has_group_id() const {
  return _internal_has_group_id();
}
inline void CMsgGCToGCBannedWordListUpdated::clear_group_id() {
  _impl_.group_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCToGCBannedWordListUpdated::_internal_group_id() const {
  return _impl_.group_id_;
}
inline uint32_t CMsgGCToGCBannedWordListUpdated::group_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCBannedWordListUpdated.group_id)
  return _internal_group_id();
}
inline void CMsgGCToGCBannedWordListUpdated::_internal_set_group_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.group_id_ = value;
}
inline void CMsgGCToGCBannedWordListUpdated::set_group_id(uint32_t value) {
  _internal_set_group_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCBannedWordListUpdated.group_id)
}

// -------------------------------------------------------------------

// CMsgGCToGCDirtySDOCache

// optional uint32 sdo_type = 1;
inline bool CMsgGCToGCDirtySDOCache::_internal_has_sdo_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCToGCDirtySDOCache::has_sdo_type() const {
  return _internal_has_sdo_type();
}
inline void CMsgGCToGCDirtySDOCache::clear_sdo_type() {
  _impl_.sdo_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGCToGCDirtySDOCache::_internal_sdo_type() const {
  return _impl_.sdo_type_;
}
inline uint32_t CMsgGCToGCDirtySDOCache::sdo_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCDirtySDOCache.sdo_type)
  return _internal_sdo_type();
}
inline void CMsgGCToGCDirtySDOCache::_internal_set_sdo_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.sdo_type_ = value;
}
inline void CMsgGCToGCDirtySDOCache::set_sdo_type(uint32_t value) {
  _internal_set_sdo_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCDirtySDOCache.sdo_type)
}

// optional uint64 key_uint64 = 2;
inline bool CMsgGCToGCDirtySDOCache::_internal_has_key_uint64() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCDirtySDOCache::has_key_uint64() const {
  return _internal_has_key_uint64();
}
inline void CMsgGCToGCDirtySDOCache::clear_key_uint64() {
  _impl_.key_uint64_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCToGCDirtySDOCache::_internal_key_uint64() const {
  return _impl_.key_uint64_;
}
inline uint64_t CMsgGCToGCDirtySDOCache::key_uint64() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCDirtySDOCache.key_uint64)
  return _internal_key_uint64();
}
inline void CMsgGCToGCDirtySDOCache::_internal_set_key_uint64(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_uint64_ = value;
}
inline void CMsgGCToGCDirtySDOCache::set_key_uint64(uint64_t value) {
  _internal_set_key_uint64(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCDirtySDOCache.key_uint64)
}

// -------------------------------------------------------------------

// CMsgGCToGCDirtyMultipleSDOCache

// optional uint32 sdo_type = 1;
inline bool CMsgGCToGCDirtyMultipleSDOCache::_internal_has_sdo_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCDirtyMultipleSDOCache::has_sdo_type() const {
  return _internal_has_sdo_type();
}
inline void CMsgGCToGCDirtyMultipleSDOCache::clear_sdo_type() {
  _impl_.sdo_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCToGCDirtyMultipleSDOCache::_internal_sdo_type() const {
  return _impl_.sdo_type_;
}
inline uint32_t CMsgGCToGCDirtyMultipleSDOCache::sdo_type() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCDirtyMultipleSDOCache.sdo_type)
  return _internal_sdo_type();
}
inline void CMsgGCToGCDirtyMultipleSDOCache::_internal_set_sdo_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sdo_type_ = value;
}
inline void CMsgGCToGCDirtyMultipleSDOCache::set_sdo_type(uint32_t value) {
  _internal_set_sdo_type(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCDirtyMultipleSDOCache.sdo_type)
}

// repeated uint64 key_uint64 = 2;
inline int CMsgGCToGCDirtyMultipleSDOCache::_internal_key_uint64_size() const {
  return _impl_.key_uint64_.size();
}
inline int CMsgGCToGCDirtyMultipleSDOCache::key_uint64_size() const {
  return _internal_key_uint64_size();
}
inline void CMsgGCToGCDirtyMultipleSDOCache::clear_key_uint64() {
  _impl_.key_uint64_.Clear();
}
inline uint64_t CMsgGCToGCDirtyMultipleSDOCache::_internal_key_uint64(int index) const {
  return _impl_.key_uint64_.Get(index);
}
inline uint64_t CMsgGCToGCDirtyMultipleSDOCache::key_uint64(int index) const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCDirtyMultipleSDOCache.key_uint64)
  return _internal_key_uint64(index);
}
inline void CMsgGCToGCDirtyMultipleSDOCache::set_key_uint64(int index, uint64_t value) {
  _impl_.key_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCDirtyMultipleSDOCache.key_uint64)
}
inline void CMsgGCToGCDirtyMultipleSDOCache::_internal_add_key_uint64(uint64_t value) {
  _impl_.key_uint64_.Add(value);
}
inline void CMsgGCToGCDirtyMultipleSDOCache::add_key_uint64(uint64_t value) {
  _internal_add_key_uint64(value);
  // @@protoc_insertion_point(field_add:CMsgGCToGCDirtyMultipleSDOCache.key_uint64)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCToGCDirtyMultipleSDOCache::_internal_key_uint64() const {
  return _impl_.key_uint64_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgGCToGCDirtyMultipleSDOCache::key_uint64() const {
  // @@protoc_insertion_point(field_list:CMsgGCToGCDirtyMultipleSDOCache.key_uint64)
  return _internal_key_uint64();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCToGCDirtyMultipleSDOCache::_internal_mutable_key_uint64() {
  return &_impl_.key_uint64_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgGCToGCDirtyMultipleSDOCache::mutable_key_uint64() {
  // @@protoc_insertion_point(field_mutable_list:CMsgGCToGCDirtyMultipleSDOCache.key_uint64)
  return _internal_mutable_key_uint64();
}

// -------------------------------------------------------------------

// CMsgGCCollectItem

// optional uint64 collection_item_id = 1;
inline bool CMsgGCCollectItem::_internal_has_collection_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCCollectItem::has_collection_item_id() const {
  return _internal_has_collection_item_id();
}
inline void CMsgGCCollectItem::clear_collection_item_id() {
  _impl_.collection_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCCollectItem::_internal_collection_item_id() const {
  return _impl_.collection_item_id_;
}
inline uint64_t CMsgGCCollectItem::collection_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCCollectItem.collection_item_id)
  return _internal_collection_item_id();
}
inline void CMsgGCCollectItem::_internal_set_collection_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.collection_item_id_ = value;
}
inline void CMsgGCCollectItem::set_collection_item_id(uint64_t value) {
  _internal_set_collection_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCCollectItem.collection_item_id)
}

// optional uint64 subject_item_id = 2;
inline bool CMsgGCCollectItem::_internal_has_subject_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCCollectItem::has_subject_item_id() const {
  return _internal_has_subject_item_id();
}
inline void CMsgGCCollectItem::clear_subject_item_id() {
  _impl_.subject_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgGCCollectItem::_internal_subject_item_id() const {
  return _impl_.subject_item_id_;
}
inline uint64_t CMsgGCCollectItem::subject_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCCollectItem.subject_item_id)
  return _internal_subject_item_id();
}
inline void CMsgGCCollectItem::_internal_set_subject_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.subject_item_id_ = value;
}
inline void CMsgGCCollectItem::set_subject_item_id(uint64_t value) {
  _internal_set_subject_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCCollectItem.subject_item_id)
}

// -------------------------------------------------------------------

// CMsgSDONoMemcached

// -------------------------------------------------------------------

// CMsgGCToGCUpdateSQLKeyValue

// optional string key_name = 1;
inline bool CMsgGCToGCUpdateSQLKeyValue::_internal_has_key_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCUpdateSQLKeyValue::has_key_name() const {
  return _internal_has_key_name();
}
inline void CMsgGCToGCUpdateSQLKeyValue::clear_key_name() {
  _impl_.key_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCToGCUpdateSQLKeyValue::key_name() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCUpdateSQLKeyValue.key_name)
  return _internal_key_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCToGCUpdateSQLKeyValue::set_key_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.key_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCToGCUpdateSQLKeyValue.key_name)
}
inline std::string* CMsgGCToGCUpdateSQLKeyValue::mutable_key_name() {
  std::string* _s = _internal_mutable_key_name();
  // @@protoc_insertion_point(field_mutable:CMsgGCToGCUpdateSQLKeyValue.key_name)
  return _s;
}
inline const std::string& CMsgGCToGCUpdateSQLKeyValue::_internal_key_name() const {
  return _impl_.key_name_.Get();
}
inline void CMsgGCToGCUpdateSQLKeyValue::_internal_set_key_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCToGCUpdateSQLKeyValue::_internal_mutable_key_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.key_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCToGCUpdateSQLKeyValue::release_key_name() {
  // @@protoc_insertion_point(field_release:CMsgGCToGCUpdateSQLKeyValue.key_name)
  if (!_internal_has_key_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.key_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_name_.IsDefault()) {
    _impl_.key_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCToGCUpdateSQLKeyValue::set_allocated_key_name(std::string* key_name) {
  if (key_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_name_.SetAllocated(key_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_name_.IsDefault()) {
    _impl_.key_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCToGCUpdateSQLKeyValue.key_name)
}

// -------------------------------------------------------------------

// CMsgGCToGCIsTrustedServer

// optional fixed64 steam_id = 1;
inline bool CMsgGCToGCIsTrustedServer::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCIsTrustedServer::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CMsgGCToGCIsTrustedServer::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCToGCIsTrustedServer::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CMsgGCToGCIsTrustedServer::steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCIsTrustedServer.steam_id)
  return _internal_steam_id();
}
inline void CMsgGCToGCIsTrustedServer::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.steam_id_ = value;
}
inline void CMsgGCToGCIsTrustedServer::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCIsTrustedServer.steam_id)
}

// -------------------------------------------------------------------

// CMsgGCToGCIsTrustedServerResponse

// optional bool is_trusted = 1;
inline bool CMsgGCToGCIsTrustedServerResponse::_internal_has_is_trusted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCIsTrustedServerResponse::has_is_trusted() const {
  return _internal_has_is_trusted();
}
inline void CMsgGCToGCIsTrustedServerResponse::clear_is_trusted() {
  _impl_.is_trusted_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CMsgGCToGCIsTrustedServerResponse::_internal_is_trusted() const {
  return _impl_.is_trusted_;
}
inline bool CMsgGCToGCIsTrustedServerResponse::is_trusted() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCIsTrustedServerResponse.is_trusted)
  return _internal_is_trusted();
}
inline void CMsgGCToGCIsTrustedServerResponse::_internal_set_is_trusted(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.is_trusted_ = value;
}
inline void CMsgGCToGCIsTrustedServerResponse::set_is_trusted(bool value) {
  _internal_set_is_trusted(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCIsTrustedServerResponse.is_trusted)
}

// -------------------------------------------------------------------

// CMsgGCToGCBroadcastConsoleCommand

// optional string con_command = 1;
inline bool CMsgGCToGCBroadcastConsoleCommand::_internal_has_con_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCBroadcastConsoleCommand::has_con_command() const {
  return _internal_has_con_command();
}
inline void CMsgGCToGCBroadcastConsoleCommand::clear_con_command() {
  _impl_.con_command_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGCToGCBroadcastConsoleCommand::con_command() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCBroadcastConsoleCommand.con_command)
  return _internal_con_command();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGCToGCBroadcastConsoleCommand::set_con_command(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.con_command_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGCToGCBroadcastConsoleCommand.con_command)
}
inline std::string* CMsgGCToGCBroadcastConsoleCommand::mutable_con_command() {
  std::string* _s = _internal_mutable_con_command();
  // @@protoc_insertion_point(field_mutable:CMsgGCToGCBroadcastConsoleCommand.con_command)
  return _s;
}
inline const std::string& CMsgGCToGCBroadcastConsoleCommand::_internal_con_command() const {
  return _impl_.con_command_.Get();
}
inline void CMsgGCToGCBroadcastConsoleCommand::_internal_set_con_command(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.con_command_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGCToGCBroadcastConsoleCommand::_internal_mutable_con_command() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.con_command_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGCToGCBroadcastConsoleCommand::release_con_command() {
  // @@protoc_insertion_point(field_release:CMsgGCToGCBroadcastConsoleCommand.con_command)
  if (!_internal_has_con_command()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.con_command_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.con_command_.IsDefault()) {
    _impl_.con_command_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGCToGCBroadcastConsoleCommand::set_allocated_con_command(std::string* con_command) {
  if (con_command != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.con_command_.SetAllocated(con_command, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.con_command_.IsDefault()) {
    _impl_.con_command_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGCToGCBroadcastConsoleCommand.con_command)
}

// -------------------------------------------------------------------

// CMsgGCServerVersionUpdated

// optional uint32 server_version = 1;
inline bool CMsgGCServerVersionUpdated::_internal_has_server_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCServerVersionUpdated::has_server_version() const {
  return _internal_has_server_version();
}
inline void CMsgGCServerVersionUpdated::clear_server_version() {
  _impl_.server_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCServerVersionUpdated::_internal_server_version() const {
  return _impl_.server_version_;
}
inline uint32_t CMsgGCServerVersionUpdated::server_version() const {
  // @@protoc_insertion_point(field_get:CMsgGCServerVersionUpdated.server_version)
  return _internal_server_version();
}
inline void CMsgGCServerVersionUpdated::_internal_set_server_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.server_version_ = value;
}
inline void CMsgGCServerVersionUpdated::set_server_version(uint32_t value) {
  _internal_set_server_version(value);
  // @@protoc_insertion_point(field_set:CMsgGCServerVersionUpdated.server_version)
}

// -------------------------------------------------------------------

// CMsgGCClientVersionUpdated

// optional uint32 client_version = 1;
inline bool CMsgGCClientVersionUpdated::_internal_has_client_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCClientVersionUpdated::has_client_version() const {
  return _internal_has_client_version();
}
inline void CMsgGCClientVersionUpdated::clear_client_version() {
  _impl_.client_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgGCClientVersionUpdated::_internal_client_version() const {
  return _impl_.client_version_;
}
inline uint32_t CMsgGCClientVersionUpdated::client_version() const {
  // @@protoc_insertion_point(field_get:CMsgGCClientVersionUpdated.client_version)
  return _internal_client_version();
}
inline void CMsgGCClientVersionUpdated::_internal_set_client_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.client_version_ = value;
}
inline void CMsgGCClientVersionUpdated::set_client_version(uint32_t value) {
  _internal_set_client_version(value);
  // @@protoc_insertion_point(field_set:CMsgGCClientVersionUpdated.client_version)
}

// -------------------------------------------------------------------

// CMsgGCToGCWebAPIAccountChanged

// -------------------------------------------------------------------

// CMsgGCToGCRequestPassportItemGrant

// optional fixed64 steam_id = 1;
inline bool CMsgGCToGCRequestPassportItemGrant::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGCToGCRequestPassportItemGrant::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CMsgGCToGCRequestPassportItemGrant::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgGCToGCRequestPassportItemGrant::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CMsgGCToGCRequestPassportItemGrant::steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCRequestPassportItemGrant.steam_id)
  return _internal_steam_id();
}
inline void CMsgGCToGCRequestPassportItemGrant::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.steam_id_ = value;
}
inline void CMsgGCToGCRequestPassportItemGrant::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCRequestPassportItemGrant.steam_id)
}

// optional uint32 league_id = 2;
inline bool CMsgGCToGCRequestPassportItemGrant::_internal_has_league_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGCToGCRequestPassportItemGrant::has_league_id() const {
  return _internal_has_league_id();
}
inline void CMsgGCToGCRequestPassportItemGrant::clear_league_id() {
  _impl_.league_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGCToGCRequestPassportItemGrant::_internal_league_id() const {
  return _impl_.league_id_;
}
inline uint32_t CMsgGCToGCRequestPassportItemGrant::league_id() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCRequestPassportItemGrant.league_id)
  return _internal_league_id();
}
inline void CMsgGCToGCRequestPassportItemGrant::_internal_set_league_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.league_id_ = value;
}
inline void CMsgGCToGCRequestPassportItemGrant::set_league_id(uint32_t value) {
  _internal_set_league_id(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCRequestPassportItemGrant.league_id)
}

// optional int32 reward_flag = 3;
inline bool CMsgGCToGCRequestPassportItemGrant::_internal_has_reward_flag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGCToGCRequestPassportItemGrant::has_reward_flag() const {
  return _internal_has_reward_flag();
}
inline void CMsgGCToGCRequestPassportItemGrant::clear_reward_flag() {
  _impl_.reward_flag_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgGCToGCRequestPassportItemGrant::_internal_reward_flag() const {
  return _impl_.reward_flag_;
}
inline int32_t CMsgGCToGCRequestPassportItemGrant::reward_flag() const {
  // @@protoc_insertion_point(field_get:CMsgGCToGCRequestPassportItemGrant.reward_flag)
  return _internal_reward_flag();
}
inline void CMsgGCToGCRequestPassportItemGrant::_internal_set_reward_flag(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.reward_flag_ = value;
}
inline void CMsgGCToGCRequestPassportItemGrant::set_reward_flag(int32_t value) {
  _internal_set_reward_flag(value);
  // @@protoc_insertion_point(field_set:CMsgGCToGCRequestPassportItemGrant.reward_flag)
}

// -------------------------------------------------------------------

// CMsgGameServerInfo

// optional fixed32 server_public_ip_addr = 1;
inline bool CMsgGameServerInfo::_internal_has_server_public_ip_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_public_ip_addr() const {
  return _internal_has_server_public_ip_addr();
}
inline void CMsgGameServerInfo::clear_server_public_ip_addr() {
  _impl_.server_public_ip_addr_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgGameServerInfo::_internal_server_public_ip_addr() const {
  return _impl_.server_public_ip_addr_;
}
inline uint32_t CMsgGameServerInfo::server_public_ip_addr() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_public_ip_addr)
  return _internal_server_public_ip_addr();
}
inline void CMsgGameServerInfo::_internal_set_server_public_ip_addr(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.server_public_ip_addr_ = value;
}
inline void CMsgGameServerInfo::set_server_public_ip_addr(uint32_t value) {
  _internal_set_server_public_ip_addr(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_public_ip_addr)
}

// optional fixed32 server_private_ip_addr = 2;
inline bool CMsgGameServerInfo::_internal_has_server_private_ip_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_private_ip_addr() const {
  return _internal_has_server_private_ip_addr();
}
inline void CMsgGameServerInfo::clear_server_private_ip_addr() {
  _impl_.server_private_ip_addr_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgGameServerInfo::_internal_server_private_ip_addr() const {
  return _impl_.server_private_ip_addr_;
}
inline uint32_t CMsgGameServerInfo::server_private_ip_addr() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_private_ip_addr)
  return _internal_server_private_ip_addr();
}
inline void CMsgGameServerInfo::_internal_set_server_private_ip_addr(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.server_private_ip_addr_ = value;
}
inline void CMsgGameServerInfo::set_server_private_ip_addr(uint32_t value) {
  _internal_set_server_private_ip_addr(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_private_ip_addr)
}

// optional uint32 server_port = 3;
inline bool CMsgGameServerInfo::_internal_has_server_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_port() const {
  return _internal_has_server_port();
}
inline void CMsgGameServerInfo::clear_server_port() {
  _impl_.server_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgGameServerInfo::_internal_server_port() const {
  return _impl_.server_port_;
}
inline uint32_t CMsgGameServerInfo::server_port() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_port)
  return _internal_server_port();
}
inline void CMsgGameServerInfo::_internal_set_server_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.server_port_ = value;
}
inline void CMsgGameServerInfo::set_server_port(uint32_t value) {
  _internal_set_server_port(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_port)
}

// optional uint32 server_tv_port = 4;
inline bool CMsgGameServerInfo::_internal_has_server_tv_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_tv_port() const {
  return _internal_has_server_tv_port();
}
inline void CMsgGameServerInfo::clear_server_tv_port() {
  _impl_.server_tv_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgGameServerInfo::_internal_server_tv_port() const {
  return _impl_.server_tv_port_;
}
inline uint32_t CMsgGameServerInfo::server_tv_port() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_tv_port)
  return _internal_server_tv_port();
}
inline void CMsgGameServerInfo::_internal_set_server_tv_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.server_tv_port_ = value;
}
inline void CMsgGameServerInfo::set_server_tv_port(uint32_t value) {
  _internal_set_server_tv_port(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_tv_port)
}

// optional string server_key = 5;
inline bool CMsgGameServerInfo::_internal_has_server_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_key() const {
  return _internal_has_server_key();
}
inline void CMsgGameServerInfo::clear_server_key() {
  _impl_.server_key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgGameServerInfo::server_key() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_key)
  return _internal_server_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgGameServerInfo::set_server_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.server_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_key)
}
inline std::string* CMsgGameServerInfo::mutable_server_key() {
  std::string* _s = _internal_mutable_server_key();
  // @@protoc_insertion_point(field_mutable:CMsgGameServerInfo.server_key)
  return _s;
}
inline const std::string& CMsgGameServerInfo::_internal_server_key() const {
  return _impl_.server_key_.Get();
}
inline void CMsgGameServerInfo::_internal_set_server_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.server_key_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgGameServerInfo::_internal_mutable_server_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.server_key_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgGameServerInfo::release_server_key() {
  // @@protoc_insertion_point(field_release:CMsgGameServerInfo.server_key)
  if (!_internal_has_server_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.server_key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.server_key_.IsDefault()) {
    _impl_.server_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgGameServerInfo::set_allocated_server_key(std::string* server_key) {
  if (server_key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.server_key_.SetAllocated(server_key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.server_key_.IsDefault()) {
    _impl_.server_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgGameServerInfo.server_key)
}

// optional bool server_hibernation = 6;
inline bool CMsgGameServerInfo::_internal_has_server_hibernation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_hibernation() const {
  return _internal_has_server_hibernation();
}
inline void CMsgGameServerInfo::clear_server_hibernation() {
  _impl_.server_hibernation_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CMsgGameServerInfo::_internal_server_hibernation() const {
  return _impl_.server_hibernation_;
}
inline bool CMsgGameServerInfo::server_hibernation() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_hibernation)
  return _internal_server_hibernation();
}
inline void CMsgGameServerInfo::_internal_set_server_hibernation(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.server_hibernation_ = value;
}
inline void CMsgGameServerInfo::set_server_hibernation(bool value) {
  _internal_set_server_hibernation(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_hibernation)
}

// optional .CMsgGameServerInfo.ServerType server_type = 7 [default = UNSPECIFIED];
inline bool CMsgGameServerInfo::_internal_has_server_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_type() const {
  return _internal_has_server_type();
}
inline void CMsgGameServerInfo::clear_server_type() {
  _impl_.server_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::CMsgGameServerInfo_ServerType CMsgGameServerInfo::_internal_server_type() const {
  return static_cast< ::CMsgGameServerInfo_ServerType >(_impl_.server_type_);
}
inline ::CMsgGameServerInfo_ServerType CMsgGameServerInfo::server_type() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_type)
  return _internal_server_type();
}
inline void CMsgGameServerInfo::_internal_set_server_type(::CMsgGameServerInfo_ServerType value) {
  assert(::CMsgGameServerInfo_ServerType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.server_type_ = value;
}
inline void CMsgGameServerInfo::set_server_type(::CMsgGameServerInfo_ServerType value) {
  _internal_set_server_type(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_type)
}

// optional uint32 server_region = 8;
inline bool CMsgGameServerInfo::_internal_has_server_region() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_region() const {
  return _internal_has_server_region();
}
inline void CMsgGameServerInfo::clear_server_region() {
  _impl_.server_region_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgGameServerInfo::_internal_server_region() const {
  return _impl_.server_region_;
}
inline uint32_t CMsgGameServerInfo::server_region() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_region)
  return _internal_server_region();
}
inline void CMsgGameServerInfo::_internal_set_server_region(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.server_region_ = value;
}
inline void CMsgGameServerInfo::set_server_region(uint32_t value) {
  _internal_set_server_region(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_region)
}

// optional float server_loadavg = 9;
inline bool CMsgGameServerInfo::_internal_has_server_loadavg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_loadavg() const {
  return _internal_has_server_loadavg();
}
inline void CMsgGameServerInfo::clear_server_loadavg() {
  _impl_.server_loadavg_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float CMsgGameServerInfo::_internal_server_loadavg() const {
  return _impl_.server_loadavg_;
}
inline float CMsgGameServerInfo::server_loadavg() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_loadavg)
  return _internal_server_loadavg();
}
inline void CMsgGameServerInfo::_internal_set_server_loadavg(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.server_loadavg_ = value;
}
inline void CMsgGameServerInfo::set_server_loadavg(float value) {
  _internal_set_server_loadavg(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_loadavg)
}

// optional float server_tv_broadcast_time = 10;
inline bool CMsgGameServerInfo::_internal_has_server_tv_broadcast_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_tv_broadcast_time() const {
  return _internal_has_server_tv_broadcast_time();
}
inline void CMsgGameServerInfo::clear_server_tv_broadcast_time() {
  _impl_.server_tv_broadcast_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float CMsgGameServerInfo::_internal_server_tv_broadcast_time() const {
  return _impl_.server_tv_broadcast_time_;
}
inline float CMsgGameServerInfo::server_tv_broadcast_time() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_tv_broadcast_time)
  return _internal_server_tv_broadcast_time();
}
inline void CMsgGameServerInfo::_internal_set_server_tv_broadcast_time(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.server_tv_broadcast_time_ = value;
}
inline void CMsgGameServerInfo::set_server_tv_broadcast_time(float value) {
  _internal_set_server_tv_broadcast_time(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_tv_broadcast_time)
}

// optional float server_game_time = 11;
inline bool CMsgGameServerInfo::_internal_has_server_game_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_game_time() const {
  return _internal_has_server_game_time();
}
inline void CMsgGameServerInfo::clear_server_game_time() {
  _impl_.server_game_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float CMsgGameServerInfo::_internal_server_game_time() const {
  return _impl_.server_game_time_;
}
inline float CMsgGameServerInfo::server_game_time() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_game_time)
  return _internal_server_game_time();
}
inline void CMsgGameServerInfo::_internal_set_server_game_time(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.server_game_time_ = value;
}
inline void CMsgGameServerInfo::set_server_game_time(float value) {
  _internal_set_server_game_time(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_game_time)
}

// optional fixed64 server_relay_connected_steam_id = 12;
inline bool CMsgGameServerInfo::_internal_has_server_relay_connected_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_server_relay_connected_steam_id() const {
  return _internal_has_server_relay_connected_steam_id();
}
inline void CMsgGameServerInfo::clear_server_relay_connected_steam_id() {
  _impl_.server_relay_connected_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint64_t CMsgGameServerInfo::_internal_server_relay_connected_steam_id() const {
  return _impl_.server_relay_connected_steam_id_;
}
inline uint64_t CMsgGameServerInfo::server_relay_connected_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.server_relay_connected_steam_id)
  return _internal_server_relay_connected_steam_id();
}
inline void CMsgGameServerInfo::_internal_set_server_relay_connected_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.server_relay_connected_steam_id_ = value;
}
inline void CMsgGameServerInfo::set_server_relay_connected_steam_id(uint64_t value) {
  _internal_set_server_relay_connected_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.server_relay_connected_steam_id)
}

// optional uint32 relay_slots_max = 13;
inline bool CMsgGameServerInfo::_internal_has_relay_slots_max() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_relay_slots_max() const {
  return _internal_has_relay_slots_max();
}
inline void CMsgGameServerInfo::clear_relay_slots_max() {
  _impl_.relay_slots_max_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgGameServerInfo::_internal_relay_slots_max() const {
  return _impl_.relay_slots_max_;
}
inline uint32_t CMsgGameServerInfo::relay_slots_max() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.relay_slots_max)
  return _internal_relay_slots_max();
}
inline void CMsgGameServerInfo::_internal_set_relay_slots_max(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.relay_slots_max_ = value;
}
inline void CMsgGameServerInfo::set_relay_slots_max(uint32_t value) {
  _internal_set_relay_slots_max(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.relay_slots_max)
}

// optional int32 relays_connected = 14;
inline bool CMsgGameServerInfo::_internal_has_relays_connected() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_relays_connected() const {
  return _internal_has_relays_connected();
}
inline void CMsgGameServerInfo::clear_relays_connected() {
  _impl_.relays_connected_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CMsgGameServerInfo::_internal_relays_connected() const {
  return _impl_.relays_connected_;
}
inline int32_t CMsgGameServerInfo::relays_connected() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.relays_connected)
  return _internal_relays_connected();
}
inline void CMsgGameServerInfo::_internal_set_relays_connected(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.relays_connected_ = value;
}
inline void CMsgGameServerInfo::set_relays_connected(int32_t value) {
  _internal_set_relays_connected(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.relays_connected)
}

// optional int32 relay_clients_connected = 15;
inline bool CMsgGameServerInfo::_internal_has_relay_clients_connected() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_relay_clients_connected() const {
  return _internal_has_relay_clients_connected();
}
inline void CMsgGameServerInfo::clear_relay_clients_connected() {
  _impl_.relay_clients_connected_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t CMsgGameServerInfo::_internal_relay_clients_connected() const {
  return _impl_.relay_clients_connected_;
}
inline int32_t CMsgGameServerInfo::relay_clients_connected() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.relay_clients_connected)
  return _internal_relay_clients_connected();
}
inline void CMsgGameServerInfo::_internal_set_relay_clients_connected(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.relay_clients_connected_ = value;
}
inline void CMsgGameServerInfo::set_relay_clients_connected(int32_t value) {
  _internal_set_relay_clients_connected(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.relay_clients_connected)
}

// optional fixed64 relayed_game_server_steam_id = 16;
inline bool CMsgGameServerInfo::_internal_has_relayed_game_server_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_relayed_game_server_steam_id() const {
  return _internal_has_relayed_game_server_steam_id();
}
inline void CMsgGameServerInfo::clear_relayed_game_server_steam_id() {
  _impl_.relayed_game_server_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t CMsgGameServerInfo::_internal_relayed_game_server_steam_id() const {
  return _impl_.relayed_game_server_steam_id_;
}
inline uint64_t CMsgGameServerInfo::relayed_game_server_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.relayed_game_server_steam_id)
  return _internal_relayed_game_server_steam_id();
}
inline void CMsgGameServerInfo::_internal_set_relayed_game_server_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.relayed_game_server_steam_id_ = value;
}
inline void CMsgGameServerInfo::set_relayed_game_server_steam_id(uint64_t value) {
  _internal_set_relayed_game_server_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.relayed_game_server_steam_id)
}

// optional uint32 parent_relay_count = 17;
inline bool CMsgGameServerInfo::_internal_has_parent_relay_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_parent_relay_count() const {
  return _internal_has_parent_relay_count();
}
inline void CMsgGameServerInfo::clear_parent_relay_count() {
  _impl_.parent_relay_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t CMsgGameServerInfo::_internal_parent_relay_count() const {
  return _impl_.parent_relay_count_;
}
inline uint32_t CMsgGameServerInfo::parent_relay_count() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.parent_relay_count)
  return _internal_parent_relay_count();
}
inline void CMsgGameServerInfo::_internal_set_parent_relay_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.parent_relay_count_ = value;
}
inline void CMsgGameServerInfo::set_parent_relay_count(uint32_t value) {
  _internal_set_parent_relay_count(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.parent_relay_count)
}

// optional fixed64 tv_secret_code = 18;
inline bool CMsgGameServerInfo::_internal_has_tv_secret_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CMsgGameServerInfo::has_tv_secret_code() const {
  return _internal_has_tv_secret_code();
}
inline void CMsgGameServerInfo::clear_tv_secret_code() {
  _impl_.tv_secret_code_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint64_t CMsgGameServerInfo::_internal_tv_secret_code() const {
  return _impl_.tv_secret_code_;
}
inline uint64_t CMsgGameServerInfo::tv_secret_code() const {
  // @@protoc_insertion_point(field_get:CMsgGameServerInfo.tv_secret_code)
  return _internal_tv_secret_code();
}
inline void CMsgGameServerInfo::_internal_set_tv_secret_code(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.tv_secret_code_ = value;
}
inline void CMsgGameServerInfo::set_tv_secret_code(uint64_t value) {
  _internal_set_tv_secret_code(value);
  // @@protoc_insertion_point(field_set:CMsgGameServerInfo.tv_secret_code)
}

// -------------------------------------------------------------------

// CSOEconEquipSlot

// optional uint32 account_id = 1 [(.key_field) = true];
inline bool CSOEconEquipSlot::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconEquipSlot::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconEquipSlot::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSOEconEquipSlot::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconEquipSlot::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconEquipSlot.account_id)
  return _internal_account_id();
}
inline void CSOEconEquipSlot::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.account_id_ = value;
}
inline void CSOEconEquipSlot::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconEquipSlot.account_id)
}

// optional uint32 class_id = 2 [(.key_field) = true];
inline bool CSOEconEquipSlot::_internal_has_class_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconEquipSlot::has_class_id() const {
  return _internal_has_class_id();
}
inline void CSOEconEquipSlot::clear_class_id() {
  _impl_.class_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconEquipSlot::_internal_class_id() const {
  return _impl_.class_id_;
}
inline uint32_t CSOEconEquipSlot::class_id() const {
  // @@protoc_insertion_point(field_get:CSOEconEquipSlot.class_id)
  return _internal_class_id();
}
inline void CSOEconEquipSlot::_internal_set_class_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.class_id_ = value;
}
inline void CSOEconEquipSlot::set_class_id(uint32_t value) {
  _internal_set_class_id(value);
  // @@protoc_insertion_point(field_set:CSOEconEquipSlot.class_id)
}

// optional uint32 slot_id = 3 [(.key_field) = true];
inline bool CSOEconEquipSlot::_internal_has_slot_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconEquipSlot::has_slot_id() const {
  return _internal_has_slot_id();
}
inline void CSOEconEquipSlot::clear_slot_id() {
  _impl_.slot_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconEquipSlot::_internal_slot_id() const {
  return _impl_.slot_id_;
}
inline uint32_t CSOEconEquipSlot::slot_id() const {
  // @@protoc_insertion_point(field_get:CSOEconEquipSlot.slot_id)
  return _internal_slot_id();
}
inline void CSOEconEquipSlot::_internal_set_slot_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.slot_id_ = value;
}
inline void CSOEconEquipSlot::set_slot_id(uint32_t value) {
  _internal_set_slot_id(value);
  // @@protoc_insertion_point(field_set:CSOEconEquipSlot.slot_id)
}

// optional uint64 item_id = 4;
inline bool CSOEconEquipSlot::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconEquipSlot::has_item_id() const {
  return _internal_has_item_id();
}
inline void CSOEconEquipSlot::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CSOEconEquipSlot::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CSOEconEquipSlot::item_id() const {
  // @@protoc_insertion_point(field_get:CSOEconEquipSlot.item_id)
  return _internal_item_id();
}
inline void CSOEconEquipSlot::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_id_ = value;
}
inline void CSOEconEquipSlot::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CSOEconEquipSlot.item_id)
}

// optional uint32 item_definition = 5;
inline bool CSOEconEquipSlot::_internal_has_item_definition() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOEconEquipSlot::has_item_definition() const {
  return _internal_has_item_definition();
}
inline void CSOEconEquipSlot::clear_item_definition() {
  _impl_.item_definition_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CSOEconEquipSlot::_internal_item_definition() const {
  return _impl_.item_definition_;
}
inline uint32_t CSOEconEquipSlot::item_definition() const {
  // @@protoc_insertion_point(field_get:CSOEconEquipSlot.item_definition)
  return _internal_item_definition();
}
inline void CSOEconEquipSlot::_internal_set_item_definition(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.item_definition_ = value;
}
inline void CSOEconEquipSlot::set_item_definition(uint32_t value) {
  _internal_set_item_definition(value);
  // @@protoc_insertion_point(field_set:CSOEconEquipSlot.item_definition)
}

// -------------------------------------------------------------------

// CMsgAdjustEquipSlot

// optional uint32 class_id = 1;
inline bool CMsgAdjustEquipSlot::_internal_has_class_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgAdjustEquipSlot::has_class_id() const {
  return _internal_has_class_id();
}
inline void CMsgAdjustEquipSlot::clear_class_id() {
  _impl_.class_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgAdjustEquipSlot::_internal_class_id() const {
  return _impl_.class_id_;
}
inline uint32_t CMsgAdjustEquipSlot::class_id() const {
  // @@protoc_insertion_point(field_get:CMsgAdjustEquipSlot.class_id)
  return _internal_class_id();
}
inline void CMsgAdjustEquipSlot::_internal_set_class_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.class_id_ = value;
}
inline void CMsgAdjustEquipSlot::set_class_id(uint32_t value) {
  _internal_set_class_id(value);
  // @@protoc_insertion_point(field_set:CMsgAdjustEquipSlot.class_id)
}

// optional uint32 slot_id = 2;
inline bool CMsgAdjustEquipSlot::_internal_has_slot_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgAdjustEquipSlot::has_slot_id() const {
  return _internal_has_slot_id();
}
inline void CMsgAdjustEquipSlot::clear_slot_id() {
  _impl_.slot_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgAdjustEquipSlot::_internal_slot_id() const {
  return _impl_.slot_id_;
}
inline uint32_t CMsgAdjustEquipSlot::slot_id() const {
  // @@protoc_insertion_point(field_get:CMsgAdjustEquipSlot.slot_id)
  return _internal_slot_id();
}
inline void CMsgAdjustEquipSlot::_internal_set_slot_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.slot_id_ = value;
}
inline void CMsgAdjustEquipSlot::set_slot_id(uint32_t value) {
  _internal_set_slot_id(value);
  // @@protoc_insertion_point(field_set:CMsgAdjustEquipSlot.slot_id)
}

// optional uint64 item_id = 3;
inline bool CMsgAdjustEquipSlot::_internal_has_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgAdjustEquipSlot::has_item_id() const {
  return _internal_has_item_id();
}
inline void CMsgAdjustEquipSlot::clear_item_id() {
  _impl_.item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgAdjustEquipSlot::_internal_item_id() const {
  return _impl_.item_id_;
}
inline uint64_t CMsgAdjustEquipSlot::item_id() const {
  // @@protoc_insertion_point(field_get:CMsgAdjustEquipSlot.item_id)
  return _internal_item_id();
}
inline void CMsgAdjustEquipSlot::_internal_set_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_id_ = value;
}
inline void CMsgAdjustEquipSlot::set_item_id(uint64_t value) {
  _internal_set_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgAdjustEquipSlot.item_id)
}

// -------------------------------------------------------------------

// CMsgAdjustEquipSlots

// repeated .CMsgAdjustEquipSlot slots = 1;
inline int CMsgAdjustEquipSlots::_internal_slots_size() const {
  return _impl_.slots_.size();
}
inline int CMsgAdjustEquipSlots::slots_size() const {
  return _internal_slots_size();
}
inline void CMsgAdjustEquipSlots::clear_slots() {
  _impl_.slots_.Clear();
}
inline ::CMsgAdjustEquipSlot* CMsgAdjustEquipSlots::mutable_slots(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgAdjustEquipSlots.slots)
  return _impl_.slots_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgAdjustEquipSlot >*
CMsgAdjustEquipSlots::mutable_slots() {
  // @@protoc_insertion_point(field_mutable_list:CMsgAdjustEquipSlots.slots)
  return &_impl_.slots_;
}
inline const ::CMsgAdjustEquipSlot& CMsgAdjustEquipSlots::_internal_slots(int index) const {
  return _impl_.slots_.Get(index);
}
inline const ::CMsgAdjustEquipSlot& CMsgAdjustEquipSlots::slots(int index) const {
  // @@protoc_insertion_point(field_get:CMsgAdjustEquipSlots.slots)
  return _internal_slots(index);
}
inline ::CMsgAdjustEquipSlot* CMsgAdjustEquipSlots::_internal_add_slots() {
  return _impl_.slots_.Add();
}
inline ::CMsgAdjustEquipSlot* CMsgAdjustEquipSlots::add_slots() {
  ::CMsgAdjustEquipSlot* _add = _internal_add_slots();
  // @@protoc_insertion_point(field_add:CMsgAdjustEquipSlots.slots)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgAdjustEquipSlot >&
CMsgAdjustEquipSlots::slots() const {
  // @@protoc_insertion_point(field_list:CMsgAdjustEquipSlots.slots)
  return _impl_.slots_;
}

// optional uint32 change_num = 2;
inline bool CMsgAdjustEquipSlots::_internal_has_change_num() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgAdjustEquipSlots::has_change_num() const {
  return _internal_has_change_num();
}
inline void CMsgAdjustEquipSlots::clear_change_num() {
  _impl_.change_num_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgAdjustEquipSlots::_internal_change_num() const {
  return _impl_.change_num_;
}
inline uint32_t CMsgAdjustEquipSlots::change_num() const {
  // @@protoc_insertion_point(field_get:CMsgAdjustEquipSlots.change_num)
  return _internal_change_num();
}
inline void CMsgAdjustEquipSlots::_internal_set_change_num(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.change_num_ = value;
}
inline void CMsgAdjustEquipSlots::set_change_num(uint32_t value) {
  _internal_set_change_num(value);
  // @@protoc_insertion_point(field_set:CMsgAdjustEquipSlots.change_num)
}

// -------------------------------------------------------------------

// CMsgOpenCrate

// optional uint64 tool_item_id = 1;
inline bool CMsgOpenCrate::_internal_has_tool_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgOpenCrate::has_tool_item_id() const {
  return _internal_has_tool_item_id();
}
inline void CMsgOpenCrate::clear_tool_item_id() {
  _impl_.tool_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgOpenCrate::_internal_tool_item_id() const {
  return _impl_.tool_item_id_;
}
inline uint64_t CMsgOpenCrate::tool_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgOpenCrate.tool_item_id)
  return _internal_tool_item_id();
}
inline void CMsgOpenCrate::_internal_set_tool_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.tool_item_id_ = value;
}
inline void CMsgOpenCrate::set_tool_item_id(uint64_t value) {
  _internal_set_tool_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgOpenCrate.tool_item_id)
}

// optional uint64 subject_item_id = 2;
inline bool CMsgOpenCrate::_internal_has_subject_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgOpenCrate::has_subject_item_id() const {
  return _internal_has_subject_item_id();
}
inline void CMsgOpenCrate::clear_subject_item_id() {
  _impl_.subject_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgOpenCrate::_internal_subject_item_id() const {
  return _impl_.subject_item_id_;
}
inline uint64_t CMsgOpenCrate::subject_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgOpenCrate.subject_item_id)
  return _internal_subject_item_id();
}
inline void CMsgOpenCrate::_internal_set_subject_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.subject_item_id_ = value;
}
inline void CMsgOpenCrate::set_subject_item_id(uint64_t value) {
  _internal_set_subject_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgOpenCrate.subject_item_id)
}

// optional bool for_rental = 3;
inline bool CMsgOpenCrate::_internal_has_for_rental() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgOpenCrate::has_for_rental() const {
  return _internal_has_for_rental();
}
inline void CMsgOpenCrate::clear_for_rental() {
  _impl_.for_rental_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CMsgOpenCrate::_internal_for_rental() const {
  return _impl_.for_rental_;
}
inline bool CMsgOpenCrate::for_rental() const {
  // @@protoc_insertion_point(field_get:CMsgOpenCrate.for_rental)
  return _internal_for_rental();
}
inline void CMsgOpenCrate::_internal_set_for_rental(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.for_rental_ = value;
}
inline void CMsgOpenCrate::set_for_rental(bool value) {
  _internal_set_for_rental(value);
  // @@protoc_insertion_point(field_set:CMsgOpenCrate.for_rental)
}

// optional uint32 points_remaining = 4;
inline bool CMsgOpenCrate::_internal_has_points_remaining() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgOpenCrate::has_points_remaining() const {
  return _internal_has_points_remaining();
}
inline void CMsgOpenCrate::clear_points_remaining() {
  _impl_.points_remaining_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgOpenCrate::_internal_points_remaining() const {
  return _impl_.points_remaining_;
}
inline uint32_t CMsgOpenCrate::points_remaining() const {
  // @@protoc_insertion_point(field_get:CMsgOpenCrate.points_remaining)
  return _internal_points_remaining();
}
inline void CMsgOpenCrate::_internal_set_points_remaining(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.points_remaining_ = value;
}
inline void CMsgOpenCrate::set_points_remaining(uint32_t value) {
  _internal_set_points_remaining(value);
  // @@protoc_insertion_point(field_set:CMsgOpenCrate.points_remaining)
}

// -------------------------------------------------------------------

// CSOEconRentalHistory

// optional uint32 account_id = 1 [(.key_field) = true];
inline bool CSOEconRentalHistory::_internal_has_account_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSOEconRentalHistory::has_account_id() const {
  return _internal_has_account_id();
}
inline void CSOEconRentalHistory::clear_account_id() {
  _impl_.account_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSOEconRentalHistory::_internal_account_id() const {
  return _impl_.account_id_;
}
inline uint32_t CSOEconRentalHistory::account_id() const {
  // @@protoc_insertion_point(field_get:CSOEconRentalHistory.account_id)
  return _internal_account_id();
}
inline void CSOEconRentalHistory::_internal_set_account_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.account_id_ = value;
}
inline void CSOEconRentalHistory::set_account_id(uint32_t value) {
  _internal_set_account_id(value);
  // @@protoc_insertion_point(field_set:CSOEconRentalHistory.account_id)
}

// optional uint64 crate_item_id = 2 [(.key_field) = true];
inline bool CSOEconRentalHistory::_internal_has_crate_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSOEconRentalHistory::has_crate_item_id() const {
  return _internal_has_crate_item_id();
}
inline void CSOEconRentalHistory::clear_crate_item_id() {
  _impl_.crate_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CSOEconRentalHistory::_internal_crate_item_id() const {
  return _impl_.crate_item_id_;
}
inline uint64_t CSOEconRentalHistory::crate_item_id() const {
  // @@protoc_insertion_point(field_get:CSOEconRentalHistory.crate_item_id)
  return _internal_crate_item_id();
}
inline void CSOEconRentalHistory::_internal_set_crate_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.crate_item_id_ = value;
}
inline void CSOEconRentalHistory::set_crate_item_id(uint64_t value) {
  _internal_set_crate_item_id(value);
  // @@protoc_insertion_point(field_set:CSOEconRentalHistory.crate_item_id)
}

// optional uint32 crate_def_index = 3;
inline bool CSOEconRentalHistory::_internal_has_crate_def_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSOEconRentalHistory::has_crate_def_index() const {
  return _internal_has_crate_def_index();
}
inline void CSOEconRentalHistory::clear_crate_def_index() {
  _impl_.crate_def_index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CSOEconRentalHistory::_internal_crate_def_index() const {
  return _impl_.crate_def_index_;
}
inline uint32_t CSOEconRentalHistory::crate_def_index() const {
  // @@protoc_insertion_point(field_get:CSOEconRentalHistory.crate_def_index)
  return _internal_crate_def_index();
}
inline void CSOEconRentalHistory::_internal_set_crate_def_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.crate_def_index_ = value;
}
inline void CSOEconRentalHistory::set_crate_def_index(uint32_t value) {
  _internal_set_crate_def_index(value);
  // @@protoc_insertion_point(field_set:CSOEconRentalHistory.crate_def_index)
}

// optional uint32 issue_date = 4;
inline bool CSOEconRentalHistory::_internal_has_issue_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSOEconRentalHistory::has_issue_date() const {
  return _internal_has_issue_date();
}
inline void CSOEconRentalHistory::clear_issue_date() {
  _impl_.issue_date_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSOEconRentalHistory::_internal_issue_date() const {
  return _impl_.issue_date_;
}
inline uint32_t CSOEconRentalHistory::issue_date() const {
  // @@protoc_insertion_point(field_get:CSOEconRentalHistory.issue_date)
  return _internal_issue_date();
}
inline void CSOEconRentalHistory::_internal_set_issue_date(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.issue_date_ = value;
}
inline void CSOEconRentalHistory::set_issue_date(uint32_t value) {
  _internal_set_issue_date(value);
  // @@protoc_insertion_point(field_set:CSOEconRentalHistory.issue_date)
}

// optional uint32 expiration_date = 5;
inline bool CSOEconRentalHistory::_internal_has_expiration_date() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSOEconRentalHistory::has_expiration_date() const {
  return _internal_has_expiration_date();
}
inline void CSOEconRentalHistory::clear_expiration_date() {
  _impl_.expiration_date_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CSOEconRentalHistory::_internal_expiration_date() const {
  return _impl_.expiration_date_;
}
inline uint32_t CSOEconRentalHistory::expiration_date() const {
  // @@protoc_insertion_point(field_get:CSOEconRentalHistory.expiration_date)
  return _internal_expiration_date();
}
inline void CSOEconRentalHistory::_internal_set_expiration_date(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.expiration_date_ = value;
}
inline void CSOEconRentalHistory::set_expiration_date(uint32_t value) {
  _internal_set_expiration_date(value);
  // @@protoc_insertion_point(field_set:CSOEconRentalHistory.expiration_date)
}

// -------------------------------------------------------------------

// CMsgAcknowledgeRentalExpiration

// optional uint64 crate_item_id = 1;
inline bool CMsgAcknowledgeRentalExpiration::_internal_has_crate_item_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgAcknowledgeRentalExpiration::has_crate_item_id() const {
  return _internal_has_crate_item_id();
}
inline void CMsgAcknowledgeRentalExpiration::clear_crate_item_id() {
  _impl_.crate_item_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgAcknowledgeRentalExpiration::_internal_crate_item_id() const {
  return _impl_.crate_item_id_;
}
inline uint64_t CMsgAcknowledgeRentalExpiration::crate_item_id() const {
  // @@protoc_insertion_point(field_get:CMsgAcknowledgeRentalExpiration.crate_item_id)
  return _internal_crate_item_id();
}
inline void CMsgAcknowledgeRentalExpiration::_internal_set_crate_item_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.crate_item_id_ = value;
}
inline void CMsgAcknowledgeRentalExpiration::set_crate_item_id(uint64_t value) {
  _internal_set_crate_item_id(value);
  // @@protoc_insertion_point(field_set:CMsgAcknowledgeRentalExpiration.crate_item_id)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::CMsgGameServerInfo_ServerType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgGameServerInfo_ServerType>() {
  return ::CMsgGameServerInfo_ServerType_descriptor();
}
template <> struct is_proto_enum< ::EGCBaseMsg> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EGCBaseMsg>() {
  return ::EGCBaseMsg_descriptor();
}
template <> struct is_proto_enum< ::EGCBaseProtoObjectTypes> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EGCBaseProtoObjectTypes>() {
  return ::EGCBaseProtoObjectTypes_descriptor();
}
template <> struct is_proto_enum< ::GC_BannedWordType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::GC_BannedWordType>() {
  return ::GC_BannedWordType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_base_5fgcmessages_2eproto
