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

#ifndef GOOGLE_PROTOBUF_INCLUDED_usermessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_usermessages_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 "networkbasetypes.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_usermessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_usermessages_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_usermessages_2eproto;
class CEntityMessageDoSpark;
struct CEntityMessageDoSparkDefaultTypeInternal;
extern CEntityMessageDoSparkDefaultTypeInternal _CEntityMessageDoSpark_default_instance_;
class CEntityMessageFixAngle;
struct CEntityMessageFixAngleDefaultTypeInternal;
extern CEntityMessageFixAngleDefaultTypeInternal _CEntityMessageFixAngle_default_instance_;
class CEntityMessagePlayJingle;
struct CEntityMessagePlayJingleDefaultTypeInternal;
extern CEntityMessagePlayJingleDefaultTypeInternal _CEntityMessagePlayJingle_default_instance_;
class CEntityMessagePropagateForce;
struct CEntityMessagePropagateForceDefaultTypeInternal;
extern CEntityMessagePropagateForceDefaultTypeInternal _CEntityMessagePropagateForce_default_instance_;
class CEntityMessageRemoveAllDecals;
struct CEntityMessageRemoveAllDecalsDefaultTypeInternal;
extern CEntityMessageRemoveAllDecalsDefaultTypeInternal _CEntityMessageRemoveAllDecals_default_instance_;
class CEntityMessageScreenOverlay;
struct CEntityMessageScreenOverlayDefaultTypeInternal;
extern CEntityMessageScreenOverlayDefaultTypeInternal _CEntityMessageScreenOverlay_default_instance_;
class CUserMessageAchievementEvent;
struct CUserMessageAchievementEventDefaultTypeInternal;
extern CUserMessageAchievementEventDefaultTypeInternal _CUserMessageAchievementEvent_default_instance_;
class CUserMessageAmmoDenied;
struct CUserMessageAmmoDeniedDefaultTypeInternal;
extern CUserMessageAmmoDeniedDefaultTypeInternal _CUserMessageAmmoDenied_default_instance_;
class CUserMessageAnimStateGraphState;
struct CUserMessageAnimStateGraphStateDefaultTypeInternal;
extern CUserMessageAnimStateGraphStateDefaultTypeInternal _CUserMessageAnimStateGraphState_default_instance_;
class CUserMessageAudioParameter;
struct CUserMessageAudioParameterDefaultTypeInternal;
extern CUserMessageAudioParameterDefaultTypeInternal _CUserMessageAudioParameter_default_instance_;
class CUserMessageCameraTransition;
struct CUserMessageCameraTransitionDefaultTypeInternal;
extern CUserMessageCameraTransitionDefaultTypeInternal _CUserMessageCameraTransition_default_instance_;
class CUserMessageCameraTransition_Transition_DataDriven;
struct CUserMessageCameraTransition_Transition_DataDrivenDefaultTypeInternal;
extern CUserMessageCameraTransition_Transition_DataDrivenDefaultTypeInternal _CUserMessageCameraTransition_Transition_DataDriven_default_instance_;
class CUserMessageCloseCaption;
struct CUserMessageCloseCaptionDefaultTypeInternal;
extern CUserMessageCloseCaptionDefaultTypeInternal _CUserMessageCloseCaption_default_instance_;
class CUserMessageCloseCaptionDirect;
struct CUserMessageCloseCaptionDirectDefaultTypeInternal;
extern CUserMessageCloseCaptionDirectDefaultTypeInternal _CUserMessageCloseCaptionDirect_default_instance_;
class CUserMessageCloseCaptionPlaceholder;
struct CUserMessageCloseCaptionPlaceholderDefaultTypeInternal;
extern CUserMessageCloseCaptionPlaceholderDefaultTypeInternal _CUserMessageCloseCaptionPlaceholder_default_instance_;
class CUserMessageColoredText;
struct CUserMessageColoredTextDefaultTypeInternal;
extern CUserMessageColoredTextDefaultTypeInternal _CUserMessageColoredText_default_instance_;
class CUserMessageCreditsMsg;
struct CUserMessageCreditsMsgDefaultTypeInternal;
extern CUserMessageCreditsMsgDefaultTypeInternal _CUserMessageCreditsMsg_default_instance_;
class CUserMessageCurrentTimescale;
struct CUserMessageCurrentTimescaleDefaultTypeInternal;
extern CUserMessageCurrentTimescaleDefaultTypeInternal _CUserMessageCurrentTimescale_default_instance_;
class CUserMessageDesiredTimescale;
struct CUserMessageDesiredTimescaleDefaultTypeInternal;
extern CUserMessageDesiredTimescaleDefaultTypeInternal _CUserMessageDesiredTimescale_default_instance_;
class CUserMessageFade;
struct CUserMessageFadeDefaultTypeInternal;
extern CUserMessageFadeDefaultTypeInternal _CUserMessageFade_default_instance_;
class CUserMessageGameTitle;
struct CUserMessageGameTitleDefaultTypeInternal;
extern CUserMessageGameTitleDefaultTypeInternal _CUserMessageGameTitle_default_instance_;
class CUserMessageHapticsManagerEffect;
struct CUserMessageHapticsManagerEffectDefaultTypeInternal;
extern CUserMessageHapticsManagerEffectDefaultTypeInternal _CUserMessageHapticsManagerEffect_default_instance_;
class CUserMessageHapticsManagerPulse;
struct CUserMessageHapticsManagerPulseDefaultTypeInternal;
extern CUserMessageHapticsManagerPulseDefaultTypeInternal _CUserMessageHapticsManagerPulse_default_instance_;
class CUserMessageHudMsg;
struct CUserMessageHudMsgDefaultTypeInternal;
extern CUserMessageHudMsgDefaultTypeInternal _CUserMessageHudMsg_default_instance_;
class CUserMessageHudText;
struct CUserMessageHudTextDefaultTypeInternal;
extern CUserMessageHudTextDefaultTypeInternal _CUserMessageHudText_default_instance_;
class CUserMessageItemPickup;
struct CUserMessageItemPickupDefaultTypeInternal;
extern CUserMessageItemPickupDefaultTypeInternal _CUserMessageItemPickup_default_instance_;
class CUserMessageLagCompensationError;
struct CUserMessageLagCompensationErrorDefaultTypeInternal;
extern CUserMessageLagCompensationErrorDefaultTypeInternal _CUserMessageLagCompensationError_default_instance_;
class CUserMessageRequestDiagnostic;
struct CUserMessageRequestDiagnosticDefaultTypeInternal;
extern CUserMessageRequestDiagnosticDefaultTypeInternal _CUserMessageRequestDiagnostic_default_instance_;
class CUserMessageRequestDiagnostic_Diagnostic;
struct CUserMessageRequestDiagnostic_DiagnosticDefaultTypeInternal;
extern CUserMessageRequestDiagnostic_DiagnosticDefaultTypeInternal _CUserMessageRequestDiagnostic_Diagnostic_default_instance_;
class CUserMessageRequestDllStatus;
struct CUserMessageRequestDllStatusDefaultTypeInternal;
extern CUserMessageRequestDllStatusDefaultTypeInternal _CUserMessageRequestDllStatus_default_instance_;
class CUserMessageRequestInventory;
struct CUserMessageRequestInventoryDefaultTypeInternal;
extern CUserMessageRequestInventoryDefaultTypeInternal _CUserMessageRequestInventory_default_instance_;
class CUserMessageRequestState;
struct CUserMessageRequestStateDefaultTypeInternal;
extern CUserMessageRequestStateDefaultTypeInternal _CUserMessageRequestState_default_instance_;
class CUserMessageRequestUtilAction;
struct CUserMessageRequestUtilActionDefaultTypeInternal;
extern CUserMessageRequestUtilActionDefaultTypeInternal _CUserMessageRequestUtilAction_default_instance_;
class CUserMessageResetHUD;
struct CUserMessageResetHUDDefaultTypeInternal;
extern CUserMessageResetHUDDefaultTypeInternal _CUserMessageResetHUD_default_instance_;
class CUserMessageRumble;
struct CUserMessageRumbleDefaultTypeInternal;
extern CUserMessageRumbleDefaultTypeInternal _CUserMessageRumble_default_instance_;
class CUserMessageSayText;
struct CUserMessageSayTextDefaultTypeInternal;
extern CUserMessageSayTextDefaultTypeInternal _CUserMessageSayText_default_instance_;
class CUserMessageSayText2;
struct CUserMessageSayText2DefaultTypeInternal;
extern CUserMessageSayText2DefaultTypeInternal _CUserMessageSayText2_default_instance_;
class CUserMessageSayTextChannel;
struct CUserMessageSayTextChannelDefaultTypeInternal;
extern CUserMessageSayTextChannelDefaultTypeInternal _CUserMessageSayTextChannel_default_instance_;
class CUserMessageScreenTilt;
struct CUserMessageScreenTiltDefaultTypeInternal;
extern CUserMessageScreenTiltDefaultTypeInternal _CUserMessageScreenTilt_default_instance_;
class CUserMessageSendAudio;
struct CUserMessageSendAudioDefaultTypeInternal;
extern CUserMessageSendAudioDefaultTypeInternal _CUserMessageSendAudio_default_instance_;
class CUserMessageServerFrameTime;
struct CUserMessageServerFrameTimeDefaultTypeInternal;
extern CUserMessageServerFrameTimeDefaultTypeInternal _CUserMessageServerFrameTime_default_instance_;
class CUserMessageShake;
struct CUserMessageShakeDefaultTypeInternal;
extern CUserMessageShakeDefaultTypeInternal _CUserMessageShake_default_instance_;
class CUserMessageShakeDir;
struct CUserMessageShakeDirDefaultTypeInternal;
extern CUserMessageShakeDirDefaultTypeInternal _CUserMessageShakeDir_default_instance_;
class CUserMessageShowMenu;
struct CUserMessageShowMenuDefaultTypeInternal;
extern CUserMessageShowMenuDefaultTypeInternal _CUserMessageShowMenu_default_instance_;
class CUserMessageTextMsg;
struct CUserMessageTextMsgDefaultTypeInternal;
extern CUserMessageTextMsgDefaultTypeInternal _CUserMessageTextMsg_default_instance_;
class CUserMessageUpdateCssClasses;
struct CUserMessageUpdateCssClassesDefaultTypeInternal;
extern CUserMessageUpdateCssClassesDefaultTypeInternal _CUserMessageUpdateCssClasses_default_instance_;
class CUserMessageVoiceMask;
struct CUserMessageVoiceMaskDefaultTypeInternal;
extern CUserMessageVoiceMaskDefaultTypeInternal _CUserMessageVoiceMask_default_instance_;
class CUserMessageWaterShake;
struct CUserMessageWaterShakeDefaultTypeInternal;
extern CUserMessageWaterShakeDefaultTypeInternal _CUserMessageWaterShake_default_instance_;
class CUserMessage_Diagnostic_Response;
struct CUserMessage_Diagnostic_ResponseDefaultTypeInternal;
extern CUserMessage_Diagnostic_ResponseDefaultTypeInternal _CUserMessage_Diagnostic_Response_default_instance_;
class CUserMessage_Diagnostic_Response_Diagnostic;
struct CUserMessage_Diagnostic_Response_DiagnosticDefaultTypeInternal;
extern CUserMessage_Diagnostic_Response_DiagnosticDefaultTypeInternal _CUserMessage_Diagnostic_Response_Diagnostic_default_instance_;
class CUserMessage_DllStatus;
struct CUserMessage_DllStatusDefaultTypeInternal;
extern CUserMessage_DllStatusDefaultTypeInternal _CUserMessage_DllStatus_default_instance_;
class CUserMessage_DllStatus_CModule;
struct CUserMessage_DllStatus_CModuleDefaultTypeInternal;
extern CUserMessage_DllStatus_CModuleDefaultTypeInternal _CUserMessage_DllStatus_CModule_default_instance_;
class CUserMessage_DllStatus_CVDiagnostic;
struct CUserMessage_DllStatus_CVDiagnosticDefaultTypeInternal;
extern CUserMessage_DllStatus_CVDiagnosticDefaultTypeInternal _CUserMessage_DllStatus_CVDiagnostic_default_instance_;
class CUserMessage_ExtraUserData;
struct CUserMessage_ExtraUserDataDefaultTypeInternal;
extern CUserMessage_ExtraUserDataDefaultTypeInternal _CUserMessage_ExtraUserData_default_instance_;
class CUserMessage_Inventory_Response;
struct CUserMessage_Inventory_ResponseDefaultTypeInternal;
extern CUserMessage_Inventory_ResponseDefaultTypeInternal _CUserMessage_Inventory_Response_default_instance_;
class CUserMessage_Inventory_Response_InventoryDetail;
struct CUserMessage_Inventory_Response_InventoryDetailDefaultTypeInternal;
extern CUserMessage_Inventory_Response_InventoryDetailDefaultTypeInternal _CUserMessage_Inventory_Response_InventoryDetail_default_instance_;
class CUserMessage_NotifyResponseFound;
struct CUserMessage_NotifyResponseFoundDefaultTypeInternal;
extern CUserMessage_NotifyResponseFoundDefaultTypeInternal _CUserMessage_NotifyResponseFound_default_instance_;
class CUserMessage_NotifyResponseFound_Criteria;
struct CUserMessage_NotifyResponseFound_CriteriaDefaultTypeInternal;
extern CUserMessage_NotifyResponseFound_CriteriaDefaultTypeInternal _CUserMessage_NotifyResponseFound_Criteria_default_instance_;
class CUserMessage_PlayResponseConditional;
struct CUserMessage_PlayResponseConditionalDefaultTypeInternal;
extern CUserMessage_PlayResponseConditionalDefaultTypeInternal _CUserMessage_PlayResponseConditional_default_instance_;
class CUserMessage_UtilMsg_Response;
struct CUserMessage_UtilMsg_ResponseDefaultTypeInternal;
extern CUserMessage_UtilMsg_ResponseDefaultTypeInternal _CUserMessage_UtilMsg_Response_default_instance_;
class CUserMessage_UtilMsg_Response_ItemDetail;
struct CUserMessage_UtilMsg_Response_ItemDetailDefaultTypeInternal;
extern CUserMessage_UtilMsg_Response_ItemDetailDefaultTypeInternal _CUserMessage_UtilMsg_Response_ItemDetail_default_instance_;
class CUserMsg_CustomGameEvent;
struct CUserMsg_CustomGameEventDefaultTypeInternal;
extern CUserMsg_CustomGameEventDefaultTypeInternal _CUserMsg_CustomGameEvent_default_instance_;
class CUserMsg_HudError;
struct CUserMsg_HudErrorDefaultTypeInternal;
extern CUserMsg_HudErrorDefaultTypeInternal _CUserMsg_HudError_default_instance_;
class CUserMsg_ParticleManager;
struct CUserMsg_ParticleManagerDefaultTypeInternal;
extern CUserMsg_ParticleManagerDefaultTypeInternal _CUserMsg_ParticleManager_default_instance_;
class CUserMsg_ParticleManager_AddFan;
struct CUserMsg_ParticleManager_AddFanDefaultTypeInternal;
extern CUserMsg_ParticleManager_AddFanDefaultTypeInternal _CUserMsg_ParticleManager_AddFan_default_instance_;
class CUserMsg_ParticleManager_AddModellistOverrideElement;
struct CUserMsg_ParticleManager_AddModellistOverrideElementDefaultTypeInternal;
extern CUserMsg_ParticleManager_AddModellistOverrideElementDefaultTypeInternal _CUserMsg_ParticleManager_AddModellistOverrideElement_default_instance_;
class CUserMsg_ParticleManager_ChangeControlPointAttachment;
struct CUserMsg_ParticleManager_ChangeControlPointAttachmentDefaultTypeInternal;
extern CUserMsg_ParticleManager_ChangeControlPointAttachmentDefaultTypeInternal _CUserMsg_ParticleManager_ChangeControlPointAttachment_default_instance_;
class CUserMsg_ParticleManager_ClearModellistOverride;
struct CUserMsg_ParticleManager_ClearModellistOverrideDefaultTypeInternal;
extern CUserMsg_ParticleManager_ClearModellistOverrideDefaultTypeInternal _CUserMsg_ParticleManager_ClearModellistOverride_default_instance_;
class CUserMsg_ParticleManager_CreateParticle;
struct CUserMsg_ParticleManager_CreateParticleDefaultTypeInternal;
extern CUserMsg_ParticleManager_CreateParticleDefaultTypeInternal _CUserMsg_ParticleManager_CreateParticle_default_instance_;
class CUserMsg_ParticleManager_CreatePhysicsSim;
struct CUserMsg_ParticleManager_CreatePhysicsSimDefaultTypeInternal;
extern CUserMsg_ParticleManager_CreatePhysicsSimDefaultTypeInternal _CUserMsg_ParticleManager_CreatePhysicsSim_default_instance_;
class CUserMsg_ParticleManager_DestroyParticle;
struct CUserMsg_ParticleManager_DestroyParticleDefaultTypeInternal;
extern CUserMsg_ParticleManager_DestroyParticleDefaultTypeInternal _CUserMsg_ParticleManager_DestroyParticle_default_instance_;
class CUserMsg_ParticleManager_DestroyParticleInvolving;
struct CUserMsg_ParticleManager_DestroyParticleInvolvingDefaultTypeInternal;
extern CUserMsg_ParticleManager_DestroyParticleInvolvingDefaultTypeInternal _CUserMsg_ParticleManager_DestroyParticleInvolving_default_instance_;
class CUserMsg_ParticleManager_DestroyParticleNamed;
struct CUserMsg_ParticleManager_DestroyParticleNamedDefaultTypeInternal;
extern CUserMsg_ParticleManager_DestroyParticleNamedDefaultTypeInternal _CUserMsg_ParticleManager_DestroyParticleNamed_default_instance_;
class CUserMsg_ParticleManager_DestroyPhysicsSim;
struct CUserMsg_ParticleManager_DestroyPhysicsSimDefaultTypeInternal;
extern CUserMsg_ParticleManager_DestroyPhysicsSimDefaultTypeInternal _CUserMsg_ParticleManager_DestroyPhysicsSim_default_instance_;
class CUserMsg_ParticleManager_FreezeParticleInvolving;
struct CUserMsg_ParticleManager_FreezeParticleInvolvingDefaultTypeInternal;
extern CUserMsg_ParticleManager_FreezeParticleInvolvingDefaultTypeInternal _CUserMsg_ParticleManager_FreezeParticleInvolving_default_instance_;
class CUserMsg_ParticleManager_ParticleCanFreeze;
struct CUserMsg_ParticleManager_ParticleCanFreezeDefaultTypeInternal;
extern CUserMsg_ParticleManager_ParticleCanFreezeDefaultTypeInternal _CUserMsg_ParticleManager_ParticleCanFreeze_default_instance_;
class CUserMsg_ParticleManager_ParticleFreezeTransitionOverride;
struct CUserMsg_ParticleManager_ParticleFreezeTransitionOverrideDefaultTypeInternal;
extern CUserMsg_ParticleManager_ParticleFreezeTransitionOverrideDefaultTypeInternal _CUserMsg_ParticleManager_ParticleFreezeTransitionOverride_default_instance_;
class CUserMsg_ParticleManager_ParticleSkipToTime;
struct CUserMsg_ParticleManager_ParticleSkipToTimeDefaultTypeInternal;
extern CUserMsg_ParticleManager_ParticleSkipToTimeDefaultTypeInternal _CUserMsg_ParticleManager_ParticleSkipToTime_default_instance_;
class CUserMsg_ParticleManager_ReleaseParticleIndex;
struct CUserMsg_ParticleManager_ReleaseParticleIndexDefaultTypeInternal;
extern CUserMsg_ParticleManager_ReleaseParticleIndexDefaultTypeInternal _CUserMsg_ParticleManager_ReleaseParticleIndex_default_instance_;
class CUserMsg_ParticleManager_RemoveFan;
struct CUserMsg_ParticleManager_RemoveFanDefaultTypeInternal;
extern CUserMsg_ParticleManager_RemoveFanDefaultTypeInternal _CUserMsg_ParticleManager_RemoveFan_default_instance_;
class CUserMsg_ParticleManager_SetControlPointModel;
struct CUserMsg_ParticleManager_SetControlPointModelDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetControlPointModelDefaultTypeInternal _CUserMsg_ParticleManager_SetControlPointModel_default_instance_;
class CUserMsg_ParticleManager_SetControlPointSnapshot;
struct CUserMsg_ParticleManager_SetControlPointSnapshotDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetControlPointSnapshotDefaultTypeInternal _CUserMsg_ParticleManager_SetControlPointSnapshot_default_instance_;
class CUserMsg_ParticleManager_SetMaterialOverride;
struct CUserMsg_ParticleManager_SetMaterialOverrideDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetMaterialOverrideDefaultTypeInternal _CUserMsg_ParticleManager_SetMaterialOverride_default_instance_;
class CUserMsg_ParticleManager_SetParticleClusterGrowth;
struct CUserMsg_ParticleManager_SetParticleClusterGrowthDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleClusterGrowthDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleClusterGrowth_default_instance_;
class CUserMsg_ParticleManager_SetParticleFoWProperties;
struct CUserMsg_ParticleManager_SetParticleFoWPropertiesDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleFoWPropertiesDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleFoWProperties_default_instance_;
class CUserMsg_ParticleManager_SetParticleNamedValueContext;
struct CUserMsg_ParticleManager_SetParticleNamedValueContextDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleNamedValueContextDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleNamedValueContext_default_instance_;
class CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext;
struct CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContextDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContextDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext_default_instance_;
class CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue;
struct CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValueDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValueDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue_default_instance_;
class CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue;
struct CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValueDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValueDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue_default_instance_;
class CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue;
struct CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValueDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValueDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue_default_instance_;
class CUserMsg_ParticleManager_SetParticleShouldCheckFoW;
struct CUserMsg_ParticleManager_SetParticleShouldCheckFoWDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleShouldCheckFoWDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleShouldCheckFoW_default_instance_;
class CUserMsg_ParticleManager_SetParticleText;
struct CUserMsg_ParticleManager_SetParticleTextDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetParticleTextDefaultTypeInternal _CUserMsg_ParticleManager_SetParticleText_default_instance_;
class CUserMsg_ParticleManager_SetSceneObjectGenericFlag;
struct CUserMsg_ParticleManager_SetSceneObjectGenericFlagDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetSceneObjectGenericFlagDefaultTypeInternal _CUserMsg_ParticleManager_SetSceneObjectGenericFlag_default_instance_;
class CUserMsg_ParticleManager_SetSceneObjectTintAndDesat;
struct CUserMsg_ParticleManager_SetSceneObjectTintAndDesatDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetSceneObjectTintAndDesatDefaultTypeInternal _CUserMsg_ParticleManager_SetSceneObjectTintAndDesat_default_instance_;
class CUserMsg_ParticleManager_SetTextureAttribute;
struct CUserMsg_ParticleManager_SetTextureAttributeDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetTextureAttributeDefaultTypeInternal _CUserMsg_ParticleManager_SetTextureAttribute_default_instance_;
class CUserMsg_ParticleManager_SetVData;
struct CUserMsg_ParticleManager_SetVDataDefaultTypeInternal;
extern CUserMsg_ParticleManager_SetVDataDefaultTypeInternal _CUserMsg_ParticleManager_SetVData_default_instance_;
class CUserMsg_ParticleManager_UpdateEntityPosition;
struct CUserMsg_ParticleManager_UpdateEntityPositionDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateEntityPositionDefaultTypeInternal _CUserMsg_ParticleManager_UpdateEntityPosition_default_instance_;
class CUserMsg_ParticleManager_UpdateFan;
struct CUserMsg_ParticleManager_UpdateFanDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateFanDefaultTypeInternal _CUserMsg_ParticleManager_UpdateFan_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleEnt;
struct CUserMsg_ParticleManager_UpdateParticleEntDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleEntDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleEnt_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleFallback;
struct CUserMsg_ParticleManager_UpdateParticleFallbackDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleFallbackDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleFallback_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE;
struct CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETEDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETEDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleOffset;
struct CUserMsg_ParticleManager_UpdateParticleOffsetDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleOffsetDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleOffset_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE;
struct CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETEDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETEDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleSetFrozen;
struct CUserMsg_ParticleManager_UpdateParticleSetFrozenDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleSetFrozenDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleSetFrozen_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleShouldDraw;
struct CUserMsg_ParticleManager_UpdateParticleShouldDrawDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleShouldDrawDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleShouldDraw_default_instance_;
class CUserMsg_ParticleManager_UpdateParticleTransform;
struct CUserMsg_ParticleManager_UpdateParticleTransformDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticleTransformDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticleTransform_default_instance_;
class CUserMsg_ParticleManager_UpdateParticle_OBSOLETE;
struct CUserMsg_ParticleManager_UpdateParticle_OBSOLETEDefaultTypeInternal;
extern CUserMsg_ParticleManager_UpdateParticle_OBSOLETEDefaultTypeInternal _CUserMsg_ParticleManager_UpdateParticle_OBSOLETE_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CEntityMessageDoSpark* Arena::CreateMaybeMessage<::CEntityMessageDoSpark>(Arena*);
template<> ::CEntityMessageFixAngle* Arena::CreateMaybeMessage<::CEntityMessageFixAngle>(Arena*);
template<> ::CEntityMessagePlayJingle* Arena::CreateMaybeMessage<::CEntityMessagePlayJingle>(Arena*);
template<> ::CEntityMessagePropagateForce* Arena::CreateMaybeMessage<::CEntityMessagePropagateForce>(Arena*);
template<> ::CEntityMessageRemoveAllDecals* Arena::CreateMaybeMessage<::CEntityMessageRemoveAllDecals>(Arena*);
template<> ::CEntityMessageScreenOverlay* Arena::CreateMaybeMessage<::CEntityMessageScreenOverlay>(Arena*);
template<> ::CUserMessageAchievementEvent* Arena::CreateMaybeMessage<::CUserMessageAchievementEvent>(Arena*);
template<> ::CUserMessageAmmoDenied* Arena::CreateMaybeMessage<::CUserMessageAmmoDenied>(Arena*);
template<> ::CUserMessageAnimStateGraphState* Arena::CreateMaybeMessage<::CUserMessageAnimStateGraphState>(Arena*);
template<> ::CUserMessageAudioParameter* Arena::CreateMaybeMessage<::CUserMessageAudioParameter>(Arena*);
template<> ::CUserMessageCameraTransition* Arena::CreateMaybeMessage<::CUserMessageCameraTransition>(Arena*);
template<> ::CUserMessageCameraTransition_Transition_DataDriven* Arena::CreateMaybeMessage<::CUserMessageCameraTransition_Transition_DataDriven>(Arena*);
template<> ::CUserMessageCloseCaption* Arena::CreateMaybeMessage<::CUserMessageCloseCaption>(Arena*);
template<> ::CUserMessageCloseCaptionDirect* Arena::CreateMaybeMessage<::CUserMessageCloseCaptionDirect>(Arena*);
template<> ::CUserMessageCloseCaptionPlaceholder* Arena::CreateMaybeMessage<::CUserMessageCloseCaptionPlaceholder>(Arena*);
template<> ::CUserMessageColoredText* Arena::CreateMaybeMessage<::CUserMessageColoredText>(Arena*);
template<> ::CUserMessageCreditsMsg* Arena::CreateMaybeMessage<::CUserMessageCreditsMsg>(Arena*);
template<> ::CUserMessageCurrentTimescale* Arena::CreateMaybeMessage<::CUserMessageCurrentTimescale>(Arena*);
template<> ::CUserMessageDesiredTimescale* Arena::CreateMaybeMessage<::CUserMessageDesiredTimescale>(Arena*);
template<> ::CUserMessageFade* Arena::CreateMaybeMessage<::CUserMessageFade>(Arena*);
template<> ::CUserMessageGameTitle* Arena::CreateMaybeMessage<::CUserMessageGameTitle>(Arena*);
template<> ::CUserMessageHapticsManagerEffect* Arena::CreateMaybeMessage<::CUserMessageHapticsManagerEffect>(Arena*);
template<> ::CUserMessageHapticsManagerPulse* Arena::CreateMaybeMessage<::CUserMessageHapticsManagerPulse>(Arena*);
template<> ::CUserMessageHudMsg* Arena::CreateMaybeMessage<::CUserMessageHudMsg>(Arena*);
template<> ::CUserMessageHudText* Arena::CreateMaybeMessage<::CUserMessageHudText>(Arena*);
template<> ::CUserMessageItemPickup* Arena::CreateMaybeMessage<::CUserMessageItemPickup>(Arena*);
template<> ::CUserMessageLagCompensationError* Arena::CreateMaybeMessage<::CUserMessageLagCompensationError>(Arena*);
template<> ::CUserMessageRequestDiagnostic* Arena::CreateMaybeMessage<::CUserMessageRequestDiagnostic>(Arena*);
template<> ::CUserMessageRequestDiagnostic_Diagnostic* Arena::CreateMaybeMessage<::CUserMessageRequestDiagnostic_Diagnostic>(Arena*);
template<> ::CUserMessageRequestDllStatus* Arena::CreateMaybeMessage<::CUserMessageRequestDllStatus>(Arena*);
template<> ::CUserMessageRequestInventory* Arena::CreateMaybeMessage<::CUserMessageRequestInventory>(Arena*);
template<> ::CUserMessageRequestState* Arena::CreateMaybeMessage<::CUserMessageRequestState>(Arena*);
template<> ::CUserMessageRequestUtilAction* Arena::CreateMaybeMessage<::CUserMessageRequestUtilAction>(Arena*);
template<> ::CUserMessageResetHUD* Arena::CreateMaybeMessage<::CUserMessageResetHUD>(Arena*);
template<> ::CUserMessageRumble* Arena::CreateMaybeMessage<::CUserMessageRumble>(Arena*);
template<> ::CUserMessageSayText* Arena::CreateMaybeMessage<::CUserMessageSayText>(Arena*);
template<> ::CUserMessageSayText2* Arena::CreateMaybeMessage<::CUserMessageSayText2>(Arena*);
template<> ::CUserMessageSayTextChannel* Arena::CreateMaybeMessage<::CUserMessageSayTextChannel>(Arena*);
template<> ::CUserMessageScreenTilt* Arena::CreateMaybeMessage<::CUserMessageScreenTilt>(Arena*);
template<> ::CUserMessageSendAudio* Arena::CreateMaybeMessage<::CUserMessageSendAudio>(Arena*);
template<> ::CUserMessageServerFrameTime* Arena::CreateMaybeMessage<::CUserMessageServerFrameTime>(Arena*);
template<> ::CUserMessageShake* Arena::CreateMaybeMessage<::CUserMessageShake>(Arena*);
template<> ::CUserMessageShakeDir* Arena::CreateMaybeMessage<::CUserMessageShakeDir>(Arena*);
template<> ::CUserMessageShowMenu* Arena::CreateMaybeMessage<::CUserMessageShowMenu>(Arena*);
template<> ::CUserMessageTextMsg* Arena::CreateMaybeMessage<::CUserMessageTextMsg>(Arena*);
template<> ::CUserMessageUpdateCssClasses* Arena::CreateMaybeMessage<::CUserMessageUpdateCssClasses>(Arena*);
template<> ::CUserMessageVoiceMask* Arena::CreateMaybeMessage<::CUserMessageVoiceMask>(Arena*);
template<> ::CUserMessageWaterShake* Arena::CreateMaybeMessage<::CUserMessageWaterShake>(Arena*);
template<> ::CUserMessage_Diagnostic_Response* Arena::CreateMaybeMessage<::CUserMessage_Diagnostic_Response>(Arena*);
template<> ::CUserMessage_Diagnostic_Response_Diagnostic* Arena::CreateMaybeMessage<::CUserMessage_Diagnostic_Response_Diagnostic>(Arena*);
template<> ::CUserMessage_DllStatus* Arena::CreateMaybeMessage<::CUserMessage_DllStatus>(Arena*);
template<> ::CUserMessage_DllStatus_CModule* Arena::CreateMaybeMessage<::CUserMessage_DllStatus_CModule>(Arena*);
template<> ::CUserMessage_DllStatus_CVDiagnostic* Arena::CreateMaybeMessage<::CUserMessage_DllStatus_CVDiagnostic>(Arena*);
template<> ::CUserMessage_ExtraUserData* Arena::CreateMaybeMessage<::CUserMessage_ExtraUserData>(Arena*);
template<> ::CUserMessage_Inventory_Response* Arena::CreateMaybeMessage<::CUserMessage_Inventory_Response>(Arena*);
template<> ::CUserMessage_Inventory_Response_InventoryDetail* Arena::CreateMaybeMessage<::CUserMessage_Inventory_Response_InventoryDetail>(Arena*);
template<> ::CUserMessage_NotifyResponseFound* Arena::CreateMaybeMessage<::CUserMessage_NotifyResponseFound>(Arena*);
template<> ::CUserMessage_NotifyResponseFound_Criteria* Arena::CreateMaybeMessage<::CUserMessage_NotifyResponseFound_Criteria>(Arena*);
template<> ::CUserMessage_PlayResponseConditional* Arena::CreateMaybeMessage<::CUserMessage_PlayResponseConditional>(Arena*);
template<> ::CUserMessage_UtilMsg_Response* Arena::CreateMaybeMessage<::CUserMessage_UtilMsg_Response>(Arena*);
template<> ::CUserMessage_UtilMsg_Response_ItemDetail* Arena::CreateMaybeMessage<::CUserMessage_UtilMsg_Response_ItemDetail>(Arena*);
template<> ::CUserMsg_CustomGameEvent* Arena::CreateMaybeMessage<::CUserMsg_CustomGameEvent>(Arena*);
template<> ::CUserMsg_HudError* Arena::CreateMaybeMessage<::CUserMsg_HudError>(Arena*);
template<> ::CUserMsg_ParticleManager* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager>(Arena*);
template<> ::CUserMsg_ParticleManager_AddFan* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_AddFan>(Arena*);
template<> ::CUserMsg_ParticleManager_AddModellistOverrideElement* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_AddModellistOverrideElement>(Arena*);
template<> ::CUserMsg_ParticleManager_ChangeControlPointAttachment* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ChangeControlPointAttachment>(Arena*);
template<> ::CUserMsg_ParticleManager_ClearModellistOverride* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ClearModellistOverride>(Arena*);
template<> ::CUserMsg_ParticleManager_CreateParticle* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_CreateParticle>(Arena*);
template<> ::CUserMsg_ParticleManager_CreatePhysicsSim* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_CreatePhysicsSim>(Arena*);
template<> ::CUserMsg_ParticleManager_DestroyParticle* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticle>(Arena*);
template<> ::CUserMsg_ParticleManager_DestroyParticleInvolving* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticleInvolving>(Arena*);
template<> ::CUserMsg_ParticleManager_DestroyParticleNamed* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticleNamed>(Arena*);
template<> ::CUserMsg_ParticleManager_DestroyPhysicsSim* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyPhysicsSim>(Arena*);
template<> ::CUserMsg_ParticleManager_FreezeParticleInvolving* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_FreezeParticleInvolving>(Arena*);
template<> ::CUserMsg_ParticleManager_ParticleCanFreeze* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleCanFreeze>(Arena*);
template<> ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride>(Arena*);
template<> ::CUserMsg_ParticleManager_ParticleSkipToTime* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleSkipToTime>(Arena*);
template<> ::CUserMsg_ParticleManager_ReleaseParticleIndex* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_ReleaseParticleIndex>(Arena*);
template<> ::CUserMsg_ParticleManager_RemoveFan* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_RemoveFan>(Arena*);
template<> ::CUserMsg_ParticleManager_SetControlPointModel* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetControlPointModel>(Arena*);
template<> ::CUserMsg_ParticleManager_SetControlPointSnapshot* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetControlPointSnapshot>(Arena*);
template<> ::CUserMsg_ParticleManager_SetMaterialOverride* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetMaterialOverride>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleClusterGrowth* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleClusterGrowth>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleFoWProperties* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleFoWProperties>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleNamedValueContext* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleShouldCheckFoW>(Arena*);
template<> ::CUserMsg_ParticleManager_SetParticleText* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleText>(Arena*);
template<> ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetSceneObjectGenericFlag>(Arena*);
template<> ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat>(Arena*);
template<> ::CUserMsg_ParticleManager_SetTextureAttribute* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetTextureAttribute>(Arena*);
template<> ::CUserMsg_ParticleManager_SetVData* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_SetVData>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateEntityPosition* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateEntityPosition>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateFan* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateFan>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleEnt* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleEnt>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleFallback* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleFallback>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleOffset* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleOffset>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleSetFrozen>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleShouldDraw>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticleTransform* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleTransform>(Arena*);
template<> ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* Arena::CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum EBaseUserMessages : int {
  UM_AchievementEvent = 101,
  UM_CloseCaption = 102,
  UM_CloseCaptionDirect = 103,
  UM_CurrentTimescale = 104,
  UM_DesiredTimescale = 105,
  UM_Fade = 106,
  UM_GameTitle = 107,
  UM_HudMsg = 110,
  UM_HudText = 111,
  UM_ColoredText = 113,
  UM_RequestState = 114,
  UM_ResetHUD = 115,
  UM_Rumble = 116,
  UM_SayText = 117,
  UM_SayText2 = 118,
  UM_SayTextChannel = 119,
  UM_Shake = 120,
  UM_ShakeDir = 121,
  UM_WaterShake = 122,
  UM_TextMsg = 124,
  UM_ScreenTilt = 125,
  UM_VoiceMask = 128,
  UM_SendAudio = 130,
  UM_ItemPickup = 131,
  UM_AmmoDenied = 132,
  UM_ShowMenu = 134,
  UM_CreditsMsg = 135,
  UM_CloseCaptionPlaceholder = 142,
  UM_CameraTransition = 143,
  UM_AudioParameter = 144,
  UM_ParticleManager = 145,
  UM_HudError = 146,
  UM_CustomGameEvent = 148,
  UM_AnimGraphUpdate = 149,
  UM_HapticsManagerPulse = 150,
  UM_HapticsManagerEffect = 151,
  UM_UpdateCssClasses = 153,
  UM_ServerFrameTime = 154,
  UM_LagCompensationError = 155,
  UM_RequestDllStatus = 156,
  UM_RequestUtilAction = 157,
  UM_UtilActionResponse = 158,
  UM_DllStatusResponse = 159,
  UM_RequestInventory = 160,
  UM_InventoryResponse = 161,
  UM_RequestDiagnostic = 162,
  UM_DiagnosticResponse = 163,
  UM_ExtraUserData = 164,
  UM_NotifyResponseFound = 165,
  UM_PlayResponseConditional = 166,
  UM_MAX_BASE = 200
};
bool EBaseUserMessages_IsValid(int value);
constexpr EBaseUserMessages EBaseUserMessages_MIN = UM_AchievementEvent;
constexpr EBaseUserMessages EBaseUserMessages_MAX = UM_MAX_BASE;
constexpr int EBaseUserMessages_ARRAYSIZE = EBaseUserMessages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EBaseUserMessages_descriptor();
template<typename T>
inline const std::string& EBaseUserMessages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EBaseUserMessages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EBaseUserMessages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EBaseUserMessages_descriptor(), enum_t_value);
}
inline bool EBaseUserMessages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EBaseUserMessages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EBaseUserMessages>(
    EBaseUserMessages_descriptor(), name, value);
}
enum EBaseEntityMessages : int {
  EM_PlayJingle = 136,
  EM_ScreenOverlay = 137,
  EM_RemoveAllDecals = 138,
  EM_PropagateForce = 139,
  EM_DoSpark = 140,
  EM_FixAngle = 141
};
bool EBaseEntityMessages_IsValid(int value);
constexpr EBaseEntityMessages EBaseEntityMessages_MIN = EM_PlayJingle;
constexpr EBaseEntityMessages EBaseEntityMessages_MAX = EM_FixAngle;
constexpr int EBaseEntityMessages_ARRAYSIZE = EBaseEntityMessages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EBaseEntityMessages_descriptor();
template<typename T>
inline const std::string& EBaseEntityMessages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EBaseEntityMessages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EBaseEntityMessages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EBaseEntityMessages_descriptor(), enum_t_value);
}
inline bool EBaseEntityMessages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EBaseEntityMessages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EBaseEntityMessages>(
    EBaseEntityMessages_descriptor(), name, value);
}
enum eRollType : int {
  ROLL_NONE = -1,
  ROLL_STATS = 0,
  ROLL_CREDITS = 1,
  ROLL_LATE_JOIN_LOGO = 2,
  ROLL_OUTTRO = 3
};
bool eRollType_IsValid(int value);
constexpr eRollType eRollType_MIN = ROLL_NONE;
constexpr eRollType eRollType_MAX = ROLL_OUTTRO;
constexpr int eRollType_ARRAYSIZE = eRollType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* eRollType_descriptor();
template<typename T>
inline const std::string& eRollType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, eRollType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function eRollType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    eRollType_descriptor(), enum_t_value);
}
inline bool eRollType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, eRollType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<eRollType>(
    eRollType_descriptor(), name, value);
}
enum PARTICLE_MESSAGE : int {
  GAME_PARTICLE_MANAGER_EVENT_CREATE = 0,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE = 1,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_FORWARD = 2,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_ORIENTATION = 3,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_FALLBACK = 4,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_ENT = 5,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_OFFSET = 6,
  GAME_PARTICLE_MANAGER_EVENT_DESTROY = 7,
  GAME_PARTICLE_MANAGER_EVENT_DESTROY_INVOLVING = 8,
  GAME_PARTICLE_MANAGER_EVENT_RELEASE = 9,
  GAME_PARTICLE_MANAGER_EVENT_LATENCY = 10,
  GAME_PARTICLE_MANAGER_EVENT_SHOULD_DRAW = 11,
  GAME_PARTICLE_MANAGER_EVENT_FROZEN = 12,
  GAME_PARTICLE_MANAGER_EVENT_CHANGE_CONTROL_POINT_ATTACHMENT = 13,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_ENTITY_POSITION = 14,
  GAME_PARTICLE_MANAGER_EVENT_SET_FOW_PROPERTIES = 15,
  GAME_PARTICLE_MANAGER_EVENT_SET_TEXT = 16,
  GAME_PARTICLE_MANAGER_EVENT_SET_SHOULD_CHECK_FOW = 17,
  GAME_PARTICLE_MANAGER_EVENT_SET_CONTROL_POINT_MODEL = 18,
  GAME_PARTICLE_MANAGER_EVENT_SET_CONTROL_POINT_SNAPSHOT = 19,
  GAME_PARTICLE_MANAGER_EVENT_SET_TEXTURE_ATTRIBUTE = 20,
  GAME_PARTICLE_MANAGER_EVENT_SET_SCENE_OBJECT_GENERIC_FLAG = 21,
  GAME_PARTICLE_MANAGER_EVENT_SET_SCENE_OBJECT_TINT_AND_DESAT = 22,
  GAME_PARTICLE_MANAGER_EVENT_DESTROY_NAMED = 23,
  GAME_PARTICLE_MANAGER_EVENT_SKIP_TO_TIME = 24,
  GAME_PARTICLE_MANAGER_EVENT_CAN_FREEZE = 25,
  GAME_PARTICLE_MANAGER_EVENT_SET_NAMED_VALUE_CONTEXT = 26,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_TRANSFORM = 27,
  GAME_PARTICLE_MANAGER_EVENT_FREEZE_TRANSITION_OVERRIDE = 28,
  GAME_PARTICLE_MANAGER_EVENT_FREEZE_INVOLVING = 29,
  GAME_PARTICLE_MANAGER_EVENT_ADD_MODELLIST_OVERRIDE_ELEMENT = 30,
  GAME_PARTICLE_MANAGER_EVENT_CLEAR_MODELLIST_OVERRIDE = 31,
  GAME_PARTICLE_MANAGER_EVENT_CREATE_PHYSICS_SIM = 32,
  GAME_PARTICLE_MANAGER_EVENT_DESTROY_PHYSICS_SIM = 33,
  GAME_PARTICLE_MANAGER_EVENT_SET_VDATA = 34,
  GAME_PARTICLE_MANAGER_EVENT_SET_MATERIAL_OVERRIDE = 35,
  GAME_PARTICLE_MANAGER_EVENT_ADD_FAN = 36,
  GAME_PARTICLE_MANAGER_EVENT_UPDATE_FAN = 37,
  GAME_PARTICLE_MANAGER_EVENT_SET_CLUSTER_GROWTH = 38,
  GAME_PARTICLE_MANAGER_EVENT_REMOVE_FAN = 39
};
bool PARTICLE_MESSAGE_IsValid(int value);
constexpr PARTICLE_MESSAGE PARTICLE_MESSAGE_MIN = GAME_PARTICLE_MANAGER_EVENT_CREATE;
constexpr PARTICLE_MESSAGE PARTICLE_MESSAGE_MAX = GAME_PARTICLE_MANAGER_EVENT_REMOVE_FAN;
constexpr int PARTICLE_MESSAGE_ARRAYSIZE = PARTICLE_MESSAGE_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PARTICLE_MESSAGE_descriptor();
template<typename T>
inline const std::string& PARTICLE_MESSAGE_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PARTICLE_MESSAGE>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PARTICLE_MESSAGE_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PARTICLE_MESSAGE_descriptor(), enum_t_value);
}
inline bool PARTICLE_MESSAGE_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PARTICLE_MESSAGE* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PARTICLE_MESSAGE>(
    PARTICLE_MESSAGE_descriptor(), name, value);
}
enum EHapticPulseType : int {
  VR_HAND_HAPTIC_PULSE_LIGHT = 0,
  VR_HAND_HAPTIC_PULSE_MEDIUM = 1,
  VR_HAND_HAPTIC_PULSE_STRONG = 2
};
bool EHapticPulseType_IsValid(int value);
constexpr EHapticPulseType EHapticPulseType_MIN = VR_HAND_HAPTIC_PULSE_LIGHT;
constexpr EHapticPulseType EHapticPulseType_MAX = VR_HAND_HAPTIC_PULSE_STRONG;
constexpr int EHapticPulseType_ARRAYSIZE = EHapticPulseType_MAX + 1;

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

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

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

  inline CUserMessageAchievementEvent& operator=(const CUserMessageAchievementEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageAchievementEvent& operator=(CUserMessageAchievementEvent&& 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 CUserMessageAchievementEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageAchievementEvent* internal_default_instance() {
    return reinterpret_cast<const CUserMessageAchievementEvent*>(
               &_CUserMessageAchievementEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CUserMessageAchievementEvent& a, CUserMessageAchievementEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageAchievementEvent* 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(CUserMessageAchievementEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageAchievementEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageAchievementEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageAchievementEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageAchievementEvent& from) {
    CUserMessageAchievementEvent::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(CUserMessageAchievementEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageAchievementEvent";
  }
  protected:
  explicit CUserMessageAchievementEvent(::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 {
    kAchievementFieldNumber = 1,
  };
  // optional uint32 achievement = 1;
  bool has_achievement() const;
  private:
  bool _internal_has_achievement() const;
  public:
  void clear_achievement();
  uint32_t achievement() const;
  void set_achievement(uint32_t value);
  private:
  uint32_t _internal_achievement() const;
  void _internal_set_achievement(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageAchievementEvent)
 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 achievement_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCloseCaption& operator=(const CUserMessageCloseCaption& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCloseCaption& operator=(CUserMessageCloseCaption&& 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 CUserMessageCloseCaption& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCloseCaption* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCloseCaption*>(
               &_CUserMessageCloseCaption_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CUserMessageCloseCaption& a, CUserMessageCloseCaption& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCloseCaption* 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(CUserMessageCloseCaption* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCloseCaption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCloseCaption>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCloseCaption& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCloseCaption& from) {
    CUserMessageCloseCaption::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(CUserMessageCloseCaption* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCloseCaption";
  }
  protected:
  explicit CUserMessageCloseCaption(::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 {
    kHashFieldNumber = 1,
    kDurationFieldNumber = 2,
    kFromPlayerFieldNumber = 3,
    kEntIndexFieldNumber = 4,
  };
  // optional fixed32 hash = 1;
  bool has_hash() const;
  private:
  bool _internal_has_hash() const;
  public:
  void clear_hash();
  uint32_t hash() const;
  void set_hash(uint32_t value);
  private:
  uint32_t _internal_hash() const;
  void _internal_set_hash(uint32_t value);
  public:

  // optional float duration = 2;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional bool from_player = 3;
  bool has_from_player() const;
  private:
  bool _internal_has_from_player() const;
  public:
  void clear_from_player();
  bool from_player() const;
  void set_from_player(bool value);
  private:
  bool _internal_from_player() const;
  void _internal_set_from_player(bool value);
  public:

  // optional int32 ent_index = 4 [default = -1];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  int32_t ent_index() const;
  void set_ent_index(int32_t value);
  private:
  int32_t _internal_ent_index() const;
  void _internal_set_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCloseCaption)
 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 hash_;
    float duration_;
    bool from_player_;
    int32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCloseCaptionDirect& operator=(const CUserMessageCloseCaptionDirect& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCloseCaptionDirect& operator=(CUserMessageCloseCaptionDirect&& 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 CUserMessageCloseCaptionDirect& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCloseCaptionDirect* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCloseCaptionDirect*>(
               &_CUserMessageCloseCaptionDirect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CUserMessageCloseCaptionDirect& a, CUserMessageCloseCaptionDirect& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCloseCaptionDirect* 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(CUserMessageCloseCaptionDirect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCloseCaptionDirect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCloseCaptionDirect>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCloseCaptionDirect& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCloseCaptionDirect& from) {
    CUserMessageCloseCaptionDirect::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(CUserMessageCloseCaptionDirect* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCloseCaptionDirect";
  }
  protected:
  explicit CUserMessageCloseCaptionDirect(::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 {
    kHashFieldNumber = 1,
    kDurationFieldNumber = 2,
    kFromPlayerFieldNumber = 3,
    kEntIndexFieldNumber = 4,
  };
  // optional fixed32 hash = 1;
  bool has_hash() const;
  private:
  bool _internal_has_hash() const;
  public:
  void clear_hash();
  uint32_t hash() const;
  void set_hash(uint32_t value);
  private:
  uint32_t _internal_hash() const;
  void _internal_set_hash(uint32_t value);
  public:

  // optional float duration = 2;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional bool from_player = 3;
  bool has_from_player() const;
  private:
  bool _internal_has_from_player() const;
  public:
  void clear_from_player();
  bool from_player() const;
  void set_from_player(bool value);
  private:
  bool _internal_from_player() const;
  void _internal_set_from_player(bool value);
  public:

  // optional int32 ent_index = 4 [default = -1];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  int32_t ent_index() const;
  void set_ent_index(int32_t value);
  private:
  int32_t _internal_ent_index() const;
  void _internal_set_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCloseCaptionDirect)
 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 hash_;
    float duration_;
    bool from_player_;
    int32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCloseCaptionPlaceholder& operator=(const CUserMessageCloseCaptionPlaceholder& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCloseCaptionPlaceholder& operator=(CUserMessageCloseCaptionPlaceholder&& 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 CUserMessageCloseCaptionPlaceholder& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCloseCaptionPlaceholder* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCloseCaptionPlaceholder*>(
               &_CUserMessageCloseCaptionPlaceholder_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CUserMessageCloseCaptionPlaceholder& a, CUserMessageCloseCaptionPlaceholder& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCloseCaptionPlaceholder* 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(CUserMessageCloseCaptionPlaceholder* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCloseCaptionPlaceholder* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCloseCaptionPlaceholder>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCloseCaptionPlaceholder& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCloseCaptionPlaceholder& from) {
    CUserMessageCloseCaptionPlaceholder::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(CUserMessageCloseCaptionPlaceholder* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCloseCaptionPlaceholder";
  }
  protected:
  explicit CUserMessageCloseCaptionPlaceholder(::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 {
    kStringFieldNumber = 1,
    kDurationFieldNumber = 2,
    kFromPlayerFieldNumber = 3,
    kEntIndexFieldNumber = 4,
  };
  // optional string string = 1;
  bool has_string() const;
  private:
  bool _internal_has_string() const;
  public:
  void clear_string();
  const std::string& string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string();
  PROTOBUF_NODISCARD std::string* release_string();
  void set_allocated_string(std::string* string);
  private:
  const std::string& _internal_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string(const std::string& value);
  std::string* _internal_mutable_string();
  public:

  // optional float duration = 2;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional bool from_player = 3;
  bool has_from_player() const;
  private:
  bool _internal_has_from_player() const;
  public:
  void clear_from_player();
  bool from_player() const;
  void set_from_player(bool value);
  private:
  bool _internal_from_player() const;
  void _internal_set_from_player(bool value);
  public:

  // optional int32 ent_index = 4 [default = -1];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  int32_t ent_index() const;
  void set_ent_index(int32_t value);
  private:
  int32_t _internal_ent_index() const;
  void _internal_set_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCloseCaptionPlaceholder)
 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 string_;
    float duration_;
    bool from_player_;
    int32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCurrentTimescale& operator=(const CUserMessageCurrentTimescale& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCurrentTimescale& operator=(CUserMessageCurrentTimescale&& 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 CUserMessageCurrentTimescale& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCurrentTimescale* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCurrentTimescale*>(
               &_CUserMessageCurrentTimescale_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CUserMessageCurrentTimescale& a, CUserMessageCurrentTimescale& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCurrentTimescale* 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(CUserMessageCurrentTimescale* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCurrentTimescale* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCurrentTimescale>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCurrentTimescale& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCurrentTimescale& from) {
    CUserMessageCurrentTimescale::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(CUserMessageCurrentTimescale* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCurrentTimescale";
  }
  protected:
  explicit CUserMessageCurrentTimescale(::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 {
    kCurrentFieldNumber = 1,
  };
  // optional float current = 1;
  bool has_current() const;
  private:
  bool _internal_has_current() const;
  public:
  void clear_current();
  float current() const;
  void set_current(float value);
  private:
  float _internal_current() const;
  void _internal_set_current(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCurrentTimescale)
 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_;
    float current_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageDesiredTimescale& operator=(const CUserMessageDesiredTimescale& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageDesiredTimescale& operator=(CUserMessageDesiredTimescale&& 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 CUserMessageDesiredTimescale& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageDesiredTimescale* internal_default_instance() {
    return reinterpret_cast<const CUserMessageDesiredTimescale*>(
               &_CUserMessageDesiredTimescale_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CUserMessageDesiredTimescale& a, CUserMessageDesiredTimescale& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageDesiredTimescale* 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(CUserMessageDesiredTimescale* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageDesiredTimescale* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageDesiredTimescale>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageDesiredTimescale& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageDesiredTimescale& from) {
    CUserMessageDesiredTimescale::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(CUserMessageDesiredTimescale* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageDesiredTimescale";
  }
  protected:
  explicit CUserMessageDesiredTimescale(::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 {
    kDesiredFieldNumber = 1,
    kAccelerationFieldNumber = 2,
    kMinblendrateFieldNumber = 3,
    kBlenddeltamultiplierFieldNumber = 4,
  };
  // optional float desired = 1;
  bool has_desired() const;
  private:
  bool _internal_has_desired() const;
  public:
  void clear_desired();
  float desired() const;
  void set_desired(float value);
  private:
  float _internal_desired() const;
  void _internal_set_desired(float value);
  public:

  // optional float acceleration = 2;
  bool has_acceleration() const;
  private:
  bool _internal_has_acceleration() const;
  public:
  void clear_acceleration();
  float acceleration() const;
  void set_acceleration(float value);
  private:
  float _internal_acceleration() const;
  void _internal_set_acceleration(float value);
  public:

  // optional float minblendrate = 3;
  bool has_minblendrate() const;
  private:
  bool _internal_has_minblendrate() const;
  public:
  void clear_minblendrate();
  float minblendrate() const;
  void set_minblendrate(float value);
  private:
  float _internal_minblendrate() const;
  void _internal_set_minblendrate(float value);
  public:

  // optional float blenddeltamultiplier = 4;
  bool has_blenddeltamultiplier() const;
  private:
  bool _internal_has_blenddeltamultiplier() const;
  public:
  void clear_blenddeltamultiplier();
  float blenddeltamultiplier() const;
  void set_blenddeltamultiplier(float value);
  private:
  float _internal_blenddeltamultiplier() const;
  void _internal_set_blenddeltamultiplier(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageDesiredTimescale)
 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_;
    float desired_;
    float acceleration_;
    float minblendrate_;
    float blenddeltamultiplier_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageFade& operator=(const CUserMessageFade& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageFade& operator=(CUserMessageFade&& 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 CUserMessageFade& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageFade* internal_default_instance() {
    return reinterpret_cast<const CUserMessageFade*>(
               &_CUserMessageFade_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CUserMessageFade& a, CUserMessageFade& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageFade* 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(CUserMessageFade* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageFade* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageFade>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageFade& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageFade& from) {
    CUserMessageFade::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(CUserMessageFade* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageFade";
  }
  protected:
  explicit CUserMessageFade(::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 {
    kDurationFieldNumber = 1,
    kHoldTimeFieldNumber = 2,
    kFlagsFieldNumber = 3,
    kColorFieldNumber = 4,
  };
  // optional uint32 duration = 1;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  uint32_t duration() const;
  void set_duration(uint32_t value);
  private:
  uint32_t _internal_duration() const;
  void _internal_set_duration(uint32_t value);
  public:

  // optional uint32 hold_time = 2;
  bool has_hold_time() const;
  private:
  bool _internal_has_hold_time() const;
  public:
  void clear_hold_time();
  uint32_t hold_time() const;
  void set_hold_time(uint32_t value);
  private:
  uint32_t _internal_hold_time() const;
  void _internal_set_hold_time(uint32_t value);
  public:

  // optional uint32 flags = 3;
  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 fixed32 color = 4;
  bool has_color() const;
  private:
  bool _internal_has_color() const;
  public:
  void clear_color();
  uint32_t color() const;
  void set_color(uint32_t value);
  private:
  uint32_t _internal_color() const;
  void _internal_set_color(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageFade)
 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 duration_;
    uint32_t hold_time_;
    uint32_t flags_;
    uint32_t color_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageShake& operator=(const CUserMessageShake& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageShake& operator=(CUserMessageShake&& 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 CUserMessageShake& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageShake* internal_default_instance() {
    return reinterpret_cast<const CUserMessageShake*>(
               &_CUserMessageShake_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CUserMessageShake& a, CUserMessageShake& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageShake* 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(CUserMessageShake* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageShake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageShake>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageShake& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageShake& from) {
    CUserMessageShake::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(CUserMessageShake* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageShake";
  }
  protected:
  explicit CUserMessageShake(::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 {
    kCommandFieldNumber = 1,
    kAmplitudeFieldNumber = 2,
    kFrequencyFieldNumber = 3,
    kDurationFieldNumber = 4,
  };
  // optional uint32 command = 1;
  bool has_command() const;
  private:
  bool _internal_has_command() const;
  public:
  void clear_command();
  uint32_t command() const;
  void set_command(uint32_t value);
  private:
  uint32_t _internal_command() const;
  void _internal_set_command(uint32_t value);
  public:

  // optional float amplitude = 2;
  bool has_amplitude() const;
  private:
  bool _internal_has_amplitude() const;
  public:
  void clear_amplitude();
  float amplitude() const;
  void set_amplitude(float value);
  private:
  float _internal_amplitude() const;
  void _internal_set_amplitude(float value);
  public:

  // optional float frequency = 3;
  bool has_frequency() const;
  private:
  bool _internal_has_frequency() const;
  public:
  void clear_frequency();
  float frequency() const;
  void set_frequency(float value);
  private:
  float _internal_frequency() const;
  void _internal_set_frequency(float value);
  public:

  // optional float duration = 4;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageShake)
 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 command_;
    float amplitude_;
    float frequency_;
    float duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageShakeDir& operator=(const CUserMessageShakeDir& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageShakeDir& operator=(CUserMessageShakeDir&& 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 CUserMessageShakeDir& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageShakeDir* internal_default_instance() {
    return reinterpret_cast<const CUserMessageShakeDir*>(
               &_CUserMessageShakeDir_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CUserMessageShakeDir& a, CUserMessageShakeDir& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageShakeDir* 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(CUserMessageShakeDir* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageShakeDir* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageShakeDir>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageShakeDir& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageShakeDir& from) {
    CUserMessageShakeDir::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(CUserMessageShakeDir* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageShakeDir";
  }
  protected:
  explicit CUserMessageShakeDir(::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 {
    kShakeFieldNumber = 1,
    kDirectionFieldNumber = 2,
  };
  // optional .CUserMessageShake shake = 1;
  bool has_shake() const;
  private:
  bool _internal_has_shake() const;
  public:
  void clear_shake();
  const ::CUserMessageShake& shake() const;
  PROTOBUF_NODISCARD ::CUserMessageShake* release_shake();
  ::CUserMessageShake* mutable_shake();
  void set_allocated_shake(::CUserMessageShake* shake);
  private:
  const ::CUserMessageShake& _internal_shake() const;
  ::CUserMessageShake* _internal_mutable_shake();
  public:
  void unsafe_arena_set_allocated_shake(
      ::CUserMessageShake* shake);
  ::CUserMessageShake* unsafe_arena_release_shake();

  // optional .CMsgVector direction = 2;
  bool has_direction() const;
  private:
  bool _internal_has_direction() const;
  public:
  void clear_direction();
  const ::CMsgVector& direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_direction();
  ::CMsgVector* mutable_direction();
  void set_allocated_direction(::CMsgVector* direction);
  private:
  const ::CMsgVector& _internal_direction() const;
  ::CMsgVector* _internal_mutable_direction();
  public:
  void unsafe_arena_set_allocated_direction(
      ::CMsgVector* direction);
  ::CMsgVector* unsafe_arena_release_direction();

  // @@protoc_insertion_point(class_scope:CUserMessageShakeDir)
 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_;
    ::CUserMessageShake* shake_;
    ::CMsgVector* direction_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageWaterShake& operator=(const CUserMessageWaterShake& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageWaterShake& operator=(CUserMessageWaterShake&& 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 CUserMessageWaterShake& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageWaterShake* internal_default_instance() {
    return reinterpret_cast<const CUserMessageWaterShake*>(
               &_CUserMessageWaterShake_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CUserMessageWaterShake& a, CUserMessageWaterShake& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageWaterShake* 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(CUserMessageWaterShake* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageWaterShake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageWaterShake>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageWaterShake& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageWaterShake& from) {
    CUserMessageWaterShake::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(CUserMessageWaterShake* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageWaterShake";
  }
  protected:
  explicit CUserMessageWaterShake(::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 {
    kCommandFieldNumber = 1,
    kAmplitudeFieldNumber = 2,
    kFrequencyFieldNumber = 3,
    kDurationFieldNumber = 4,
  };
  // optional uint32 command = 1;
  bool has_command() const;
  private:
  bool _internal_has_command() const;
  public:
  void clear_command();
  uint32_t command() const;
  void set_command(uint32_t value);
  private:
  uint32_t _internal_command() const;
  void _internal_set_command(uint32_t value);
  public:

  // optional float amplitude = 2;
  bool has_amplitude() const;
  private:
  bool _internal_has_amplitude() const;
  public:
  void clear_amplitude();
  float amplitude() const;
  void set_amplitude(float value);
  private:
  float _internal_amplitude() const;
  void _internal_set_amplitude(float value);
  public:

  // optional float frequency = 3;
  bool has_frequency() const;
  private:
  bool _internal_has_frequency() const;
  public:
  void clear_frequency();
  float frequency() const;
  void set_frequency(float value);
  private:
  float _internal_frequency() const;
  void _internal_set_frequency(float value);
  public:

  // optional float duration = 4;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageWaterShake)
 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 command_;
    float amplitude_;
    float frequency_;
    float duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageScreenTilt& operator=(const CUserMessageScreenTilt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageScreenTilt& operator=(CUserMessageScreenTilt&& 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 CUserMessageScreenTilt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageScreenTilt* internal_default_instance() {
    return reinterpret_cast<const CUserMessageScreenTilt*>(
               &_CUserMessageScreenTilt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CUserMessageScreenTilt& a, CUserMessageScreenTilt& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageScreenTilt* 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(CUserMessageScreenTilt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageScreenTilt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageScreenTilt>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageScreenTilt& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageScreenTilt& from) {
    CUserMessageScreenTilt::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(CUserMessageScreenTilt* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageScreenTilt";
  }
  protected:
  explicit CUserMessageScreenTilt(::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 {
    kAngleFieldNumber = 3,
    kCommandFieldNumber = 1,
    kEaseInOutFieldNumber = 2,
    kDurationFieldNumber = 4,
    kTimeFieldNumber = 5,
  };
  // optional .CMsgVector angle = 3;
  bool has_angle() const;
  private:
  bool _internal_has_angle() const;
  public:
  void clear_angle();
  const ::CMsgVector& angle() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_angle();
  ::CMsgVector* mutable_angle();
  void set_allocated_angle(::CMsgVector* angle);
  private:
  const ::CMsgVector& _internal_angle() const;
  ::CMsgVector* _internal_mutable_angle();
  public:
  void unsafe_arena_set_allocated_angle(
      ::CMsgVector* angle);
  ::CMsgVector* unsafe_arena_release_angle();

  // optional uint32 command = 1;
  bool has_command() const;
  private:
  bool _internal_has_command() const;
  public:
  void clear_command();
  uint32_t command() const;
  void set_command(uint32_t value);
  private:
  uint32_t _internal_command() const;
  void _internal_set_command(uint32_t value);
  public:

  // optional bool ease_in_out = 2;
  bool has_ease_in_out() const;
  private:
  bool _internal_has_ease_in_out() const;
  public:
  void clear_ease_in_out();
  bool ease_in_out() const;
  void set_ease_in_out(bool value);
  private:
  bool _internal_ease_in_out() const;
  void _internal_set_ease_in_out(bool value);
  public:

  // optional float duration = 4;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional float time = 5;
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  float time() const;
  void set_time(float value);
  private:
  float _internal_time() const;
  void _internal_set_time(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageScreenTilt)
 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_;
    ::CMsgVector* angle_;
    uint32_t command_;
    bool ease_in_out_;
    float duration_;
    float time_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageSayText& operator=(const CUserMessageSayText& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageSayText& operator=(CUserMessageSayText&& 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 CUserMessageSayText& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageSayText* internal_default_instance() {
    return reinterpret_cast<const CUserMessageSayText*>(
               &_CUserMessageSayText_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CUserMessageSayText& a, CUserMessageSayText& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageSayText* 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(CUserMessageSayText* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageSayText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageSayText>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageSayText& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageSayText& from) {
    CUserMessageSayText::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(CUserMessageSayText* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageSayText";
  }
  protected:
  explicit CUserMessageSayText(::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 {
    kTextFieldNumber = 2,
    kChatFieldNumber = 3,
    kPlayerindexFieldNumber = 1,
  };
  // optional string text = 2;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // optional bool chat = 3;
  bool has_chat() const;
  private:
  bool _internal_has_chat() const;
  public:
  void clear_chat();
  bool chat() const;
  void set_chat(bool value);
  private:
  bool _internal_chat() const;
  void _internal_set_chat(bool value);
  public:

  // optional int32 playerindex = 1 [default = -1];
  bool has_playerindex() const;
  private:
  bool _internal_has_playerindex() const;
  public:
  void clear_playerindex();
  int32_t playerindex() const;
  void set_playerindex(int32_t value);
  private:
  int32_t _internal_playerindex() const;
  void _internal_set_playerindex(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageSayText)
 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 text_;
    bool chat_;
    int32_t playerindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageSayText2& operator=(const CUserMessageSayText2& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageSayText2& operator=(CUserMessageSayText2&& 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 CUserMessageSayText2& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageSayText2* internal_default_instance() {
    return reinterpret_cast<const CUserMessageSayText2*>(
               &_CUserMessageSayText2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CUserMessageSayText2& a, CUserMessageSayText2& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageSayText2* 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(CUserMessageSayText2* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageSayText2* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageSayText2>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageSayText2& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageSayText2& from) {
    CUserMessageSayText2::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(CUserMessageSayText2* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageSayText2";
  }
  protected:
  explicit CUserMessageSayText2(::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 {
    kMessagenameFieldNumber = 3,
    kParam1FieldNumber = 4,
    kParam2FieldNumber = 5,
    kParam3FieldNumber = 6,
    kParam4FieldNumber = 7,
    kChatFieldNumber = 2,
    kEntityindexFieldNumber = 1,
  };
  // optional string messagename = 3;
  bool has_messagename() const;
  private:
  bool _internal_has_messagename() const;
  public:
  void clear_messagename();
  const std::string& messagename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_messagename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_messagename();
  PROTOBUF_NODISCARD std::string* release_messagename();
  void set_allocated_messagename(std::string* messagename);
  private:
  const std::string& _internal_messagename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagename(const std::string& value);
  std::string* _internal_mutable_messagename();
  public:

  // optional string param1 = 4;
  bool has_param1() const;
  private:
  bool _internal_has_param1() const;
  public:
  void clear_param1();
  const std::string& param1() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param1(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param1();
  PROTOBUF_NODISCARD std::string* release_param1();
  void set_allocated_param1(std::string* param1);
  private:
  const std::string& _internal_param1() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param1(const std::string& value);
  std::string* _internal_mutable_param1();
  public:

  // optional string param2 = 5;
  bool has_param2() const;
  private:
  bool _internal_has_param2() const;
  public:
  void clear_param2();
  const std::string& param2() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param2(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param2();
  PROTOBUF_NODISCARD std::string* release_param2();
  void set_allocated_param2(std::string* param2);
  private:
  const std::string& _internal_param2() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param2(const std::string& value);
  std::string* _internal_mutable_param2();
  public:

  // optional string param3 = 6;
  bool has_param3() const;
  private:
  bool _internal_has_param3() const;
  public:
  void clear_param3();
  const std::string& param3() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param3(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param3();
  PROTOBUF_NODISCARD std::string* release_param3();
  void set_allocated_param3(std::string* param3);
  private:
  const std::string& _internal_param3() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param3(const std::string& value);
  std::string* _internal_mutable_param3();
  public:

  // optional string param4 = 7;
  bool has_param4() const;
  private:
  bool _internal_has_param4() const;
  public:
  void clear_param4();
  const std::string& param4() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param4(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param4();
  PROTOBUF_NODISCARD std::string* release_param4();
  void set_allocated_param4(std::string* param4);
  private:
  const std::string& _internal_param4() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param4(const std::string& value);
  std::string* _internal_mutable_param4();
  public:

  // optional bool chat = 2;
  bool has_chat() const;
  private:
  bool _internal_has_chat() const;
  public:
  void clear_chat();
  bool chat() const;
  void set_chat(bool value);
  private:
  bool _internal_chat() const;
  void _internal_set_chat(bool value);
  public:

  // optional int32 entityindex = 1 [default = -1];
  bool has_entityindex() const;
  private:
  bool _internal_has_entityindex() const;
  public:
  void clear_entityindex();
  int32_t entityindex() const;
  void set_entityindex(int32_t value);
  private:
  int32_t _internal_entityindex() const;
  void _internal_set_entityindex(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageSayText2)
 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 messagename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param1_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param2_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param3_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param4_;
    bool chat_;
    int32_t entityindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageHudMsg& operator=(const CUserMessageHudMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageHudMsg& operator=(CUserMessageHudMsg&& 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 CUserMessageHudMsg& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageHudMsg* internal_default_instance() {
    return reinterpret_cast<const CUserMessageHudMsg*>(
               &_CUserMessageHudMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CUserMessageHudMsg& a, CUserMessageHudMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageHudMsg* 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(CUserMessageHudMsg* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageHudMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageHudMsg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageHudMsg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageHudMsg& from) {
    CUserMessageHudMsg::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(CUserMessageHudMsg* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageHudMsg";
  }
  protected:
  explicit CUserMessageHudMsg(::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 = 11,
    kChannelFieldNumber = 1,
    kXFieldNumber = 2,
    kYFieldNumber = 3,
    kColor1FieldNumber = 4,
    kColor2FieldNumber = 5,
    kEffectFieldNumber = 6,
  };
  // optional string message = 11;
  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:

  // optional uint32 channel = 1;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  uint32_t channel() const;
  void set_channel(uint32_t value);
  private:
  uint32_t _internal_channel() const;
  void _internal_set_channel(uint32_t value);
  public:

  // optional float x = 2;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // optional float y = 3;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

  // optional fixed32 color1 = 4;
  bool has_color1() const;
  private:
  bool _internal_has_color1() const;
  public:
  void clear_color1();
  uint32_t color1() const;
  void set_color1(uint32_t value);
  private:
  uint32_t _internal_color1() const;
  void _internal_set_color1(uint32_t value);
  public:

  // optional fixed32 color2 = 5;
  bool has_color2() const;
  private:
  bool _internal_has_color2() const;
  public:
  void clear_color2();
  uint32_t color2() const;
  void set_color2(uint32_t value);
  private:
  uint32_t _internal_color2() const;
  void _internal_set_color2(uint32_t value);
  public:

  // optional uint32 effect = 6;
  bool has_effect() const;
  private:
  bool _internal_has_effect() const;
  public:
  void clear_effect();
  uint32_t effect() const;
  void set_effect(uint32_t value);
  private:
  uint32_t _internal_effect() const;
  void _internal_set_effect(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageHudMsg)
 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_;
    uint32_t channel_;
    float x_;
    float y_;
    uint32_t color1_;
    uint32_t color2_;
    uint32_t effect_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageHudText& operator=(const CUserMessageHudText& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageHudText& operator=(CUserMessageHudText&& 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 CUserMessageHudText& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageHudText* internal_default_instance() {
    return reinterpret_cast<const CUserMessageHudText*>(
               &_CUserMessageHudText_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CUserMessageHudText& a, CUserMessageHudText& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageHudText* 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(CUserMessageHudText* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageHudText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageHudText>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageHudText& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageHudText& from) {
    CUserMessageHudText::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(CUserMessageHudText* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageHudText";
  }
  protected:
  explicit CUserMessageHudText(::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:CUserMessageHudText)
 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_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageTextMsg& operator=(const CUserMessageTextMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageTextMsg& operator=(CUserMessageTextMsg&& 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 CUserMessageTextMsg& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageTextMsg* internal_default_instance() {
    return reinterpret_cast<const CUserMessageTextMsg*>(
               &_CUserMessageTextMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CUserMessageTextMsg& a, CUserMessageTextMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageTextMsg* 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(CUserMessageTextMsg* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageTextMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageTextMsg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageTextMsg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageTextMsg& from) {
    CUserMessageTextMsg::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(CUserMessageTextMsg* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageTextMsg";
  }
  protected:
  explicit CUserMessageTextMsg(::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 {
    kParamFieldNumber = 2,
    kDestFieldNumber = 1,
  };
  // repeated string param = 2;
  int param_size() const;
  private:
  int _internal_param_size() const;
  public:
  void clear_param();
  const std::string& param(int index) const;
  std::string* mutable_param(int index);
  void set_param(int index, const std::string& value);
  void set_param(int index, std::string&& value);
  void set_param(int index, const char* value);
  void set_param(int index, const char* value, size_t size);
  std::string* add_param();
  void add_param(const std::string& value);
  void add_param(std::string&& value);
  void add_param(const char* value);
  void add_param(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& param() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_param();
  private:
  const std::string& _internal_param(int index) const;
  std::string* _internal_add_param();
  public:

  // optional uint32 dest = 1;
  bool has_dest() const;
  private:
  bool _internal_has_dest() const;
  public:
  void clear_dest();
  uint32_t dest() const;
  void set_dest(uint32_t value);
  private:
  uint32_t _internal_dest() const;
  void _internal_set_dest(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageTextMsg)
 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> param_;
    uint32_t dest_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageGameTitle& operator=(const CUserMessageGameTitle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageGameTitle& operator=(CUserMessageGameTitle&& 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 CUserMessageGameTitle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageGameTitle* internal_default_instance() {
    return reinterpret_cast<const CUserMessageGameTitle*>(
               &_CUserMessageGameTitle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(CUserMessageGameTitle& a, CUserMessageGameTitle& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageGameTitle* 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(CUserMessageGameTitle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageGameTitle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageGameTitle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMessageGameTitle& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMessageGameTitle& 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 "CUserMessageGameTitle";
  }
  protected:
  explicit CUserMessageGameTitle(::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:CUserMessageGameTitle)
 private:
  class _Internal;

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

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

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

  inline CUserMessageResetHUD& operator=(const CUserMessageResetHUD& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageResetHUD& operator=(CUserMessageResetHUD&& 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 CUserMessageResetHUD& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageResetHUD* internal_default_instance() {
    return reinterpret_cast<const CUserMessageResetHUD*>(
               &_CUserMessageResetHUD_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(CUserMessageResetHUD& a, CUserMessageResetHUD& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageResetHUD* 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(CUserMessageResetHUD* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageResetHUD* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageResetHUD>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMessageResetHUD& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMessageResetHUD& 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 "CUserMessageResetHUD";
  }
  protected:
  explicit CUserMessageResetHUD(::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:CUserMessageResetHUD)
 private:
  class _Internal;

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

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

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

  inline CUserMessageSendAudio& operator=(const CUserMessageSendAudio& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageSendAudio& operator=(CUserMessageSendAudio&& 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 CUserMessageSendAudio& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageSendAudio* internal_default_instance() {
    return reinterpret_cast<const CUserMessageSendAudio*>(
               &_CUserMessageSendAudio_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(CUserMessageSendAudio& a, CUserMessageSendAudio& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageSendAudio* 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(CUserMessageSendAudio* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageSendAudio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageSendAudio>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageSendAudio& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageSendAudio& from) {
    CUserMessageSendAudio::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(CUserMessageSendAudio* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageSendAudio";
  }
  protected:
  explicit CUserMessageSendAudio(::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 {
    kSoundnameFieldNumber = 1,
    kStopFieldNumber = 2,
  };
  // optional string soundname = 1;
  bool has_soundname() const;
  private:
  bool _internal_has_soundname() const;
  public:
  void clear_soundname();
  const std::string& soundname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_soundname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_soundname();
  PROTOBUF_NODISCARD std::string* release_soundname();
  void set_allocated_soundname(std::string* soundname);
  private:
  const std::string& _internal_soundname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_soundname(const std::string& value);
  std::string* _internal_mutable_soundname();
  public:

  // optional bool stop = 2;
  bool has_stop() const;
  private:
  bool _internal_has_stop() const;
  public:
  void clear_stop();
  bool stop() const;
  void set_stop(bool value);
  private:
  bool _internal_stop() const;
  void _internal_set_stop(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageSendAudio)
 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 soundname_;
    bool stop_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageAudioParameter& operator=(const CUserMessageAudioParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageAudioParameter& operator=(CUserMessageAudioParameter&& 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 CUserMessageAudioParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageAudioParameter* internal_default_instance() {
    return reinterpret_cast<const CUserMessageAudioParameter*>(
               &_CUserMessageAudioParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(CUserMessageAudioParameter& a, CUserMessageAudioParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageAudioParameter* 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(CUserMessageAudioParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageAudioParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageAudioParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageAudioParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageAudioParameter& from) {
    CUserMessageAudioParameter::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(CUserMessageAudioParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageAudioParameter";
  }
  protected:
  explicit CUserMessageAudioParameter(::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 {
    kParameterTypeFieldNumber = 1,
    kNameHashCodeFieldNumber = 2,
    kValueFieldNumber = 3,
    kIntValueFieldNumber = 4,
  };
  // optional uint32 parameter_type = 1;
  bool has_parameter_type() const;
  private:
  bool _internal_has_parameter_type() const;
  public:
  void clear_parameter_type();
  uint32_t parameter_type() const;
  void set_parameter_type(uint32_t value);
  private:
  uint32_t _internal_parameter_type() const;
  void _internal_set_parameter_type(uint32_t value);
  public:

  // optional uint32 name_hash_code = 2;
  bool has_name_hash_code() const;
  private:
  bool _internal_has_name_hash_code() const;
  public:
  void clear_name_hash_code();
  uint32_t name_hash_code() const;
  void set_name_hash_code(uint32_t value);
  private:
  uint32_t _internal_name_hash_code() const;
  void _internal_set_name_hash_code(uint32_t value);
  public:

  // optional float value = 3;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  float value() const;
  void set_value(float value);
  private:
  float _internal_value() const;
  void _internal_set_value(float value);
  public:

  // optional uint32 int_value = 4;
  bool has_int_value() const;
  private:
  bool _internal_has_int_value() const;
  public:
  void clear_int_value();
  uint32_t int_value() const;
  void set_int_value(uint32_t value);
  private:
  uint32_t _internal_int_value() const;
  void _internal_set_int_value(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageAudioParameter)
 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 parameter_type_;
    uint32_t name_hash_code_;
    float value_;
    uint32_t int_value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageVoiceMask& operator=(const CUserMessageVoiceMask& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageVoiceMask& operator=(CUserMessageVoiceMask&& 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 CUserMessageVoiceMask& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageVoiceMask* internal_default_instance() {
    return reinterpret_cast<const CUserMessageVoiceMask*>(
               &_CUserMessageVoiceMask_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(CUserMessageVoiceMask& a, CUserMessageVoiceMask& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageVoiceMask* 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(CUserMessageVoiceMask* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageVoiceMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageVoiceMask>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageVoiceMask& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageVoiceMask& from) {
    CUserMessageVoiceMask::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(CUserMessageVoiceMask* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageVoiceMask";
  }
  protected:
  explicit CUserMessageVoiceMask(::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 {
    kGamerulesMasksFieldNumber = 1,
    kBanMasksFieldNumber = 2,
    kModEnableFieldNumber = 3,
  };
  // repeated uint32 gamerules_masks = 1;
  int gamerules_masks_size() const;
  private:
  int _internal_gamerules_masks_size() const;
  public:
  void clear_gamerules_masks();
  private:
  uint32_t _internal_gamerules_masks(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_gamerules_masks() const;
  void _internal_add_gamerules_masks(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_gamerules_masks();
  public:
  uint32_t gamerules_masks(int index) const;
  void set_gamerules_masks(int index, uint32_t value);
  void add_gamerules_masks(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      gamerules_masks() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_gamerules_masks();

  // repeated uint32 ban_masks = 2;
  int ban_masks_size() const;
  private:
  int _internal_ban_masks_size() const;
  public:
  void clear_ban_masks();
  private:
  uint32_t _internal_ban_masks(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ban_masks() const;
  void _internal_add_ban_masks(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ban_masks();
  public:
  uint32_t ban_masks(int index) const;
  void set_ban_masks(int index, uint32_t value);
  void add_ban_masks(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ban_masks() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ban_masks();

  // optional bool mod_enable = 3;
  bool has_mod_enable() const;
  private:
  bool _internal_has_mod_enable() const;
  public:
  void clear_mod_enable();
  bool mod_enable() const;
  void set_mod_enable(bool value);
  private:
  bool _internal_mod_enable() const;
  void _internal_set_mod_enable(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageVoiceMask)
 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 > gamerules_masks_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > ban_masks_;
    bool mod_enable_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestState& operator=(const CUserMessageRequestState& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestState& operator=(CUserMessageRequestState&& 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 CUserMessageRequestState& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestState* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestState*>(
               &_CUserMessageRequestState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(CUserMessageRequestState& a, CUserMessageRequestState& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestState* 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(CUserMessageRequestState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestState>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMessageRequestState& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMessageRequestState& 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 "CUserMessageRequestState";
  }
  protected:
  explicit CUserMessageRequestState(::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:CUserMessageRequestState)
 private:
  class _Internal;

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

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

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

  inline CUserMessageRumble& operator=(const CUserMessageRumble& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRumble& operator=(CUserMessageRumble&& 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 CUserMessageRumble& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRumble* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRumble*>(
               &_CUserMessageRumble_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(CUserMessageRumble& a, CUserMessageRumble& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRumble* 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(CUserMessageRumble* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRumble* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRumble>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRumble& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRumble& from) {
    CUserMessageRumble::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(CUserMessageRumble* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRumble";
  }
  protected:
  explicit CUserMessageRumble(::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 {
    kIndexFieldNumber = 1,
    kDataFieldNumber = 2,
    kFlagsFieldNumber = 3,
  };
  // optional int32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // optional int32 data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  int32_t data() const;
  void set_data(int32_t value);
  private:
  int32_t _internal_data() const;
  void _internal_set_data(int32_t value);
  public:

  // optional int32 flags = 3;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  int32_t flags() const;
  void set_flags(int32_t value);
  private:
  int32_t _internal_flags() const;
  void _internal_set_flags(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageRumble)
 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 index_;
    int32_t data_;
    int32_t flags_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageSayTextChannel& operator=(const CUserMessageSayTextChannel& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageSayTextChannel& operator=(CUserMessageSayTextChannel&& 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 CUserMessageSayTextChannel& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageSayTextChannel* internal_default_instance() {
    return reinterpret_cast<const CUserMessageSayTextChannel*>(
               &_CUserMessageSayTextChannel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(CUserMessageSayTextChannel& a, CUserMessageSayTextChannel& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageSayTextChannel* 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(CUserMessageSayTextChannel* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageSayTextChannel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageSayTextChannel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageSayTextChannel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageSayTextChannel& from) {
    CUserMessageSayTextChannel::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(CUserMessageSayTextChannel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageSayTextChannel";
  }
  protected:
  explicit CUserMessageSayTextChannel(::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 {
    kTextFieldNumber = 3,
    kPlayerFieldNumber = 1,
    kChannelFieldNumber = 2,
  };
  // optional string text = 3;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // optional int32 player = 1;
  bool has_player() const;
  private:
  bool _internal_has_player() const;
  public:
  void clear_player();
  int32_t player() const;
  void set_player(int32_t value);
  private:
  int32_t _internal_player() const;
  void _internal_set_player(int32_t value);
  public:

  // optional int32 channel = 2;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  int32_t channel() const;
  void set_channel(int32_t value);
  private:
  int32_t _internal_channel() const;
  void _internal_set_channel(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageSayTextChannel)
 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 text_;
    int32_t player_;
    int32_t channel_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageColoredText& operator=(const CUserMessageColoredText& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageColoredText& operator=(CUserMessageColoredText&& 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 CUserMessageColoredText& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageColoredText* internal_default_instance() {
    return reinterpret_cast<const CUserMessageColoredText*>(
               &_CUserMessageColoredText_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(CUserMessageColoredText& a, CUserMessageColoredText& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageColoredText* 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(CUserMessageColoredText* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageColoredText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageColoredText>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageColoredText& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageColoredText& from) {
    CUserMessageColoredText::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(CUserMessageColoredText* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageColoredText";
  }
  protected:
  explicit CUserMessageColoredText(::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 {
    kTextFieldNumber = 2,
    kColorFieldNumber = 1,
    kResetFieldNumber = 3,
    kContextValueFieldNumber = 5,
    kContextTeamIdFieldNumber = 6,
    kContextPlayerSlotFieldNumber = 4,
  };
  // optional string text = 2;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // optional uint32 color = 1;
  bool has_color() const;
  private:
  bool _internal_has_color() const;
  public:
  void clear_color();
  uint32_t color() const;
  void set_color(uint32_t value);
  private:
  uint32_t _internal_color() const;
  void _internal_set_color(uint32_t value);
  public:

  // optional bool reset = 3;
  bool has_reset() const;
  private:
  bool _internal_has_reset() const;
  public:
  void clear_reset();
  bool reset() const;
  void set_reset(bool value);
  private:
  bool _internal_reset() const;
  void _internal_set_reset(bool value);
  public:

  // optional int32 context_value = 5;
  bool has_context_value() const;
  private:
  bool _internal_has_context_value() const;
  public:
  void clear_context_value();
  int32_t context_value() const;
  void set_context_value(int32_t value);
  private:
  int32_t _internal_context_value() const;
  void _internal_set_context_value(int32_t value);
  public:

  // optional int32 context_team_id = 6;
  bool has_context_team_id() const;
  private:
  bool _internal_has_context_team_id() const;
  public:
  void clear_context_team_id();
  int32_t context_team_id() const;
  void set_context_team_id(int32_t value);
  private:
  int32_t _internal_context_team_id() const;
  void _internal_set_context_team_id(int32_t value);
  public:

  // optional int32 context_player_slot = 4 [default = -1];
  bool has_context_player_slot() const;
  private:
  bool _internal_has_context_player_slot() const;
  public:
  void clear_context_player_slot();
  int32_t context_player_slot() const;
  void set_context_player_slot(int32_t value);
  private:
  int32_t _internal_context_player_slot() const;
  void _internal_set_context_player_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageColoredText)
 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 text_;
    uint32_t color_;
    bool reset_;
    int32_t context_value_;
    int32_t context_team_id_;
    int32_t context_player_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageItemPickup& operator=(const CUserMessageItemPickup& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageItemPickup& operator=(CUserMessageItemPickup&& 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 CUserMessageItemPickup& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageItemPickup* internal_default_instance() {
    return reinterpret_cast<const CUserMessageItemPickup*>(
               &_CUserMessageItemPickup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(CUserMessageItemPickup& a, CUserMessageItemPickup& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageItemPickup* 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(CUserMessageItemPickup* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageItemPickup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageItemPickup>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageItemPickup& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageItemPickup& from) {
    CUserMessageItemPickup::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(CUserMessageItemPickup* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageItemPickup";
  }
  protected:
  explicit CUserMessageItemPickup(::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 {
    kItemnameFieldNumber = 1,
  };
  // optional string itemname = 1;
  bool has_itemname() const;
  private:
  bool _internal_has_itemname() const;
  public:
  void clear_itemname();
  const std::string& itemname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_itemname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_itemname();
  PROTOBUF_NODISCARD std::string* release_itemname();
  void set_allocated_itemname(std::string* itemname);
  private:
  const std::string& _internal_itemname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_itemname(const std::string& value);
  std::string* _internal_mutable_itemname();
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageItemPickup)
 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 itemname_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageAmmoDenied& operator=(const CUserMessageAmmoDenied& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageAmmoDenied& operator=(CUserMessageAmmoDenied&& 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 CUserMessageAmmoDenied& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageAmmoDenied* internal_default_instance() {
    return reinterpret_cast<const CUserMessageAmmoDenied*>(
               &_CUserMessageAmmoDenied_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(CUserMessageAmmoDenied& a, CUserMessageAmmoDenied& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageAmmoDenied* 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(CUserMessageAmmoDenied* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageAmmoDenied* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageAmmoDenied>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageAmmoDenied& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageAmmoDenied& from) {
    CUserMessageAmmoDenied::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(CUserMessageAmmoDenied* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageAmmoDenied";
  }
  protected:
  explicit CUserMessageAmmoDenied(::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 {
    kAmmoIdFieldNumber = 1,
  };
  // optional uint32 ammo_id = 1;
  bool has_ammo_id() const;
  private:
  bool _internal_has_ammo_id() const;
  public:
  void clear_ammo_id();
  uint32_t ammo_id() const;
  void set_ammo_id(uint32_t value);
  private:
  uint32_t _internal_ammo_id() const;
  void _internal_set_ammo_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageAmmoDenied)
 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 ammo_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageShowMenu& operator=(const CUserMessageShowMenu& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageShowMenu& operator=(CUserMessageShowMenu&& 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 CUserMessageShowMenu& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageShowMenu* internal_default_instance() {
    return reinterpret_cast<const CUserMessageShowMenu*>(
               &_CUserMessageShowMenu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(CUserMessageShowMenu& a, CUserMessageShowMenu& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageShowMenu* 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(CUserMessageShowMenu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageShowMenu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageShowMenu>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageShowMenu& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageShowMenu& from) {
    CUserMessageShowMenu::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(CUserMessageShowMenu* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageShowMenu";
  }
  protected:
  explicit CUserMessageShowMenu(::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 {
    kMenustringFieldNumber = 4,
    kValidslotsFieldNumber = 1,
    kDisplaytimeFieldNumber = 2,
    kNeedmoreFieldNumber = 3,
  };
  // optional string menustring = 4;
  bool has_menustring() const;
  private:
  bool _internal_has_menustring() const;
  public:
  void clear_menustring();
  const std::string& menustring() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_menustring(ArgT0&& arg0, ArgT... args);
  std::string* mutable_menustring();
  PROTOBUF_NODISCARD std::string* release_menustring();
  void set_allocated_menustring(std::string* menustring);
  private:
  const std::string& _internal_menustring() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_menustring(const std::string& value);
  std::string* _internal_mutable_menustring();
  public:

  // optional uint32 validslots = 1;
  bool has_validslots() const;
  private:
  bool _internal_has_validslots() const;
  public:
  void clear_validslots();
  uint32_t validslots() const;
  void set_validslots(uint32_t value);
  private:
  uint32_t _internal_validslots() const;
  void _internal_set_validslots(uint32_t value);
  public:

  // optional uint32 displaytime = 2;
  bool has_displaytime() const;
  private:
  bool _internal_has_displaytime() const;
  public:
  void clear_displaytime();
  uint32_t displaytime() const;
  void set_displaytime(uint32_t value);
  private:
  uint32_t _internal_displaytime() const;
  void _internal_set_displaytime(uint32_t value);
  public:

  // optional bool needmore = 3;
  bool has_needmore() const;
  private:
  bool _internal_has_needmore() const;
  public:
  void clear_needmore();
  bool needmore() const;
  void set_needmore(bool value);
  private:
  bool _internal_needmore() const;
  void _internal_set_needmore(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageShowMenu)
 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 menustring_;
    uint32_t validslots_;
    uint32_t displaytime_;
    bool needmore_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCreditsMsg& operator=(const CUserMessageCreditsMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCreditsMsg& operator=(CUserMessageCreditsMsg&& 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 CUserMessageCreditsMsg& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCreditsMsg* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCreditsMsg*>(
               &_CUserMessageCreditsMsg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(CUserMessageCreditsMsg& a, CUserMessageCreditsMsg& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCreditsMsg* 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(CUserMessageCreditsMsg* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCreditsMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCreditsMsg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCreditsMsg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCreditsMsg& from) {
    CUserMessageCreditsMsg::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(CUserMessageCreditsMsg* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCreditsMsg";
  }
  protected:
  explicit CUserMessageCreditsMsg(::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 {
    kLogoLengthFieldNumber = 2,
    kRolltypeFieldNumber = 1,
  };
  // optional float logo_length = 2;
  bool has_logo_length() const;
  private:
  bool _internal_has_logo_length() const;
  public:
  void clear_logo_length();
  float logo_length() const;
  void set_logo_length(float value);
  private:
  float _internal_logo_length() const;
  void _internal_set_logo_length(float value);
  public:

  // optional .eRollType rolltype = 1 [default = ROLL_NONE];
  bool has_rolltype() const;
  private:
  bool _internal_has_rolltype() const;
  public:
  void clear_rolltype();
  ::eRollType rolltype() const;
  void set_rolltype(::eRollType value);
  private:
  ::eRollType _internal_rolltype() const;
  void _internal_set_rolltype(::eRollType value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCreditsMsg)
 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_;
    float logo_length_;
    int rolltype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessagePlayJingle& operator=(const CEntityMessagePlayJingle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessagePlayJingle& operator=(CEntityMessagePlayJingle&& 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 CEntityMessagePlayJingle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessagePlayJingle* internal_default_instance() {
    return reinterpret_cast<const CEntityMessagePlayJingle*>(
               &_CEntityMessagePlayJingle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(CEntityMessagePlayJingle& a, CEntityMessagePlayJingle& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessagePlayJingle* 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(CEntityMessagePlayJingle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessagePlayJingle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessagePlayJingle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessagePlayJingle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessagePlayJingle& from) {
    CEntityMessagePlayJingle::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(CEntityMessagePlayJingle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessagePlayJingle";
  }
  protected:
  explicit CEntityMessagePlayJingle(::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 {
    kEntityMsgFieldNumber = 1,
  };
  // optional .CEntityMsg entity_msg = 1;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // @@protoc_insertion_point(class_scope:CEntityMessagePlayJingle)
 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_;
    ::CEntityMsg* entity_msg_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessageScreenOverlay& operator=(const CEntityMessageScreenOverlay& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessageScreenOverlay& operator=(CEntityMessageScreenOverlay&& 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 CEntityMessageScreenOverlay& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessageScreenOverlay* internal_default_instance() {
    return reinterpret_cast<const CEntityMessageScreenOverlay*>(
               &_CEntityMessageScreenOverlay_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(CEntityMessageScreenOverlay& a, CEntityMessageScreenOverlay& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessageScreenOverlay* 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(CEntityMessageScreenOverlay* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessageScreenOverlay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessageScreenOverlay>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessageScreenOverlay& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessageScreenOverlay& from) {
    CEntityMessageScreenOverlay::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(CEntityMessageScreenOverlay* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessageScreenOverlay";
  }
  protected:
  explicit CEntityMessageScreenOverlay(::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 {
    kEntityMsgFieldNumber = 2,
    kStartEffectFieldNumber = 1,
  };
  // optional .CEntityMsg entity_msg = 2;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // optional bool start_effect = 1;
  bool has_start_effect() const;
  private:
  bool _internal_has_start_effect() const;
  public:
  void clear_start_effect();
  bool start_effect() const;
  void set_start_effect(bool value);
  private:
  bool _internal_start_effect() const;
  void _internal_set_start_effect(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CEntityMessageScreenOverlay)
 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_;
    ::CEntityMsg* entity_msg_;
    bool start_effect_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessageRemoveAllDecals& operator=(const CEntityMessageRemoveAllDecals& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessageRemoveAllDecals& operator=(CEntityMessageRemoveAllDecals&& 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 CEntityMessageRemoveAllDecals& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessageRemoveAllDecals* internal_default_instance() {
    return reinterpret_cast<const CEntityMessageRemoveAllDecals*>(
               &_CEntityMessageRemoveAllDecals_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(CEntityMessageRemoveAllDecals& a, CEntityMessageRemoveAllDecals& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessageRemoveAllDecals* 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(CEntityMessageRemoveAllDecals* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessageRemoveAllDecals* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessageRemoveAllDecals>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessageRemoveAllDecals& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessageRemoveAllDecals& from) {
    CEntityMessageRemoveAllDecals::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(CEntityMessageRemoveAllDecals* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessageRemoveAllDecals";
  }
  protected:
  explicit CEntityMessageRemoveAllDecals(::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 {
    kEntityMsgFieldNumber = 2,
    kRemoveDecalsFieldNumber = 1,
  };
  // optional .CEntityMsg entity_msg = 2;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // optional bool remove_decals = 1;
  bool has_remove_decals() const;
  private:
  bool _internal_has_remove_decals() const;
  public:
  void clear_remove_decals();
  bool remove_decals() const;
  void set_remove_decals(bool value);
  private:
  bool _internal_remove_decals() const;
  void _internal_set_remove_decals(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CEntityMessageRemoveAllDecals)
 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_;
    ::CEntityMsg* entity_msg_;
    bool remove_decals_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessagePropagateForce& operator=(const CEntityMessagePropagateForce& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessagePropagateForce& operator=(CEntityMessagePropagateForce&& 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 CEntityMessagePropagateForce& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessagePropagateForce* internal_default_instance() {
    return reinterpret_cast<const CEntityMessagePropagateForce*>(
               &_CEntityMessagePropagateForce_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(CEntityMessagePropagateForce& a, CEntityMessagePropagateForce& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessagePropagateForce* 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(CEntityMessagePropagateForce* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessagePropagateForce* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessagePropagateForce>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessagePropagateForce& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessagePropagateForce& from) {
    CEntityMessagePropagateForce::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(CEntityMessagePropagateForce* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessagePropagateForce";
  }
  protected:
  explicit CEntityMessagePropagateForce(::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 {
    kImpulseFieldNumber = 1,
    kEntityMsgFieldNumber = 2,
  };
  // optional .CMsgVector impulse = 1;
  bool has_impulse() const;
  private:
  bool _internal_has_impulse() const;
  public:
  void clear_impulse();
  const ::CMsgVector& impulse() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_impulse();
  ::CMsgVector* mutable_impulse();
  void set_allocated_impulse(::CMsgVector* impulse);
  private:
  const ::CMsgVector& _internal_impulse() const;
  ::CMsgVector* _internal_mutable_impulse();
  public:
  void unsafe_arena_set_allocated_impulse(
      ::CMsgVector* impulse);
  ::CMsgVector* unsafe_arena_release_impulse();

  // optional .CEntityMsg entity_msg = 2;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // @@protoc_insertion_point(class_scope:CEntityMessagePropagateForce)
 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_;
    ::CMsgVector* impulse_;
    ::CEntityMsg* entity_msg_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessageDoSpark& operator=(const CEntityMessageDoSpark& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessageDoSpark& operator=(CEntityMessageDoSpark&& 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 CEntityMessageDoSpark& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessageDoSpark* internal_default_instance() {
    return reinterpret_cast<const CEntityMessageDoSpark*>(
               &_CEntityMessageDoSpark_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(CEntityMessageDoSpark& a, CEntityMessageDoSpark& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessageDoSpark* 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(CEntityMessageDoSpark* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessageDoSpark* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessageDoSpark>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessageDoSpark& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessageDoSpark& from) {
    CEntityMessageDoSpark::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(CEntityMessageDoSpark* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessageDoSpark";
  }
  protected:
  explicit CEntityMessageDoSpark(::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 {
    kOriginFieldNumber = 1,
    kEntityMsgFieldNumber = 8,
    kRadiusFieldNumber = 3,
    kColorFieldNumber = 4,
    kBeamsFieldNumber = 5,
    kThickFieldNumber = 6,
    kDurationFieldNumber = 7,
    kEntityindexFieldNumber = 2,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CEntityMsg entity_msg = 8;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // optional float radius = 3;
  bool has_radius() const;
  private:
  bool _internal_has_radius() const;
  public:
  void clear_radius();
  float radius() const;
  void set_radius(float value);
  private:
  float _internal_radius() const;
  void _internal_set_radius(float value);
  public:

  // optional fixed32 color = 4;
  bool has_color() const;
  private:
  bool _internal_has_color() const;
  public:
  void clear_color();
  uint32_t color() const;
  void set_color(uint32_t value);
  private:
  uint32_t _internal_color() const;
  void _internal_set_color(uint32_t value);
  public:

  // optional uint32 beams = 5;
  bool has_beams() const;
  private:
  bool _internal_has_beams() const;
  public:
  void clear_beams();
  uint32_t beams() const;
  void set_beams(uint32_t value);
  private:
  uint32_t _internal_beams() const;
  void _internal_set_beams(uint32_t value);
  public:

  // optional float thick = 6;
  bool has_thick() const;
  private:
  bool _internal_has_thick() const;
  public:
  void clear_thick();
  float thick() const;
  void set_thick(float value);
  private:
  float _internal_thick() const;
  void _internal_set_thick(float value);
  public:

  // optional float duration = 7;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional int32 entityindex = 2 [default = -1];
  bool has_entityindex() const;
  private:
  bool _internal_has_entityindex() const;
  public:
  void clear_entityindex();
  int32_t entityindex() const;
  void set_entityindex(int32_t value);
  private:
  int32_t _internal_entityindex() const;
  void _internal_set_entityindex(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CEntityMessageDoSpark)
 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_;
    ::CMsgVector* origin_;
    ::CEntityMsg* entity_msg_;
    float radius_;
    uint32_t color_;
    uint32_t beams_;
    float thick_;
    float duration_;
    int32_t entityindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CEntityMessageFixAngle& operator=(const CEntityMessageFixAngle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CEntityMessageFixAngle& operator=(CEntityMessageFixAngle&& 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 CEntityMessageFixAngle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CEntityMessageFixAngle* internal_default_instance() {
    return reinterpret_cast<const CEntityMessageFixAngle*>(
               &_CEntityMessageFixAngle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(CEntityMessageFixAngle& a, CEntityMessageFixAngle& b) {
    a.Swap(&b);
  }
  inline void Swap(CEntityMessageFixAngle* 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(CEntityMessageFixAngle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CEntityMessageFixAngle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CEntityMessageFixAngle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CEntityMessageFixAngle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CEntityMessageFixAngle& from) {
    CEntityMessageFixAngle::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(CEntityMessageFixAngle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CEntityMessageFixAngle";
  }
  protected:
  explicit CEntityMessageFixAngle(::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 {
    kAngleFieldNumber = 2,
    kEntityMsgFieldNumber = 3,
    kRelativeFieldNumber = 1,
  };
  // optional .CMsgQAngle angle = 2;
  bool has_angle() const;
  private:
  bool _internal_has_angle() const;
  public:
  void clear_angle();
  const ::CMsgQAngle& angle() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angle();
  ::CMsgQAngle* mutable_angle();
  void set_allocated_angle(::CMsgQAngle* angle);
  private:
  const ::CMsgQAngle& _internal_angle() const;
  ::CMsgQAngle* _internal_mutable_angle();
  public:
  void unsafe_arena_set_allocated_angle(
      ::CMsgQAngle* angle);
  ::CMsgQAngle* unsafe_arena_release_angle();

  // optional .CEntityMsg entity_msg = 3;
  bool has_entity_msg() const;
  private:
  bool _internal_has_entity_msg() const;
  public:
  void clear_entity_msg();
  const ::CEntityMsg& entity_msg() const;
  PROTOBUF_NODISCARD ::CEntityMsg* release_entity_msg();
  ::CEntityMsg* mutable_entity_msg();
  void set_allocated_entity_msg(::CEntityMsg* entity_msg);
  private:
  const ::CEntityMsg& _internal_entity_msg() const;
  ::CEntityMsg* _internal_mutable_entity_msg();
  public:
  void unsafe_arena_set_allocated_entity_msg(
      ::CEntityMsg* entity_msg);
  ::CEntityMsg* unsafe_arena_release_entity_msg();

  // optional bool relative = 1;
  bool has_relative() const;
  private:
  bool _internal_has_relative() const;
  public:
  void clear_relative();
  bool relative() const;
  void set_relative(bool value);
  private:
  bool _internal_relative() const;
  void _internal_set_relative(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CEntityMessageFixAngle)
 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_;
    ::CMsgQAngle* angle_;
    ::CEntityMsg* entity_msg_;
    bool relative_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCameraTransition_Transition_DataDriven& operator=(const CUserMessageCameraTransition_Transition_DataDriven& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCameraTransition_Transition_DataDriven& operator=(CUserMessageCameraTransition_Transition_DataDriven&& 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 CUserMessageCameraTransition_Transition_DataDriven& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCameraTransition_Transition_DataDriven* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCameraTransition_Transition_DataDriven*>(
               &_CUserMessageCameraTransition_Transition_DataDriven_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(CUserMessageCameraTransition_Transition_DataDriven& a, CUserMessageCameraTransition_Transition_DataDriven& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCameraTransition_Transition_DataDriven* 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(CUserMessageCameraTransition_Transition_DataDriven* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCameraTransition_Transition_DataDriven* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCameraTransition_Transition_DataDriven>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCameraTransition_Transition_DataDriven& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCameraTransition_Transition_DataDriven& from) {
    CUserMessageCameraTransition_Transition_DataDriven::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(CUserMessageCameraTransition_Transition_DataDriven* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCameraTransition.Transition_DataDriven";
  }
  protected:
  explicit CUserMessageCameraTransition_Transition_DataDriven(::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 {
    kFilenameFieldNumber = 1,
    kDurationFieldNumber = 3,
    kAttachEntIndexFieldNumber = 2,
  };
  // optional string filename = 1;
  bool has_filename() const;
  private:
  bool _internal_has_filename() const;
  public:
  void clear_filename();
  const std::string& filename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // optional float duration = 3;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // optional int32 attach_ent_index = 2 [default = -1];
  bool has_attach_ent_index() const;
  private:
  bool _internal_has_attach_ent_index() const;
  public:
  void clear_attach_ent_index();
  int32_t attach_ent_index() const;
  void set_attach_ent_index(int32_t value);
  private:
  int32_t _internal_attach_ent_index() const;
  void _internal_set_attach_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCameraTransition.Transition_DataDriven)
 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 filename_;
    float duration_;
    int32_t attach_ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageCameraTransition& operator=(const CUserMessageCameraTransition& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageCameraTransition& operator=(CUserMessageCameraTransition&& 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 CUserMessageCameraTransition& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageCameraTransition* internal_default_instance() {
    return reinterpret_cast<const CUserMessageCameraTransition*>(
               &_CUserMessageCameraTransition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(CUserMessageCameraTransition& a, CUserMessageCameraTransition& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageCameraTransition* 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(CUserMessageCameraTransition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageCameraTransition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageCameraTransition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageCameraTransition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageCameraTransition& from) {
    CUserMessageCameraTransition::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(CUserMessageCameraTransition* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageCameraTransition";
  }
  protected:
  explicit CUserMessageCameraTransition(::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 CUserMessageCameraTransition_Transition_DataDriven Transition_DataDriven;

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

  enum : int {
    kParamsDataDrivenFieldNumber = 3,
    kCameraTypeFieldNumber = 1,
    kDurationFieldNumber = 2,
  };
  // optional .CUserMessageCameraTransition.Transition_DataDriven params_data_driven = 3;
  bool has_params_data_driven() const;
  private:
  bool _internal_has_params_data_driven() const;
  public:
  void clear_params_data_driven();
  const ::CUserMessageCameraTransition_Transition_DataDriven& params_data_driven() const;
  PROTOBUF_NODISCARD ::CUserMessageCameraTransition_Transition_DataDriven* release_params_data_driven();
  ::CUserMessageCameraTransition_Transition_DataDriven* mutable_params_data_driven();
  void set_allocated_params_data_driven(::CUserMessageCameraTransition_Transition_DataDriven* params_data_driven);
  private:
  const ::CUserMessageCameraTransition_Transition_DataDriven& _internal_params_data_driven() const;
  ::CUserMessageCameraTransition_Transition_DataDriven* _internal_mutable_params_data_driven();
  public:
  void unsafe_arena_set_allocated_params_data_driven(
      ::CUserMessageCameraTransition_Transition_DataDriven* params_data_driven);
  ::CUserMessageCameraTransition_Transition_DataDriven* unsafe_arena_release_params_data_driven();

  // optional uint32 camera_type = 1;
  bool has_camera_type() const;
  private:
  bool _internal_has_camera_type() const;
  public:
  void clear_camera_type();
  uint32_t camera_type() const;
  void set_camera_type(uint32_t value);
  private:
  uint32_t _internal_camera_type() const;
  void _internal_set_camera_type(uint32_t value);
  public:

  // optional float duration = 2;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageCameraTransition)
 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_;
    ::CUserMessageCameraTransition_Transition_DataDriven* params_data_driven_;
    uint32_t camera_type_;
    float duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ReleaseParticleIndex& operator=(const CUserMsg_ParticleManager_ReleaseParticleIndex& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ReleaseParticleIndex& operator=(CUserMsg_ParticleManager_ReleaseParticleIndex&& 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 CUserMsg_ParticleManager_ReleaseParticleIndex& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ReleaseParticleIndex* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ReleaseParticleIndex*>(
               &_CUserMsg_ParticleManager_ReleaseParticleIndex_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(CUserMsg_ParticleManager_ReleaseParticleIndex& a, CUserMsg_ParticleManager_ReleaseParticleIndex& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ReleaseParticleIndex* 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(CUserMsg_ParticleManager_ReleaseParticleIndex* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ReleaseParticleIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ReleaseParticleIndex>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMsg_ParticleManager_ReleaseParticleIndex& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMsg_ParticleManager_ReleaseParticleIndex& 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 "CUserMsg_ParticleManager.ReleaseParticleIndex";
  }
  protected:
  explicit CUserMsg_ParticleManager_ReleaseParticleIndex(::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:CUserMsg_ParticleManager.ReleaseParticleIndex)
 private:
  class _Internal;

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

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

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

  inline CUserMsg_ParticleManager_CreateParticle& operator=(const CUserMsg_ParticleManager_CreateParticle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_CreateParticle& operator=(CUserMsg_ParticleManager_CreateParticle&& 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 CUserMsg_ParticleManager_CreateParticle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_CreateParticle* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_CreateParticle*>(
               &_CUserMsg_ParticleManager_CreateParticle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(CUserMsg_ParticleManager_CreateParticle& a, CUserMsg_ParticleManager_CreateParticle& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_CreateParticle* 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(CUserMsg_ParticleManager_CreateParticle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_CreateParticle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_CreateParticle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_CreateParticle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_CreateParticle& from) {
    CUserMsg_ParticleManager_CreateParticle::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(CUserMsg_ParticleManager_CreateParticle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.CreateParticle";
  }
  protected:
  explicit CUserMsg_ParticleManager_CreateParticle(::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 {
    kControlPointConfigurationFieldNumber = 7,
    kAggregationPositionFieldNumber = 10,
    kParticleNameIndexFieldNumber = 1,
    kAttachTypeFieldNumber = 2,
    kTeamBehaviorFieldNumber = 6,
    kApplyVoiceBanRulesFieldNumber = 5,
    kClusterFieldNumber = 8,
    kEndcapTimeFieldNumber = 9,
    kEntityHandleFieldNumber = 3,
    kEntityHandleForModifiersFieldNumber = 4,
  };
  // optional string control_point_configuration = 7;
  bool has_control_point_configuration() const;
  private:
  bool _internal_has_control_point_configuration() const;
  public:
  void clear_control_point_configuration();
  const std::string& control_point_configuration() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_control_point_configuration(ArgT0&& arg0, ArgT... args);
  std::string* mutable_control_point_configuration();
  PROTOBUF_NODISCARD std::string* release_control_point_configuration();
  void set_allocated_control_point_configuration(std::string* control_point_configuration);
  private:
  const std::string& _internal_control_point_configuration() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_control_point_configuration(const std::string& value);
  std::string* _internal_mutable_control_point_configuration();
  public:

  // optional .CMsgVector aggregation_position = 10;
  bool has_aggregation_position() const;
  private:
  bool _internal_has_aggregation_position() const;
  public:
  void clear_aggregation_position();
  const ::CMsgVector& aggregation_position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_aggregation_position();
  ::CMsgVector* mutable_aggregation_position();
  void set_allocated_aggregation_position(::CMsgVector* aggregation_position);
  private:
  const ::CMsgVector& _internal_aggregation_position() const;
  ::CMsgVector* _internal_mutable_aggregation_position();
  public:
  void unsafe_arena_set_allocated_aggregation_position(
      ::CMsgVector* aggregation_position);
  ::CMsgVector* unsafe_arena_release_aggregation_position();

  // optional fixed64 particle_name_index = 1;
  bool has_particle_name_index() const;
  private:
  bool _internal_has_particle_name_index() const;
  public:
  void clear_particle_name_index();
  uint64_t particle_name_index() const;
  void set_particle_name_index(uint64_t value);
  private:
  uint64_t _internal_particle_name_index() const;
  void _internal_set_particle_name_index(uint64_t value);
  public:

  // optional int32 attach_type = 2;
  bool has_attach_type() const;
  private:
  bool _internal_has_attach_type() const;
  public:
  void clear_attach_type();
  int32_t attach_type() const;
  void set_attach_type(int32_t value);
  private:
  int32_t _internal_attach_type() const;
  void _internal_set_attach_type(int32_t value);
  public:

  // optional int32 team_behavior = 6;
  bool has_team_behavior() const;
  private:
  bool _internal_has_team_behavior() const;
  public:
  void clear_team_behavior();
  int32_t team_behavior() const;
  void set_team_behavior(int32_t value);
  private:
  int32_t _internal_team_behavior() const;
  void _internal_set_team_behavior(int32_t value);
  public:

  // optional bool apply_voice_ban_rules = 5;
  bool has_apply_voice_ban_rules() const;
  private:
  bool _internal_has_apply_voice_ban_rules() const;
  public:
  void clear_apply_voice_ban_rules();
  bool apply_voice_ban_rules() const;
  void set_apply_voice_ban_rules(bool value);
  private:
  bool _internal_apply_voice_ban_rules() const;
  void _internal_set_apply_voice_ban_rules(bool value);
  public:

  // optional bool cluster = 8;
  bool has_cluster() const;
  private:
  bool _internal_has_cluster() const;
  public:
  void clear_cluster();
  bool cluster() const;
  void set_cluster(bool value);
  private:
  bool _internal_cluster() const;
  void _internal_set_cluster(bool value);
  public:

  // optional float endcap_time = 9;
  bool has_endcap_time() const;
  private:
  bool _internal_has_endcap_time() const;
  public:
  void clear_endcap_time();
  float endcap_time() const;
  void set_endcap_time(float value);
  private:
  float _internal_endcap_time() const;
  void _internal_set_endcap_time(float value);
  public:

  // optional uint32 entity_handle = 3 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // optional uint32 entity_handle_for_modifiers = 4 [default = 16777215];
  bool has_entity_handle_for_modifiers() const;
  private:
  bool _internal_has_entity_handle_for_modifiers() const;
  public:
  void clear_entity_handle_for_modifiers();
  uint32_t entity_handle_for_modifiers() const;
  void set_entity_handle_for_modifiers(uint32_t value);
  private:
  uint32_t _internal_entity_handle_for_modifiers() const;
  void _internal_set_entity_handle_for_modifiers(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.CreateParticle)
 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 control_point_configuration_;
    ::CMsgVector* aggregation_position_;
    uint64_t particle_name_index_;
    int32_t attach_type_;
    int32_t team_behavior_;
    bool apply_voice_ban_rules_;
    bool cluster_;
    float endcap_time_;
    uint32_t entity_handle_;
    uint32_t entity_handle_for_modifiers_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_DestroyParticle& operator=(const CUserMsg_ParticleManager_DestroyParticle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_DestroyParticle& operator=(CUserMsg_ParticleManager_DestroyParticle&& 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 CUserMsg_ParticleManager_DestroyParticle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_DestroyParticle* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_DestroyParticle*>(
               &_CUserMsg_ParticleManager_DestroyParticle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(CUserMsg_ParticleManager_DestroyParticle& a, CUserMsg_ParticleManager_DestroyParticle& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_DestroyParticle* 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(CUserMsg_ParticleManager_DestroyParticle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_DestroyParticle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_DestroyParticle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_DestroyParticle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_DestroyParticle& from) {
    CUserMsg_ParticleManager_DestroyParticle::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(CUserMsg_ParticleManager_DestroyParticle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.DestroyParticle";
  }
  protected:
  explicit CUserMsg_ParticleManager_DestroyParticle(::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 {
    kDestroyImmediatelyFieldNumber = 1,
  };
  // optional bool destroy_immediately = 1;
  bool has_destroy_immediately() const;
  private:
  bool _internal_has_destroy_immediately() const;
  public:
  void clear_destroy_immediately();
  bool destroy_immediately() const;
  void set_destroy_immediately(bool value);
  private:
  bool _internal_destroy_immediately() const;
  void _internal_set_destroy_immediately(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.DestroyParticle)
 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 destroy_immediately_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_DestroyParticleInvolving& operator=(const CUserMsg_ParticleManager_DestroyParticleInvolving& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_DestroyParticleInvolving& operator=(CUserMsg_ParticleManager_DestroyParticleInvolving&& 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 CUserMsg_ParticleManager_DestroyParticleInvolving& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_DestroyParticleInvolving* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_DestroyParticleInvolving*>(
               &_CUserMsg_ParticleManager_DestroyParticleInvolving_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(CUserMsg_ParticleManager_DestroyParticleInvolving& a, CUserMsg_ParticleManager_DestroyParticleInvolving& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_DestroyParticleInvolving* 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(CUserMsg_ParticleManager_DestroyParticleInvolving* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_DestroyParticleInvolving* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_DestroyParticleInvolving>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_DestroyParticleInvolving& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_DestroyParticleInvolving& from) {
    CUserMsg_ParticleManager_DestroyParticleInvolving::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(CUserMsg_ParticleManager_DestroyParticleInvolving* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.DestroyParticleInvolving";
  }
  protected:
  explicit CUserMsg_ParticleManager_DestroyParticleInvolving(::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 {
    kDestroyImmediatelyFieldNumber = 1,
    kEntityHandleFieldNumber = 3,
  };
  // optional bool destroy_immediately = 1;
  bool has_destroy_immediately() const;
  private:
  bool _internal_has_destroy_immediately() const;
  public:
  void clear_destroy_immediately();
  bool destroy_immediately() const;
  void set_destroy_immediately(bool value);
  private:
  bool _internal_destroy_immediately() const;
  void _internal_set_destroy_immediately(bool value);
  public:

  // optional uint32 entity_handle = 3 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.DestroyParticleInvolving)
 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 destroy_immediately_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_DestroyParticleNamed& operator=(const CUserMsg_ParticleManager_DestroyParticleNamed& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_DestroyParticleNamed& operator=(CUserMsg_ParticleManager_DestroyParticleNamed&& 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 CUserMsg_ParticleManager_DestroyParticleNamed& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_DestroyParticleNamed* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_DestroyParticleNamed*>(
               &_CUserMsg_ParticleManager_DestroyParticleNamed_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(CUserMsg_ParticleManager_DestroyParticleNamed& a, CUserMsg_ParticleManager_DestroyParticleNamed& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_DestroyParticleNamed* 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(CUserMsg_ParticleManager_DestroyParticleNamed* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_DestroyParticleNamed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_DestroyParticleNamed>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_DestroyParticleNamed& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_DestroyParticleNamed& from) {
    CUserMsg_ParticleManager_DestroyParticleNamed::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(CUserMsg_ParticleManager_DestroyParticleNamed* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.DestroyParticleNamed";
  }
  protected:
  explicit CUserMsg_ParticleManager_DestroyParticleNamed(::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 {
    kParticleNameIndexFieldNumber = 1,
    kDestroyImmediatelyFieldNumber = 3,
    kPlayEndcapFieldNumber = 4,
    kEntityHandleFieldNumber = 2,
  };
  // optional fixed64 particle_name_index = 1;
  bool has_particle_name_index() const;
  private:
  bool _internal_has_particle_name_index() const;
  public:
  void clear_particle_name_index();
  uint64_t particle_name_index() const;
  void set_particle_name_index(uint64_t value);
  private:
  uint64_t _internal_particle_name_index() const;
  void _internal_set_particle_name_index(uint64_t value);
  public:

  // optional bool destroy_immediately = 3;
  bool has_destroy_immediately() const;
  private:
  bool _internal_has_destroy_immediately() const;
  public:
  void clear_destroy_immediately();
  bool destroy_immediately() const;
  void set_destroy_immediately(bool value);
  private:
  bool _internal_destroy_immediately() const;
  void _internal_set_destroy_immediately(bool value);
  public:

  // optional bool play_endcap = 4;
  bool has_play_endcap() const;
  private:
  bool _internal_has_play_endcap() const;
  public:
  void clear_play_endcap();
  bool play_endcap() const;
  void set_play_endcap(bool value);
  private:
  bool _internal_play_endcap() const;
  void _internal_set_play_endcap(bool value);
  public:

  // optional uint32 entity_handle = 2 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.DestroyParticleNamed)
 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 particle_name_index_;
    bool destroy_immediately_;
    bool play_endcap_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& operator=(const CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& operator=(CUserMsg_ParticleManager_UpdateParticle_OBSOLETE&& 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 CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticle_OBSOLETE*>(
               &_CUserMsg_ParticleManager_UpdateParticle_OBSOLETE_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& a, CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* 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(CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticle_OBSOLETE>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& from) {
    CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::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(CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticle_OBSOLETE";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticle_OBSOLETE(::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 {
    kPositionFieldNumber = 2,
    kControlPointFieldNumber = 1,
  };
  // optional .CMsgVector position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::CMsgVector& position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_position();
  ::CMsgVector* mutable_position();
  void set_allocated_position(::CMsgVector* position);
  private:
  const ::CMsgVector& _internal_position() const;
  ::CMsgVector* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::CMsgVector* position);
  ::CMsgVector* unsafe_arena_release_position();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE)
 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_;
    ::CMsgVector* position_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& operator=(const CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& operator=(CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE&& 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 CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE*>(
               &_CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& a, CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* 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(CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& from) {
    CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::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(CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE(::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 {
    kForwardFieldNumber = 2,
    kControlPointFieldNumber = 1,
  };
  // optional .CMsgVector forward = 2;
  bool has_forward() const;
  private:
  bool _internal_has_forward() const;
  public:
  void clear_forward();
  const ::CMsgVector& forward() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_forward();
  ::CMsgVector* mutable_forward();
  void set_allocated_forward(::CMsgVector* forward);
  private:
  const ::CMsgVector& _internal_forward() const;
  ::CMsgVector* _internal_mutable_forward();
  public:
  void unsafe_arena_set_allocated_forward(
      ::CMsgVector* forward);
  ::CMsgVector* unsafe_arena_release_forward();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE)
 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_;
    ::CMsgVector* forward_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& operator=(const CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& operator=(CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE&& 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 CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE*>(
               &_CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& a, CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* 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(CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& from) {
    CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::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(CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE(::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 {
    kForwardFieldNumber = 2,
    kDeprecatedRightFieldNumber = 3,
    kUpFieldNumber = 4,
    kLeftFieldNumber = 5,
    kControlPointFieldNumber = 1,
  };
  // optional .CMsgVector forward = 2;
  bool has_forward() const;
  private:
  bool _internal_has_forward() const;
  public:
  void clear_forward();
  const ::CMsgVector& forward() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_forward();
  ::CMsgVector* mutable_forward();
  void set_allocated_forward(::CMsgVector* forward);
  private:
  const ::CMsgVector& _internal_forward() const;
  ::CMsgVector* _internal_mutable_forward();
  public:
  void unsafe_arena_set_allocated_forward(
      ::CMsgVector* forward);
  ::CMsgVector* unsafe_arena_release_forward();

  // optional .CMsgVector deprecated_right = 3;
  bool has_deprecated_right() const;
  private:
  bool _internal_has_deprecated_right() const;
  public:
  void clear_deprecated_right();
  const ::CMsgVector& deprecated_right() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_deprecated_right();
  ::CMsgVector* mutable_deprecated_right();
  void set_allocated_deprecated_right(::CMsgVector* deprecated_right);
  private:
  const ::CMsgVector& _internal_deprecated_right() const;
  ::CMsgVector* _internal_mutable_deprecated_right();
  public:
  void unsafe_arena_set_allocated_deprecated_right(
      ::CMsgVector* deprecated_right);
  ::CMsgVector* unsafe_arena_release_deprecated_right();

  // optional .CMsgVector up = 4;
  bool has_up() const;
  private:
  bool _internal_has_up() const;
  public:
  void clear_up();
  const ::CMsgVector& up() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_up();
  ::CMsgVector* mutable_up();
  void set_allocated_up(::CMsgVector* up);
  private:
  const ::CMsgVector& _internal_up() const;
  ::CMsgVector* _internal_mutable_up();
  public:
  void unsafe_arena_set_allocated_up(
      ::CMsgVector* up);
  ::CMsgVector* unsafe_arena_release_up();

  // optional .CMsgVector left = 5;
  bool has_left() const;
  private:
  bool _internal_has_left() const;
  public:
  void clear_left();
  const ::CMsgVector& left() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_left();
  ::CMsgVector* mutable_left();
  void set_allocated_left(::CMsgVector* left);
  private:
  const ::CMsgVector& _internal_left() const;
  ::CMsgVector* _internal_mutable_left();
  public:
  void unsafe_arena_set_allocated_left(
      ::CMsgVector* left);
  ::CMsgVector* unsafe_arena_release_left();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE)
 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_;
    ::CMsgVector* forward_;
    ::CMsgVector* deprecated_right_;
    ::CMsgVector* up_;
    ::CMsgVector* left_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleTransform& operator=(const CUserMsg_ParticleManager_UpdateParticleTransform& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleTransform& operator=(CUserMsg_ParticleManager_UpdateParticleTransform&& 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 CUserMsg_ParticleManager_UpdateParticleTransform& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleTransform* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleTransform*>(
               &_CUserMsg_ParticleManager_UpdateParticleTransform_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleTransform& a, CUserMsg_ParticleManager_UpdateParticleTransform& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleTransform* 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(CUserMsg_ParticleManager_UpdateParticleTransform* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleTransform* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleTransform>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleTransform& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleTransform& from) {
    CUserMsg_ParticleManager_UpdateParticleTransform::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(CUserMsg_ParticleManager_UpdateParticleTransform* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleTransform";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleTransform(::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 {
    kPositionFieldNumber = 2,
    kOrientationFieldNumber = 3,
    kControlPointFieldNumber = 1,
    kInterpolationIntervalFieldNumber = 4,
  };
  // optional .CMsgVector position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::CMsgVector& position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_position();
  ::CMsgVector* mutable_position();
  void set_allocated_position(::CMsgVector* position);
  private:
  const ::CMsgVector& _internal_position() const;
  ::CMsgVector* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::CMsgVector* position);
  ::CMsgVector* unsafe_arena_release_position();

  // optional .CMsgQuaternion orientation = 3;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::CMsgQuaternion& orientation() const;
  PROTOBUF_NODISCARD ::CMsgQuaternion* release_orientation();
  ::CMsgQuaternion* mutable_orientation();
  void set_allocated_orientation(::CMsgQuaternion* orientation);
  private:
  const ::CMsgQuaternion& _internal_orientation() const;
  ::CMsgQuaternion* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::CMsgQuaternion* orientation);
  ::CMsgQuaternion* unsafe_arena_release_orientation();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // optional float interpolation_interval = 4;
  bool has_interpolation_interval() const;
  private:
  bool _internal_has_interpolation_interval() const;
  public:
  void clear_interpolation_interval();
  float interpolation_interval() const;
  void set_interpolation_interval(float value);
  private:
  float _internal_interpolation_interval() const;
  void _internal_set_interpolation_interval(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleTransform)
 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_;
    ::CMsgVector* position_;
    ::CMsgQuaternion* orientation_;
    int32_t control_point_;
    float interpolation_interval_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleFallback& operator=(const CUserMsg_ParticleManager_UpdateParticleFallback& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleFallback& operator=(CUserMsg_ParticleManager_UpdateParticleFallback&& 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 CUserMsg_ParticleManager_UpdateParticleFallback& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleFallback* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleFallback*>(
               &_CUserMsg_ParticleManager_UpdateParticleFallback_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleFallback& a, CUserMsg_ParticleManager_UpdateParticleFallback& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleFallback* 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(CUserMsg_ParticleManager_UpdateParticleFallback* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleFallback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleFallback>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleFallback& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleFallback& from) {
    CUserMsg_ParticleManager_UpdateParticleFallback::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(CUserMsg_ParticleManager_UpdateParticleFallback* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleFallback";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleFallback(::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 {
    kPositionFieldNumber = 2,
    kControlPointFieldNumber = 1,
  };
  // optional .CMsgVector position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::CMsgVector& position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_position();
  ::CMsgVector* mutable_position();
  void set_allocated_position(::CMsgVector* position);
  private:
  const ::CMsgVector& _internal_position() const;
  ::CMsgVector* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::CMsgVector* position);
  ::CMsgVector* unsafe_arena_release_position();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleFallback)
 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_;
    ::CMsgVector* position_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleOffset& operator=(const CUserMsg_ParticleManager_UpdateParticleOffset& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleOffset& operator=(CUserMsg_ParticleManager_UpdateParticleOffset&& 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 CUserMsg_ParticleManager_UpdateParticleOffset& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleOffset* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleOffset*>(
               &_CUserMsg_ParticleManager_UpdateParticleOffset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleOffset& a, CUserMsg_ParticleManager_UpdateParticleOffset& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleOffset* 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(CUserMsg_ParticleManager_UpdateParticleOffset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleOffset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleOffset>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleOffset& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleOffset& from) {
    CUserMsg_ParticleManager_UpdateParticleOffset::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(CUserMsg_ParticleManager_UpdateParticleOffset* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleOffset";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleOffset(::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 {
    kOriginOffsetFieldNumber = 2,
    kAngleOffsetFieldNumber = 3,
    kControlPointFieldNumber = 1,
  };
  // optional .CMsgVector origin_offset = 2;
  bool has_origin_offset() const;
  private:
  bool _internal_has_origin_offset() const;
  public:
  void clear_origin_offset();
  const ::CMsgVector& origin_offset() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin_offset();
  ::CMsgVector* mutable_origin_offset();
  void set_allocated_origin_offset(::CMsgVector* origin_offset);
  private:
  const ::CMsgVector& _internal_origin_offset() const;
  ::CMsgVector* _internal_mutable_origin_offset();
  public:
  void unsafe_arena_set_allocated_origin_offset(
      ::CMsgVector* origin_offset);
  ::CMsgVector* unsafe_arena_release_origin_offset();

  // optional .CMsgQAngle angle_offset = 3;
  bool has_angle_offset() const;
  private:
  bool _internal_has_angle_offset() const;
  public:
  void clear_angle_offset();
  const ::CMsgQAngle& angle_offset() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angle_offset();
  ::CMsgQAngle* mutable_angle_offset();
  void set_allocated_angle_offset(::CMsgQAngle* angle_offset);
  private:
  const ::CMsgQAngle& _internal_angle_offset() const;
  ::CMsgQAngle* _internal_mutable_angle_offset();
  public:
  void unsafe_arena_set_allocated_angle_offset(
      ::CMsgQAngle* angle_offset);
  ::CMsgQAngle* unsafe_arena_release_angle_offset();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleOffset)
 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_;
    ::CMsgVector* origin_offset_;
    ::CMsgQAngle* angle_offset_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleEnt& operator=(const CUserMsg_ParticleManager_UpdateParticleEnt& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleEnt& operator=(CUserMsg_ParticleManager_UpdateParticleEnt&& 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 CUserMsg_ParticleManager_UpdateParticleEnt& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleEnt* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleEnt*>(
               &_CUserMsg_ParticleManager_UpdateParticleEnt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleEnt& a, CUserMsg_ParticleManager_UpdateParticleEnt& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleEnt* 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(CUserMsg_ParticleManager_UpdateParticleEnt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleEnt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleEnt>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleEnt& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleEnt& from) {
    CUserMsg_ParticleManager_UpdateParticleEnt::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(CUserMsg_ParticleManager_UpdateParticleEnt* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleEnt";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleEnt(::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 {
    kFallbackPositionFieldNumber = 5,
    kOffsetPositionFieldNumber = 7,
    kOffsetAnglesFieldNumber = 8,
    kControlPointFieldNumber = 1,
    kAttachTypeFieldNumber = 3,
    kAttachmentFieldNumber = 4,
    kIncludeWearablesFieldNumber = 6,
    kEntityHandleFieldNumber = 2,
  };
  // optional .CMsgVector fallback_position = 5;
  bool has_fallback_position() const;
  private:
  bool _internal_has_fallback_position() const;
  public:
  void clear_fallback_position();
  const ::CMsgVector& fallback_position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fallback_position();
  ::CMsgVector* mutable_fallback_position();
  void set_allocated_fallback_position(::CMsgVector* fallback_position);
  private:
  const ::CMsgVector& _internal_fallback_position() const;
  ::CMsgVector* _internal_mutable_fallback_position();
  public:
  void unsafe_arena_set_allocated_fallback_position(
      ::CMsgVector* fallback_position);
  ::CMsgVector* unsafe_arena_release_fallback_position();

  // optional .CMsgVector offset_position = 7;
  bool has_offset_position() const;
  private:
  bool _internal_has_offset_position() const;
  public:
  void clear_offset_position();
  const ::CMsgVector& offset_position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_offset_position();
  ::CMsgVector* mutable_offset_position();
  void set_allocated_offset_position(::CMsgVector* offset_position);
  private:
  const ::CMsgVector& _internal_offset_position() const;
  ::CMsgVector* _internal_mutable_offset_position();
  public:
  void unsafe_arena_set_allocated_offset_position(
      ::CMsgVector* offset_position);
  ::CMsgVector* unsafe_arena_release_offset_position();

  // optional .CMsgQAngle offset_angles = 8;
  bool has_offset_angles() const;
  private:
  bool _internal_has_offset_angles() const;
  public:
  void clear_offset_angles();
  const ::CMsgQAngle& offset_angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_offset_angles();
  ::CMsgQAngle* mutable_offset_angles();
  void set_allocated_offset_angles(::CMsgQAngle* offset_angles);
  private:
  const ::CMsgQAngle& _internal_offset_angles() const;
  ::CMsgQAngle* _internal_mutable_offset_angles();
  public:
  void unsafe_arena_set_allocated_offset_angles(
      ::CMsgQAngle* offset_angles);
  ::CMsgQAngle* unsafe_arena_release_offset_angles();

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // optional int32 attach_type = 3;
  bool has_attach_type() const;
  private:
  bool _internal_has_attach_type() const;
  public:
  void clear_attach_type();
  int32_t attach_type() const;
  void set_attach_type(int32_t value);
  private:
  int32_t _internal_attach_type() const;
  void _internal_set_attach_type(int32_t value);
  public:

  // optional int32 attachment = 4;
  bool has_attachment() const;
  private:
  bool _internal_has_attachment() const;
  public:
  void clear_attachment();
  int32_t attachment() const;
  void set_attachment(int32_t value);
  private:
  int32_t _internal_attachment() const;
  void _internal_set_attachment(int32_t value);
  public:

  // optional bool include_wearables = 6;
  bool has_include_wearables() const;
  private:
  bool _internal_has_include_wearables() const;
  public:
  void clear_include_wearables();
  bool include_wearables() const;
  void set_include_wearables(bool value);
  private:
  bool _internal_include_wearables() const;
  void _internal_set_include_wearables(bool value);
  public:

  // optional uint32 entity_handle = 2 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleEnt)
 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_;
    ::CMsgVector* fallback_position_;
    ::CMsgVector* offset_position_;
    ::CMsgQAngle* offset_angles_;
    int32_t control_point_;
    int32_t attach_type_;
    int32_t attachment_;
    bool include_wearables_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleSetFrozen& operator=(const CUserMsg_ParticleManager_UpdateParticleSetFrozen& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleSetFrozen& operator=(CUserMsg_ParticleManager_UpdateParticleSetFrozen&& 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 CUserMsg_ParticleManager_UpdateParticleSetFrozen& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleSetFrozen* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleSetFrozen*>(
               &_CUserMsg_ParticleManager_UpdateParticleSetFrozen_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleSetFrozen& a, CUserMsg_ParticleManager_UpdateParticleSetFrozen& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleSetFrozen* 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(CUserMsg_ParticleManager_UpdateParticleSetFrozen* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleSetFrozen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleSetFrozen>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleSetFrozen& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleSetFrozen& from) {
    CUserMsg_ParticleManager_UpdateParticleSetFrozen::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(CUserMsg_ParticleManager_UpdateParticleSetFrozen* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleSetFrozen";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleSetFrozen(::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 {
    kSetFrozenFieldNumber = 1,
    kTransitionDurationFieldNumber = 2,
  };
  // optional bool set_frozen = 1;
  bool has_set_frozen() const;
  private:
  bool _internal_has_set_frozen() const;
  public:
  void clear_set_frozen();
  bool set_frozen() const;
  void set_set_frozen(bool value);
  private:
  bool _internal_set_frozen() const;
  void _internal_set_set_frozen(bool value);
  public:

  // optional float transition_duration = 2;
  bool has_transition_duration() const;
  private:
  bool _internal_has_transition_duration() const;
  public:
  void clear_transition_duration();
  float transition_duration() const;
  void set_transition_duration(float value);
  private:
  float _internal_transition_duration() const;
  void _internal_set_transition_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleSetFrozen)
 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 set_frozen_;
    float transition_duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateParticleShouldDraw& operator=(const CUserMsg_ParticleManager_UpdateParticleShouldDraw& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateParticleShouldDraw& operator=(CUserMsg_ParticleManager_UpdateParticleShouldDraw&& 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 CUserMsg_ParticleManager_UpdateParticleShouldDraw& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateParticleShouldDraw* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateParticleShouldDraw*>(
               &_CUserMsg_ParticleManager_UpdateParticleShouldDraw_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(CUserMsg_ParticleManager_UpdateParticleShouldDraw& a, CUserMsg_ParticleManager_UpdateParticleShouldDraw& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateParticleShouldDraw* 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(CUserMsg_ParticleManager_UpdateParticleShouldDraw* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateParticleShouldDraw* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateParticleShouldDraw>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateParticleShouldDraw& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateParticleShouldDraw& from) {
    CUserMsg_ParticleManager_UpdateParticleShouldDraw::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(CUserMsg_ParticleManager_UpdateParticleShouldDraw* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateParticleShouldDraw";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateParticleShouldDraw(::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 {
    kShouldDrawFieldNumber = 1,
  };
  // optional bool should_draw = 1;
  bool has_should_draw() const;
  private:
  bool _internal_has_should_draw() const;
  public:
  void clear_should_draw();
  bool should_draw() const;
  void set_should_draw(bool value);
  private:
  bool _internal_should_draw() const;
  void _internal_set_should_draw(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateParticleShouldDraw)
 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 should_draw_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ChangeControlPointAttachment& operator=(const CUserMsg_ParticleManager_ChangeControlPointAttachment& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ChangeControlPointAttachment& operator=(CUserMsg_ParticleManager_ChangeControlPointAttachment&& 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 CUserMsg_ParticleManager_ChangeControlPointAttachment& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ChangeControlPointAttachment* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ChangeControlPointAttachment*>(
               &_CUserMsg_ParticleManager_ChangeControlPointAttachment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(CUserMsg_ParticleManager_ChangeControlPointAttachment& a, CUserMsg_ParticleManager_ChangeControlPointAttachment& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ChangeControlPointAttachment* 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(CUserMsg_ParticleManager_ChangeControlPointAttachment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ChangeControlPointAttachment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ChangeControlPointAttachment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_ChangeControlPointAttachment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_ChangeControlPointAttachment& from) {
    CUserMsg_ParticleManager_ChangeControlPointAttachment::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(CUserMsg_ParticleManager_ChangeControlPointAttachment* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.ChangeControlPointAttachment";
  }
  protected:
  explicit CUserMsg_ParticleManager_ChangeControlPointAttachment(::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 {
    kAttachmentOldFieldNumber = 1,
    kAttachmentNewFieldNumber = 2,
    kEntityHandleFieldNumber = 3,
  };
  // optional int32 attachment_old = 1;
  bool has_attachment_old() const;
  private:
  bool _internal_has_attachment_old() const;
  public:
  void clear_attachment_old();
  int32_t attachment_old() const;
  void set_attachment_old(int32_t value);
  private:
  int32_t _internal_attachment_old() const;
  void _internal_set_attachment_old(int32_t value);
  public:

  // optional int32 attachment_new = 2;
  bool has_attachment_new() const;
  private:
  bool _internal_has_attachment_new() const;
  public:
  void clear_attachment_new();
  int32_t attachment_new() const;
  void set_attachment_new(int32_t value);
  private:
  int32_t _internal_attachment_new() const;
  void _internal_set_attachment_new(int32_t value);
  public:

  // optional uint32 entity_handle = 3 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.ChangeControlPointAttachment)
 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 attachment_old_;
    int32_t attachment_new_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateEntityPosition& operator=(const CUserMsg_ParticleManager_UpdateEntityPosition& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateEntityPosition& operator=(CUserMsg_ParticleManager_UpdateEntityPosition&& 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 CUserMsg_ParticleManager_UpdateEntityPosition& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateEntityPosition* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateEntityPosition*>(
               &_CUserMsg_ParticleManager_UpdateEntityPosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(CUserMsg_ParticleManager_UpdateEntityPosition& a, CUserMsg_ParticleManager_UpdateEntityPosition& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateEntityPosition* 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(CUserMsg_ParticleManager_UpdateEntityPosition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateEntityPosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateEntityPosition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateEntityPosition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateEntityPosition& from) {
    CUserMsg_ParticleManager_UpdateEntityPosition::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(CUserMsg_ParticleManager_UpdateEntityPosition* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateEntityPosition";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateEntityPosition(::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 {
    kPositionFieldNumber = 2,
    kEntityHandleFieldNumber = 1,
  };
  // optional .CMsgVector position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::CMsgVector& position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_position();
  ::CMsgVector* mutable_position();
  void set_allocated_position(::CMsgVector* position);
  private:
  const ::CMsgVector& _internal_position() const;
  ::CMsgVector* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::CMsgVector* position);
  ::CMsgVector* unsafe_arena_release_position();

  // optional uint32 entity_handle = 1 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateEntityPosition)
 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_;
    ::CMsgVector* position_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleFoWProperties& operator=(const CUserMsg_ParticleManager_SetParticleFoWProperties& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleFoWProperties& operator=(CUserMsg_ParticleManager_SetParticleFoWProperties&& 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 CUserMsg_ParticleManager_SetParticleFoWProperties& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleFoWProperties* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleFoWProperties*>(
               &_CUserMsg_ParticleManager_SetParticleFoWProperties_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(CUserMsg_ParticleManager_SetParticleFoWProperties& a, CUserMsg_ParticleManager_SetParticleFoWProperties& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleFoWProperties* 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(CUserMsg_ParticleManager_SetParticleFoWProperties* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleFoWProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleFoWProperties>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleFoWProperties& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleFoWProperties& from) {
    CUserMsg_ParticleManager_SetParticleFoWProperties::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(CUserMsg_ParticleManager_SetParticleFoWProperties* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleFoWProperties";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleFoWProperties(::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 {
    kFowControlPointFieldNumber = 1,
    kFowControlPoint2FieldNumber = 2,
    kFowRadiusFieldNumber = 3,
  };
  // optional int32 fow_control_point = 1;
  bool has_fow_control_point() const;
  private:
  bool _internal_has_fow_control_point() const;
  public:
  void clear_fow_control_point();
  int32_t fow_control_point() const;
  void set_fow_control_point(int32_t value);
  private:
  int32_t _internal_fow_control_point() const;
  void _internal_set_fow_control_point(int32_t value);
  public:

  // optional int32 fow_control_point2 = 2;
  bool has_fow_control_point2() const;
  private:
  bool _internal_has_fow_control_point2() const;
  public:
  void clear_fow_control_point2();
  int32_t fow_control_point2() const;
  void set_fow_control_point2(int32_t value);
  private:
  int32_t _internal_fow_control_point2() const;
  void _internal_set_fow_control_point2(int32_t value);
  public:

  // optional float fow_radius = 3;
  bool has_fow_radius() const;
  private:
  bool _internal_has_fow_radius() const;
  public:
  void clear_fow_radius();
  float fow_radius() const;
  void set_fow_radius(float value);
  private:
  float _internal_fow_radius() const;
  void _internal_set_fow_radius(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleFoWProperties)
 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 fow_control_point_;
    int32_t fow_control_point2_;
    float fow_radius_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleShouldCheckFoW& operator=(const CUserMsg_ParticleManager_SetParticleShouldCheckFoW& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleShouldCheckFoW& operator=(CUserMsg_ParticleManager_SetParticleShouldCheckFoW&& 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 CUserMsg_ParticleManager_SetParticleShouldCheckFoW& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleShouldCheckFoW* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleShouldCheckFoW*>(
               &_CUserMsg_ParticleManager_SetParticleShouldCheckFoW_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(CUserMsg_ParticleManager_SetParticleShouldCheckFoW& a, CUserMsg_ParticleManager_SetParticleShouldCheckFoW& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleShouldCheckFoW* 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(CUserMsg_ParticleManager_SetParticleShouldCheckFoW* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleShouldCheckFoW* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleShouldCheckFoW>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleShouldCheckFoW& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleShouldCheckFoW& from) {
    CUserMsg_ParticleManager_SetParticleShouldCheckFoW::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(CUserMsg_ParticleManager_SetParticleShouldCheckFoW* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleShouldCheckFoW";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleShouldCheckFoW(::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 {
    kCheckFowFieldNumber = 1,
  };
  // optional bool check_fow = 1;
  bool has_check_fow() const;
  private:
  bool _internal_has_check_fow() const;
  public:
  void clear_check_fow();
  bool check_fow() const;
  void set_check_fow(bool value);
  private:
  bool _internal_check_fow() const;
  void _internal_set_check_fow(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleShouldCheckFoW)
 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 check_fow_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetControlPointModel& operator=(const CUserMsg_ParticleManager_SetControlPointModel& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetControlPointModel& operator=(CUserMsg_ParticleManager_SetControlPointModel&& 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 CUserMsg_ParticleManager_SetControlPointModel& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetControlPointModel* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetControlPointModel*>(
               &_CUserMsg_ParticleManager_SetControlPointModel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(CUserMsg_ParticleManager_SetControlPointModel& a, CUserMsg_ParticleManager_SetControlPointModel& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetControlPointModel* 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(CUserMsg_ParticleManager_SetControlPointModel* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetControlPointModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetControlPointModel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetControlPointModel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetControlPointModel& from) {
    CUserMsg_ParticleManager_SetControlPointModel::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(CUserMsg_ParticleManager_SetControlPointModel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetControlPointModel";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetControlPointModel(::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 {
    kModelNameFieldNumber = 2,
    kControlPointFieldNumber = 1,
  };
  // optional string model_name = 2;
  bool has_model_name() const;
  private:
  bool _internal_has_model_name() const;
  public:
  void clear_model_name();
  const std::string& model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_name();
  PROTOBUF_NODISCARD std::string* release_model_name();
  void set_allocated_model_name(std::string* model_name);
  private:
  const std::string& _internal_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
  std::string* _internal_mutable_model_name();
  public:

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetControlPointModel)
 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 model_name_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetControlPointSnapshot& operator=(const CUserMsg_ParticleManager_SetControlPointSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetControlPointSnapshot& operator=(CUserMsg_ParticleManager_SetControlPointSnapshot&& 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 CUserMsg_ParticleManager_SetControlPointSnapshot& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetControlPointSnapshot* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetControlPointSnapshot*>(
               &_CUserMsg_ParticleManager_SetControlPointSnapshot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(CUserMsg_ParticleManager_SetControlPointSnapshot& a, CUserMsg_ParticleManager_SetControlPointSnapshot& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetControlPointSnapshot* 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(CUserMsg_ParticleManager_SetControlPointSnapshot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetControlPointSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetControlPointSnapshot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetControlPointSnapshot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetControlPointSnapshot& from) {
    CUserMsg_ParticleManager_SetControlPointSnapshot::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(CUserMsg_ParticleManager_SetControlPointSnapshot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetControlPointSnapshot";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetControlPointSnapshot(::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 {
    kSnapshotNameFieldNumber = 2,
    kControlPointFieldNumber = 1,
  };
  // optional string snapshot_name = 2;
  bool has_snapshot_name() const;
  private:
  bool _internal_has_snapshot_name() const;
  public:
  void clear_snapshot_name();
  const std::string& snapshot_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snapshot_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snapshot_name();
  PROTOBUF_NODISCARD std::string* release_snapshot_name();
  void set_allocated_snapshot_name(std::string* snapshot_name);
  private:
  const std::string& _internal_snapshot_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_name(const std::string& value);
  std::string* _internal_mutable_snapshot_name();
  public:

  // optional int32 control_point = 1;
  bool has_control_point() const;
  private:
  bool _internal_has_control_point() const;
  public:
  void clear_control_point();
  int32_t control_point() const;
  void set_control_point(int32_t value);
  private:
  int32_t _internal_control_point() const;
  void _internal_set_control_point(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetControlPointSnapshot)
 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 snapshot_name_;
    int32_t control_point_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleText& operator=(const CUserMsg_ParticleManager_SetParticleText& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleText& operator=(CUserMsg_ParticleManager_SetParticleText&& 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 CUserMsg_ParticleManager_SetParticleText& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleText* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleText*>(
               &_CUserMsg_ParticleManager_SetParticleText_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(CUserMsg_ParticleManager_SetParticleText& a, CUserMsg_ParticleManager_SetParticleText& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleText* 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(CUserMsg_ParticleManager_SetParticleText* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleText>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleText& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleText& from) {
    CUserMsg_ParticleManager_SetParticleText::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(CUserMsg_ParticleManager_SetParticleText* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleText";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleText(::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 {
    kTextFieldNumber = 1,
  };
  // optional string text = 1;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleText)
 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 text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetTextureAttribute& operator=(const CUserMsg_ParticleManager_SetTextureAttribute& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetTextureAttribute& operator=(CUserMsg_ParticleManager_SetTextureAttribute&& 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 CUserMsg_ParticleManager_SetTextureAttribute& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetTextureAttribute* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetTextureAttribute*>(
               &_CUserMsg_ParticleManager_SetTextureAttribute_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(CUserMsg_ParticleManager_SetTextureAttribute& a, CUserMsg_ParticleManager_SetTextureAttribute& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetTextureAttribute* 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(CUserMsg_ParticleManager_SetTextureAttribute* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetTextureAttribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetTextureAttribute>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetTextureAttribute& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetTextureAttribute& from) {
    CUserMsg_ParticleManager_SetTextureAttribute::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(CUserMsg_ParticleManager_SetTextureAttribute* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetTextureAttribute";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetTextureAttribute(::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 {
    kAttributeNameFieldNumber = 1,
    kTextureNameFieldNumber = 2,
  };
  // optional string attribute_name = 1;
  bool has_attribute_name() const;
  private:
  bool _internal_has_attribute_name() const;
  public:
  void clear_attribute_name();
  const std::string& attribute_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attribute_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attribute_name();
  PROTOBUF_NODISCARD std::string* release_attribute_name();
  void set_allocated_attribute_name(std::string* attribute_name);
  private:
  const std::string& _internal_attribute_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attribute_name(const std::string& value);
  std::string* _internal_mutable_attribute_name();
  public:

  // optional string texture_name = 2;
  bool has_texture_name() const;
  private:
  bool _internal_has_texture_name() const;
  public:
  void clear_texture_name();
  const std::string& texture_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_texture_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_texture_name();
  PROTOBUF_NODISCARD std::string* release_texture_name();
  void set_allocated_texture_name(std::string* texture_name);
  private:
  const std::string& _internal_texture_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_texture_name(const std::string& value);
  std::string* _internal_mutable_texture_name();
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetTextureAttribute)
 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 attribute_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr texture_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetSceneObjectGenericFlag& operator=(const CUserMsg_ParticleManager_SetSceneObjectGenericFlag& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetSceneObjectGenericFlag& operator=(CUserMsg_ParticleManager_SetSceneObjectGenericFlag&& 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 CUserMsg_ParticleManager_SetSceneObjectGenericFlag& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetSceneObjectGenericFlag* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetSceneObjectGenericFlag*>(
               &_CUserMsg_ParticleManager_SetSceneObjectGenericFlag_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(CUserMsg_ParticleManager_SetSceneObjectGenericFlag& a, CUserMsg_ParticleManager_SetSceneObjectGenericFlag& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetSceneObjectGenericFlag* 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(CUserMsg_ParticleManager_SetSceneObjectGenericFlag* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetSceneObjectGenericFlag* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetSceneObjectGenericFlag>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetSceneObjectGenericFlag& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetSceneObjectGenericFlag& from) {
    CUserMsg_ParticleManager_SetSceneObjectGenericFlag::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(CUserMsg_ParticleManager_SetSceneObjectGenericFlag* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetSceneObjectGenericFlag";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetSceneObjectGenericFlag(::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 {
    kFlagValueFieldNumber = 1,
  };
  // optional bool flag_value = 1;
  bool has_flag_value() const;
  private:
  bool _internal_has_flag_value() const;
  public:
  void clear_flag_value();
  bool flag_value() const;
  void set_flag_value(bool value);
  private:
  bool _internal_flag_value() const;
  void _internal_set_flag_value(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetSceneObjectGenericFlag)
 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 flag_value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& operator=(const CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& operator=(CUserMsg_ParticleManager_SetSceneObjectTintAndDesat&& 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 CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetSceneObjectTintAndDesat*>(
               &_CUserMsg_ParticleManager_SetSceneObjectTintAndDesat_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& a, CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* 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(CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetSceneObjectTintAndDesat>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& from) {
    CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::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(CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetSceneObjectTintAndDesat";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetSceneObjectTintAndDesat(::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 {
    kTintFieldNumber = 1,
    kDesatFieldNumber = 2,
  };
  // optional fixed32 tint = 1;
  bool has_tint() const;
  private:
  bool _internal_has_tint() const;
  public:
  void clear_tint();
  uint32_t tint() const;
  void set_tint(uint32_t value);
  private:
  uint32_t _internal_tint() const;
  void _internal_set_tint(uint32_t value);
  public:

  // optional float desat = 2;
  bool has_desat() const;
  private:
  bool _internal_has_desat() const;
  public:
  void clear_desat();
  float desat() const;
  void set_desat(float value);
  private:
  float _internal_desat() const;
  void _internal_set_desat(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetSceneObjectTintAndDesat)
 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 tint_;
    float desat_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ParticleSkipToTime& operator=(const CUserMsg_ParticleManager_ParticleSkipToTime& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ParticleSkipToTime& operator=(CUserMsg_ParticleManager_ParticleSkipToTime&& 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 CUserMsg_ParticleManager_ParticleSkipToTime& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ParticleSkipToTime* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ParticleSkipToTime*>(
               &_CUserMsg_ParticleManager_ParticleSkipToTime_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(CUserMsg_ParticleManager_ParticleSkipToTime& a, CUserMsg_ParticleManager_ParticleSkipToTime& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ParticleSkipToTime* 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(CUserMsg_ParticleManager_ParticleSkipToTime* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ParticleSkipToTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ParticleSkipToTime>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_ParticleSkipToTime& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_ParticleSkipToTime& from) {
    CUserMsg_ParticleManager_ParticleSkipToTime::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(CUserMsg_ParticleManager_ParticleSkipToTime* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.ParticleSkipToTime";
  }
  protected:
  explicit CUserMsg_ParticleManager_ParticleSkipToTime(::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 {
    kSkipToTimeFieldNumber = 1,
  };
  // optional float skip_to_time = 1;
  bool has_skip_to_time() const;
  private:
  bool _internal_has_skip_to_time() const;
  public:
  void clear_skip_to_time();
  float skip_to_time() const;
  void set_skip_to_time(float value);
  private:
  float _internal_skip_to_time() const;
  void _internal_set_skip_to_time(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.ParticleSkipToTime)
 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_;
    float skip_to_time_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ParticleCanFreeze& operator=(const CUserMsg_ParticleManager_ParticleCanFreeze& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ParticleCanFreeze& operator=(CUserMsg_ParticleManager_ParticleCanFreeze&& 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 CUserMsg_ParticleManager_ParticleCanFreeze& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ParticleCanFreeze* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ParticleCanFreeze*>(
               &_CUserMsg_ParticleManager_ParticleCanFreeze_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(CUserMsg_ParticleManager_ParticleCanFreeze& a, CUserMsg_ParticleManager_ParticleCanFreeze& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ParticleCanFreeze* 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(CUserMsg_ParticleManager_ParticleCanFreeze* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ParticleCanFreeze* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ParticleCanFreeze>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_ParticleCanFreeze& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_ParticleCanFreeze& from) {
    CUserMsg_ParticleManager_ParticleCanFreeze::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(CUserMsg_ParticleManager_ParticleCanFreeze* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.ParticleCanFreeze";
  }
  protected:
  explicit CUserMsg_ParticleManager_ParticleCanFreeze(::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 {
    kCanFreezeFieldNumber = 1,
  };
  // optional bool can_freeze = 1;
  bool has_can_freeze() const;
  private:
  bool _internal_has_can_freeze() const;
  public:
  void clear_can_freeze();
  bool can_freeze() const;
  void set_can_freeze(bool value);
  private:
  bool _internal_can_freeze() const;
  void _internal_set_can_freeze(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.ParticleCanFreeze)
 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 can_freeze_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& operator=(const CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& operator=(CUserMsg_ParticleManager_ParticleFreezeTransitionOverride&& 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 CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ParticleFreezeTransitionOverride*>(
               &_CUserMsg_ParticleManager_ParticleFreezeTransitionOverride_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  friend void swap(CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& a, CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* 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(CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ParticleFreezeTransitionOverride>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& from) {
    CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::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(CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.ParticleFreezeTransitionOverride";
  }
  protected:
  explicit CUserMsg_ParticleManager_ParticleFreezeTransitionOverride(::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 {
    kFreezeTransitionOverrideFieldNumber = 1,
  };
  // optional float freeze_transition_override = 1;
  bool has_freeze_transition_override() const;
  private:
  bool _internal_has_freeze_transition_override() const;
  public:
  void clear_freeze_transition_override();
  float freeze_transition_override() const;
  void set_freeze_transition_override(float value);
  private:
  float _internal_freeze_transition_override() const;
  void _internal_set_freeze_transition_override(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.ParticleFreezeTransitionOverride)
 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_;
    float freeze_transition_override_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_FreezeParticleInvolving& operator=(const CUserMsg_ParticleManager_FreezeParticleInvolving& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_FreezeParticleInvolving& operator=(CUserMsg_ParticleManager_FreezeParticleInvolving&& 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 CUserMsg_ParticleManager_FreezeParticleInvolving& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_FreezeParticleInvolving* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_FreezeParticleInvolving*>(
               &_CUserMsg_ParticleManager_FreezeParticleInvolving_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(CUserMsg_ParticleManager_FreezeParticleInvolving& a, CUserMsg_ParticleManager_FreezeParticleInvolving& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_FreezeParticleInvolving* 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(CUserMsg_ParticleManager_FreezeParticleInvolving* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_FreezeParticleInvolving* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_FreezeParticleInvolving>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_FreezeParticleInvolving& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_FreezeParticleInvolving& from) {
    CUserMsg_ParticleManager_FreezeParticleInvolving::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(CUserMsg_ParticleManager_FreezeParticleInvolving* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.FreezeParticleInvolving";
  }
  protected:
  explicit CUserMsg_ParticleManager_FreezeParticleInvolving(::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 {
    kSetFrozenFieldNumber = 1,
    kTransitionDurationFieldNumber = 2,
    kEntityHandleFieldNumber = 3,
  };
  // optional bool set_frozen = 1;
  bool has_set_frozen() const;
  private:
  bool _internal_has_set_frozen() const;
  public:
  void clear_set_frozen();
  bool set_frozen() const;
  void set_set_frozen(bool value);
  private:
  bool _internal_set_frozen() const;
  void _internal_set_set_frozen(bool value);
  public:

  // optional float transition_duration = 2;
  bool has_transition_duration() const;
  private:
  bool _internal_has_transition_duration() const;
  public:
  void clear_transition_duration();
  float transition_duration() const;
  void set_transition_duration(float value);
  private:
  float _internal_transition_duration() const;
  void _internal_set_transition_duration(float value);
  public:

  // optional uint32 entity_handle = 3 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.FreezeParticleInvolving)
 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 set_frozen_;
    float transition_duration_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_AddModellistOverrideElement& operator=(const CUserMsg_ParticleManager_AddModellistOverrideElement& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_AddModellistOverrideElement& operator=(CUserMsg_ParticleManager_AddModellistOverrideElement&& 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 CUserMsg_ParticleManager_AddModellistOverrideElement& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_AddModellistOverrideElement* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_AddModellistOverrideElement*>(
               &_CUserMsg_ParticleManager_AddModellistOverrideElement_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(CUserMsg_ParticleManager_AddModellistOverrideElement& a, CUserMsg_ParticleManager_AddModellistOverrideElement& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_AddModellistOverrideElement* 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(CUserMsg_ParticleManager_AddModellistOverrideElement* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_AddModellistOverrideElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_AddModellistOverrideElement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_AddModellistOverrideElement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_AddModellistOverrideElement& from) {
    CUserMsg_ParticleManager_AddModellistOverrideElement::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(CUserMsg_ParticleManager_AddModellistOverrideElement* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.AddModellistOverrideElement";
  }
  protected:
  explicit CUserMsg_ParticleManager_AddModellistOverrideElement(::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 {
    kModelNameFieldNumber = 1,
    kSpawnProbabilityFieldNumber = 2,
    kGroupidFieldNumber = 3,
  };
  // optional string model_name = 1;
  bool has_model_name() const;
  private:
  bool _internal_has_model_name() const;
  public:
  void clear_model_name();
  const std::string& model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_name();
  PROTOBUF_NODISCARD std::string* release_model_name();
  void set_allocated_model_name(std::string* model_name);
  private:
  const std::string& _internal_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
  std::string* _internal_mutable_model_name();
  public:

  // optional float spawn_probability = 2;
  bool has_spawn_probability() const;
  private:
  bool _internal_has_spawn_probability() const;
  public:
  void clear_spawn_probability();
  float spawn_probability() const;
  void set_spawn_probability(float value);
  private:
  float _internal_spawn_probability() const;
  void _internal_set_spawn_probability(float value);
  public:

  // optional uint32 groupid = 3;
  bool has_groupid() const;
  private:
  bool _internal_has_groupid() const;
  public:
  void clear_groupid();
  uint32_t groupid() const;
  void set_groupid(uint32_t value);
  private:
  uint32_t _internal_groupid() const;
  void _internal_set_groupid(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.AddModellistOverrideElement)
 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 model_name_;
    float spawn_probability_;
    uint32_t groupid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_ClearModellistOverride& operator=(const CUserMsg_ParticleManager_ClearModellistOverride& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_ClearModellistOverride& operator=(CUserMsg_ParticleManager_ClearModellistOverride&& 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 CUserMsg_ParticleManager_ClearModellistOverride& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_ClearModellistOverride* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_ClearModellistOverride*>(
               &_CUserMsg_ParticleManager_ClearModellistOverride_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(CUserMsg_ParticleManager_ClearModellistOverride& a, CUserMsg_ParticleManager_ClearModellistOverride& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_ClearModellistOverride* 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(CUserMsg_ParticleManager_ClearModellistOverride* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_ClearModellistOverride* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_ClearModellistOverride>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_ClearModellistOverride& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_ClearModellistOverride& from) {
    CUserMsg_ParticleManager_ClearModellistOverride::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(CUserMsg_ParticleManager_ClearModellistOverride* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.ClearModellistOverride";
  }
  protected:
  explicit CUserMsg_ParticleManager_ClearModellistOverride(::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 groupid = 1;
  bool has_groupid() const;
  private:
  bool _internal_has_groupid() const;
  public:
  void clear_groupid();
  uint32_t groupid() const;
  void set_groupid(uint32_t value);
  private:
  uint32_t _internal_groupid() const;
  void _internal_set_groupid(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.ClearModellistOverride)
 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 groupid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& operator=(const CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& operator=(CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue&& 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 CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue*>(
               &_CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& a, CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* 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(CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& from) {
    CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::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(CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue(::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 {
    kValueNameHashFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional uint32 value_name_hash = 1;
  bool has_value_name_hash() const;
  private:
  bool _internal_has_value_name_hash() const;
  public:
  void clear_value_name_hash();
  uint32_t value_name_hash() const;
  void set_value_name_hash(uint32_t value);
  private:
  uint32_t _internal_value_name_hash() const;
  void _internal_set_value_name_hash(uint32_t value);
  public:

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

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue)
 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 value_name_hash_;
    float value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& operator=(const CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& operator=(CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue&& 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 CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue*>(
               &_CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& a, CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* 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(CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& from) {
    CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::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(CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue(::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 {
    kValueFieldNumber = 2,
    kValueNameHashFieldNumber = 1,
  };
  // optional .CMsgVector value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::CMsgVector& value() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_value();
  ::CMsgVector* mutable_value();
  void set_allocated_value(::CMsgVector* value);
  private:
  const ::CMsgVector& _internal_value() const;
  ::CMsgVector* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::CMsgVector* value);
  ::CMsgVector* unsafe_arena_release_value();

  // optional uint32 value_name_hash = 1;
  bool has_value_name_hash() const;
  private:
  bool _internal_has_value_name_hash() const;
  public:
  void clear_value_name_hash();
  uint32_t value_name_hash() const;
  void set_value_name_hash(uint32_t value);
  private:
  uint32_t _internal_value_name_hash() const;
  void _internal_set_value_name_hash(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue)
 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_;
    ::CMsgVector* value_;
    uint32_t value_name_hash_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& operator=(const CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& operator=(CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue&& 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 CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue*>(
               &_CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& a, CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* 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(CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& from) {
    CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::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(CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue(::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 {
    kAnglesFieldNumber = 2,
    kTranslationFieldNumber = 3,
    kValueNameHashFieldNumber = 1,
  };
  // optional .CMsgQAngle angles = 2;
  bool has_angles() const;
  private:
  bool _internal_has_angles() const;
  public:
  void clear_angles();
  const ::CMsgQAngle& angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angles();
  ::CMsgQAngle* mutable_angles();
  void set_allocated_angles(::CMsgQAngle* angles);
  private:
  const ::CMsgQAngle& _internal_angles() const;
  ::CMsgQAngle* _internal_mutable_angles();
  public:
  void unsafe_arena_set_allocated_angles(
      ::CMsgQAngle* angles);
  ::CMsgQAngle* unsafe_arena_release_angles();

  // optional .CMsgVector translation = 3;
  bool has_translation() const;
  private:
  bool _internal_has_translation() const;
  public:
  void clear_translation();
  const ::CMsgVector& translation() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_translation();
  ::CMsgVector* mutable_translation();
  void set_allocated_translation(::CMsgVector* translation);
  private:
  const ::CMsgVector& _internal_translation() const;
  ::CMsgVector* _internal_mutable_translation();
  public:
  void unsafe_arena_set_allocated_translation(
      ::CMsgVector* translation);
  ::CMsgVector* unsafe_arena_release_translation();

  // optional uint32 value_name_hash = 1;
  bool has_value_name_hash() const;
  private:
  bool _internal_has_value_name_hash() const;
  public:
  void clear_value_name_hash();
  uint32_t value_name_hash() const;
  void set_value_name_hash(uint32_t value);
  private:
  uint32_t _internal_value_name_hash() const;
  void _internal_set_value_name_hash(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue)
 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_;
    ::CMsgQAngle* angles_;
    ::CMsgVector* translation_;
    uint32_t value_name_hash_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& operator=(const CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& operator=(CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext&& 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 CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext*>(
               &_CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& a, CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* 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(CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& from) {
    CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::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(CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext(::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 {
    kValueNameHashFieldNumber = 1,
    kEntIndexFieldNumber = 2,
  };
  // optional uint32 value_name_hash = 1;
  bool has_value_name_hash() const;
  private:
  bool _internal_has_value_name_hash() const;
  public:
  void clear_value_name_hash();
  uint32_t value_name_hash() const;
  void set_value_name_hash(uint32_t value);
  private:
  uint32_t _internal_value_name_hash() const;
  void _internal_set_value_name_hash(uint32_t value);
  public:

  // optional uint32 ent_index = 2 [default = 16777215];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  uint32_t ent_index() const;
  void set_ent_index(uint32_t value);
  private:
  uint32_t _internal_ent_index() const;
  void _internal_set_ent_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext)
 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 value_name_hash_;
    uint32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetParticleNamedValueContext& operator=(const CUserMsg_ParticleManager_SetParticleNamedValueContext& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleNamedValueContext& operator=(CUserMsg_ParticleManager_SetParticleNamedValueContext&& 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 CUserMsg_ParticleManager_SetParticleNamedValueContext& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleNamedValueContext* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleNamedValueContext*>(
               &_CUserMsg_ParticleManager_SetParticleNamedValueContext_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  friend void swap(CUserMsg_ParticleManager_SetParticleNamedValueContext& a, CUserMsg_ParticleManager_SetParticleNamedValueContext& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleNamedValueContext* 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(CUserMsg_ParticleManager_SetParticleNamedValueContext* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleNamedValueContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleNamedValueContext>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleNamedValueContext& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleNamedValueContext& from) {
    CUserMsg_ParticleManager_SetParticleNamedValueContext::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(CUserMsg_ParticleManager_SetParticleNamedValueContext* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleNamedValueContext";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleNamedValueContext(::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 CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue FloatContextValue;
  typedef CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue VectorContextValue;
  typedef CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue TransformContextValue;
  typedef CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext EHandleContext;

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

  enum : int {
    kFloatValuesFieldNumber = 1,
    kVectorValuesFieldNumber = 2,
    kTransformValuesFieldNumber = 3,
    kEhandleValuesFieldNumber = 4,
  };
  // repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue float_values = 1;
  int float_values_size() const;
  private:
  int _internal_float_values_size() const;
  public:
  void clear_float_values();
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* mutable_float_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue >*
      mutable_float_values();
  private:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& _internal_float_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* _internal_add_float_values();
  public:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& float_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* add_float_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue >&
      float_values() const;

  // repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue vector_values = 2;
  int vector_values_size() const;
  private:
  int _internal_vector_values_size() const;
  public:
  void clear_vector_values();
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* mutable_vector_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue >*
      mutable_vector_values();
  private:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& _internal_vector_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* _internal_add_vector_values();
  public:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& vector_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* add_vector_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue >&
      vector_values() const;

  // repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue transform_values = 3;
  int transform_values_size() const;
  private:
  int _internal_transform_values_size() const;
  public:
  void clear_transform_values();
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* mutable_transform_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue >*
      mutable_transform_values();
  private:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& _internal_transform_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* _internal_add_transform_values();
  public:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& transform_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* add_transform_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue >&
      transform_values() const;

  // repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext ehandle_values = 4;
  int ehandle_values_size() const;
  private:
  int _internal_ehandle_values_size() const;
  public:
  void clear_ehandle_values();
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* mutable_ehandle_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext >*
      mutable_ehandle_values();
  private:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& _internal_ehandle_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* _internal_add_ehandle_values();
  public:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& ehandle_values(int index) const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* add_ehandle_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext >&
      ehandle_values() const;

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleNamedValueContext)
 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< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue > float_values_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue > vector_values_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue > transform_values_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext > ehandle_values_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_CreatePhysicsSim& operator=(const CUserMsg_ParticleManager_CreatePhysicsSim& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_CreatePhysicsSim& operator=(CUserMsg_ParticleManager_CreatePhysicsSim&& 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 CUserMsg_ParticleManager_CreatePhysicsSim& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_CreatePhysicsSim* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_CreatePhysicsSim*>(
               &_CUserMsg_ParticleManager_CreatePhysicsSim_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(CUserMsg_ParticleManager_CreatePhysicsSim& a, CUserMsg_ParticleManager_CreatePhysicsSim& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_CreatePhysicsSim* 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(CUserMsg_ParticleManager_CreatePhysicsSim* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_CreatePhysicsSim* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_CreatePhysicsSim>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_CreatePhysicsSim& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_CreatePhysicsSim& from) {
    CUserMsg_ParticleManager_CreatePhysicsSim::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(CUserMsg_ParticleManager_CreatePhysicsSim* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.CreatePhysicsSim";
  }
  protected:
  explicit CUserMsg_ParticleManager_CreatePhysicsSim(::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 {
    kPropGroupNameFieldNumber = 1,
    kUseHighQualitySimulationFieldNumber = 2,
    kMaxParticleCountFieldNumber = 3,
  };
  // optional string prop_group_name = 1;
  bool has_prop_group_name() const;
  private:
  bool _internal_has_prop_group_name() const;
  public:
  void clear_prop_group_name();
  const std::string& prop_group_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prop_group_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prop_group_name();
  PROTOBUF_NODISCARD std::string* release_prop_group_name();
  void set_allocated_prop_group_name(std::string* prop_group_name);
  private:
  const std::string& _internal_prop_group_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prop_group_name(const std::string& value);
  std::string* _internal_mutable_prop_group_name();
  public:

  // optional bool use_high_quality_simulation = 2;
  bool has_use_high_quality_simulation() const;
  private:
  bool _internal_has_use_high_quality_simulation() const;
  public:
  void clear_use_high_quality_simulation();
  bool use_high_quality_simulation() const;
  void set_use_high_quality_simulation(bool value);
  private:
  bool _internal_use_high_quality_simulation() const;
  void _internal_set_use_high_quality_simulation(bool value);
  public:

  // optional uint32 max_particle_count = 3;
  bool has_max_particle_count() const;
  private:
  bool _internal_has_max_particle_count() const;
  public:
  void clear_max_particle_count();
  uint32_t max_particle_count() const;
  void set_max_particle_count(uint32_t value);
  private:
  uint32_t _internal_max_particle_count() const;
  void _internal_set_max_particle_count(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.CreatePhysicsSim)
 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 prop_group_name_;
    bool use_high_quality_simulation_;
    uint32_t max_particle_count_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_DestroyPhysicsSim& operator=(const CUserMsg_ParticleManager_DestroyPhysicsSim& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_DestroyPhysicsSim& operator=(CUserMsg_ParticleManager_DestroyPhysicsSim&& 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 CUserMsg_ParticleManager_DestroyPhysicsSim& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_DestroyPhysicsSim* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_DestroyPhysicsSim*>(
               &_CUserMsg_ParticleManager_DestroyPhysicsSim_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  friend void swap(CUserMsg_ParticleManager_DestroyPhysicsSim& a, CUserMsg_ParticleManager_DestroyPhysicsSim& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_DestroyPhysicsSim* 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(CUserMsg_ParticleManager_DestroyPhysicsSim* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_DestroyPhysicsSim* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_DestroyPhysicsSim>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMsg_ParticleManager_DestroyPhysicsSim& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMsg_ParticleManager_DestroyPhysicsSim& 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 "CUserMsg_ParticleManager.DestroyPhysicsSim";
  }
  protected:
  explicit CUserMsg_ParticleManager_DestroyPhysicsSim(::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:CUserMsg_ParticleManager.DestroyPhysicsSim)
 private:
  class _Internal;

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

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

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

  inline CUserMsg_ParticleManager_SetVData& operator=(const CUserMsg_ParticleManager_SetVData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetVData& operator=(CUserMsg_ParticleManager_SetVData&& 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 CUserMsg_ParticleManager_SetVData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetVData* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetVData*>(
               &_CUserMsg_ParticleManager_SetVData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

  friend void swap(CUserMsg_ParticleManager_SetVData& a, CUserMsg_ParticleManager_SetVData& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetVData* 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(CUserMsg_ParticleManager_SetVData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetVData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetVData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetVData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetVData& from) {
    CUserMsg_ParticleManager_SetVData::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(CUserMsg_ParticleManager_SetVData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetVData";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetVData(::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 {
    kVdataNameFieldNumber = 1,
  };
  // optional string vdata_name = 1;
  bool has_vdata_name() const;
  private:
  bool _internal_has_vdata_name() const;
  public:
  void clear_vdata_name();
  const std::string& vdata_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vdata_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vdata_name();
  PROTOBUF_NODISCARD std::string* release_vdata_name();
  void set_allocated_vdata_name(std::string* vdata_name);
  private:
  const std::string& _internal_vdata_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vdata_name(const std::string& value);
  std::string* _internal_mutable_vdata_name();
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetVData)
 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 vdata_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_SetMaterialOverride& operator=(const CUserMsg_ParticleManager_SetMaterialOverride& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetMaterialOverride& operator=(CUserMsg_ParticleManager_SetMaterialOverride&& 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 CUserMsg_ParticleManager_SetMaterialOverride& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetMaterialOverride* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetMaterialOverride*>(
               &_CUserMsg_ParticleManager_SetMaterialOverride_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

  friend void swap(CUserMsg_ParticleManager_SetMaterialOverride& a, CUserMsg_ParticleManager_SetMaterialOverride& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetMaterialOverride* 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(CUserMsg_ParticleManager_SetMaterialOverride* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetMaterialOverride* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetMaterialOverride>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetMaterialOverride& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetMaterialOverride& from) {
    CUserMsg_ParticleManager_SetMaterialOverride::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(CUserMsg_ParticleManager_SetMaterialOverride* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetMaterialOverride";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetMaterialOverride(::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 {
    kMaterialNameFieldNumber = 1,
    kIncludeChildrenFieldNumber = 2,
  };
  // optional string material_name = 1;
  bool has_material_name() const;
  private:
  bool _internal_has_material_name() const;
  public:
  void clear_material_name();
  const std::string& material_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_material_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_material_name();
  PROTOBUF_NODISCARD std::string* release_material_name();
  void set_allocated_material_name(std::string* material_name);
  private:
  const std::string& _internal_material_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_material_name(const std::string& value);
  std::string* _internal_mutable_material_name();
  public:

  // optional bool include_children = 2;
  bool has_include_children() const;
  private:
  bool _internal_has_include_children() const;
  public:
  void clear_include_children();
  bool include_children() const;
  void set_include_children(bool value);
  private:
  bool _internal_include_children() const;
  void _internal_set_include_children(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetMaterialOverride)
 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 material_name_;
    bool include_children_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_AddFan& operator=(const CUserMsg_ParticleManager_AddFan& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_AddFan& operator=(CUserMsg_ParticleManager_AddFan&& 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 CUserMsg_ParticleManager_AddFan& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_AddFan* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_AddFan*>(
               &_CUserMsg_ParticleManager_AddFan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

  friend void swap(CUserMsg_ParticleManager_AddFan& a, CUserMsg_ParticleManager_AddFan& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_AddFan* 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(CUserMsg_ParticleManager_AddFan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_AddFan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_AddFan>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_AddFan& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_AddFan& from) {
    CUserMsg_ParticleManager_AddFan::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(CUserMsg_ParticleManager_AddFan* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.AddFan";
  }
  protected:
  explicit CUserMsg_ParticleManager_AddFan(::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 {
    kFanForceCurveFieldNumber = 8,
    kAttachmentNameFieldNumber = 18,
    kBoundsMinsFieldNumber = 2,
    kBoundsMaxsFieldNumber = 3,
    kFanOriginFieldNumber = 4,
    kFanOriginOffsetFieldNumber = 5,
    kFanDirectionFieldNumber = 6,
    kActiveFieldNumber = 1,
    kFalloffFieldNumber = 9,
    kPullTowardsPointFieldNumber = 10,
    kForceFieldNumber = 7,
    kCurveMinDistFieldNumber = 11,
    kCurveMaxDistFieldNumber = 12,
    kFanTypeFieldNumber = 13,
    kConeStartRadiusFieldNumber = 14,
    kConeEndRadiusFieldNumber = 15,
    kConeLengthFieldNumber = 16,
    kEntityHandleFieldNumber = 17,
  };
  // optional string fan_force_curve = 8;
  bool has_fan_force_curve() const;
  private:
  bool _internal_has_fan_force_curve() const;
  public:
  void clear_fan_force_curve();
  const std::string& fan_force_curve() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fan_force_curve(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fan_force_curve();
  PROTOBUF_NODISCARD std::string* release_fan_force_curve();
  void set_allocated_fan_force_curve(std::string* fan_force_curve);
  private:
  const std::string& _internal_fan_force_curve() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fan_force_curve(const std::string& value);
  std::string* _internal_mutable_fan_force_curve();
  public:

  // optional string attachment_name = 18;
  bool has_attachment_name() const;
  private:
  bool _internal_has_attachment_name() const;
  public:
  void clear_attachment_name();
  const std::string& attachment_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachment_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachment_name();
  PROTOBUF_NODISCARD std::string* release_attachment_name();
  void set_allocated_attachment_name(std::string* attachment_name);
  private:
  const std::string& _internal_attachment_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachment_name(const std::string& value);
  std::string* _internal_mutable_attachment_name();
  public:

  // optional .CMsgVector bounds_mins = 2;
  bool has_bounds_mins() const;
  private:
  bool _internal_has_bounds_mins() const;
  public:
  void clear_bounds_mins();
  const ::CMsgVector& bounds_mins() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_bounds_mins();
  ::CMsgVector* mutable_bounds_mins();
  void set_allocated_bounds_mins(::CMsgVector* bounds_mins);
  private:
  const ::CMsgVector& _internal_bounds_mins() const;
  ::CMsgVector* _internal_mutable_bounds_mins();
  public:
  void unsafe_arena_set_allocated_bounds_mins(
      ::CMsgVector* bounds_mins);
  ::CMsgVector* unsafe_arena_release_bounds_mins();

  // optional .CMsgVector bounds_maxs = 3;
  bool has_bounds_maxs() const;
  private:
  bool _internal_has_bounds_maxs() const;
  public:
  void clear_bounds_maxs();
  const ::CMsgVector& bounds_maxs() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_bounds_maxs();
  ::CMsgVector* mutable_bounds_maxs();
  void set_allocated_bounds_maxs(::CMsgVector* bounds_maxs);
  private:
  const ::CMsgVector& _internal_bounds_maxs() const;
  ::CMsgVector* _internal_mutable_bounds_maxs();
  public:
  void unsafe_arena_set_allocated_bounds_maxs(
      ::CMsgVector* bounds_maxs);
  ::CMsgVector* unsafe_arena_release_bounds_maxs();

  // optional .CMsgVector fan_origin = 4;
  bool has_fan_origin() const;
  private:
  bool _internal_has_fan_origin() const;
  public:
  void clear_fan_origin();
  const ::CMsgVector& fan_origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_origin();
  ::CMsgVector* mutable_fan_origin();
  void set_allocated_fan_origin(::CMsgVector* fan_origin);
  private:
  const ::CMsgVector& _internal_fan_origin() const;
  ::CMsgVector* _internal_mutable_fan_origin();
  public:
  void unsafe_arena_set_allocated_fan_origin(
      ::CMsgVector* fan_origin);
  ::CMsgVector* unsafe_arena_release_fan_origin();

  // optional .CMsgVector fan_origin_offset = 5;
  bool has_fan_origin_offset() const;
  private:
  bool _internal_has_fan_origin_offset() const;
  public:
  void clear_fan_origin_offset();
  const ::CMsgVector& fan_origin_offset() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_origin_offset();
  ::CMsgVector* mutable_fan_origin_offset();
  void set_allocated_fan_origin_offset(::CMsgVector* fan_origin_offset);
  private:
  const ::CMsgVector& _internal_fan_origin_offset() const;
  ::CMsgVector* _internal_mutable_fan_origin_offset();
  public:
  void unsafe_arena_set_allocated_fan_origin_offset(
      ::CMsgVector* fan_origin_offset);
  ::CMsgVector* unsafe_arena_release_fan_origin_offset();

  // optional .CMsgVector fan_direction = 6;
  bool has_fan_direction() const;
  private:
  bool _internal_has_fan_direction() const;
  public:
  void clear_fan_direction();
  const ::CMsgVector& fan_direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_direction();
  ::CMsgVector* mutable_fan_direction();
  void set_allocated_fan_direction(::CMsgVector* fan_direction);
  private:
  const ::CMsgVector& _internal_fan_direction() const;
  ::CMsgVector* _internal_mutable_fan_direction();
  public:
  void unsafe_arena_set_allocated_fan_direction(
      ::CMsgVector* fan_direction);
  ::CMsgVector* unsafe_arena_release_fan_direction();

  // optional bool active = 1;
  bool has_active() const;
  private:
  bool _internal_has_active() const;
  public:
  void clear_active();
  bool active() const;
  void set_active(bool value);
  private:
  bool _internal_active() const;
  void _internal_set_active(bool value);
  public:

  // optional bool falloff = 9;
  bool has_falloff() const;
  private:
  bool _internal_has_falloff() const;
  public:
  void clear_falloff();
  bool falloff() const;
  void set_falloff(bool value);
  private:
  bool _internal_falloff() const;
  void _internal_set_falloff(bool value);
  public:

  // optional bool pull_towards_point = 10;
  bool has_pull_towards_point() const;
  private:
  bool _internal_has_pull_towards_point() const;
  public:
  void clear_pull_towards_point();
  bool pull_towards_point() const;
  void set_pull_towards_point(bool value);
  private:
  bool _internal_pull_towards_point() const;
  void _internal_set_pull_towards_point(bool value);
  public:

  // optional float force = 7;
  bool has_force() const;
  private:
  bool _internal_has_force() const;
  public:
  void clear_force();
  float force() const;
  void set_force(float value);
  private:
  float _internal_force() const;
  void _internal_set_force(float value);
  public:

  // optional float curve_min_dist = 11;
  bool has_curve_min_dist() const;
  private:
  bool _internal_has_curve_min_dist() const;
  public:
  void clear_curve_min_dist();
  float curve_min_dist() const;
  void set_curve_min_dist(float value);
  private:
  float _internal_curve_min_dist() const;
  void _internal_set_curve_min_dist(float value);
  public:

  // optional float curve_max_dist = 12;
  bool has_curve_max_dist() const;
  private:
  bool _internal_has_curve_max_dist() const;
  public:
  void clear_curve_max_dist();
  float curve_max_dist() const;
  void set_curve_max_dist(float value);
  private:
  float _internal_curve_max_dist() const;
  void _internal_set_curve_max_dist(float value);
  public:

  // optional uint32 fan_type = 13;
  bool has_fan_type() const;
  private:
  bool _internal_has_fan_type() const;
  public:
  void clear_fan_type();
  uint32_t fan_type() const;
  void set_fan_type(uint32_t value);
  private:
  uint32_t _internal_fan_type() const;
  void _internal_set_fan_type(uint32_t value);
  public:

  // optional float cone_start_radius = 14;
  bool has_cone_start_radius() const;
  private:
  bool _internal_has_cone_start_radius() const;
  public:
  void clear_cone_start_radius();
  float cone_start_radius() const;
  void set_cone_start_radius(float value);
  private:
  float _internal_cone_start_radius() const;
  void _internal_set_cone_start_radius(float value);
  public:

  // optional float cone_end_radius = 15;
  bool has_cone_end_radius() const;
  private:
  bool _internal_has_cone_end_radius() const;
  public:
  void clear_cone_end_radius();
  float cone_end_radius() const;
  void set_cone_end_radius(float value);
  private:
  float _internal_cone_end_radius() const;
  void _internal_set_cone_end_radius(float value);
  public:

  // optional float cone_length = 16;
  bool has_cone_length() const;
  private:
  bool _internal_has_cone_length() const;
  public:
  void clear_cone_length();
  float cone_length() const;
  void set_cone_length(float value);
  private:
  float _internal_cone_length() const;
  void _internal_set_cone_length(float value);
  public:

  // optional uint32 entity_handle = 17 [default = 16777215];
  bool has_entity_handle() const;
  private:
  bool _internal_has_entity_handle() const;
  public:
  void clear_entity_handle();
  uint32_t entity_handle() const;
  void set_entity_handle(uint32_t value);
  private:
  uint32_t _internal_entity_handle() const;
  void _internal_set_entity_handle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.AddFan)
 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 fan_force_curve_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachment_name_;
    ::CMsgVector* bounds_mins_;
    ::CMsgVector* bounds_maxs_;
    ::CMsgVector* fan_origin_;
    ::CMsgVector* fan_origin_offset_;
    ::CMsgVector* fan_direction_;
    bool active_;
    bool falloff_;
    bool pull_towards_point_;
    float force_;
    float curve_min_dist_;
    float curve_max_dist_;
    uint32_t fan_type_;
    float cone_start_radius_;
    float cone_end_radius_;
    float cone_length_;
    uint32_t entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_UpdateFan& operator=(const CUserMsg_ParticleManager_UpdateFan& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_UpdateFan& operator=(CUserMsg_ParticleManager_UpdateFan&& 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 CUserMsg_ParticleManager_UpdateFan& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_UpdateFan* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_UpdateFan*>(
               &_CUserMsg_ParticleManager_UpdateFan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

  friend void swap(CUserMsg_ParticleManager_UpdateFan& a, CUserMsg_ParticleManager_UpdateFan& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_UpdateFan* 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(CUserMsg_ParticleManager_UpdateFan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_UpdateFan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_UpdateFan>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_UpdateFan& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_UpdateFan& from) {
    CUserMsg_ParticleManager_UpdateFan::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(CUserMsg_ParticleManager_UpdateFan* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.UpdateFan";
  }
  protected:
  explicit CUserMsg_ParticleManager_UpdateFan(::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 {
    kFanOriginFieldNumber = 2,
    kFanOriginOffsetFieldNumber = 3,
    kFanDirectionFieldNumber = 4,
    kBoundsMinsFieldNumber = 5,
    kBoundsMaxsFieldNumber = 6,
    kActiveFieldNumber = 1,
    kFanRampRatioFieldNumber = 7,
  };
  // optional .CMsgVector fan_origin = 2;
  bool has_fan_origin() const;
  private:
  bool _internal_has_fan_origin() const;
  public:
  void clear_fan_origin();
  const ::CMsgVector& fan_origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_origin();
  ::CMsgVector* mutable_fan_origin();
  void set_allocated_fan_origin(::CMsgVector* fan_origin);
  private:
  const ::CMsgVector& _internal_fan_origin() const;
  ::CMsgVector* _internal_mutable_fan_origin();
  public:
  void unsafe_arena_set_allocated_fan_origin(
      ::CMsgVector* fan_origin);
  ::CMsgVector* unsafe_arena_release_fan_origin();

  // optional .CMsgVector fan_origin_offset = 3;
  bool has_fan_origin_offset() const;
  private:
  bool _internal_has_fan_origin_offset() const;
  public:
  void clear_fan_origin_offset();
  const ::CMsgVector& fan_origin_offset() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_origin_offset();
  ::CMsgVector* mutable_fan_origin_offset();
  void set_allocated_fan_origin_offset(::CMsgVector* fan_origin_offset);
  private:
  const ::CMsgVector& _internal_fan_origin_offset() const;
  ::CMsgVector* _internal_mutable_fan_origin_offset();
  public:
  void unsafe_arena_set_allocated_fan_origin_offset(
      ::CMsgVector* fan_origin_offset);
  ::CMsgVector* unsafe_arena_release_fan_origin_offset();

  // optional .CMsgVector fan_direction = 4;
  bool has_fan_direction() const;
  private:
  bool _internal_has_fan_direction() const;
  public:
  void clear_fan_direction();
  const ::CMsgVector& fan_direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_fan_direction();
  ::CMsgVector* mutable_fan_direction();
  void set_allocated_fan_direction(::CMsgVector* fan_direction);
  private:
  const ::CMsgVector& _internal_fan_direction() const;
  ::CMsgVector* _internal_mutable_fan_direction();
  public:
  void unsafe_arena_set_allocated_fan_direction(
      ::CMsgVector* fan_direction);
  ::CMsgVector* unsafe_arena_release_fan_direction();

  // optional .CMsgVector bounds_mins = 5;
  bool has_bounds_mins() const;
  private:
  bool _internal_has_bounds_mins() const;
  public:
  void clear_bounds_mins();
  const ::CMsgVector& bounds_mins() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_bounds_mins();
  ::CMsgVector* mutable_bounds_mins();
  void set_allocated_bounds_mins(::CMsgVector* bounds_mins);
  private:
  const ::CMsgVector& _internal_bounds_mins() const;
  ::CMsgVector* _internal_mutable_bounds_mins();
  public:
  void unsafe_arena_set_allocated_bounds_mins(
      ::CMsgVector* bounds_mins);
  ::CMsgVector* unsafe_arena_release_bounds_mins();

  // optional .CMsgVector bounds_maxs = 6;
  bool has_bounds_maxs() const;
  private:
  bool _internal_has_bounds_maxs() const;
  public:
  void clear_bounds_maxs();
  const ::CMsgVector& bounds_maxs() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_bounds_maxs();
  ::CMsgVector* mutable_bounds_maxs();
  void set_allocated_bounds_maxs(::CMsgVector* bounds_maxs);
  private:
  const ::CMsgVector& _internal_bounds_maxs() const;
  ::CMsgVector* _internal_mutable_bounds_maxs();
  public:
  void unsafe_arena_set_allocated_bounds_maxs(
      ::CMsgVector* bounds_maxs);
  ::CMsgVector* unsafe_arena_release_bounds_maxs();

  // optional bool active = 1;
  bool has_active() const;
  private:
  bool _internal_has_active() const;
  public:
  void clear_active();
  bool active() const;
  void set_active(bool value);
  private:
  bool _internal_active() const;
  void _internal_set_active(bool value);
  public:

  // optional float fan_ramp_ratio = 7;
  bool has_fan_ramp_ratio() const;
  private:
  bool _internal_has_fan_ramp_ratio() const;
  public:
  void clear_fan_ramp_ratio();
  float fan_ramp_ratio() const;
  void set_fan_ramp_ratio(float value);
  private:
  float _internal_fan_ramp_ratio() const;
  void _internal_set_fan_ramp_ratio(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.UpdateFan)
 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_;
    ::CMsgVector* fan_origin_;
    ::CMsgVector* fan_origin_offset_;
    ::CMsgVector* fan_direction_;
    ::CMsgVector* bounds_mins_;
    ::CMsgVector* bounds_maxs_;
    bool active_;
    float fan_ramp_ratio_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager_RemoveFan& operator=(const CUserMsg_ParticleManager_RemoveFan& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_RemoveFan& operator=(CUserMsg_ParticleManager_RemoveFan&& 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 CUserMsg_ParticleManager_RemoveFan& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_RemoveFan* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_RemoveFan*>(
               &_CUserMsg_ParticleManager_RemoveFan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

  friend void swap(CUserMsg_ParticleManager_RemoveFan& a, CUserMsg_ParticleManager_RemoveFan& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_RemoveFan* 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(CUserMsg_ParticleManager_RemoveFan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_RemoveFan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_RemoveFan>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CUserMsg_ParticleManager_RemoveFan& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CUserMsg_ParticleManager_RemoveFan& 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 "CUserMsg_ParticleManager.RemoveFan";
  }
  protected:
  explicit CUserMsg_ParticleManager_RemoveFan(::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:CUserMsg_ParticleManager.RemoveFan)
 private:
  class _Internal;

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

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

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

  inline CUserMsg_ParticleManager_SetParticleClusterGrowth& operator=(const CUserMsg_ParticleManager_SetParticleClusterGrowth& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager_SetParticleClusterGrowth& operator=(CUserMsg_ParticleManager_SetParticleClusterGrowth&& 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 CUserMsg_ParticleManager_SetParticleClusterGrowth& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager_SetParticleClusterGrowth* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager_SetParticleClusterGrowth*>(
               &_CUserMsg_ParticleManager_SetParticleClusterGrowth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

  friend void swap(CUserMsg_ParticleManager_SetParticleClusterGrowth& a, CUserMsg_ParticleManager_SetParticleClusterGrowth& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager_SetParticleClusterGrowth* 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(CUserMsg_ParticleManager_SetParticleClusterGrowth* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager_SetParticleClusterGrowth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager_SetParticleClusterGrowth>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager_SetParticleClusterGrowth& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager_SetParticleClusterGrowth& from) {
    CUserMsg_ParticleManager_SetParticleClusterGrowth::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(CUserMsg_ParticleManager_SetParticleClusterGrowth* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager.SetParticleClusterGrowth";
  }
  protected:
  explicit CUserMsg_ParticleManager_SetParticleClusterGrowth(::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 {
    kOriginFieldNumber = 2,
    kDurationFieldNumber = 1,
  };
  // optional .CMsgVector origin = 2;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional float duration = 1;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  float duration() const;
  void set_duration(float value);
  private:
  float _internal_duration() const;
  void _internal_set_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager.SetParticleClusterGrowth)
 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_;
    ::CMsgVector* origin_;
    float duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_ParticleManager& operator=(const CUserMsg_ParticleManager& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_ParticleManager& operator=(CUserMsg_ParticleManager&& 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 CUserMsg_ParticleManager& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_ParticleManager* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_ParticleManager*>(
               &_CUserMsg_ParticleManager_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  friend void swap(CUserMsg_ParticleManager& a, CUserMsg_ParticleManager& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_ParticleManager* 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(CUserMsg_ParticleManager* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_ParticleManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_ParticleManager>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_ParticleManager& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_ParticleManager& from) {
    CUserMsg_ParticleManager::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(CUserMsg_ParticleManager* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_ParticleManager";
  }
  protected:
  explicit CUserMsg_ParticleManager(::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 CUserMsg_ParticleManager_ReleaseParticleIndex ReleaseParticleIndex;
  typedef CUserMsg_ParticleManager_CreateParticle CreateParticle;
  typedef CUserMsg_ParticleManager_DestroyParticle DestroyParticle;
  typedef CUserMsg_ParticleManager_DestroyParticleInvolving DestroyParticleInvolving;
  typedef CUserMsg_ParticleManager_DestroyParticleNamed DestroyParticleNamed;
  typedef CUserMsg_ParticleManager_UpdateParticle_OBSOLETE UpdateParticle_OBSOLETE;
  typedef CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE UpdateParticleFwd_OBSOLETE;
  typedef CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE UpdateParticleOrient_OBSOLETE;
  typedef CUserMsg_ParticleManager_UpdateParticleTransform UpdateParticleTransform;
  typedef CUserMsg_ParticleManager_UpdateParticleFallback UpdateParticleFallback;
  typedef CUserMsg_ParticleManager_UpdateParticleOffset UpdateParticleOffset;
  typedef CUserMsg_ParticleManager_UpdateParticleEnt UpdateParticleEnt;
  typedef CUserMsg_ParticleManager_UpdateParticleSetFrozen UpdateParticleSetFrozen;
  typedef CUserMsg_ParticleManager_UpdateParticleShouldDraw UpdateParticleShouldDraw;
  typedef CUserMsg_ParticleManager_ChangeControlPointAttachment ChangeControlPointAttachment;
  typedef CUserMsg_ParticleManager_UpdateEntityPosition UpdateEntityPosition;
  typedef CUserMsg_ParticleManager_SetParticleFoWProperties SetParticleFoWProperties;
  typedef CUserMsg_ParticleManager_SetParticleShouldCheckFoW SetParticleShouldCheckFoW;
  typedef CUserMsg_ParticleManager_SetControlPointModel SetControlPointModel;
  typedef CUserMsg_ParticleManager_SetControlPointSnapshot SetControlPointSnapshot;
  typedef CUserMsg_ParticleManager_SetParticleText SetParticleText;
  typedef CUserMsg_ParticleManager_SetTextureAttribute SetTextureAttribute;
  typedef CUserMsg_ParticleManager_SetSceneObjectGenericFlag SetSceneObjectGenericFlag;
  typedef CUserMsg_ParticleManager_SetSceneObjectTintAndDesat SetSceneObjectTintAndDesat;
  typedef CUserMsg_ParticleManager_ParticleSkipToTime ParticleSkipToTime;
  typedef CUserMsg_ParticleManager_ParticleCanFreeze ParticleCanFreeze;
  typedef CUserMsg_ParticleManager_ParticleFreezeTransitionOverride ParticleFreezeTransitionOverride;
  typedef CUserMsg_ParticleManager_FreezeParticleInvolving FreezeParticleInvolving;
  typedef CUserMsg_ParticleManager_AddModellistOverrideElement AddModellistOverrideElement;
  typedef CUserMsg_ParticleManager_ClearModellistOverride ClearModellistOverride;
  typedef CUserMsg_ParticleManager_SetParticleNamedValueContext SetParticleNamedValueContext;
  typedef CUserMsg_ParticleManager_CreatePhysicsSim CreatePhysicsSim;
  typedef CUserMsg_ParticleManager_DestroyPhysicsSim DestroyPhysicsSim;
  typedef CUserMsg_ParticleManager_SetVData SetVData;
  typedef CUserMsg_ParticleManager_SetMaterialOverride SetMaterialOverride;
  typedef CUserMsg_ParticleManager_AddFan AddFan;
  typedef CUserMsg_ParticleManager_UpdateFan UpdateFan;
  typedef CUserMsg_ParticleManager_RemoveFan RemoveFan;
  typedef CUserMsg_ParticleManager_SetParticleClusterGrowth SetParticleClusterGrowth;

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

  enum : int {
    kReleaseParticleIndexFieldNumber = 3,
    kCreateParticleFieldNumber = 4,
    kDestroyParticleFieldNumber = 5,
    kDestroyParticleInvolvingFieldNumber = 6,
    kUpdateParticleFieldNumber = 7,
    kUpdateParticleFwdFieldNumber = 8,
    kUpdateParticleOrientFieldNumber = 9,
    kUpdateParticleFallbackFieldNumber = 10,
    kUpdateParticleOffsetFieldNumber = 11,
    kUpdateParticleEntFieldNumber = 12,
    kUpdateParticleShouldDrawFieldNumber = 14,
    kUpdateParticleSetFrozenFieldNumber = 15,
    kChangeControlPointAttachmentFieldNumber = 16,
    kUpdateEntityPositionFieldNumber = 17,
    kSetParticleFowPropertiesFieldNumber = 18,
    kSetParticleTextFieldNumber = 19,
    kSetParticleShouldCheckFowFieldNumber = 20,
    kSetControlPointModelFieldNumber = 21,
    kSetControlPointSnapshotFieldNumber = 22,
    kSetTextureAttributeFieldNumber = 23,
    kSetSceneObjectGenericFlagFieldNumber = 24,
    kSetSceneObjectTintAndDesatFieldNumber = 25,
    kDestroyParticleNamedFieldNumber = 26,
    kParticleSkipToTimeFieldNumber = 27,
    kParticleCanFreezeFieldNumber = 28,
    kSetNamedValueContextFieldNumber = 29,
    kUpdateParticleTransformFieldNumber = 30,
    kParticleFreezeTransitionOverrideFieldNumber = 31,
    kFreezeParticleInvolvingFieldNumber = 32,
    kAddModellistOverrideElementFieldNumber = 33,
    kClearModellistOverrideFieldNumber = 34,
    kCreatePhysicsSimFieldNumber = 35,
    kDestroyPhysicsSimFieldNumber = 36,
    kSetVdataFieldNumber = 37,
    kSetMaterialOverrideFieldNumber = 38,
    kAddFanFieldNumber = 39,
    kUpdateFanFieldNumber = 40,
    kSetParticleClusterGrowthFieldNumber = 41,
    kRemoveFanFieldNumber = 42,
    kTypeFieldNumber = 1,
    kIndexFieldNumber = 2,
  };
  // optional .CUserMsg_ParticleManager.ReleaseParticleIndex release_particle_index = 3;
  bool has_release_particle_index() const;
  private:
  bool _internal_has_release_particle_index() const;
  public:
  void clear_release_particle_index();
  const ::CUserMsg_ParticleManager_ReleaseParticleIndex& release_particle_index() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ReleaseParticleIndex* release_release_particle_index();
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* mutable_release_particle_index();
  void set_allocated_release_particle_index(::CUserMsg_ParticleManager_ReleaseParticleIndex* release_particle_index);
  private:
  const ::CUserMsg_ParticleManager_ReleaseParticleIndex& _internal_release_particle_index() const;
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* _internal_mutable_release_particle_index();
  public:
  void unsafe_arena_set_allocated_release_particle_index(
      ::CUserMsg_ParticleManager_ReleaseParticleIndex* release_particle_index);
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* unsafe_arena_release_release_particle_index();

  // optional .CUserMsg_ParticleManager.CreateParticle create_particle = 4;
  bool has_create_particle() const;
  private:
  bool _internal_has_create_particle() const;
  public:
  void clear_create_particle();
  const ::CUserMsg_ParticleManager_CreateParticle& create_particle() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_CreateParticle* release_create_particle();
  ::CUserMsg_ParticleManager_CreateParticle* mutable_create_particle();
  void set_allocated_create_particle(::CUserMsg_ParticleManager_CreateParticle* create_particle);
  private:
  const ::CUserMsg_ParticleManager_CreateParticle& _internal_create_particle() const;
  ::CUserMsg_ParticleManager_CreateParticle* _internal_mutable_create_particle();
  public:
  void unsafe_arena_set_allocated_create_particle(
      ::CUserMsg_ParticleManager_CreateParticle* create_particle);
  ::CUserMsg_ParticleManager_CreateParticle* unsafe_arena_release_create_particle();

  // optional .CUserMsg_ParticleManager.DestroyParticle destroy_particle = 5;
  bool has_destroy_particle() const;
  private:
  bool _internal_has_destroy_particle() const;
  public:
  void clear_destroy_particle();
  const ::CUserMsg_ParticleManager_DestroyParticle& destroy_particle() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_DestroyParticle* release_destroy_particle();
  ::CUserMsg_ParticleManager_DestroyParticle* mutable_destroy_particle();
  void set_allocated_destroy_particle(::CUserMsg_ParticleManager_DestroyParticle* destroy_particle);
  private:
  const ::CUserMsg_ParticleManager_DestroyParticle& _internal_destroy_particle() const;
  ::CUserMsg_ParticleManager_DestroyParticle* _internal_mutable_destroy_particle();
  public:
  void unsafe_arena_set_allocated_destroy_particle(
      ::CUserMsg_ParticleManager_DestroyParticle* destroy_particle);
  ::CUserMsg_ParticleManager_DestroyParticle* unsafe_arena_release_destroy_particle();

  // optional .CUserMsg_ParticleManager.DestroyParticleInvolving destroy_particle_involving = 6;
  bool has_destroy_particle_involving() const;
  private:
  bool _internal_has_destroy_particle_involving() const;
  public:
  void clear_destroy_particle_involving();
  const ::CUserMsg_ParticleManager_DestroyParticleInvolving& destroy_particle_involving() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_DestroyParticleInvolving* release_destroy_particle_involving();
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* mutable_destroy_particle_involving();
  void set_allocated_destroy_particle_involving(::CUserMsg_ParticleManager_DestroyParticleInvolving* destroy_particle_involving);
  private:
  const ::CUserMsg_ParticleManager_DestroyParticleInvolving& _internal_destroy_particle_involving() const;
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* _internal_mutable_destroy_particle_involving();
  public:
  void unsafe_arena_set_allocated_destroy_particle_involving(
      ::CUserMsg_ParticleManager_DestroyParticleInvolving* destroy_particle_involving);
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* unsafe_arena_release_destroy_particle_involving();

  // optional .CUserMsg_ParticleManager.UpdateParticle_OBSOLETE update_particle = 7;
  bool has_update_particle() const;
  private:
  bool _internal_has_update_particle() const;
  public:
  void clear_update_particle();
  const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& update_particle() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* release_update_particle();
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* mutable_update_particle();
  void set_allocated_update_particle(::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* update_particle);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& _internal_update_particle() const;
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* _internal_mutable_update_particle();
  public:
  void unsafe_arena_set_allocated_update_particle(
      ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* update_particle);
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* unsafe_arena_release_update_particle();

  // optional .CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE update_particle_fwd = 8;
  bool has_update_particle_fwd() const;
  private:
  bool _internal_has_update_particle_fwd() const;
  public:
  void clear_update_particle_fwd();
  const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& update_particle_fwd() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* release_update_particle_fwd();
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* mutable_update_particle_fwd();
  void set_allocated_update_particle_fwd(::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* update_particle_fwd);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& _internal_update_particle_fwd() const;
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* _internal_mutable_update_particle_fwd();
  public:
  void unsafe_arena_set_allocated_update_particle_fwd(
      ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* update_particle_fwd);
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* unsafe_arena_release_update_particle_fwd();

  // optional .CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE update_particle_orient = 9;
  bool has_update_particle_orient() const;
  private:
  bool _internal_has_update_particle_orient() const;
  public:
  void clear_update_particle_orient();
  const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& update_particle_orient() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* release_update_particle_orient();
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* mutable_update_particle_orient();
  void set_allocated_update_particle_orient(::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* update_particle_orient);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& _internal_update_particle_orient() const;
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* _internal_mutable_update_particle_orient();
  public:
  void unsafe_arena_set_allocated_update_particle_orient(
      ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* update_particle_orient);
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* unsafe_arena_release_update_particle_orient();

  // optional .CUserMsg_ParticleManager.UpdateParticleFallback update_particle_fallback = 10;
  bool has_update_particle_fallback() const;
  private:
  bool _internal_has_update_particle_fallback() const;
  public:
  void clear_update_particle_fallback();
  const ::CUserMsg_ParticleManager_UpdateParticleFallback& update_particle_fallback() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleFallback* release_update_particle_fallback();
  ::CUserMsg_ParticleManager_UpdateParticleFallback* mutable_update_particle_fallback();
  void set_allocated_update_particle_fallback(::CUserMsg_ParticleManager_UpdateParticleFallback* update_particle_fallback);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleFallback& _internal_update_particle_fallback() const;
  ::CUserMsg_ParticleManager_UpdateParticleFallback* _internal_mutable_update_particle_fallback();
  public:
  void unsafe_arena_set_allocated_update_particle_fallback(
      ::CUserMsg_ParticleManager_UpdateParticleFallback* update_particle_fallback);
  ::CUserMsg_ParticleManager_UpdateParticleFallback* unsafe_arena_release_update_particle_fallback();

  // optional .CUserMsg_ParticleManager.UpdateParticleOffset update_particle_offset = 11;
  bool has_update_particle_offset() const;
  private:
  bool _internal_has_update_particle_offset() const;
  public:
  void clear_update_particle_offset();
  const ::CUserMsg_ParticleManager_UpdateParticleOffset& update_particle_offset() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleOffset* release_update_particle_offset();
  ::CUserMsg_ParticleManager_UpdateParticleOffset* mutable_update_particle_offset();
  void set_allocated_update_particle_offset(::CUserMsg_ParticleManager_UpdateParticleOffset* update_particle_offset);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleOffset& _internal_update_particle_offset() const;
  ::CUserMsg_ParticleManager_UpdateParticleOffset* _internal_mutable_update_particle_offset();
  public:
  void unsafe_arena_set_allocated_update_particle_offset(
      ::CUserMsg_ParticleManager_UpdateParticleOffset* update_particle_offset);
  ::CUserMsg_ParticleManager_UpdateParticleOffset* unsafe_arena_release_update_particle_offset();

  // optional .CUserMsg_ParticleManager.UpdateParticleEnt update_particle_ent = 12;
  bool has_update_particle_ent() const;
  private:
  bool _internal_has_update_particle_ent() const;
  public:
  void clear_update_particle_ent();
  const ::CUserMsg_ParticleManager_UpdateParticleEnt& update_particle_ent() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleEnt* release_update_particle_ent();
  ::CUserMsg_ParticleManager_UpdateParticleEnt* mutable_update_particle_ent();
  void set_allocated_update_particle_ent(::CUserMsg_ParticleManager_UpdateParticleEnt* update_particle_ent);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleEnt& _internal_update_particle_ent() const;
  ::CUserMsg_ParticleManager_UpdateParticleEnt* _internal_mutable_update_particle_ent();
  public:
  void unsafe_arena_set_allocated_update_particle_ent(
      ::CUserMsg_ParticleManager_UpdateParticleEnt* update_particle_ent);
  ::CUserMsg_ParticleManager_UpdateParticleEnt* unsafe_arena_release_update_particle_ent();

  // optional .CUserMsg_ParticleManager.UpdateParticleShouldDraw update_particle_should_draw = 14;
  bool has_update_particle_should_draw() const;
  private:
  bool _internal_has_update_particle_should_draw() const;
  public:
  void clear_update_particle_should_draw();
  const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw& update_particle_should_draw() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* release_update_particle_should_draw();
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* mutable_update_particle_should_draw();
  void set_allocated_update_particle_should_draw(::CUserMsg_ParticleManager_UpdateParticleShouldDraw* update_particle_should_draw);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw& _internal_update_particle_should_draw() const;
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* _internal_mutable_update_particle_should_draw();
  public:
  void unsafe_arena_set_allocated_update_particle_should_draw(
      ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* update_particle_should_draw);
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* unsafe_arena_release_update_particle_should_draw();

  // optional .CUserMsg_ParticleManager.UpdateParticleSetFrozen update_particle_set_frozen = 15;
  bool has_update_particle_set_frozen() const;
  private:
  bool _internal_has_update_particle_set_frozen() const;
  public:
  void clear_update_particle_set_frozen();
  const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen& update_particle_set_frozen() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* release_update_particle_set_frozen();
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* mutable_update_particle_set_frozen();
  void set_allocated_update_particle_set_frozen(::CUserMsg_ParticleManager_UpdateParticleSetFrozen* update_particle_set_frozen);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen& _internal_update_particle_set_frozen() const;
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* _internal_mutable_update_particle_set_frozen();
  public:
  void unsafe_arena_set_allocated_update_particle_set_frozen(
      ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* update_particle_set_frozen);
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* unsafe_arena_release_update_particle_set_frozen();

  // optional .CUserMsg_ParticleManager.ChangeControlPointAttachment change_control_point_attachment = 16;
  bool has_change_control_point_attachment() const;
  private:
  bool _internal_has_change_control_point_attachment() const;
  public:
  void clear_change_control_point_attachment();
  const ::CUserMsg_ParticleManager_ChangeControlPointAttachment& change_control_point_attachment() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ChangeControlPointAttachment* release_change_control_point_attachment();
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* mutable_change_control_point_attachment();
  void set_allocated_change_control_point_attachment(::CUserMsg_ParticleManager_ChangeControlPointAttachment* change_control_point_attachment);
  private:
  const ::CUserMsg_ParticleManager_ChangeControlPointAttachment& _internal_change_control_point_attachment() const;
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* _internal_mutable_change_control_point_attachment();
  public:
  void unsafe_arena_set_allocated_change_control_point_attachment(
      ::CUserMsg_ParticleManager_ChangeControlPointAttachment* change_control_point_attachment);
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* unsafe_arena_release_change_control_point_attachment();

  // optional .CUserMsg_ParticleManager.UpdateEntityPosition update_entity_position = 17;
  bool has_update_entity_position() const;
  private:
  bool _internal_has_update_entity_position() const;
  public:
  void clear_update_entity_position();
  const ::CUserMsg_ParticleManager_UpdateEntityPosition& update_entity_position() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateEntityPosition* release_update_entity_position();
  ::CUserMsg_ParticleManager_UpdateEntityPosition* mutable_update_entity_position();
  void set_allocated_update_entity_position(::CUserMsg_ParticleManager_UpdateEntityPosition* update_entity_position);
  private:
  const ::CUserMsg_ParticleManager_UpdateEntityPosition& _internal_update_entity_position() const;
  ::CUserMsg_ParticleManager_UpdateEntityPosition* _internal_mutable_update_entity_position();
  public:
  void unsafe_arena_set_allocated_update_entity_position(
      ::CUserMsg_ParticleManager_UpdateEntityPosition* update_entity_position);
  ::CUserMsg_ParticleManager_UpdateEntityPosition* unsafe_arena_release_update_entity_position();

  // optional .CUserMsg_ParticleManager.SetParticleFoWProperties set_particle_fow_properties = 18;
  bool has_set_particle_fow_properties() const;
  private:
  bool _internal_has_set_particle_fow_properties() const;
  public:
  void clear_set_particle_fow_properties();
  const ::CUserMsg_ParticleManager_SetParticleFoWProperties& set_particle_fow_properties() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetParticleFoWProperties* release_set_particle_fow_properties();
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* mutable_set_particle_fow_properties();
  void set_allocated_set_particle_fow_properties(::CUserMsg_ParticleManager_SetParticleFoWProperties* set_particle_fow_properties);
  private:
  const ::CUserMsg_ParticleManager_SetParticleFoWProperties& _internal_set_particle_fow_properties() const;
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* _internal_mutable_set_particle_fow_properties();
  public:
  void unsafe_arena_set_allocated_set_particle_fow_properties(
      ::CUserMsg_ParticleManager_SetParticleFoWProperties* set_particle_fow_properties);
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* unsafe_arena_release_set_particle_fow_properties();

  // optional .CUserMsg_ParticleManager.SetParticleText set_particle_text = 19;
  bool has_set_particle_text() const;
  private:
  bool _internal_has_set_particle_text() const;
  public:
  void clear_set_particle_text();
  const ::CUserMsg_ParticleManager_SetParticleText& set_particle_text() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetParticleText* release_set_particle_text();
  ::CUserMsg_ParticleManager_SetParticleText* mutable_set_particle_text();
  void set_allocated_set_particle_text(::CUserMsg_ParticleManager_SetParticleText* set_particle_text);
  private:
  const ::CUserMsg_ParticleManager_SetParticleText& _internal_set_particle_text() const;
  ::CUserMsg_ParticleManager_SetParticleText* _internal_mutable_set_particle_text();
  public:
  void unsafe_arena_set_allocated_set_particle_text(
      ::CUserMsg_ParticleManager_SetParticleText* set_particle_text);
  ::CUserMsg_ParticleManager_SetParticleText* unsafe_arena_release_set_particle_text();

  // optional .CUserMsg_ParticleManager.SetParticleShouldCheckFoW set_particle_should_check_fow = 20;
  bool has_set_particle_should_check_fow() const;
  private:
  bool _internal_has_set_particle_should_check_fow() const;
  public:
  void clear_set_particle_should_check_fow();
  const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW& set_particle_should_check_fow() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* release_set_particle_should_check_fow();
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* mutable_set_particle_should_check_fow();
  void set_allocated_set_particle_should_check_fow(::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* set_particle_should_check_fow);
  private:
  const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW& _internal_set_particle_should_check_fow() const;
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* _internal_mutable_set_particle_should_check_fow();
  public:
  void unsafe_arena_set_allocated_set_particle_should_check_fow(
      ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* set_particle_should_check_fow);
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* unsafe_arena_release_set_particle_should_check_fow();

  // optional .CUserMsg_ParticleManager.SetControlPointModel set_control_point_model = 21;
  bool has_set_control_point_model() const;
  private:
  bool _internal_has_set_control_point_model() const;
  public:
  void clear_set_control_point_model();
  const ::CUserMsg_ParticleManager_SetControlPointModel& set_control_point_model() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetControlPointModel* release_set_control_point_model();
  ::CUserMsg_ParticleManager_SetControlPointModel* mutable_set_control_point_model();
  void set_allocated_set_control_point_model(::CUserMsg_ParticleManager_SetControlPointModel* set_control_point_model);
  private:
  const ::CUserMsg_ParticleManager_SetControlPointModel& _internal_set_control_point_model() const;
  ::CUserMsg_ParticleManager_SetControlPointModel* _internal_mutable_set_control_point_model();
  public:
  void unsafe_arena_set_allocated_set_control_point_model(
      ::CUserMsg_ParticleManager_SetControlPointModel* set_control_point_model);
  ::CUserMsg_ParticleManager_SetControlPointModel* unsafe_arena_release_set_control_point_model();

  // optional .CUserMsg_ParticleManager.SetControlPointSnapshot set_control_point_snapshot = 22;
  bool has_set_control_point_snapshot() const;
  private:
  bool _internal_has_set_control_point_snapshot() const;
  public:
  void clear_set_control_point_snapshot();
  const ::CUserMsg_ParticleManager_SetControlPointSnapshot& set_control_point_snapshot() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetControlPointSnapshot* release_set_control_point_snapshot();
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* mutable_set_control_point_snapshot();
  void set_allocated_set_control_point_snapshot(::CUserMsg_ParticleManager_SetControlPointSnapshot* set_control_point_snapshot);
  private:
  const ::CUserMsg_ParticleManager_SetControlPointSnapshot& _internal_set_control_point_snapshot() const;
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* _internal_mutable_set_control_point_snapshot();
  public:
  void unsafe_arena_set_allocated_set_control_point_snapshot(
      ::CUserMsg_ParticleManager_SetControlPointSnapshot* set_control_point_snapshot);
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* unsafe_arena_release_set_control_point_snapshot();

  // optional .CUserMsg_ParticleManager.SetTextureAttribute set_texture_attribute = 23;
  bool has_set_texture_attribute() const;
  private:
  bool _internal_has_set_texture_attribute() const;
  public:
  void clear_set_texture_attribute();
  const ::CUserMsg_ParticleManager_SetTextureAttribute& set_texture_attribute() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetTextureAttribute* release_set_texture_attribute();
  ::CUserMsg_ParticleManager_SetTextureAttribute* mutable_set_texture_attribute();
  void set_allocated_set_texture_attribute(::CUserMsg_ParticleManager_SetTextureAttribute* set_texture_attribute);
  private:
  const ::CUserMsg_ParticleManager_SetTextureAttribute& _internal_set_texture_attribute() const;
  ::CUserMsg_ParticleManager_SetTextureAttribute* _internal_mutable_set_texture_attribute();
  public:
  void unsafe_arena_set_allocated_set_texture_attribute(
      ::CUserMsg_ParticleManager_SetTextureAttribute* set_texture_attribute);
  ::CUserMsg_ParticleManager_SetTextureAttribute* unsafe_arena_release_set_texture_attribute();

  // optional .CUserMsg_ParticleManager.SetSceneObjectGenericFlag set_scene_object_generic_flag = 24;
  bool has_set_scene_object_generic_flag() const;
  private:
  bool _internal_has_set_scene_object_generic_flag() const;
  public:
  void clear_set_scene_object_generic_flag();
  const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag& set_scene_object_generic_flag() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* release_set_scene_object_generic_flag();
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* mutable_set_scene_object_generic_flag();
  void set_allocated_set_scene_object_generic_flag(::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* set_scene_object_generic_flag);
  private:
  const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag& _internal_set_scene_object_generic_flag() const;
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* _internal_mutable_set_scene_object_generic_flag();
  public:
  void unsafe_arena_set_allocated_set_scene_object_generic_flag(
      ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* set_scene_object_generic_flag);
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* unsafe_arena_release_set_scene_object_generic_flag();

  // optional .CUserMsg_ParticleManager.SetSceneObjectTintAndDesat set_scene_object_tint_and_desat = 25;
  bool has_set_scene_object_tint_and_desat() const;
  private:
  bool _internal_has_set_scene_object_tint_and_desat() const;
  public:
  void clear_set_scene_object_tint_and_desat();
  const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& set_scene_object_tint_and_desat() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* release_set_scene_object_tint_and_desat();
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* mutable_set_scene_object_tint_and_desat();
  void set_allocated_set_scene_object_tint_and_desat(::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* set_scene_object_tint_and_desat);
  private:
  const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& _internal_set_scene_object_tint_and_desat() const;
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* _internal_mutable_set_scene_object_tint_and_desat();
  public:
  void unsafe_arena_set_allocated_set_scene_object_tint_and_desat(
      ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* set_scene_object_tint_and_desat);
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* unsafe_arena_release_set_scene_object_tint_and_desat();

  // optional .CUserMsg_ParticleManager.DestroyParticleNamed destroy_particle_named = 26;
  bool has_destroy_particle_named() const;
  private:
  bool _internal_has_destroy_particle_named() const;
  public:
  void clear_destroy_particle_named();
  const ::CUserMsg_ParticleManager_DestroyParticleNamed& destroy_particle_named() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_DestroyParticleNamed* release_destroy_particle_named();
  ::CUserMsg_ParticleManager_DestroyParticleNamed* mutable_destroy_particle_named();
  void set_allocated_destroy_particle_named(::CUserMsg_ParticleManager_DestroyParticleNamed* destroy_particle_named);
  private:
  const ::CUserMsg_ParticleManager_DestroyParticleNamed& _internal_destroy_particle_named() const;
  ::CUserMsg_ParticleManager_DestroyParticleNamed* _internal_mutable_destroy_particle_named();
  public:
  void unsafe_arena_set_allocated_destroy_particle_named(
      ::CUserMsg_ParticleManager_DestroyParticleNamed* destroy_particle_named);
  ::CUserMsg_ParticleManager_DestroyParticleNamed* unsafe_arena_release_destroy_particle_named();

  // optional .CUserMsg_ParticleManager.ParticleSkipToTime particle_skip_to_time = 27;
  bool has_particle_skip_to_time() const;
  private:
  bool _internal_has_particle_skip_to_time() const;
  public:
  void clear_particle_skip_to_time();
  const ::CUserMsg_ParticleManager_ParticleSkipToTime& particle_skip_to_time() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ParticleSkipToTime* release_particle_skip_to_time();
  ::CUserMsg_ParticleManager_ParticleSkipToTime* mutable_particle_skip_to_time();
  void set_allocated_particle_skip_to_time(::CUserMsg_ParticleManager_ParticleSkipToTime* particle_skip_to_time);
  private:
  const ::CUserMsg_ParticleManager_ParticleSkipToTime& _internal_particle_skip_to_time() const;
  ::CUserMsg_ParticleManager_ParticleSkipToTime* _internal_mutable_particle_skip_to_time();
  public:
  void unsafe_arena_set_allocated_particle_skip_to_time(
      ::CUserMsg_ParticleManager_ParticleSkipToTime* particle_skip_to_time);
  ::CUserMsg_ParticleManager_ParticleSkipToTime* unsafe_arena_release_particle_skip_to_time();

  // optional .CUserMsg_ParticleManager.ParticleCanFreeze particle_can_freeze = 28;
  bool has_particle_can_freeze() const;
  private:
  bool _internal_has_particle_can_freeze() const;
  public:
  void clear_particle_can_freeze();
  const ::CUserMsg_ParticleManager_ParticleCanFreeze& particle_can_freeze() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ParticleCanFreeze* release_particle_can_freeze();
  ::CUserMsg_ParticleManager_ParticleCanFreeze* mutable_particle_can_freeze();
  void set_allocated_particle_can_freeze(::CUserMsg_ParticleManager_ParticleCanFreeze* particle_can_freeze);
  private:
  const ::CUserMsg_ParticleManager_ParticleCanFreeze& _internal_particle_can_freeze() const;
  ::CUserMsg_ParticleManager_ParticleCanFreeze* _internal_mutable_particle_can_freeze();
  public:
  void unsafe_arena_set_allocated_particle_can_freeze(
      ::CUserMsg_ParticleManager_ParticleCanFreeze* particle_can_freeze);
  ::CUserMsg_ParticleManager_ParticleCanFreeze* unsafe_arena_release_particle_can_freeze();

  // optional .CUserMsg_ParticleManager.SetParticleNamedValueContext set_named_value_context = 29;
  bool has_set_named_value_context() const;
  private:
  bool _internal_has_set_named_value_context() const;
  public:
  void clear_set_named_value_context();
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext& set_named_value_context() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetParticleNamedValueContext* release_set_named_value_context();
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* mutable_set_named_value_context();
  void set_allocated_set_named_value_context(::CUserMsg_ParticleManager_SetParticleNamedValueContext* set_named_value_context);
  private:
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext& _internal_set_named_value_context() const;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* _internal_mutable_set_named_value_context();
  public:
  void unsafe_arena_set_allocated_set_named_value_context(
      ::CUserMsg_ParticleManager_SetParticleNamedValueContext* set_named_value_context);
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* unsafe_arena_release_set_named_value_context();

  // optional .CUserMsg_ParticleManager.UpdateParticleTransform update_particle_transform = 30;
  bool has_update_particle_transform() const;
  private:
  bool _internal_has_update_particle_transform() const;
  public:
  void clear_update_particle_transform();
  const ::CUserMsg_ParticleManager_UpdateParticleTransform& update_particle_transform() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateParticleTransform* release_update_particle_transform();
  ::CUserMsg_ParticleManager_UpdateParticleTransform* mutable_update_particle_transform();
  void set_allocated_update_particle_transform(::CUserMsg_ParticleManager_UpdateParticleTransform* update_particle_transform);
  private:
  const ::CUserMsg_ParticleManager_UpdateParticleTransform& _internal_update_particle_transform() const;
  ::CUserMsg_ParticleManager_UpdateParticleTransform* _internal_mutable_update_particle_transform();
  public:
  void unsafe_arena_set_allocated_update_particle_transform(
      ::CUserMsg_ParticleManager_UpdateParticleTransform* update_particle_transform);
  ::CUserMsg_ParticleManager_UpdateParticleTransform* unsafe_arena_release_update_particle_transform();

  // optional .CUserMsg_ParticleManager.ParticleFreezeTransitionOverride particle_freeze_transition_override = 31;
  bool has_particle_freeze_transition_override() const;
  private:
  bool _internal_has_particle_freeze_transition_override() const;
  public:
  void clear_particle_freeze_transition_override();
  const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& particle_freeze_transition_override() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* release_particle_freeze_transition_override();
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* mutable_particle_freeze_transition_override();
  void set_allocated_particle_freeze_transition_override(::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* particle_freeze_transition_override);
  private:
  const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& _internal_particle_freeze_transition_override() const;
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* _internal_mutable_particle_freeze_transition_override();
  public:
  void unsafe_arena_set_allocated_particle_freeze_transition_override(
      ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* particle_freeze_transition_override);
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* unsafe_arena_release_particle_freeze_transition_override();

  // optional .CUserMsg_ParticleManager.FreezeParticleInvolving freeze_particle_involving = 32;
  bool has_freeze_particle_involving() const;
  private:
  bool _internal_has_freeze_particle_involving() const;
  public:
  void clear_freeze_particle_involving();
  const ::CUserMsg_ParticleManager_FreezeParticleInvolving& freeze_particle_involving() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_FreezeParticleInvolving* release_freeze_particle_involving();
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* mutable_freeze_particle_involving();
  void set_allocated_freeze_particle_involving(::CUserMsg_ParticleManager_FreezeParticleInvolving* freeze_particle_involving);
  private:
  const ::CUserMsg_ParticleManager_FreezeParticleInvolving& _internal_freeze_particle_involving() const;
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* _internal_mutable_freeze_particle_involving();
  public:
  void unsafe_arena_set_allocated_freeze_particle_involving(
      ::CUserMsg_ParticleManager_FreezeParticleInvolving* freeze_particle_involving);
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* unsafe_arena_release_freeze_particle_involving();

  // optional .CUserMsg_ParticleManager.AddModellistOverrideElement add_modellist_override_element = 33;
  bool has_add_modellist_override_element() const;
  private:
  bool _internal_has_add_modellist_override_element() const;
  public:
  void clear_add_modellist_override_element();
  const ::CUserMsg_ParticleManager_AddModellistOverrideElement& add_modellist_override_element() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_AddModellistOverrideElement* release_add_modellist_override_element();
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* mutable_add_modellist_override_element();
  void set_allocated_add_modellist_override_element(::CUserMsg_ParticleManager_AddModellistOverrideElement* add_modellist_override_element);
  private:
  const ::CUserMsg_ParticleManager_AddModellistOverrideElement& _internal_add_modellist_override_element() const;
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* _internal_mutable_add_modellist_override_element();
  public:
  void unsafe_arena_set_allocated_add_modellist_override_element(
      ::CUserMsg_ParticleManager_AddModellistOverrideElement* add_modellist_override_element);
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* unsafe_arena_release_add_modellist_override_element();

  // optional .CUserMsg_ParticleManager.ClearModellistOverride clear_modellist_override = 34;
  bool has_clear_modellist_override() const;
  private:
  bool _internal_has_clear_modellist_override() const;
  public:
  void clear_clear_modellist_override();
  const ::CUserMsg_ParticleManager_ClearModellistOverride& clear_modellist_override() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_ClearModellistOverride* release_clear_modellist_override();
  ::CUserMsg_ParticleManager_ClearModellistOverride* mutable_clear_modellist_override();
  void set_allocated_clear_modellist_override(::CUserMsg_ParticleManager_ClearModellistOverride* clear_modellist_override);
  private:
  const ::CUserMsg_ParticleManager_ClearModellistOverride& _internal_clear_modellist_override() const;
  ::CUserMsg_ParticleManager_ClearModellistOverride* _internal_mutable_clear_modellist_override();
  public:
  void unsafe_arena_set_allocated_clear_modellist_override(
      ::CUserMsg_ParticleManager_ClearModellistOverride* clear_modellist_override);
  ::CUserMsg_ParticleManager_ClearModellistOverride* unsafe_arena_release_clear_modellist_override();

  // optional .CUserMsg_ParticleManager.CreatePhysicsSim create_physics_sim = 35;
  bool has_create_physics_sim() const;
  private:
  bool _internal_has_create_physics_sim() const;
  public:
  void clear_create_physics_sim();
  const ::CUserMsg_ParticleManager_CreatePhysicsSim& create_physics_sim() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_CreatePhysicsSim* release_create_physics_sim();
  ::CUserMsg_ParticleManager_CreatePhysicsSim* mutable_create_physics_sim();
  void set_allocated_create_physics_sim(::CUserMsg_ParticleManager_CreatePhysicsSim* create_physics_sim);
  private:
  const ::CUserMsg_ParticleManager_CreatePhysicsSim& _internal_create_physics_sim() const;
  ::CUserMsg_ParticleManager_CreatePhysicsSim* _internal_mutable_create_physics_sim();
  public:
  void unsafe_arena_set_allocated_create_physics_sim(
      ::CUserMsg_ParticleManager_CreatePhysicsSim* create_physics_sim);
  ::CUserMsg_ParticleManager_CreatePhysicsSim* unsafe_arena_release_create_physics_sim();

  // optional .CUserMsg_ParticleManager.DestroyPhysicsSim destroy_physics_sim = 36;
  bool has_destroy_physics_sim() const;
  private:
  bool _internal_has_destroy_physics_sim() const;
  public:
  void clear_destroy_physics_sim();
  const ::CUserMsg_ParticleManager_DestroyPhysicsSim& destroy_physics_sim() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_DestroyPhysicsSim* release_destroy_physics_sim();
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* mutable_destroy_physics_sim();
  void set_allocated_destroy_physics_sim(::CUserMsg_ParticleManager_DestroyPhysicsSim* destroy_physics_sim);
  private:
  const ::CUserMsg_ParticleManager_DestroyPhysicsSim& _internal_destroy_physics_sim() const;
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* _internal_mutable_destroy_physics_sim();
  public:
  void unsafe_arena_set_allocated_destroy_physics_sim(
      ::CUserMsg_ParticleManager_DestroyPhysicsSim* destroy_physics_sim);
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* unsafe_arena_release_destroy_physics_sim();

  // optional .CUserMsg_ParticleManager.SetVData set_vdata = 37;
  bool has_set_vdata() const;
  private:
  bool _internal_has_set_vdata() const;
  public:
  void clear_set_vdata();
  const ::CUserMsg_ParticleManager_SetVData& set_vdata() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetVData* release_set_vdata();
  ::CUserMsg_ParticleManager_SetVData* mutable_set_vdata();
  void set_allocated_set_vdata(::CUserMsg_ParticleManager_SetVData* set_vdata);
  private:
  const ::CUserMsg_ParticleManager_SetVData& _internal_set_vdata() const;
  ::CUserMsg_ParticleManager_SetVData* _internal_mutable_set_vdata();
  public:
  void unsafe_arena_set_allocated_set_vdata(
      ::CUserMsg_ParticleManager_SetVData* set_vdata);
  ::CUserMsg_ParticleManager_SetVData* unsafe_arena_release_set_vdata();

  // optional .CUserMsg_ParticleManager.SetMaterialOverride set_material_override = 38;
  bool has_set_material_override() const;
  private:
  bool _internal_has_set_material_override() const;
  public:
  void clear_set_material_override();
  const ::CUserMsg_ParticleManager_SetMaterialOverride& set_material_override() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetMaterialOverride* release_set_material_override();
  ::CUserMsg_ParticleManager_SetMaterialOverride* mutable_set_material_override();
  void set_allocated_set_material_override(::CUserMsg_ParticleManager_SetMaterialOverride* set_material_override);
  private:
  const ::CUserMsg_ParticleManager_SetMaterialOverride& _internal_set_material_override() const;
  ::CUserMsg_ParticleManager_SetMaterialOverride* _internal_mutable_set_material_override();
  public:
  void unsafe_arena_set_allocated_set_material_override(
      ::CUserMsg_ParticleManager_SetMaterialOverride* set_material_override);
  ::CUserMsg_ParticleManager_SetMaterialOverride* unsafe_arena_release_set_material_override();

  // optional .CUserMsg_ParticleManager.AddFan add_fan = 39;
  bool has_add_fan() const;
  private:
  bool _internal_has_add_fan() const;
  public:
  void clear_add_fan();
  const ::CUserMsg_ParticleManager_AddFan& add_fan() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_AddFan* release_add_fan();
  ::CUserMsg_ParticleManager_AddFan* mutable_add_fan();
  void set_allocated_add_fan(::CUserMsg_ParticleManager_AddFan* add_fan);
  private:
  const ::CUserMsg_ParticleManager_AddFan& _internal_add_fan() const;
  ::CUserMsg_ParticleManager_AddFan* _internal_mutable_add_fan();
  public:
  void unsafe_arena_set_allocated_add_fan(
      ::CUserMsg_ParticleManager_AddFan* add_fan);
  ::CUserMsg_ParticleManager_AddFan* unsafe_arena_release_add_fan();

  // optional .CUserMsg_ParticleManager.UpdateFan update_fan = 40;
  bool has_update_fan() const;
  private:
  bool _internal_has_update_fan() const;
  public:
  void clear_update_fan();
  const ::CUserMsg_ParticleManager_UpdateFan& update_fan() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_UpdateFan* release_update_fan();
  ::CUserMsg_ParticleManager_UpdateFan* mutable_update_fan();
  void set_allocated_update_fan(::CUserMsg_ParticleManager_UpdateFan* update_fan);
  private:
  const ::CUserMsg_ParticleManager_UpdateFan& _internal_update_fan() const;
  ::CUserMsg_ParticleManager_UpdateFan* _internal_mutable_update_fan();
  public:
  void unsafe_arena_set_allocated_update_fan(
      ::CUserMsg_ParticleManager_UpdateFan* update_fan);
  ::CUserMsg_ParticleManager_UpdateFan* unsafe_arena_release_update_fan();

  // optional .CUserMsg_ParticleManager.SetParticleClusterGrowth set_particle_cluster_growth = 41;
  bool has_set_particle_cluster_growth() const;
  private:
  bool _internal_has_set_particle_cluster_growth() const;
  public:
  void clear_set_particle_cluster_growth();
  const ::CUserMsg_ParticleManager_SetParticleClusterGrowth& set_particle_cluster_growth() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_SetParticleClusterGrowth* release_set_particle_cluster_growth();
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* mutable_set_particle_cluster_growth();
  void set_allocated_set_particle_cluster_growth(::CUserMsg_ParticleManager_SetParticleClusterGrowth* set_particle_cluster_growth);
  private:
  const ::CUserMsg_ParticleManager_SetParticleClusterGrowth& _internal_set_particle_cluster_growth() const;
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* _internal_mutable_set_particle_cluster_growth();
  public:
  void unsafe_arena_set_allocated_set_particle_cluster_growth(
      ::CUserMsg_ParticleManager_SetParticleClusterGrowth* set_particle_cluster_growth);
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* unsafe_arena_release_set_particle_cluster_growth();

  // optional .CUserMsg_ParticleManager.RemoveFan remove_fan = 42;
  bool has_remove_fan() const;
  private:
  bool _internal_has_remove_fan() const;
  public:
  void clear_remove_fan();
  const ::CUserMsg_ParticleManager_RemoveFan& remove_fan() const;
  PROTOBUF_NODISCARD ::CUserMsg_ParticleManager_RemoveFan* release_remove_fan();
  ::CUserMsg_ParticleManager_RemoveFan* mutable_remove_fan();
  void set_allocated_remove_fan(::CUserMsg_ParticleManager_RemoveFan* remove_fan);
  private:
  const ::CUserMsg_ParticleManager_RemoveFan& _internal_remove_fan() const;
  ::CUserMsg_ParticleManager_RemoveFan* _internal_mutable_remove_fan();
  public:
  void unsafe_arena_set_allocated_remove_fan(
      ::CUserMsg_ParticleManager_RemoveFan* remove_fan);
  ::CUserMsg_ParticleManager_RemoveFan* unsafe_arena_release_remove_fan();

  // optional .PARTICLE_MESSAGE type = 1 [default = GAME_PARTICLE_MANAGER_EVENT_CREATE];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::PARTICLE_MESSAGE type() const;
  void set_type(::PARTICLE_MESSAGE value);
  private:
  ::PARTICLE_MESSAGE _internal_type() const;
  void _internal_set_type(::PARTICLE_MESSAGE value);
  public:

  // optional uint32 index = 2;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:


  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {

    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);

    return to_add;
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CUserMsg_ParticleManager, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }

  // @@protoc_insertion_point(class_scope:CUserMsg_ParticleManager)
 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::ExtensionSet _extensions_;

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CUserMsg_ParticleManager_ReleaseParticleIndex* release_particle_index_;
    ::CUserMsg_ParticleManager_CreateParticle* create_particle_;
    ::CUserMsg_ParticleManager_DestroyParticle* destroy_particle_;
    ::CUserMsg_ParticleManager_DestroyParticleInvolving* destroy_particle_involving_;
    ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* update_particle_;
    ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* update_particle_fwd_;
    ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* update_particle_orient_;
    ::CUserMsg_ParticleManager_UpdateParticleFallback* update_particle_fallback_;
    ::CUserMsg_ParticleManager_UpdateParticleOffset* update_particle_offset_;
    ::CUserMsg_ParticleManager_UpdateParticleEnt* update_particle_ent_;
    ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* update_particle_should_draw_;
    ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* update_particle_set_frozen_;
    ::CUserMsg_ParticleManager_ChangeControlPointAttachment* change_control_point_attachment_;
    ::CUserMsg_ParticleManager_UpdateEntityPosition* update_entity_position_;
    ::CUserMsg_ParticleManager_SetParticleFoWProperties* set_particle_fow_properties_;
    ::CUserMsg_ParticleManager_SetParticleText* set_particle_text_;
    ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* set_particle_should_check_fow_;
    ::CUserMsg_ParticleManager_SetControlPointModel* set_control_point_model_;
    ::CUserMsg_ParticleManager_SetControlPointSnapshot* set_control_point_snapshot_;
    ::CUserMsg_ParticleManager_SetTextureAttribute* set_texture_attribute_;
    ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* set_scene_object_generic_flag_;
    ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* set_scene_object_tint_and_desat_;
    ::CUserMsg_ParticleManager_DestroyParticleNamed* destroy_particle_named_;
    ::CUserMsg_ParticleManager_ParticleSkipToTime* particle_skip_to_time_;
    ::CUserMsg_ParticleManager_ParticleCanFreeze* particle_can_freeze_;
    ::CUserMsg_ParticleManager_SetParticleNamedValueContext* set_named_value_context_;
    ::CUserMsg_ParticleManager_UpdateParticleTransform* update_particle_transform_;
    ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* particle_freeze_transition_override_;
    ::CUserMsg_ParticleManager_FreezeParticleInvolving* freeze_particle_involving_;
    ::CUserMsg_ParticleManager_AddModellistOverrideElement* add_modellist_override_element_;
    ::CUserMsg_ParticleManager_ClearModellistOverride* clear_modellist_override_;
    ::CUserMsg_ParticleManager_CreatePhysicsSim* create_physics_sim_;
    ::CUserMsg_ParticleManager_DestroyPhysicsSim* destroy_physics_sim_;
    ::CUserMsg_ParticleManager_SetVData* set_vdata_;
    ::CUserMsg_ParticleManager_SetMaterialOverride* set_material_override_;
    ::CUserMsg_ParticleManager_AddFan* add_fan_;
    ::CUserMsg_ParticleManager_UpdateFan* update_fan_;
    ::CUserMsg_ParticleManager_SetParticleClusterGrowth* set_particle_cluster_growth_;
    ::CUserMsg_ParticleManager_RemoveFan* remove_fan_;
    int type_;
    uint32_t index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_HudError& operator=(const CUserMsg_HudError& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_HudError& operator=(CUserMsg_HudError&& 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 CUserMsg_HudError& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_HudError* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_HudError*>(
               &_CUserMsg_HudError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  friend void swap(CUserMsg_HudError& a, CUserMsg_HudError& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_HudError* 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(CUserMsg_HudError* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_HudError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_HudError>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_HudError& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_HudError& from) {
    CUserMsg_HudError::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(CUserMsg_HudError* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_HudError";
  }
  protected:
  explicit CUserMsg_HudError(::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 {
    kOrderIdFieldNumber = 1,
  };
  // optional int32 order_id = 1;
  bool has_order_id() const;
  private:
  bool _internal_has_order_id() const;
  public:
  void clear_order_id();
  int32_t order_id() const;
  void set_order_id(int32_t value);
  private:
  int32_t _internal_order_id() const;
  void _internal_set_order_id(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_HudError)
 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 order_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMsg_CustomGameEvent& operator=(const CUserMsg_CustomGameEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMsg_CustomGameEvent& operator=(CUserMsg_CustomGameEvent&& 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 CUserMsg_CustomGameEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMsg_CustomGameEvent* internal_default_instance() {
    return reinterpret_cast<const CUserMsg_CustomGameEvent*>(
               &_CUserMsg_CustomGameEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  friend void swap(CUserMsg_CustomGameEvent& a, CUserMsg_CustomGameEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMsg_CustomGameEvent* 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(CUserMsg_CustomGameEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMsg_CustomGameEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMsg_CustomGameEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMsg_CustomGameEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMsg_CustomGameEvent& from) {
    CUserMsg_CustomGameEvent::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(CUserMsg_CustomGameEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMsg_CustomGameEvent";
  }
  protected:
  explicit CUserMsg_CustomGameEvent(::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 {
    kEventNameFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // optional string event_name = 1;
  bool has_event_name() const;
  private:
  bool _internal_has_event_name() const;
  public:
  void clear_event_name();
  const std::string& event_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_event_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_event_name();
  PROTOBUF_NODISCARD std::string* release_event_name();
  void set_allocated_event_name(std::string* event_name);
  private:
  const std::string& _internal_event_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_event_name(const std::string& value);
  std::string* _internal_mutable_event_name();
  public:

  // optional bytes data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:CUserMsg_CustomGameEvent)
 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 event_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageHapticsManagerPulse& operator=(const CUserMessageHapticsManagerPulse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageHapticsManagerPulse& operator=(CUserMessageHapticsManagerPulse&& 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 CUserMessageHapticsManagerPulse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageHapticsManagerPulse* internal_default_instance() {
    return reinterpret_cast<const CUserMessageHapticsManagerPulse*>(
               &_CUserMessageHapticsManagerPulse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    83;

  friend void swap(CUserMessageHapticsManagerPulse& a, CUserMessageHapticsManagerPulse& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageHapticsManagerPulse* 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(CUserMessageHapticsManagerPulse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageHapticsManagerPulse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageHapticsManagerPulse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageHapticsManagerPulse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageHapticsManagerPulse& from) {
    CUserMessageHapticsManagerPulse::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(CUserMessageHapticsManagerPulse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageHapticsManagerPulse";
  }
  protected:
  explicit CUserMessageHapticsManagerPulse(::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 {
    kHandIdFieldNumber = 1,
    kEffectAmplitudeFieldNumber = 2,
    kEffectFrequencyFieldNumber = 3,
    kEffectDurationFieldNumber = 4,
  };
  // optional int32 hand_id = 1;
  bool has_hand_id() const;
  private:
  bool _internal_has_hand_id() const;
  public:
  void clear_hand_id();
  int32_t hand_id() const;
  void set_hand_id(int32_t value);
  private:
  int32_t _internal_hand_id() const;
  void _internal_set_hand_id(int32_t value);
  public:

  // optional float effect_amplitude = 2;
  bool has_effect_amplitude() const;
  private:
  bool _internal_has_effect_amplitude() const;
  public:
  void clear_effect_amplitude();
  float effect_amplitude() const;
  void set_effect_amplitude(float value);
  private:
  float _internal_effect_amplitude() const;
  void _internal_set_effect_amplitude(float value);
  public:

  // optional float effect_frequency = 3;
  bool has_effect_frequency() const;
  private:
  bool _internal_has_effect_frequency() const;
  public:
  void clear_effect_frequency();
  float effect_frequency() const;
  void set_effect_frequency(float value);
  private:
  float _internal_effect_frequency() const;
  void _internal_set_effect_frequency(float value);
  public:

  // optional float effect_duration = 4;
  bool has_effect_duration() const;
  private:
  bool _internal_has_effect_duration() const;
  public:
  void clear_effect_duration();
  float effect_duration() const;
  void set_effect_duration(float value);
  private:
  float _internal_effect_duration() const;
  void _internal_set_effect_duration(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageHapticsManagerPulse)
 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 hand_id_;
    float effect_amplitude_;
    float effect_frequency_;
    float effect_duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageHapticsManagerEffect& operator=(const CUserMessageHapticsManagerEffect& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageHapticsManagerEffect& operator=(CUserMessageHapticsManagerEffect&& 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 CUserMessageHapticsManagerEffect& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageHapticsManagerEffect* internal_default_instance() {
    return reinterpret_cast<const CUserMessageHapticsManagerEffect*>(
               &_CUserMessageHapticsManagerEffect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    84;

  friend void swap(CUserMessageHapticsManagerEffect& a, CUserMessageHapticsManagerEffect& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageHapticsManagerEffect* 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(CUserMessageHapticsManagerEffect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageHapticsManagerEffect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageHapticsManagerEffect>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageHapticsManagerEffect& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageHapticsManagerEffect& from) {
    CUserMessageHapticsManagerEffect::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(CUserMessageHapticsManagerEffect* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageHapticsManagerEffect";
  }
  protected:
  explicit CUserMessageHapticsManagerEffect(::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 {
    kHandIdFieldNumber = 1,
    kEffectNameHashCodeFieldNumber = 2,
    kEffectScaleFieldNumber = 3,
  };
  // optional int32 hand_id = 1;
  bool has_hand_id() const;
  private:
  bool _internal_has_hand_id() const;
  public:
  void clear_hand_id();
  int32_t hand_id() const;
  void set_hand_id(int32_t value);
  private:
  int32_t _internal_hand_id() const;
  void _internal_set_hand_id(int32_t value);
  public:

  // optional uint32 effect_name_hash_code = 2;
  bool has_effect_name_hash_code() const;
  private:
  bool _internal_has_effect_name_hash_code() const;
  public:
  void clear_effect_name_hash_code();
  uint32_t effect_name_hash_code() const;
  void set_effect_name_hash_code(uint32_t value);
  private:
  uint32_t _internal_effect_name_hash_code() const;
  void _internal_set_effect_name_hash_code(uint32_t value);
  public:

  // optional float effect_scale = 3;
  bool has_effect_scale() const;
  private:
  bool _internal_has_effect_scale() const;
  public:
  void clear_effect_scale();
  float effect_scale() const;
  void set_effect_scale(float value);
  private:
  float _internal_effect_scale() const;
  void _internal_set_effect_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageHapticsManagerEffect)
 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 hand_id_;
    uint32_t effect_name_hash_code_;
    float effect_scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageAnimStateGraphState& operator=(const CUserMessageAnimStateGraphState& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageAnimStateGraphState& operator=(CUserMessageAnimStateGraphState&& 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 CUserMessageAnimStateGraphState& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageAnimStateGraphState* internal_default_instance() {
    return reinterpret_cast<const CUserMessageAnimStateGraphState*>(
               &_CUserMessageAnimStateGraphState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    85;

  friend void swap(CUserMessageAnimStateGraphState& a, CUserMessageAnimStateGraphState& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageAnimStateGraphState* 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(CUserMessageAnimStateGraphState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageAnimStateGraphState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageAnimStateGraphState>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageAnimStateGraphState& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageAnimStateGraphState& from) {
    CUserMessageAnimStateGraphState::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(CUserMessageAnimStateGraphState* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageAnimStateGraphState";
  }
  protected:
  explicit CUserMessageAnimStateGraphState(::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 {
    kDataFieldNumber = 2,
    kEntityIndexFieldNumber = 1,
  };
  // optional bytes data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 entity_index = 1;
  bool has_entity_index() const;
  private:
  bool _internal_has_entity_index() const;
  public:
  void clear_entity_index();
  int32_t entity_index() const;
  void set_entity_index(int32_t value);
  private:
  int32_t _internal_entity_index() const;
  void _internal_set_entity_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageAnimStateGraphState)
 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 data_;
    int32_t entity_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageUpdateCssClasses& operator=(const CUserMessageUpdateCssClasses& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageUpdateCssClasses& operator=(CUserMessageUpdateCssClasses&& 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 CUserMessageUpdateCssClasses& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageUpdateCssClasses* internal_default_instance() {
    return reinterpret_cast<const CUserMessageUpdateCssClasses*>(
               &_CUserMessageUpdateCssClasses_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    86;

  friend void swap(CUserMessageUpdateCssClasses& a, CUserMessageUpdateCssClasses& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageUpdateCssClasses* 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(CUserMessageUpdateCssClasses* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageUpdateCssClasses* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageUpdateCssClasses>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageUpdateCssClasses& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageUpdateCssClasses& from) {
    CUserMessageUpdateCssClasses::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(CUserMessageUpdateCssClasses* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageUpdateCssClasses";
  }
  protected:
  explicit CUserMessageUpdateCssClasses(::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 {
    kCssClassesFieldNumber = 2,
    kTargetWorldPanelFieldNumber = 1,
    kIsAddFieldNumber = 3,
  };
  // optional string css_classes = 2;
  bool has_css_classes() const;
  private:
  bool _internal_has_css_classes() const;
  public:
  void clear_css_classes();
  const std::string& css_classes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_css_classes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_css_classes();
  PROTOBUF_NODISCARD std::string* release_css_classes();
  void set_allocated_css_classes(std::string* css_classes);
  private:
  const std::string& _internal_css_classes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_css_classes(const std::string& value);
  std::string* _internal_mutable_css_classes();
  public:

  // optional int32 target_world_panel = 1;
  bool has_target_world_panel() const;
  private:
  bool _internal_has_target_world_panel() const;
  public:
  void clear_target_world_panel();
  int32_t target_world_panel() const;
  void set_target_world_panel(int32_t value);
  private:
  int32_t _internal_target_world_panel() const;
  void _internal_set_target_world_panel(int32_t value);
  public:

  // optional bool is_add = 3;
  bool has_is_add() const;
  private:
  bool _internal_has_is_add() const;
  public:
  void clear_is_add();
  bool is_add() const;
  void set_is_add(bool value);
  private:
  bool _internal_is_add() const;
  void _internal_set_is_add(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageUpdateCssClasses)
 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 css_classes_;
    int32_t target_world_panel_;
    bool is_add_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageServerFrameTime& operator=(const CUserMessageServerFrameTime& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageServerFrameTime& operator=(CUserMessageServerFrameTime&& 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 CUserMessageServerFrameTime& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageServerFrameTime* internal_default_instance() {
    return reinterpret_cast<const CUserMessageServerFrameTime*>(
               &_CUserMessageServerFrameTime_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    87;

  friend void swap(CUserMessageServerFrameTime& a, CUserMessageServerFrameTime& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageServerFrameTime* 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(CUserMessageServerFrameTime* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageServerFrameTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageServerFrameTime>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageServerFrameTime& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageServerFrameTime& from) {
    CUserMessageServerFrameTime::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(CUserMessageServerFrameTime* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageServerFrameTime";
  }
  protected:
  explicit CUserMessageServerFrameTime(::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 {
    kFrameTimeFieldNumber = 1,
  };
  // optional float frame_time = 1;
  bool has_frame_time() const;
  private:
  bool _internal_has_frame_time() const;
  public:
  void clear_frame_time();
  float frame_time() const;
  void set_frame_time(float value);
  private:
  float _internal_frame_time() const;
  void _internal_set_frame_time(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageServerFrameTime)
 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_;
    float frame_time_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageLagCompensationError& operator=(const CUserMessageLagCompensationError& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageLagCompensationError& operator=(CUserMessageLagCompensationError&& 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 CUserMessageLagCompensationError& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageLagCompensationError* internal_default_instance() {
    return reinterpret_cast<const CUserMessageLagCompensationError*>(
               &_CUserMessageLagCompensationError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    88;

  friend void swap(CUserMessageLagCompensationError& a, CUserMessageLagCompensationError& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageLagCompensationError* 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(CUserMessageLagCompensationError* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageLagCompensationError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageLagCompensationError>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageLagCompensationError& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageLagCompensationError& from) {
    CUserMessageLagCompensationError::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(CUserMessageLagCompensationError* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageLagCompensationError";
  }
  protected:
  explicit CUserMessageLagCompensationError(::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 {
    kDistanceFieldNumber = 1,
  };
  // optional float distance = 1;
  bool has_distance() const;
  private:
  bool _internal_has_distance() const;
  public:
  void clear_distance();
  float distance() const;
  void set_distance(float value);
  private:
  float _internal_distance() const;
  void _internal_set_distance(float value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageLagCompensationError)
 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_;
    float distance_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestDllStatus& operator=(const CUserMessageRequestDllStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestDllStatus& operator=(CUserMessageRequestDllStatus&& 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 CUserMessageRequestDllStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestDllStatus* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestDllStatus*>(
               &_CUserMessageRequestDllStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    89;

  friend void swap(CUserMessageRequestDllStatus& a, CUserMessageRequestDllStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestDllStatus* 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(CUserMessageRequestDllStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestDllStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestDllStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRequestDllStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRequestDllStatus& from) {
    CUserMessageRequestDllStatus::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(CUserMessageRequestDllStatus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRequestDllStatus";
  }
  protected:
  explicit CUserMessageRequestDllStatus(::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 {
    kDllActionFieldNumber = 1,
    kFullReportFieldNumber = 2,
  };
  // optional string dll_action = 1;
  bool has_dll_action() const;
  private:
  bool _internal_has_dll_action() const;
  public:
  void clear_dll_action();
  const std::string& dll_action() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dll_action(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dll_action();
  PROTOBUF_NODISCARD std::string* release_dll_action();
  void set_allocated_dll_action(std::string* dll_action);
  private:
  const std::string& _internal_dll_action() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dll_action(const std::string& value);
  std::string* _internal_mutable_dll_action();
  public:

  // optional bool full_report = 2;
  bool has_full_report() const;
  private:
  bool _internal_has_full_report() const;
  public:
  void clear_full_report();
  bool full_report() const;
  void set_full_report(bool value);
  private:
  bool _internal_full_report() const;
  void _internal_set_full_report(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageRequestDllStatus)
 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 dll_action_;
    bool full_report_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestUtilAction& operator=(const CUserMessageRequestUtilAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestUtilAction& operator=(CUserMessageRequestUtilAction&& 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 CUserMessageRequestUtilAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestUtilAction* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestUtilAction*>(
               &_CUserMessageRequestUtilAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    90;

  friend void swap(CUserMessageRequestUtilAction& a, CUserMessageRequestUtilAction& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestUtilAction* 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(CUserMessageRequestUtilAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestUtilAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestUtilAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRequestUtilAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRequestUtilAction& from) {
    CUserMessageRequestUtilAction::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(CUserMessageRequestUtilAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRequestUtilAction";
  }
  protected:
  explicit CUserMessageRequestUtilAction(::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 {
    kUtil1FieldNumber = 2,
    kUtil2FieldNumber = 3,
    kUtil3FieldNumber = 4,
    kUtil4FieldNumber = 5,
    kUtil5FieldNumber = 6,
  };
  // optional int32 util1 = 2;
  bool has_util1() const;
  private:
  bool _internal_has_util1() const;
  public:
  void clear_util1();
  int32_t util1() const;
  void set_util1(int32_t value);
  private:
  int32_t _internal_util1() const;
  void _internal_set_util1(int32_t value);
  public:

  // optional int32 util2 = 3;
  bool has_util2() const;
  private:
  bool _internal_has_util2() const;
  public:
  void clear_util2();
  int32_t util2() const;
  void set_util2(int32_t value);
  private:
  int32_t _internal_util2() const;
  void _internal_set_util2(int32_t value);
  public:

  // optional int32 util3 = 4;
  bool has_util3() const;
  private:
  bool _internal_has_util3() const;
  public:
  void clear_util3();
  int32_t util3() const;
  void set_util3(int32_t value);
  private:
  int32_t _internal_util3() const;
  void _internal_set_util3(int32_t value);
  public:

  // optional int32 util4 = 5;
  bool has_util4() const;
  private:
  bool _internal_has_util4() const;
  public:
  void clear_util4();
  int32_t util4() const;
  void set_util4(int32_t value);
  private:
  int32_t _internal_util4() const;
  void _internal_set_util4(int32_t value);
  public:

  // optional int32 util5 = 6;
  bool has_util5() const;
  private:
  bool _internal_has_util5() const;
  public:
  void clear_util5();
  int32_t util5() const;
  void set_util5(int32_t value);
  private:
  int32_t _internal_util5() const;
  void _internal_set_util5(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageRequestUtilAction)
 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 util1_;
    int32_t util2_;
    int32_t util3_;
    int32_t util4_;
    int32_t util5_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_UtilMsg_Response_ItemDetail& operator=(const CUserMessage_UtilMsg_Response_ItemDetail& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_UtilMsg_Response_ItemDetail& operator=(CUserMessage_UtilMsg_Response_ItemDetail&& 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 CUserMessage_UtilMsg_Response_ItemDetail& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_UtilMsg_Response_ItemDetail* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_UtilMsg_Response_ItemDetail*>(
               &_CUserMessage_UtilMsg_Response_ItemDetail_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    91;

  friend void swap(CUserMessage_UtilMsg_Response_ItemDetail& a, CUserMessage_UtilMsg_Response_ItemDetail& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_UtilMsg_Response_ItemDetail* 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(CUserMessage_UtilMsg_Response_ItemDetail* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_UtilMsg_Response_ItemDetail* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_UtilMsg_Response_ItemDetail>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_UtilMsg_Response_ItemDetail& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_UtilMsg_Response_ItemDetail& from) {
    CUserMessage_UtilMsg_Response_ItemDetail::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(CUserMessage_UtilMsg_Response_ItemDetail* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_UtilMsg_Response.ItemDetail";
  }
  protected:
  explicit CUserMessage_UtilMsg_Response_ItemDetail(::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 = 4,
    kIndexFieldNumber = 1,
    kHashFieldNumber = 2,
    kCrcFieldNumber = 3,
  };
  // optional string name = 4;
  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 int32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // optional int32 hash = 2;
  bool has_hash() const;
  private:
  bool _internal_has_hash() const;
  public:
  void clear_hash();
  int32_t hash() const;
  void set_hash(int32_t value);
  private:
  int32_t _internal_hash() const;
  void _internal_set_hash(int32_t value);
  public:

  // optional int32 crc = 3;
  bool has_crc() const;
  private:
  bool _internal_has_crc() const;
  public:
  void clear_crc();
  int32_t crc() const;
  void set_crc(int32_t value);
  private:
  int32_t _internal_crc() const;
  void _internal_set_crc(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_UtilMsg_Response.ItemDetail)
 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_;
    int32_t index_;
    int32_t hash_;
    int32_t crc_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_UtilMsg_Response& operator=(const CUserMessage_UtilMsg_Response& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_UtilMsg_Response& operator=(CUserMessage_UtilMsg_Response&& 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 CUserMessage_UtilMsg_Response& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_UtilMsg_Response* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_UtilMsg_Response*>(
               &_CUserMessage_UtilMsg_Response_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    92;

  friend void swap(CUserMessage_UtilMsg_Response& a, CUserMessage_UtilMsg_Response& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_UtilMsg_Response* 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(CUserMessage_UtilMsg_Response* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_UtilMsg_Response* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_UtilMsg_Response>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_UtilMsg_Response& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_UtilMsg_Response& from) {
    CUserMessage_UtilMsg_Response::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(CUserMessage_UtilMsg_Response* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_UtilMsg_Response";
  }
  protected:
  explicit CUserMessage_UtilMsg_Response(::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 CUserMessage_UtilMsg_Response_ItemDetail ItemDetail;

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

  enum : int {
    kCrcPartFieldNumber = 5,
    kCrcPart2FieldNumber = 6,
    kItemdetailsFieldNumber = 9,
    kCrcFieldNumber = 1,
    kItemCountFieldNumber = 2,
    kCrc2FieldNumber = 3,
    kItemCount2FieldNumber = 4,
    kClientTimestampFieldNumber = 7,
    kPlatformFieldNumber = 8,
    kItemgroupFieldNumber = 10,
    kTotalCountFieldNumber = 11,
    kTotalCount2FieldNumber = 12,
  };
  // repeated int32 crc_part = 5;
  int crc_part_size() const;
  private:
  int _internal_crc_part_size() const;
  public:
  void clear_crc_part();
  private:
  int32_t _internal_crc_part(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_crc_part() const;
  void _internal_add_crc_part(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_crc_part();
  public:
  int32_t crc_part(int index) const;
  void set_crc_part(int index, int32_t value);
  void add_crc_part(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      crc_part() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_crc_part();

  // repeated int32 crc_part2 = 6;
  int crc_part2_size() const;
  private:
  int _internal_crc_part2_size() const;
  public:
  void clear_crc_part2();
  private:
  int32_t _internal_crc_part2(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_crc_part2() const;
  void _internal_add_crc_part2(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_crc_part2();
  public:
  int32_t crc_part2(int index) const;
  void set_crc_part2(int index, int32_t value);
  void add_crc_part2(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      crc_part2() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_crc_part2();

  // repeated .CUserMessage_UtilMsg_Response.ItemDetail itemdetails = 9;
  int itemdetails_size() const;
  private:
  int _internal_itemdetails_size() const;
  public:
  void clear_itemdetails();
  ::CUserMessage_UtilMsg_Response_ItemDetail* mutable_itemdetails(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_UtilMsg_Response_ItemDetail >*
      mutable_itemdetails();
  private:
  const ::CUserMessage_UtilMsg_Response_ItemDetail& _internal_itemdetails(int index) const;
  ::CUserMessage_UtilMsg_Response_ItemDetail* _internal_add_itemdetails();
  public:
  const ::CUserMessage_UtilMsg_Response_ItemDetail& itemdetails(int index) const;
  ::CUserMessage_UtilMsg_Response_ItemDetail* add_itemdetails();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_UtilMsg_Response_ItemDetail >&
      itemdetails() const;

  // optional fixed32 crc = 1;
  bool has_crc() const;
  private:
  bool _internal_has_crc() const;
  public:
  void clear_crc();
  uint32_t crc() const;
  void set_crc(uint32_t value);
  private:
  uint32_t _internal_crc() const;
  void _internal_set_crc(uint32_t value);
  public:

  // optional int32 item_count = 2;
  bool has_item_count() const;
  private:
  bool _internal_has_item_count() const;
  public:
  void clear_item_count();
  int32_t item_count() const;
  void set_item_count(int32_t value);
  private:
  int32_t _internal_item_count() const;
  void _internal_set_item_count(int32_t value);
  public:

  // optional fixed32 crc2 = 3;
  bool has_crc2() const;
  private:
  bool _internal_has_crc2() const;
  public:
  void clear_crc2();
  uint32_t crc2() const;
  void set_crc2(uint32_t value);
  private:
  uint32_t _internal_crc2() const;
  void _internal_set_crc2(uint32_t value);
  public:

  // optional int32 item_count2 = 4;
  bool has_item_count2() const;
  private:
  bool _internal_has_item_count2() const;
  public:
  void clear_item_count2();
  int32_t item_count2() const;
  void set_item_count2(int32_t value);
  private:
  int32_t _internal_item_count2() const;
  void _internal_set_item_count2(int32_t value);
  public:

  // optional int32 client_timestamp = 7;
  bool has_client_timestamp() const;
  private:
  bool _internal_has_client_timestamp() const;
  public:
  void clear_client_timestamp();
  int32_t client_timestamp() const;
  void set_client_timestamp(int32_t value);
  private:
  int32_t _internal_client_timestamp() const;
  void _internal_set_client_timestamp(int32_t value);
  public:

  // optional int32 platform = 8;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  int32_t platform() const;
  void set_platform(int32_t value);
  private:
  int32_t _internal_platform() const;
  void _internal_set_platform(int32_t value);
  public:

  // optional int32 itemgroup = 10;
  bool has_itemgroup() const;
  private:
  bool _internal_has_itemgroup() const;
  public:
  void clear_itemgroup();
  int32_t itemgroup() const;
  void set_itemgroup(int32_t value);
  private:
  int32_t _internal_itemgroup() const;
  void _internal_set_itemgroup(int32_t value);
  public:

  // optional int32 total_count = 11;
  bool has_total_count() const;
  private:
  bool _internal_has_total_count() const;
  public:
  void clear_total_count();
  int32_t total_count() const;
  void set_total_count(int32_t value);
  private:
  int32_t _internal_total_count() const;
  void _internal_set_total_count(int32_t value);
  public:

  // optional int32 total_count2 = 12;
  bool has_total_count2() const;
  private:
  bool _internal_has_total_count2() const;
  public:
  void clear_total_count2();
  int32_t total_count2() const;
  void set_total_count2(int32_t value);
  private:
  int32_t _internal_total_count2() const;
  void _internal_set_total_count2(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_UtilMsg_Response)
 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< int32_t > crc_part_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > crc_part2_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_UtilMsg_Response_ItemDetail > itemdetails_;
    uint32_t crc_;
    int32_t item_count_;
    uint32_t crc2_;
    int32_t item_count2_;
    int32_t client_timestamp_;
    int32_t platform_;
    int32_t itemgroup_;
    int32_t total_count_;
    int32_t total_count2_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_DllStatus_CVDiagnostic& operator=(const CUserMessage_DllStatus_CVDiagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_DllStatus_CVDiagnostic& operator=(CUserMessage_DllStatus_CVDiagnostic&& 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 CUserMessage_DllStatus_CVDiagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_DllStatus_CVDiagnostic* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_DllStatus_CVDiagnostic*>(
               &_CUserMessage_DllStatus_CVDiagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    93;

  friend void swap(CUserMessage_DllStatus_CVDiagnostic& a, CUserMessage_DllStatus_CVDiagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_DllStatus_CVDiagnostic* 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(CUserMessage_DllStatus_CVDiagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_DllStatus_CVDiagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_DllStatus_CVDiagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_DllStatus_CVDiagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_DllStatus_CVDiagnostic& from) {
    CUserMessage_DllStatus_CVDiagnostic::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(CUserMessage_DllStatus_CVDiagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_DllStatus.CVDiagnostic";
  }
  protected:
  explicit CUserMessage_DllStatus_CVDiagnostic(::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 {
    kStringValueFieldNumber = 4,
    kIdFieldNumber = 1,
    kExtendedFieldNumber = 2,
    kValueFieldNumber = 3,
  };
  // optional string string_value = 4;
  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 uint32 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // optional uint32 extended = 2;
  bool has_extended() const;
  private:
  bool _internal_has_extended() const;
  public:
  void clear_extended();
  uint32_t extended() const;
  void set_extended(uint32_t value);
  private:
  uint32_t _internal_extended() const;
  void _internal_set_extended(uint32_t value);
  public:

  // optional uint64 value = 3;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  uint64_t value() const;
  void set_value(uint64_t value);
  private:
  uint64_t _internal_value() const;
  void _internal_set_value(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_DllStatus.CVDiagnostic)
 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 string_value_;
    uint32_t id_;
    uint32_t extended_;
    uint64_t value_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_DllStatus_CModule& operator=(const CUserMessage_DllStatus_CModule& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_DllStatus_CModule& operator=(CUserMessage_DllStatus_CModule&& 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 CUserMessage_DllStatus_CModule& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_DllStatus_CModule* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_DllStatus_CModule*>(
               &_CUserMessage_DllStatus_CModule_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    94;

  friend void swap(CUserMessage_DllStatus_CModule& a, CUserMessage_DllStatus_CModule& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_DllStatus_CModule* 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(CUserMessage_DllStatus_CModule* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_DllStatus_CModule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_DllStatus_CModule>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_DllStatus_CModule& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_DllStatus_CModule& from) {
    CUserMessage_DllStatus_CModule::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(CUserMessage_DllStatus_CModule* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_DllStatus.CModule";
  }
  protected:
  explicit CUserMessage_DllStatus_CModule(::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 = 2,
    kBaseAddrFieldNumber = 1,
    kSizeFieldNumber = 3,
    kTimestampFieldNumber = 4,
  };
  // 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 uint64 base_addr = 1;
  bool has_base_addr() const;
  private:
  bool _internal_has_base_addr() const;
  public:
  void clear_base_addr();
  uint64_t base_addr() const;
  void set_base_addr(uint64_t value);
  private:
  uint64_t _internal_base_addr() const;
  void _internal_set_base_addr(uint64_t value);
  public:

  // optional uint32 size = 3;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  uint32_t size() const;
  void set_size(uint32_t value);
  private:
  uint32_t _internal_size() const;
  void _internal_set_size(uint32_t value);
  public:

  // optional uint32 timestamp = 4;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  uint32_t timestamp() const;
  void set_timestamp(uint32_t value);
  private:
  uint32_t _internal_timestamp() const;
  void _internal_set_timestamp(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_DllStatus.CModule)
 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_;
    uint64_t base_addr_;
    uint32_t size_;
    uint32_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_DllStatus& operator=(const CUserMessage_DllStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_DllStatus& operator=(CUserMessage_DllStatus&& 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 CUserMessage_DllStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_DllStatus* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_DllStatus*>(
               &_CUserMessage_DllStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    95;

  friend void swap(CUserMessage_DllStatus& a, CUserMessage_DllStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_DllStatus* 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(CUserMessage_DllStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_DllStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_DllStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_DllStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_DllStatus& from) {
    CUserMessage_DllStatus::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(CUserMessage_DllStatus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_DllStatus";
  }
  protected:
  explicit CUserMessage_DllStatus(::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 CUserMessage_DllStatus_CVDiagnostic CVDiagnostic;
  typedef CUserMessage_DllStatus_CModule CModule;

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

  enum : int {
    kDiagnosticsFieldNumber = 7,
    kModulesFieldNumber = 8,
    kFileReportFieldNumber = 1,
    kCommandLineFieldNumber = 2,
    kTotalFilesFieldNumber = 3,
    kProcessIdFieldNumber = 4,
    kClientTimeFieldNumber = 6,
    kOsversionFieldNumber = 5,
  };
  // repeated .CUserMessage_DllStatus.CVDiagnostic diagnostics = 7;
  int diagnostics_size() const;
  private:
  int _internal_diagnostics_size() const;
  public:
  void clear_diagnostics();
  ::CUserMessage_DllStatus_CVDiagnostic* mutable_diagnostics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CVDiagnostic >*
      mutable_diagnostics();
  private:
  const ::CUserMessage_DllStatus_CVDiagnostic& _internal_diagnostics(int index) const;
  ::CUserMessage_DllStatus_CVDiagnostic* _internal_add_diagnostics();
  public:
  const ::CUserMessage_DllStatus_CVDiagnostic& diagnostics(int index) const;
  ::CUserMessage_DllStatus_CVDiagnostic* add_diagnostics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CVDiagnostic >&
      diagnostics() const;

  // repeated .CUserMessage_DllStatus.CModule modules = 8;
  int modules_size() const;
  private:
  int _internal_modules_size() const;
  public:
  void clear_modules();
  ::CUserMessage_DllStatus_CModule* mutable_modules(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CModule >*
      mutable_modules();
  private:
  const ::CUserMessage_DllStatus_CModule& _internal_modules(int index) const;
  ::CUserMessage_DllStatus_CModule* _internal_add_modules();
  public:
  const ::CUserMessage_DllStatus_CModule& modules(int index) const;
  ::CUserMessage_DllStatus_CModule* add_modules();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CModule >&
      modules() const;

  // optional string file_report = 1;
  bool has_file_report() const;
  private:
  bool _internal_has_file_report() const;
  public:
  void clear_file_report();
  const std::string& file_report() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_file_report(ArgT0&& arg0, ArgT... args);
  std::string* mutable_file_report();
  PROTOBUF_NODISCARD std::string* release_file_report();
  void set_allocated_file_report(std::string* file_report);
  private:
  const std::string& _internal_file_report() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_report(const std::string& value);
  std::string* _internal_mutable_file_report();
  public:

  // optional string command_line = 2;
  bool has_command_line() const;
  private:
  bool _internal_has_command_line() const;
  public:
  void clear_command_line();
  const std::string& command_line() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_command_line(ArgT0&& arg0, ArgT... args);
  std::string* mutable_command_line();
  PROTOBUF_NODISCARD std::string* release_command_line();
  void set_allocated_command_line(std::string* command_line);
  private:
  const std::string& _internal_command_line() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_command_line(const std::string& value);
  std::string* _internal_mutable_command_line();
  public:

  // optional uint32 total_files = 3;
  bool has_total_files() const;
  private:
  bool _internal_has_total_files() const;
  public:
  void clear_total_files();
  uint32_t total_files() const;
  void set_total_files(uint32_t value);
  private:
  uint32_t _internal_total_files() const;
  void _internal_set_total_files(uint32_t value);
  public:

  // optional uint32 process_id = 4;
  bool has_process_id() const;
  private:
  bool _internal_has_process_id() const;
  public:
  void clear_process_id();
  uint32_t process_id() const;
  void set_process_id(uint32_t value);
  private:
  uint32_t _internal_process_id() const;
  void _internal_set_process_id(uint32_t value);
  public:

  // optional uint64 client_time = 6;
  bool has_client_time() const;
  private:
  bool _internal_has_client_time() const;
  public:
  void clear_client_time();
  uint64_t client_time() const;
  void set_client_time(uint64_t value);
  private:
  uint64_t _internal_client_time() const;
  void _internal_set_client_time(uint64_t value);
  public:

  // optional int32 osversion = 5;
  bool has_osversion() const;
  private:
  bool _internal_has_osversion() const;
  public:
  void clear_osversion();
  int32_t osversion() const;
  void set_osversion(int32_t value);
  private:
  int32_t _internal_osversion() const;
  void _internal_set_osversion(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_DllStatus)
 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< ::CUserMessage_DllStatus_CVDiagnostic > diagnostics_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CModule > modules_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_report_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr command_line_;
    uint32_t total_files_;
    uint32_t process_id_;
    uint64_t client_time_;
    int32_t osversion_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestInventory& operator=(const CUserMessageRequestInventory& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestInventory& operator=(CUserMessageRequestInventory&& 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 CUserMessageRequestInventory& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestInventory* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestInventory*>(
               &_CUserMessageRequestInventory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    96;

  friend void swap(CUserMessageRequestInventory& a, CUserMessageRequestInventory& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestInventory* 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(CUserMessageRequestInventory* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestInventory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestInventory>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRequestInventory& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRequestInventory& from) {
    CUserMessageRequestInventory::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(CUserMessageRequestInventory* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRequestInventory";
  }
  protected:
  explicit CUserMessageRequestInventory(::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 {
    kInventoryFieldNumber = 1,
    kOffsetFieldNumber = 2,
    kOptionsFieldNumber = 3,
  };
  // optional int32 inventory = 1;
  bool has_inventory() const;
  private:
  bool _internal_has_inventory() const;
  public:
  void clear_inventory();
  int32_t inventory() const;
  void set_inventory(int32_t value);
  private:
  int32_t _internal_inventory() const;
  void _internal_set_inventory(int32_t value);
  public:

  // optional int32 offset = 2;
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  int32_t offset() const;
  void set_offset(int32_t value);
  private:
  int32_t _internal_offset() const;
  void _internal_set_offset(int32_t value);
  public:

  // optional int32 options = 3;
  bool has_options() const;
  private:
  bool _internal_has_options() const;
  public:
  void clear_options();
  int32_t options() const;
  void set_options(int32_t value);
  private:
  int32_t _internal_options() const;
  void _internal_set_options(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageRequestInventory)
 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 inventory_;
    int32_t offset_;
    int32_t options_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_Inventory_Response_InventoryDetail& operator=(const CUserMessage_Inventory_Response_InventoryDetail& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_Inventory_Response_InventoryDetail& operator=(CUserMessage_Inventory_Response_InventoryDetail&& 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 CUserMessage_Inventory_Response_InventoryDetail& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_Inventory_Response_InventoryDetail* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_Inventory_Response_InventoryDetail*>(
               &_CUserMessage_Inventory_Response_InventoryDetail_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    97;

  friend void swap(CUserMessage_Inventory_Response_InventoryDetail& a, CUserMessage_Inventory_Response_InventoryDetail& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_Inventory_Response_InventoryDetail* 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(CUserMessage_Inventory_Response_InventoryDetail* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_Inventory_Response_InventoryDetail* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_Inventory_Response_InventoryDetail>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_Inventory_Response_InventoryDetail& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_Inventory_Response_InventoryDetail& from) {
    CUserMessage_Inventory_Response_InventoryDetail::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(CUserMessage_Inventory_Response_InventoryDetail* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_Inventory_Response.InventoryDetail";
  }
  protected:
  explicit CUserMessage_Inventory_Response_InventoryDetail(::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 = 6,
    kBaseNameFieldNumber = 7,
    kPrimaryFieldNumber = 2,
    kOffsetFieldNumber = 3,
    kFirstFieldNumber = 4,
    kIndexFieldNumber = 1,
    kBaseDetailFieldNumber = 8,
    kBaseFieldNumber = 5,
    kBaseTimeFieldNumber = 9,
    kBaseHashFieldNumber = 10,
  };
  // optional string name = 6;
  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 base_name = 7;
  bool has_base_name() const;
  private:
  bool _internal_has_base_name() const;
  public:
  void clear_base_name();
  const std::string& base_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_base_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_base_name();
  PROTOBUF_NODISCARD std::string* release_base_name();
  void set_allocated_base_name(std::string* base_name);
  private:
  const std::string& _internal_base_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_base_name(const std::string& value);
  std::string* _internal_mutable_base_name();
  public:

  // optional int64 primary = 2;
  bool has_primary() const;
  private:
  bool _internal_has_primary() const;
  public:
  void clear_primary();
  int64_t primary() const;
  void set_primary(int64_t value);
  private:
  int64_t _internal_primary() const;
  void _internal_set_primary(int64_t value);
  public:

  // optional int64 offset = 3;
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // optional int64 first = 4;
  bool has_first() const;
  private:
  bool _internal_has_first() const;
  public:
  void clear_first();
  int64_t first() const;
  void set_first(int64_t value);
  private:
  int64_t _internal_first() const;
  void _internal_set_first(int64_t value);
  public:

  // optional int32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // optional int32 base_detail = 8;
  bool has_base_detail() const;
  private:
  bool _internal_has_base_detail() const;
  public:
  void clear_base_detail();
  int32_t base_detail() const;
  void set_base_detail(int32_t value);
  private:
  int32_t _internal_base_detail() const;
  void _internal_set_base_detail(int32_t value);
  public:

  // optional int64 base = 5;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  int64_t base() const;
  void set_base(int64_t value);
  private:
  int64_t _internal_base() const;
  void _internal_set_base(int64_t value);
  public:

  // optional int32 base_time = 9;
  bool has_base_time() const;
  private:
  bool _internal_has_base_time() const;
  public:
  void clear_base_time();
  int32_t base_time() const;
  void set_base_time(int32_t value);
  private:
  int32_t _internal_base_time() const;
  void _internal_set_base_time(int32_t value);
  public:

  // optional int32 base_hash = 10;
  bool has_base_hash() const;
  private:
  bool _internal_has_base_hash() const;
  public:
  void clear_base_hash();
  int32_t base_hash() const;
  void set_base_hash(int32_t value);
  private:
  int32_t _internal_base_hash() const;
  void _internal_set_base_hash(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_Inventory_Response.InventoryDetail)
 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 base_name_;
    int64_t primary_;
    int64_t offset_;
    int64_t first_;
    int32_t index_;
    int32_t base_detail_;
    int64_t base_;
    int32_t base_time_;
    int32_t base_hash_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_Inventory_Response& operator=(const CUserMessage_Inventory_Response& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_Inventory_Response& operator=(CUserMessage_Inventory_Response&& 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 CUserMessage_Inventory_Response& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_Inventory_Response* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_Inventory_Response*>(
               &_CUserMessage_Inventory_Response_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    98;

  friend void swap(CUserMessage_Inventory_Response& a, CUserMessage_Inventory_Response& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_Inventory_Response* 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(CUserMessage_Inventory_Response* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_Inventory_Response* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_Inventory_Response>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_Inventory_Response& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_Inventory_Response& from) {
    CUserMessage_Inventory_Response::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(CUserMessage_Inventory_Response* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_Inventory_Response";
  }
  protected:
  explicit CUserMessage_Inventory_Response(::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 CUserMessage_Inventory_Response_InventoryDetail InventoryDetail;

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

  enum : int {
    kInventoriesFieldNumber = 9,
    kInventories2FieldNumber = 10,
    kInventories3FieldNumber = 14,
    kCrcFieldNumber = 1,
    kItemCountFieldNumber = 2,
    kOsversionFieldNumber = 5,
    kPerfTimeFieldNumber = 6,
    kClientTimestampFieldNumber = 7,
    kPlatformFieldNumber = 8,
    kInvTypeFieldNumber = 11,
    kBuildVersionFieldNumber = 12,
    kStartTimeFieldNumber = 15,
    kInstanceFieldNumber = 13,
  };
  // repeated .CUserMessage_Inventory_Response.InventoryDetail inventories = 9;
  int inventories_size() const;
  private:
  int _internal_inventories_size() const;
  public:
  void clear_inventories();
  ::CUserMessage_Inventory_Response_InventoryDetail* mutable_inventories(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
      mutable_inventories();
  private:
  const ::CUserMessage_Inventory_Response_InventoryDetail& _internal_inventories(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* _internal_add_inventories();
  public:
  const ::CUserMessage_Inventory_Response_InventoryDetail& inventories(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* add_inventories();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
      inventories() const;

  // repeated .CUserMessage_Inventory_Response.InventoryDetail inventories2 = 10;
  int inventories2_size() const;
  private:
  int _internal_inventories2_size() const;
  public:
  void clear_inventories2();
  ::CUserMessage_Inventory_Response_InventoryDetail* mutable_inventories2(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
      mutable_inventories2();
  private:
  const ::CUserMessage_Inventory_Response_InventoryDetail& _internal_inventories2(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* _internal_add_inventories2();
  public:
  const ::CUserMessage_Inventory_Response_InventoryDetail& inventories2(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* add_inventories2();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
      inventories2() const;

  // repeated .CUserMessage_Inventory_Response.InventoryDetail inventories3 = 14;
  int inventories3_size() const;
  private:
  int _internal_inventories3_size() const;
  public:
  void clear_inventories3();
  ::CUserMessage_Inventory_Response_InventoryDetail* mutable_inventories3(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
      mutable_inventories3();
  private:
  const ::CUserMessage_Inventory_Response_InventoryDetail& _internal_inventories3(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* _internal_add_inventories3();
  public:
  const ::CUserMessage_Inventory_Response_InventoryDetail& inventories3(int index) const;
  ::CUserMessage_Inventory_Response_InventoryDetail* add_inventories3();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
      inventories3() const;

  // optional fixed32 crc = 1;
  bool has_crc() const;
  private:
  bool _internal_has_crc() const;
  public:
  void clear_crc();
  uint32_t crc() const;
  void set_crc(uint32_t value);
  private:
  uint32_t _internal_crc() const;
  void _internal_set_crc(uint32_t value);
  public:

  // optional int32 item_count = 2;
  bool has_item_count() const;
  private:
  bool _internal_has_item_count() const;
  public:
  void clear_item_count();
  int32_t item_count() const;
  void set_item_count(int32_t value);
  private:
  int32_t _internal_item_count() const;
  void _internal_set_item_count(int32_t value);
  public:

  // optional int32 osversion = 5;
  bool has_osversion() const;
  private:
  bool _internal_has_osversion() const;
  public:
  void clear_osversion();
  int32_t osversion() const;
  void set_osversion(int32_t value);
  private:
  int32_t _internal_osversion() const;
  void _internal_set_osversion(int32_t value);
  public:

  // optional int32 perf_time = 6;
  bool has_perf_time() const;
  private:
  bool _internal_has_perf_time() const;
  public:
  void clear_perf_time();
  int32_t perf_time() const;
  void set_perf_time(int32_t value);
  private:
  int32_t _internal_perf_time() const;
  void _internal_set_perf_time(int32_t value);
  public:

  // optional int32 client_timestamp = 7;
  bool has_client_timestamp() const;
  private:
  bool _internal_has_client_timestamp() const;
  public:
  void clear_client_timestamp();
  int32_t client_timestamp() const;
  void set_client_timestamp(int32_t value);
  private:
  int32_t _internal_client_timestamp() const;
  void _internal_set_client_timestamp(int32_t value);
  public:

  // optional int32 platform = 8;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  int32_t platform() const;
  void set_platform(int32_t value);
  private:
  int32_t _internal_platform() const;
  void _internal_set_platform(int32_t value);
  public:

  // optional int32 inv_type = 11;
  bool has_inv_type() const;
  private:
  bool _internal_has_inv_type() const;
  public:
  void clear_inv_type();
  int32_t inv_type() const;
  void set_inv_type(int32_t value);
  private:
  int32_t _internal_inv_type() const;
  void _internal_set_inv_type(int32_t value);
  public:

  // optional int32 build_version = 12;
  bool has_build_version() const;
  private:
  bool _internal_has_build_version() const;
  public:
  void clear_build_version();
  int32_t build_version() const;
  void set_build_version(int32_t value);
  private:
  int32_t _internal_build_version() const;
  void _internal_set_build_version(int32_t value);
  public:

  // optional int64 start_time = 15;
  bool has_start_time() const;
  private:
  bool _internal_has_start_time() const;
  public:
  void clear_start_time();
  int64_t start_time() const;
  void set_start_time(int64_t value);
  private:
  int64_t _internal_start_time() const;
  void _internal_set_start_time(int64_t value);
  public:

  // optional int32 instance = 13;
  bool has_instance() const;
  private:
  bool _internal_has_instance() const;
  public:
  void clear_instance();
  int32_t instance() const;
  void set_instance(int32_t value);
  private:
  int32_t _internal_instance() const;
  void _internal_set_instance(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_Inventory_Response)
 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< ::CUserMessage_Inventory_Response_InventoryDetail > inventories_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail > inventories2_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail > inventories3_;
    uint32_t crc_;
    int32_t item_count_;
    int32_t osversion_;
    int32_t perf_time_;
    int32_t client_timestamp_;
    int32_t platform_;
    int32_t inv_type_;
    int32_t build_version_;
    int64_t start_time_;
    int32_t instance_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestDiagnostic_Diagnostic& operator=(const CUserMessageRequestDiagnostic_Diagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestDiagnostic_Diagnostic& operator=(CUserMessageRequestDiagnostic_Diagnostic&& 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 CUserMessageRequestDiagnostic_Diagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestDiagnostic_Diagnostic* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestDiagnostic_Diagnostic*>(
               &_CUserMessageRequestDiagnostic_Diagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    99;

  friend void swap(CUserMessageRequestDiagnostic_Diagnostic& a, CUserMessageRequestDiagnostic_Diagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestDiagnostic_Diagnostic* 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(CUserMessageRequestDiagnostic_Diagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestDiagnostic_Diagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestDiagnostic_Diagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRequestDiagnostic_Diagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRequestDiagnostic_Diagnostic& from) {
    CUserMessageRequestDiagnostic_Diagnostic::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(CUserMessageRequestDiagnostic_Diagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRequestDiagnostic.Diagnostic";
  }
  protected:
  explicit CUserMessageRequestDiagnostic_Diagnostic(::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 = 10,
    kAliasFieldNumber = 11,
    kVardetailFieldNumber = 12,
    kOffsetFieldNumber = 2,
    kIndexFieldNumber = 1,
    kParamFieldNumber = 3,
    kLengthFieldNumber = 4,
    kTypeFieldNumber = 5,
    kBaseFieldNumber = 6,
    kRangeFieldNumber = 7,
    kExtentFieldNumber = 8,
    kDetailFieldNumber = 9,
    kContextFieldNumber = 13,
  };
  // optional string name = 10;
  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 alias = 11;
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const std::string& alias() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alias(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alias();
  PROTOBUF_NODISCARD std::string* release_alias();
  void set_allocated_alias(std::string* alias);
  private:
  const std::string& _internal_alias() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alias(const std::string& value);
  std::string* _internal_mutable_alias();
  public:

  // optional bytes vardetail = 12;
  bool has_vardetail() const;
  private:
  bool _internal_has_vardetail() const;
  public:
  void clear_vardetail();
  const std::string& vardetail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vardetail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vardetail();
  PROTOBUF_NODISCARD std::string* release_vardetail();
  void set_allocated_vardetail(std::string* vardetail);
  private:
  const std::string& _internal_vardetail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vardetail(const std::string& value);
  std::string* _internal_mutable_vardetail();
  public:

  // optional int64 offset = 2;
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // optional int32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // optional int32 param = 3;
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  int32_t param() const;
  void set_param(int32_t value);
  private:
  int32_t _internal_param() const;
  void _internal_set_param(int32_t value);
  public:

  // optional int32 length = 4;
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  int32_t length() const;
  void set_length(int32_t value);
  private:
  int32_t _internal_length() const;
  void _internal_set_length(int32_t value);
  public:

  // optional int32 type = 5;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // optional int64 base = 6;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  int64_t base() const;
  void set_base(int64_t value);
  private:
  int64_t _internal_base() const;
  void _internal_set_base(int64_t value);
  public:

  // optional int64 range = 7;
  bool has_range() const;
  private:
  bool _internal_has_range() const;
  public:
  void clear_range();
  int64_t range() const;
  void set_range(int64_t value);
  private:
  int64_t _internal_range() const;
  void _internal_set_range(int64_t value);
  public:

  // optional int64 extent = 8;
  bool has_extent() const;
  private:
  bool _internal_has_extent() const;
  public:
  void clear_extent();
  int64_t extent() const;
  void set_extent(int64_t value);
  private:
  int64_t _internal_extent() const;
  void _internal_set_extent(int64_t value);
  public:

  // optional int64 detail = 9;
  bool has_detail() const;
  private:
  bool _internal_has_detail() const;
  public:
  void clear_detail();
  int64_t detail() const;
  void set_detail(int64_t value);
  private:
  int64_t _internal_detail() const;
  void _internal_set_detail(int64_t value);
  public:

  // optional int32 context = 13;
  bool has_context() const;
  private:
  bool _internal_has_context() const;
  public:
  void clear_context();
  int32_t context() const;
  void set_context(int32_t value);
  private:
  int32_t _internal_context() const;
  void _internal_set_context(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessageRequestDiagnostic.Diagnostic)
 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 alias_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vardetail_;
    int64_t offset_;
    int32_t index_;
    int32_t param_;
    int32_t length_;
    int32_t type_;
    int64_t base_;
    int64_t range_;
    int64_t extent_;
    int64_t detail_;
    int32_t context_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessageRequestDiagnostic& operator=(const CUserMessageRequestDiagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessageRequestDiagnostic& operator=(CUserMessageRequestDiagnostic&& 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 CUserMessageRequestDiagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessageRequestDiagnostic* internal_default_instance() {
    return reinterpret_cast<const CUserMessageRequestDiagnostic*>(
               &_CUserMessageRequestDiagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    100;

  friend void swap(CUserMessageRequestDiagnostic& a, CUserMessageRequestDiagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessageRequestDiagnostic* 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(CUserMessageRequestDiagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessageRequestDiagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessageRequestDiagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessageRequestDiagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessageRequestDiagnostic& from) {
    CUserMessageRequestDiagnostic::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(CUserMessageRequestDiagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessageRequestDiagnostic";
  }
  protected:
  explicit CUserMessageRequestDiagnostic(::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 CUserMessageRequestDiagnostic_Diagnostic Diagnostic;

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

  enum : int {
    kDiagnosticsFieldNumber = 1,
  };
  // repeated .CUserMessageRequestDiagnostic.Diagnostic diagnostics = 1;
  int diagnostics_size() const;
  private:
  int _internal_diagnostics_size() const;
  public:
  void clear_diagnostics();
  ::CUserMessageRequestDiagnostic_Diagnostic* mutable_diagnostics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessageRequestDiagnostic_Diagnostic >*
      mutable_diagnostics();
  private:
  const ::CUserMessageRequestDiagnostic_Diagnostic& _internal_diagnostics(int index) const;
  ::CUserMessageRequestDiagnostic_Diagnostic* _internal_add_diagnostics();
  public:
  const ::CUserMessageRequestDiagnostic_Diagnostic& diagnostics(int index) const;
  ::CUserMessageRequestDiagnostic_Diagnostic* add_diagnostics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessageRequestDiagnostic_Diagnostic >&
      diagnostics() const;

  // @@protoc_insertion_point(class_scope:CUserMessageRequestDiagnostic)
 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< ::CUserMessageRequestDiagnostic_Diagnostic > diagnostics_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_Diagnostic_Response_Diagnostic& operator=(const CUserMessage_Diagnostic_Response_Diagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_Diagnostic_Response_Diagnostic& operator=(CUserMessage_Diagnostic_Response_Diagnostic&& 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 CUserMessage_Diagnostic_Response_Diagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_Diagnostic_Response_Diagnostic* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_Diagnostic_Response_Diagnostic*>(
               &_CUserMessage_Diagnostic_Response_Diagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    101;

  friend void swap(CUserMessage_Diagnostic_Response_Diagnostic& a, CUserMessage_Diagnostic_Response_Diagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_Diagnostic_Response_Diagnostic* 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(CUserMessage_Diagnostic_Response_Diagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_Diagnostic_Response_Diagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_Diagnostic_Response_Diagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_Diagnostic_Response_Diagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_Diagnostic_Response_Diagnostic& from) {
    CUserMessage_Diagnostic_Response_Diagnostic::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(CUserMessage_Diagnostic_Response_Diagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_Diagnostic_Response.Diagnostic";
  }
  protected:
  explicit CUserMessage_Diagnostic_Response_Diagnostic(::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 {
    kDetailFieldNumber = 5,
    kNameFieldNumber = 10,
    kAliasFieldNumber = 11,
    kBackupFieldNumber = 12,
    kOffsetFieldNumber = 2,
    kIndexFieldNumber = 1,
    kParamFieldNumber = 3,
    kBaseFieldNumber = 6,
    kLengthFieldNumber = 4,
    kTypeFieldNumber = 8,
    kRangeFieldNumber = 7,
    kControlFieldNumber = 14,
    kAugmentFieldNumber = 15,
    kPlaceboFieldNumber = 16,
    kContextFieldNumber = 13,
  };
  // optional bytes detail = 5;
  bool has_detail() const;
  private:
  bool _internal_has_detail() const;
  public:
  void clear_detail();
  const std::string& detail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_detail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_detail();
  PROTOBUF_NODISCARD std::string* release_detail();
  void set_allocated_detail(std::string* detail);
  private:
  const std::string& _internal_detail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_detail(const std::string& value);
  std::string* _internal_mutable_detail();
  public:

  // optional string name = 10;
  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 alias = 11;
  bool has_alias() const;
  private:
  bool _internal_has_alias() const;
  public:
  void clear_alias();
  const std::string& alias() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alias(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alias();
  PROTOBUF_NODISCARD std::string* release_alias();
  void set_allocated_alias(std::string* alias);
  private:
  const std::string& _internal_alias() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alias(const std::string& value);
  std::string* _internal_mutable_alias();
  public:

  // optional bytes backup = 12;
  bool has_backup() const;
  private:
  bool _internal_has_backup() const;
  public:
  void clear_backup();
  const std::string& backup() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_backup(ArgT0&& arg0, ArgT... args);
  std::string* mutable_backup();
  PROTOBUF_NODISCARD std::string* release_backup();
  void set_allocated_backup(std::string* backup);
  private:
  const std::string& _internal_backup() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_backup(const std::string& value);
  std::string* _internal_mutable_backup();
  public:

  // optional int64 offset = 2;
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // optional int32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // optional int32 param = 3;
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  int32_t param() const;
  void set_param(int32_t value);
  private:
  int32_t _internal_param() const;
  void _internal_set_param(int32_t value);
  public:

  // optional int64 base = 6;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  int64_t base() const;
  void set_base(int64_t value);
  private:
  int64_t _internal_base() const;
  void _internal_set_base(int64_t value);
  public:

  // optional int32 length = 4;
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  int32_t length() const;
  void set_length(int32_t value);
  private:
  int32_t _internal_length() const;
  void _internal_set_length(int32_t value);
  public:

  // optional int32 type = 8;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // optional int64 range = 7;
  bool has_range() const;
  private:
  bool _internal_has_range() const;
  public:
  void clear_range();
  int64_t range() const;
  void set_range(int64_t value);
  private:
  int64_t _internal_range() const;
  void _internal_set_range(int64_t value);
  public:

  // optional int64 control = 14;
  bool has_control() const;
  private:
  bool _internal_has_control() const;
  public:
  void clear_control();
  int64_t control() const;
  void set_control(int64_t value);
  private:
  int64_t _internal_control() const;
  void _internal_set_control(int64_t value);
  public:

  // optional int64 augment = 15;
  bool has_augment() const;
  private:
  bool _internal_has_augment() const;
  public:
  void clear_augment();
  int64_t augment() const;
  void set_augment(int64_t value);
  private:
  int64_t _internal_augment() const;
  void _internal_set_augment(int64_t value);
  public:

  // optional int64 placebo = 16;
  bool has_placebo() const;
  private:
  bool _internal_has_placebo() const;
  public:
  void clear_placebo();
  int64_t placebo() const;
  void set_placebo(int64_t value);
  private:
  int64_t _internal_placebo() const;
  void _internal_set_placebo(int64_t value);
  public:

  // optional int32 context = 13;
  bool has_context() const;
  private:
  bool _internal_has_context() const;
  public:
  void clear_context();
  int32_t context() const;
  void set_context(int32_t value);
  private:
  int32_t _internal_context() const;
  void _internal_set_context(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_Diagnostic_Response.Diagnostic)
 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 detail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alias_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backup_;
    int64_t offset_;
    int32_t index_;
    int32_t param_;
    int64_t base_;
    int32_t length_;
    int32_t type_;
    int64_t range_;
    int64_t control_;
    int64_t augment_;
    int64_t placebo_;
    int32_t context_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_Diagnostic_Response& operator=(const CUserMessage_Diagnostic_Response& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_Diagnostic_Response& operator=(CUserMessage_Diagnostic_Response&& 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 CUserMessage_Diagnostic_Response& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_Diagnostic_Response* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_Diagnostic_Response*>(
               &_CUserMessage_Diagnostic_Response_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    102;

  friend void swap(CUserMessage_Diagnostic_Response& a, CUserMessage_Diagnostic_Response& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_Diagnostic_Response* 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(CUserMessage_Diagnostic_Response* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_Diagnostic_Response* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_Diagnostic_Response>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_Diagnostic_Response& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_Diagnostic_Response& from) {
    CUserMessage_Diagnostic_Response::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(CUserMessage_Diagnostic_Response* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_Diagnostic_Response";
  }
  protected:
  explicit CUserMessage_Diagnostic_Response(::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 CUserMessage_Diagnostic_Response_Diagnostic Diagnostic;

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

  enum : int {
    kDiagnosticsFieldNumber = 1,
    kBuildVersionFieldNumber = 2,
    kInstanceFieldNumber = 3,
    kStartTimeFieldNumber = 4,
    kOsversionFieldNumber = 5,
    kPlatformFieldNumber = 6,
  };
  // repeated .CUserMessage_Diagnostic_Response.Diagnostic diagnostics = 1;
  int diagnostics_size() const;
  private:
  int _internal_diagnostics_size() const;
  public:
  void clear_diagnostics();
  ::CUserMessage_Diagnostic_Response_Diagnostic* mutable_diagnostics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Diagnostic_Response_Diagnostic >*
      mutable_diagnostics();
  private:
  const ::CUserMessage_Diagnostic_Response_Diagnostic& _internal_diagnostics(int index) const;
  ::CUserMessage_Diagnostic_Response_Diagnostic* _internal_add_diagnostics();
  public:
  const ::CUserMessage_Diagnostic_Response_Diagnostic& diagnostics(int index) const;
  ::CUserMessage_Diagnostic_Response_Diagnostic* add_diagnostics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Diagnostic_Response_Diagnostic >&
      diagnostics() const;

  // optional int32 build_version = 2;
  bool has_build_version() const;
  private:
  bool _internal_has_build_version() const;
  public:
  void clear_build_version();
  int32_t build_version() const;
  void set_build_version(int32_t value);
  private:
  int32_t _internal_build_version() const;
  void _internal_set_build_version(int32_t value);
  public:

  // optional int32 instance = 3;
  bool has_instance() const;
  private:
  bool _internal_has_instance() const;
  public:
  void clear_instance();
  int32_t instance() const;
  void set_instance(int32_t value);
  private:
  int32_t _internal_instance() const;
  void _internal_set_instance(int32_t value);
  public:

  // optional int64 start_time = 4;
  bool has_start_time() const;
  private:
  bool _internal_has_start_time() const;
  public:
  void clear_start_time();
  int64_t start_time() const;
  void set_start_time(int64_t value);
  private:
  int64_t _internal_start_time() const;
  void _internal_set_start_time(int64_t value);
  public:

  // optional int32 osversion = 5;
  bool has_osversion() const;
  private:
  bool _internal_has_osversion() const;
  public:
  void clear_osversion();
  int32_t osversion() const;
  void set_osversion(int32_t value);
  private:
  int32_t _internal_osversion() const;
  void _internal_set_osversion(int32_t value);
  public:

  // optional int32 platform = 6;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  int32_t platform() const;
  void set_platform(int32_t value);
  private:
  int32_t _internal_platform() const;
  void _internal_set_platform(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_Diagnostic_Response)
 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< ::CUserMessage_Diagnostic_Response_Diagnostic > diagnostics_;
    int32_t build_version_;
    int32_t instance_;
    int64_t start_time_;
    int32_t osversion_;
    int32_t platform_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_ExtraUserData& operator=(const CUserMessage_ExtraUserData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_ExtraUserData& operator=(CUserMessage_ExtraUserData&& 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 CUserMessage_ExtraUserData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_ExtraUserData* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_ExtraUserData*>(
               &_CUserMessage_ExtraUserData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    103;

  friend void swap(CUserMessage_ExtraUserData& a, CUserMessage_ExtraUserData& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_ExtraUserData* 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(CUserMessage_ExtraUserData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_ExtraUserData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_ExtraUserData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_ExtraUserData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_ExtraUserData& from) {
    CUserMessage_ExtraUserData::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(CUserMessage_ExtraUserData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_ExtraUserData";
  }
  protected:
  explicit CUserMessage_ExtraUserData(::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 {
    kDetail1FieldNumber = 4,
    kDetail2FieldNumber = 5,
    kValue1FieldNumber = 2,
    kValue2FieldNumber = 3,
    kItemFieldNumber = 1,
  };
  // repeated bytes detail1 = 4;
  int detail1_size() const;
  private:
  int _internal_detail1_size() const;
  public:
  void clear_detail1();
  const std::string& detail1(int index) const;
  std::string* mutable_detail1(int index);
  void set_detail1(int index, const std::string& value);
  void set_detail1(int index, std::string&& value);
  void set_detail1(int index, const char* value);
  void set_detail1(int index, const void* value, size_t size);
  std::string* add_detail1();
  void add_detail1(const std::string& value);
  void add_detail1(std::string&& value);
  void add_detail1(const char* value);
  void add_detail1(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& detail1() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_detail1();
  private:
  const std::string& _internal_detail1(int index) const;
  std::string* _internal_add_detail1();
  public:

  // repeated bytes detail2 = 5;
  int detail2_size() const;
  private:
  int _internal_detail2_size() const;
  public:
  void clear_detail2();
  const std::string& detail2(int index) const;
  std::string* mutable_detail2(int index);
  void set_detail2(int index, const std::string& value);
  void set_detail2(int index, std::string&& value);
  void set_detail2(int index, const char* value);
  void set_detail2(int index, const void* value, size_t size);
  std::string* add_detail2();
  void add_detail2(const std::string& value);
  void add_detail2(std::string&& value);
  void add_detail2(const char* value);
  void add_detail2(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& detail2() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_detail2();
  private:
  const std::string& _internal_detail2(int index) const;
  std::string* _internal_add_detail2();
  public:

  // optional int64 value1 = 2;
  bool has_value1() const;
  private:
  bool _internal_has_value1() const;
  public:
  void clear_value1();
  int64_t value1() const;
  void set_value1(int64_t value);
  private:
  int64_t _internal_value1() const;
  void _internal_set_value1(int64_t value);
  public:

  // optional int64 value2 = 3;
  bool has_value2() const;
  private:
  bool _internal_has_value2() const;
  public:
  void clear_value2();
  int64_t value2() const;
  void set_value2(int64_t value);
  private:
  int64_t _internal_value2() const;
  void _internal_set_value2(int64_t value);
  public:

  // optional int32 item = 1;
  bool has_item() const;
  private:
  bool _internal_has_item() const;
  public:
  void clear_item();
  int32_t item() const;
  void set_item(int32_t value);
  private:
  int32_t _internal_item() const;
  void _internal_set_item(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_ExtraUserData)
 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> detail1_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> detail2_;
    int64_t value1_;
    int64_t value2_;
    int32_t item_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_NotifyResponseFound_Criteria& operator=(const CUserMessage_NotifyResponseFound_Criteria& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_NotifyResponseFound_Criteria& operator=(CUserMessage_NotifyResponseFound_Criteria&& 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 CUserMessage_NotifyResponseFound_Criteria& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_NotifyResponseFound_Criteria* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_NotifyResponseFound_Criteria*>(
               &_CUserMessage_NotifyResponseFound_Criteria_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    104;

  friend void swap(CUserMessage_NotifyResponseFound_Criteria& a, CUserMessage_NotifyResponseFound_Criteria& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_NotifyResponseFound_Criteria* 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(CUserMessage_NotifyResponseFound_Criteria* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_NotifyResponseFound_Criteria* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_NotifyResponseFound_Criteria>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_NotifyResponseFound_Criteria& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_NotifyResponseFound_Criteria& from) {
    CUserMessage_NotifyResponseFound_Criteria::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(CUserMessage_NotifyResponseFound_Criteria* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_NotifyResponseFound.Criteria";
  }
  protected:
  explicit CUserMessage_NotifyResponseFound_Criteria(::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 {
    kValueFieldNumber = 2,
    kNameSymbolFieldNumber = 1,
  };
  // 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:

  // optional uint32 name_symbol = 1;
  bool has_name_symbol() const;
  private:
  bool _internal_has_name_symbol() const;
  public:
  void clear_name_symbol();
  uint32_t name_symbol() const;
  void set_name_symbol(uint32_t value);
  private:
  uint32_t _internal_name_symbol() const;
  void _internal_set_name_symbol(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_NotifyResponseFound.Criteria)
 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_;
    uint32_t name_symbol_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_NotifyResponseFound& operator=(const CUserMessage_NotifyResponseFound& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_NotifyResponseFound& operator=(CUserMessage_NotifyResponseFound&& 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 CUserMessage_NotifyResponseFound& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_NotifyResponseFound* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_NotifyResponseFound*>(
               &_CUserMessage_NotifyResponseFound_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    105;

  friend void swap(CUserMessage_NotifyResponseFound& a, CUserMessage_NotifyResponseFound& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_NotifyResponseFound* 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(CUserMessage_NotifyResponseFound* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_NotifyResponseFound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_NotifyResponseFound>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_NotifyResponseFound& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_NotifyResponseFound& from) {
    CUserMessage_NotifyResponseFound::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(CUserMessage_NotifyResponseFound* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_NotifyResponseFound";
  }
  protected:
  explicit CUserMessage_NotifyResponseFound(::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 CUserMessage_NotifyResponseFound_Criteria Criteria;

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

  enum : int {
    kCriteriaFieldNumber = 5,
    kIntCriteriaNamesFieldNumber = 6,
    kIntCriteriaValuesFieldNumber = 7,
    kFloatCriteriaNamesFieldNumber = 8,
    kFloatCriteriaValuesFieldNumber = 9,
    kSymbolCriteriaNamesFieldNumber = 10,
    kSymbolCriteriaValuesFieldNumber = 11,
    kRuleNameFieldNumber = 2,
    kResponseValueFieldNumber = 3,
    kResponseConceptFieldNumber = 4,
    kSpeakResultFieldNumber = 12,
    kEntIndexFieldNumber = 1,
  };
  // repeated .CUserMessage_NotifyResponseFound.Criteria criteria = 5;
  int criteria_size() const;
  private:
  int _internal_criteria_size() const;
  public:
  void clear_criteria();
  ::CUserMessage_NotifyResponseFound_Criteria* mutable_criteria(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_NotifyResponseFound_Criteria >*
      mutable_criteria();
  private:
  const ::CUserMessage_NotifyResponseFound_Criteria& _internal_criteria(int index) const;
  ::CUserMessage_NotifyResponseFound_Criteria* _internal_add_criteria();
  public:
  const ::CUserMessage_NotifyResponseFound_Criteria& criteria(int index) const;
  ::CUserMessage_NotifyResponseFound_Criteria* add_criteria();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_NotifyResponseFound_Criteria >&
      criteria() const;

  // repeated uint32 int_criteria_names = 6 [packed = true];
  int int_criteria_names_size() const;
  private:
  int _internal_int_criteria_names_size() const;
  public:
  void clear_int_criteria_names();
  private:
  uint32_t _internal_int_criteria_names(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_int_criteria_names() const;
  void _internal_add_int_criteria_names(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_int_criteria_names();
  public:
  uint32_t int_criteria_names(int index) const;
  void set_int_criteria_names(int index, uint32_t value);
  void add_int_criteria_names(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      int_criteria_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_int_criteria_names();

  // repeated int32 int_criteria_values = 7 [packed = true];
  int int_criteria_values_size() const;
  private:
  int _internal_int_criteria_values_size() const;
  public:
  void clear_int_criteria_values();
  private:
  int32_t _internal_int_criteria_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_int_criteria_values() const;
  void _internal_add_int_criteria_values(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_int_criteria_values();
  public:
  int32_t int_criteria_values(int index) const;
  void set_int_criteria_values(int index, int32_t value);
  void add_int_criteria_values(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      int_criteria_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_int_criteria_values();

  // repeated uint32 float_criteria_names = 8 [packed = true];
  int float_criteria_names_size() const;
  private:
  int _internal_float_criteria_names_size() const;
  public:
  void clear_float_criteria_names();
  private:
  uint32_t _internal_float_criteria_names(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_float_criteria_names() const;
  void _internal_add_float_criteria_names(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_float_criteria_names();
  public:
  uint32_t float_criteria_names(int index) const;
  void set_float_criteria_names(int index, uint32_t value);
  void add_float_criteria_names(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      float_criteria_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_float_criteria_names();

  // repeated float float_criteria_values = 9;
  int float_criteria_values_size() const;
  private:
  int _internal_float_criteria_values_size() const;
  public:
  void clear_float_criteria_values();
  private:
  float _internal_float_criteria_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_float_criteria_values() const;
  void _internal_add_float_criteria_values(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_float_criteria_values();
  public:
  float float_criteria_values(int index) const;
  void set_float_criteria_values(int index, float value);
  void add_float_criteria_values(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      float_criteria_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_float_criteria_values();

  // repeated uint32 symbol_criteria_names = 10 [packed = true];
  int symbol_criteria_names_size() const;
  private:
  int _internal_symbol_criteria_names_size() const;
  public:
  void clear_symbol_criteria_names();
  private:
  uint32_t _internal_symbol_criteria_names(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_symbol_criteria_names() const;
  void _internal_add_symbol_criteria_names(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_symbol_criteria_names();
  public:
  uint32_t symbol_criteria_names(int index) const;
  void set_symbol_criteria_names(int index, uint32_t value);
  void add_symbol_criteria_names(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      symbol_criteria_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_symbol_criteria_names();

  // repeated uint32 symbol_criteria_values = 11 [packed = true];
  int symbol_criteria_values_size() const;
  private:
  int _internal_symbol_criteria_values_size() const;
  public:
  void clear_symbol_criteria_values();
  private:
  uint32_t _internal_symbol_criteria_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_symbol_criteria_values() const;
  void _internal_add_symbol_criteria_values(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_symbol_criteria_values();
  public:
  uint32_t symbol_criteria_values(int index) const;
  void set_symbol_criteria_values(int index, uint32_t value);
  void add_symbol_criteria_values(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      symbol_criteria_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_symbol_criteria_values();

  // optional string rule_name = 2;
  bool has_rule_name() const;
  private:
  bool _internal_has_rule_name() const;
  public:
  void clear_rule_name();
  const std::string& rule_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rule_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rule_name();
  PROTOBUF_NODISCARD std::string* release_rule_name();
  void set_allocated_rule_name(std::string* rule_name);
  private:
  const std::string& _internal_rule_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rule_name(const std::string& value);
  std::string* _internal_mutable_rule_name();
  public:

  // optional string response_value = 3;
  bool has_response_value() const;
  private:
  bool _internal_has_response_value() const;
  public:
  void clear_response_value();
  const std::string& response_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_response_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_response_value();
  PROTOBUF_NODISCARD std::string* release_response_value();
  void set_allocated_response_value(std::string* response_value);
  private:
  const std::string& _internal_response_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_value(const std::string& value);
  std::string* _internal_mutable_response_value();
  public:

  // optional string response_concept = 4;
  bool has_response_concept() const;
  private:
  bool _internal_has_response_concept() const;
  public:
  void clear_response_concept();
  const std::string& response_concept() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_response_concept(ArgT0&& arg0, ArgT... args);
  std::string* mutable_response_concept();
  PROTOBUF_NODISCARD std::string* release_response_concept();
  void set_allocated_response_concept(std::string* response_concept);
  private:
  const std::string& _internal_response_concept() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_concept(const std::string& value);
  std::string* _internal_mutable_response_concept();
  public:

  // optional int32 speak_result = 12;
  bool has_speak_result() const;
  private:
  bool _internal_has_speak_result() const;
  public:
  void clear_speak_result();
  int32_t speak_result() const;
  void set_speak_result(int32_t value);
  private:
  int32_t _internal_speak_result() const;
  void _internal_set_speak_result(int32_t value);
  public:

  // optional int32 ent_index = 1 [default = -1];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  int32_t ent_index() const;
  void set_ent_index(int32_t value);
  private:
  int32_t _internal_ent_index() const;
  void _internal_set_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_NotifyResponseFound)
 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< ::CUserMessage_NotifyResponseFound_Criteria > criteria_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > int_criteria_names_;
    mutable std::atomic<int> _int_criteria_names_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > int_criteria_values_;
    mutable std::atomic<int> _int_criteria_values_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > float_criteria_names_;
    mutable std::atomic<int> _float_criteria_names_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_criteria_values_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > symbol_criteria_names_;
    mutable std::atomic<int> _symbol_criteria_names_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > symbol_criteria_values_;
    mutable std::atomic<int> _symbol_criteria_values_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rule_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_value_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_concept_;
    int32_t speak_result_;
    int32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CUserMessage_PlayResponseConditional& operator=(const CUserMessage_PlayResponseConditional& from) {
    CopyFrom(from);
    return *this;
  }
  inline CUserMessage_PlayResponseConditional& operator=(CUserMessage_PlayResponseConditional&& 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 CUserMessage_PlayResponseConditional& default_instance() {
    return *internal_default_instance();
  }
  static inline const CUserMessage_PlayResponseConditional* internal_default_instance() {
    return reinterpret_cast<const CUserMessage_PlayResponseConditional*>(
               &_CUserMessage_PlayResponseConditional_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    106;

  friend void swap(CUserMessage_PlayResponseConditional& a, CUserMessage_PlayResponseConditional& b) {
    a.Swap(&b);
  }
  inline void Swap(CUserMessage_PlayResponseConditional* 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(CUserMessage_PlayResponseConditional* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CUserMessage_PlayResponseConditional* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CUserMessage_PlayResponseConditional>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CUserMessage_PlayResponseConditional& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CUserMessage_PlayResponseConditional& from) {
    CUserMessage_PlayResponseConditional::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(CUserMessage_PlayResponseConditional* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CUserMessage_PlayResponseConditional";
  }
  protected:
  explicit CUserMessage_PlayResponseConditional(::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 {
    kPlayerSlotsFieldNumber = 2,
    kResponseFieldNumber = 3,
    kEntOriginFieldNumber = 4,
    kPreDelayFieldNumber = 5,
    kMixPriorityFieldNumber = 6,
    kEntIndexFieldNumber = 1,
  };
  // repeated int32 player_slots = 2;
  int player_slots_size() const;
  private:
  int _internal_player_slots_size() const;
  public:
  void clear_player_slots();
  private:
  int32_t _internal_player_slots(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_player_slots() const;
  void _internal_add_player_slots(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_player_slots();
  public:
  int32_t player_slots(int index) const;
  void set_player_slots(int index, int32_t value);
  void add_player_slots(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      player_slots() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_player_slots();

  // optional string response = 3;
  bool has_response() const;
  private:
  bool _internal_has_response() const;
  public:
  void clear_response();
  const std::string& response() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_response(ArgT0&& arg0, ArgT... args);
  std::string* mutable_response();
  PROTOBUF_NODISCARD std::string* release_response();
  void set_allocated_response(std::string* response);
  private:
  const std::string& _internal_response() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response(const std::string& value);
  std::string* _internal_mutable_response();
  public:

  // optional .CMsgVector ent_origin = 4;
  bool has_ent_origin() const;
  private:
  bool _internal_has_ent_origin() const;
  public:
  void clear_ent_origin();
  const ::CMsgVector& ent_origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_ent_origin();
  ::CMsgVector* mutable_ent_origin();
  void set_allocated_ent_origin(::CMsgVector* ent_origin);
  private:
  const ::CMsgVector& _internal_ent_origin() const;
  ::CMsgVector* _internal_mutable_ent_origin();
  public:
  void unsafe_arena_set_allocated_ent_origin(
      ::CMsgVector* ent_origin);
  ::CMsgVector* unsafe_arena_release_ent_origin();

  // optional float pre_delay = 5;
  bool has_pre_delay() const;
  private:
  bool _internal_has_pre_delay() const;
  public:
  void clear_pre_delay();
  float pre_delay() const;
  void set_pre_delay(float value);
  private:
  float _internal_pre_delay() const;
  void _internal_set_pre_delay(float value);
  public:

  // optional int32 mix_priority = 6;
  bool has_mix_priority() const;
  private:
  bool _internal_has_mix_priority() const;
  public:
  void clear_mix_priority();
  int32_t mix_priority() const;
  void set_mix_priority(int32_t value);
  private:
  int32_t _internal_mix_priority() const;
  void _internal_set_mix_priority(int32_t value);
  public:

  // optional int32 ent_index = 1 [default = -1];
  bool has_ent_index() const;
  private:
  bool _internal_has_ent_index() const;
  public:
  void clear_ent_index();
  int32_t ent_index() const;
  void set_ent_index(int32_t value);
  private:
  int32_t _internal_ent_index() const;
  void _internal_set_ent_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CUserMessage_PlayResponseConditional)
 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< int32_t > player_slots_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_;
    ::CMsgVector* ent_origin_;
    float pre_delay_;
    int32_t mix_priority_;
    int32_t ent_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usermessages_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CUserMessageAchievementEvent

// optional uint32 achievement = 1;
inline bool CUserMessageAchievementEvent::_internal_has_achievement() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageAchievementEvent::has_achievement() const {
  return _internal_has_achievement();
}
inline void CUserMessageAchievementEvent::clear_achievement() {
  _impl_.achievement_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageAchievementEvent::_internal_achievement() const {
  return _impl_.achievement_;
}
inline uint32_t CUserMessageAchievementEvent::achievement() const {
  // @@protoc_insertion_point(field_get:CUserMessageAchievementEvent.achievement)
  return _internal_achievement();
}
inline void CUserMessageAchievementEvent::_internal_set_achievement(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.achievement_ = value;
}
inline void CUserMessageAchievementEvent::set_achievement(uint32_t value) {
  _internal_set_achievement(value);
  // @@protoc_insertion_point(field_set:CUserMessageAchievementEvent.achievement)
}

// -------------------------------------------------------------------

// CUserMessageCloseCaption

// optional fixed32 hash = 1;
inline bool CUserMessageCloseCaption::_internal_has_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCloseCaption::has_hash() const {
  return _internal_has_hash();
}
inline void CUserMessageCloseCaption::clear_hash() {
  _impl_.hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageCloseCaption::_internal_hash() const {
  return _impl_.hash_;
}
inline uint32_t CUserMessageCloseCaption::hash() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaption.hash)
  return _internal_hash();
}
inline void CUserMessageCloseCaption::_internal_set_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hash_ = value;
}
inline void CUserMessageCloseCaption::set_hash(uint32_t value) {
  _internal_set_hash(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaption.hash)
}

// optional float duration = 2;
inline bool CUserMessageCloseCaption::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCloseCaption::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageCloseCaption::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageCloseCaption::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageCloseCaption::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaption.duration)
  return _internal_duration();
}
inline void CUserMessageCloseCaption::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void CUserMessageCloseCaption::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaption.duration)
}

// optional bool from_player = 3;
inline bool CUserMessageCloseCaption::_internal_has_from_player() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageCloseCaption::has_from_player() const {
  return _internal_has_from_player();
}
inline void CUserMessageCloseCaption::clear_from_player() {
  _impl_.from_player_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageCloseCaption::_internal_from_player() const {
  return _impl_.from_player_;
}
inline bool CUserMessageCloseCaption::from_player() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaption.from_player)
  return _internal_from_player();
}
inline void CUserMessageCloseCaption::_internal_set_from_player(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.from_player_ = value;
}
inline void CUserMessageCloseCaption::set_from_player(bool value) {
  _internal_set_from_player(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaption.from_player)
}

// optional int32 ent_index = 4 [default = -1];
inline bool CUserMessageCloseCaption::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageCloseCaption::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMessageCloseCaption::clear_ent_index() {
  _impl_.ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessageCloseCaption::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline int32_t CUserMessageCloseCaption::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaption.ent_index)
  return _internal_ent_index();
}
inline void CUserMessageCloseCaption::_internal_set_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ent_index_ = value;
}
inline void CUserMessageCloseCaption::set_ent_index(int32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaption.ent_index)
}

// -------------------------------------------------------------------

// CUserMessageCloseCaptionDirect

// optional fixed32 hash = 1;
inline bool CUserMessageCloseCaptionDirect::_internal_has_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionDirect::has_hash() const {
  return _internal_has_hash();
}
inline void CUserMessageCloseCaptionDirect::clear_hash() {
  _impl_.hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageCloseCaptionDirect::_internal_hash() const {
  return _impl_.hash_;
}
inline uint32_t CUserMessageCloseCaptionDirect::hash() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionDirect.hash)
  return _internal_hash();
}
inline void CUserMessageCloseCaptionDirect::_internal_set_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hash_ = value;
}
inline void CUserMessageCloseCaptionDirect::set_hash(uint32_t value) {
  _internal_set_hash(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionDirect.hash)
}

// optional float duration = 2;
inline bool CUserMessageCloseCaptionDirect::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionDirect::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageCloseCaptionDirect::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageCloseCaptionDirect::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageCloseCaptionDirect::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionDirect.duration)
  return _internal_duration();
}
inline void CUserMessageCloseCaptionDirect::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void CUserMessageCloseCaptionDirect::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionDirect.duration)
}

// optional bool from_player = 3;
inline bool CUserMessageCloseCaptionDirect::_internal_has_from_player() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionDirect::has_from_player() const {
  return _internal_has_from_player();
}
inline void CUserMessageCloseCaptionDirect::clear_from_player() {
  _impl_.from_player_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageCloseCaptionDirect::_internal_from_player() const {
  return _impl_.from_player_;
}
inline bool CUserMessageCloseCaptionDirect::from_player() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionDirect.from_player)
  return _internal_from_player();
}
inline void CUserMessageCloseCaptionDirect::_internal_set_from_player(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.from_player_ = value;
}
inline void CUserMessageCloseCaptionDirect::set_from_player(bool value) {
  _internal_set_from_player(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionDirect.from_player)
}

// optional int32 ent_index = 4 [default = -1];
inline bool CUserMessageCloseCaptionDirect::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionDirect::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMessageCloseCaptionDirect::clear_ent_index() {
  _impl_.ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessageCloseCaptionDirect::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline int32_t CUserMessageCloseCaptionDirect::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionDirect.ent_index)
  return _internal_ent_index();
}
inline void CUserMessageCloseCaptionDirect::_internal_set_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ent_index_ = value;
}
inline void CUserMessageCloseCaptionDirect::set_ent_index(int32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionDirect.ent_index)
}

// -------------------------------------------------------------------

// CUserMessageCloseCaptionPlaceholder

// optional string string = 1;
inline bool CUserMessageCloseCaptionPlaceholder::_internal_has_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionPlaceholder::has_string() const {
  return _internal_has_string();
}
inline void CUserMessageCloseCaptionPlaceholder::clear_string() {
  _impl_.string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageCloseCaptionPlaceholder::string() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionPlaceholder.string)
  return _internal_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageCloseCaptionPlaceholder::set_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionPlaceholder.string)
}
inline std::string* CUserMessageCloseCaptionPlaceholder::mutable_string() {
  std::string* _s = _internal_mutable_string();
  // @@protoc_insertion_point(field_mutable:CUserMessageCloseCaptionPlaceholder.string)
  return _s;
}
inline const std::string& CUserMessageCloseCaptionPlaceholder::_internal_string() const {
  return _impl_.string_.Get();
}
inline void CUserMessageCloseCaptionPlaceholder::_internal_set_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.string_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageCloseCaptionPlaceholder::_internal_mutable_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.string_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageCloseCaptionPlaceholder::release_string() {
  // @@protoc_insertion_point(field_release:CUserMessageCloseCaptionPlaceholder.string)
  if (!_internal_has_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_.IsDefault()) {
    _impl_.string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageCloseCaptionPlaceholder::set_allocated_string(std::string* string) {
  if (string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.string_.SetAllocated(string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_.IsDefault()) {
    _impl_.string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageCloseCaptionPlaceholder.string)
}

// optional float duration = 2;
inline bool CUserMessageCloseCaptionPlaceholder::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionPlaceholder::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageCloseCaptionPlaceholder::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageCloseCaptionPlaceholder::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageCloseCaptionPlaceholder::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionPlaceholder.duration)
  return _internal_duration();
}
inline void CUserMessageCloseCaptionPlaceholder::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void CUserMessageCloseCaptionPlaceholder::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionPlaceholder.duration)
}

// optional bool from_player = 3;
inline bool CUserMessageCloseCaptionPlaceholder::_internal_has_from_player() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionPlaceholder::has_from_player() const {
  return _internal_has_from_player();
}
inline void CUserMessageCloseCaptionPlaceholder::clear_from_player() {
  _impl_.from_player_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageCloseCaptionPlaceholder::_internal_from_player() const {
  return _impl_.from_player_;
}
inline bool CUserMessageCloseCaptionPlaceholder::from_player() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionPlaceholder.from_player)
  return _internal_from_player();
}
inline void CUserMessageCloseCaptionPlaceholder::_internal_set_from_player(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.from_player_ = value;
}
inline void CUserMessageCloseCaptionPlaceholder::set_from_player(bool value) {
  _internal_set_from_player(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionPlaceholder.from_player)
}

// optional int32 ent_index = 4 [default = -1];
inline bool CUserMessageCloseCaptionPlaceholder::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageCloseCaptionPlaceholder::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMessageCloseCaptionPlaceholder::clear_ent_index() {
  _impl_.ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessageCloseCaptionPlaceholder::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline int32_t CUserMessageCloseCaptionPlaceholder::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessageCloseCaptionPlaceholder.ent_index)
  return _internal_ent_index();
}
inline void CUserMessageCloseCaptionPlaceholder::_internal_set_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ent_index_ = value;
}
inline void CUserMessageCloseCaptionPlaceholder::set_ent_index(int32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageCloseCaptionPlaceholder.ent_index)
}

// -------------------------------------------------------------------

// CUserMessageCurrentTimescale

// optional float current = 1;
inline bool CUserMessageCurrentTimescale::_internal_has_current() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCurrentTimescale::has_current() const {
  return _internal_has_current();
}
inline void CUserMessageCurrentTimescale::clear_current() {
  _impl_.current_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMessageCurrentTimescale::_internal_current() const {
  return _impl_.current_;
}
inline float CUserMessageCurrentTimescale::current() const {
  // @@protoc_insertion_point(field_get:CUserMessageCurrentTimescale.current)
  return _internal_current();
}
inline void CUserMessageCurrentTimescale::_internal_set_current(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.current_ = value;
}
inline void CUserMessageCurrentTimescale::set_current(float value) {
  _internal_set_current(value);
  // @@protoc_insertion_point(field_set:CUserMessageCurrentTimescale.current)
}

// -------------------------------------------------------------------

// CUserMessageDesiredTimescale

// optional float desired = 1;
inline bool CUserMessageDesiredTimescale::_internal_has_desired() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageDesiredTimescale::has_desired() const {
  return _internal_has_desired();
}
inline void CUserMessageDesiredTimescale::clear_desired() {
  _impl_.desired_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMessageDesiredTimescale::_internal_desired() const {
  return _impl_.desired_;
}
inline float CUserMessageDesiredTimescale::desired() const {
  // @@protoc_insertion_point(field_get:CUserMessageDesiredTimescale.desired)
  return _internal_desired();
}
inline void CUserMessageDesiredTimescale::_internal_set_desired(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.desired_ = value;
}
inline void CUserMessageDesiredTimescale::set_desired(float value) {
  _internal_set_desired(value);
  // @@protoc_insertion_point(field_set:CUserMessageDesiredTimescale.desired)
}

// optional float acceleration = 2;
inline bool CUserMessageDesiredTimescale::_internal_has_acceleration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageDesiredTimescale::has_acceleration() const {
  return _internal_has_acceleration();
}
inline void CUserMessageDesiredTimescale::clear_acceleration() {
  _impl_.acceleration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageDesiredTimescale::_internal_acceleration() const {
  return _impl_.acceleration_;
}
inline float CUserMessageDesiredTimescale::acceleration() const {
  // @@protoc_insertion_point(field_get:CUserMessageDesiredTimescale.acceleration)
  return _internal_acceleration();
}
inline void CUserMessageDesiredTimescale::_internal_set_acceleration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.acceleration_ = value;
}
inline void CUserMessageDesiredTimescale::set_acceleration(float value) {
  _internal_set_acceleration(value);
  // @@protoc_insertion_point(field_set:CUserMessageDesiredTimescale.acceleration)
}

// optional float minblendrate = 3;
inline bool CUserMessageDesiredTimescale::_internal_has_minblendrate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageDesiredTimescale::has_minblendrate() const {
  return _internal_has_minblendrate();
}
inline void CUserMessageDesiredTimescale::clear_minblendrate() {
  _impl_.minblendrate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageDesiredTimescale::_internal_minblendrate() const {
  return _impl_.minblendrate_;
}
inline float CUserMessageDesiredTimescale::minblendrate() const {
  // @@protoc_insertion_point(field_get:CUserMessageDesiredTimescale.minblendrate)
  return _internal_minblendrate();
}
inline void CUserMessageDesiredTimescale::_internal_set_minblendrate(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.minblendrate_ = value;
}
inline void CUserMessageDesiredTimescale::set_minblendrate(float value) {
  _internal_set_minblendrate(value);
  // @@protoc_insertion_point(field_set:CUserMessageDesiredTimescale.minblendrate)
}

// optional float blenddeltamultiplier = 4;
inline bool CUserMessageDesiredTimescale::_internal_has_blenddeltamultiplier() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageDesiredTimescale::has_blenddeltamultiplier() const {
  return _internal_has_blenddeltamultiplier();
}
inline void CUserMessageDesiredTimescale::clear_blenddeltamultiplier() {
  _impl_.blenddeltamultiplier_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageDesiredTimescale::_internal_blenddeltamultiplier() const {
  return _impl_.blenddeltamultiplier_;
}
inline float CUserMessageDesiredTimescale::blenddeltamultiplier() const {
  // @@protoc_insertion_point(field_get:CUserMessageDesiredTimescale.blenddeltamultiplier)
  return _internal_blenddeltamultiplier();
}
inline void CUserMessageDesiredTimescale::_internal_set_blenddeltamultiplier(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.blenddeltamultiplier_ = value;
}
inline void CUserMessageDesiredTimescale::set_blenddeltamultiplier(float value) {
  _internal_set_blenddeltamultiplier(value);
  // @@protoc_insertion_point(field_set:CUserMessageDesiredTimescale.blenddeltamultiplier)
}

// -------------------------------------------------------------------

// CUserMessageFade

// optional uint32 duration = 1;
inline bool CUserMessageFade::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageFade::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageFade::clear_duration() {
  _impl_.duration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageFade::_internal_duration() const {
  return _impl_.duration_;
}
inline uint32_t CUserMessageFade::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageFade.duration)
  return _internal_duration();
}
inline void CUserMessageFade::_internal_set_duration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.duration_ = value;
}
inline void CUserMessageFade::set_duration(uint32_t value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageFade.duration)
}

// optional uint32 hold_time = 2;
inline bool CUserMessageFade::_internal_has_hold_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageFade::has_hold_time() const {
  return _internal_has_hold_time();
}
inline void CUserMessageFade::clear_hold_time() {
  _impl_.hold_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageFade::_internal_hold_time() const {
  return _impl_.hold_time_;
}
inline uint32_t CUserMessageFade::hold_time() const {
  // @@protoc_insertion_point(field_get:CUserMessageFade.hold_time)
  return _internal_hold_time();
}
inline void CUserMessageFade::_internal_set_hold_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.hold_time_ = value;
}
inline void CUserMessageFade::set_hold_time(uint32_t value) {
  _internal_set_hold_time(value);
  // @@protoc_insertion_point(field_set:CUserMessageFade.hold_time)
}

// optional uint32 flags = 3;
inline bool CUserMessageFade::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageFade::has_flags() const {
  return _internal_has_flags();
}
inline void CUserMessageFade::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessageFade::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t CUserMessageFade::flags() const {
  // @@protoc_insertion_point(field_get:CUserMessageFade.flags)
  return _internal_flags();
}
inline void CUserMessageFade::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.flags_ = value;
}
inline void CUserMessageFade::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CUserMessageFade.flags)
}

// optional fixed32 color = 4;
inline bool CUserMessageFade::_internal_has_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageFade::has_color() const {
  return _internal_has_color();
}
inline void CUserMessageFade::clear_color() {
  _impl_.color_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CUserMessageFade::_internal_color() const {
  return _impl_.color_;
}
inline uint32_t CUserMessageFade::color() const {
  // @@protoc_insertion_point(field_get:CUserMessageFade.color)
  return _internal_color();
}
inline void CUserMessageFade::_internal_set_color(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.color_ = value;
}
inline void CUserMessageFade::set_color(uint32_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:CUserMessageFade.color)
}

// -------------------------------------------------------------------

// CUserMessageShake

// optional uint32 command = 1;
inline bool CUserMessageShake::_internal_has_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageShake::has_command() const {
  return _internal_has_command();
}
inline void CUserMessageShake::clear_command() {
  _impl_.command_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageShake::_internal_command() const {
  return _impl_.command_;
}
inline uint32_t CUserMessageShake::command() const {
  // @@protoc_insertion_point(field_get:CUserMessageShake.command)
  return _internal_command();
}
inline void CUserMessageShake::_internal_set_command(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.command_ = value;
}
inline void CUserMessageShake::set_command(uint32_t value) {
  _internal_set_command(value);
  // @@protoc_insertion_point(field_set:CUserMessageShake.command)
}

// optional float amplitude = 2;
inline bool CUserMessageShake::_internal_has_amplitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageShake::has_amplitude() const {
  return _internal_has_amplitude();
}
inline void CUserMessageShake::clear_amplitude() {
  _impl_.amplitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageShake::_internal_amplitude() const {
  return _impl_.amplitude_;
}
inline float CUserMessageShake::amplitude() const {
  // @@protoc_insertion_point(field_get:CUserMessageShake.amplitude)
  return _internal_amplitude();
}
inline void CUserMessageShake::_internal_set_amplitude(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.amplitude_ = value;
}
inline void CUserMessageShake::set_amplitude(float value) {
  _internal_set_amplitude(value);
  // @@protoc_insertion_point(field_set:CUserMessageShake.amplitude)
}

// optional float frequency = 3;
inline bool CUserMessageShake::_internal_has_frequency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageShake::has_frequency() const {
  return _internal_has_frequency();
}
inline void CUserMessageShake::clear_frequency() {
  _impl_.frequency_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageShake::_internal_frequency() const {
  return _impl_.frequency_;
}
inline float CUserMessageShake::frequency() const {
  // @@protoc_insertion_point(field_get:CUserMessageShake.frequency)
  return _internal_frequency();
}
inline void CUserMessageShake::_internal_set_frequency(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.frequency_ = value;
}
inline void CUserMessageShake::set_frequency(float value) {
  _internal_set_frequency(value);
  // @@protoc_insertion_point(field_set:CUserMessageShake.frequency)
}

// optional float duration = 4;
inline bool CUserMessageShake::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageShake::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageShake::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageShake::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageShake::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageShake.duration)
  return _internal_duration();
}
inline void CUserMessageShake::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.duration_ = value;
}
inline void CUserMessageShake::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageShake.duration)
}

// -------------------------------------------------------------------

// CUserMessageShakeDir

// optional .CUserMessageShake shake = 1;
inline bool CUserMessageShakeDir::_internal_has_shake() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.shake_ != nullptr);
  return value;
}
inline bool CUserMessageShakeDir::has_shake() const {
  return _internal_has_shake();
}
inline void CUserMessageShakeDir::clear_shake() {
  if (_impl_.shake_ != nullptr) _impl_.shake_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CUserMessageShake& CUserMessageShakeDir::_internal_shake() const {
  const ::CUserMessageShake* p = _impl_.shake_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMessageShake&>(
      ::_CUserMessageShake_default_instance_);
}
inline const ::CUserMessageShake& CUserMessageShakeDir::shake() const {
  // @@protoc_insertion_point(field_get:CUserMessageShakeDir.shake)
  return _internal_shake();
}
inline void CUserMessageShakeDir::unsafe_arena_set_allocated_shake(
    ::CUserMessageShake* shake) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shake_);
  }
  _impl_.shake_ = shake;
  if (shake) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMessageShakeDir.shake)
}
inline ::CUserMessageShake* CUserMessageShakeDir::release_shake() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMessageShake* temp = _impl_.shake_;
  _impl_.shake_ = 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 ::CUserMessageShake* CUserMessageShakeDir::unsafe_arena_release_shake() {
  // @@protoc_insertion_point(field_release:CUserMessageShakeDir.shake)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMessageShake* temp = _impl_.shake_;
  _impl_.shake_ = nullptr;
  return temp;
}
inline ::CUserMessageShake* CUserMessageShakeDir::_internal_mutable_shake() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.shake_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMessageShake>(GetArenaForAllocation());
    _impl_.shake_ = p;
  }
  return _impl_.shake_;
}
inline ::CUserMessageShake* CUserMessageShakeDir::mutable_shake() {
  ::CUserMessageShake* _msg = _internal_mutable_shake();
  // @@protoc_insertion_point(field_mutable:CUserMessageShakeDir.shake)
  return _msg;
}
inline void CUserMessageShakeDir::set_allocated_shake(::CUserMessageShake* shake) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.shake_;
  }
  if (shake) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shake);
    if (message_arena != submessage_arena) {
      shake = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shake, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.shake_ = shake;
  // @@protoc_insertion_point(field_set_allocated:CUserMessageShakeDir.shake)
}

// optional .CMsgVector direction = 2;
inline bool CUserMessageShakeDir::_internal_has_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.direction_ != nullptr);
  return value;
}
inline bool CUserMessageShakeDir::has_direction() const {
  return _internal_has_direction();
}
inline const ::CMsgVector& CUserMessageShakeDir::_internal_direction() const {
  const ::CMsgVector* p = _impl_.direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMessageShakeDir::direction() const {
  // @@protoc_insertion_point(field_get:CUserMessageShakeDir.direction)
  return _internal_direction();
}
inline void CUserMessageShakeDir::unsafe_arena_set_allocated_direction(
    ::CMsgVector* direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  _impl_.direction_ = direction;
  if (direction) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMessageShakeDir.direction)
}
inline ::CMsgVector* CUserMessageShakeDir::release_direction() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = 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 ::CMsgVector* CUserMessageShakeDir::unsafe_arena_release_direction() {
  // @@protoc_insertion_point(field_release:CUserMessageShakeDir.direction)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMessageShakeDir::_internal_mutable_direction() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.direction_ = p;
  }
  return _impl_.direction_;
}
inline ::CMsgVector* CUserMessageShakeDir::mutable_direction() {
  ::CMsgVector* _msg = _internal_mutable_direction();
  // @@protoc_insertion_point(field_mutable:CUserMessageShakeDir.direction)
  return _msg;
}
inline void CUserMessageShakeDir::set_allocated_direction(::CMsgVector* direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  if (direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(direction));
    if (message_arena != submessage_arena) {
      direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.direction_ = direction;
  // @@protoc_insertion_point(field_set_allocated:CUserMessageShakeDir.direction)
}

// -------------------------------------------------------------------

// CUserMessageWaterShake

// optional uint32 command = 1;
inline bool CUserMessageWaterShake::_internal_has_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageWaterShake::has_command() const {
  return _internal_has_command();
}
inline void CUserMessageWaterShake::clear_command() {
  _impl_.command_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageWaterShake::_internal_command() const {
  return _impl_.command_;
}
inline uint32_t CUserMessageWaterShake::command() const {
  // @@protoc_insertion_point(field_get:CUserMessageWaterShake.command)
  return _internal_command();
}
inline void CUserMessageWaterShake::_internal_set_command(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.command_ = value;
}
inline void CUserMessageWaterShake::set_command(uint32_t value) {
  _internal_set_command(value);
  // @@protoc_insertion_point(field_set:CUserMessageWaterShake.command)
}

// optional float amplitude = 2;
inline bool CUserMessageWaterShake::_internal_has_amplitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageWaterShake::has_amplitude() const {
  return _internal_has_amplitude();
}
inline void CUserMessageWaterShake::clear_amplitude() {
  _impl_.amplitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageWaterShake::_internal_amplitude() const {
  return _impl_.amplitude_;
}
inline float CUserMessageWaterShake::amplitude() const {
  // @@protoc_insertion_point(field_get:CUserMessageWaterShake.amplitude)
  return _internal_amplitude();
}
inline void CUserMessageWaterShake::_internal_set_amplitude(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.amplitude_ = value;
}
inline void CUserMessageWaterShake::set_amplitude(float value) {
  _internal_set_amplitude(value);
  // @@protoc_insertion_point(field_set:CUserMessageWaterShake.amplitude)
}

// optional float frequency = 3;
inline bool CUserMessageWaterShake::_internal_has_frequency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageWaterShake::has_frequency() const {
  return _internal_has_frequency();
}
inline void CUserMessageWaterShake::clear_frequency() {
  _impl_.frequency_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageWaterShake::_internal_frequency() const {
  return _impl_.frequency_;
}
inline float CUserMessageWaterShake::frequency() const {
  // @@protoc_insertion_point(field_get:CUserMessageWaterShake.frequency)
  return _internal_frequency();
}
inline void CUserMessageWaterShake::_internal_set_frequency(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.frequency_ = value;
}
inline void CUserMessageWaterShake::set_frequency(float value) {
  _internal_set_frequency(value);
  // @@protoc_insertion_point(field_set:CUserMessageWaterShake.frequency)
}

// optional float duration = 4;
inline bool CUserMessageWaterShake::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageWaterShake::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageWaterShake::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageWaterShake::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageWaterShake::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageWaterShake.duration)
  return _internal_duration();
}
inline void CUserMessageWaterShake::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.duration_ = value;
}
inline void CUserMessageWaterShake::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageWaterShake.duration)
}

// -------------------------------------------------------------------

// CUserMessageScreenTilt

// optional uint32 command = 1;
inline bool CUserMessageScreenTilt::_internal_has_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageScreenTilt::has_command() const {
  return _internal_has_command();
}
inline void CUserMessageScreenTilt::clear_command() {
  _impl_.command_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageScreenTilt::_internal_command() const {
  return _impl_.command_;
}
inline uint32_t CUserMessageScreenTilt::command() const {
  // @@protoc_insertion_point(field_get:CUserMessageScreenTilt.command)
  return _internal_command();
}
inline void CUserMessageScreenTilt::_internal_set_command(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.command_ = value;
}
inline void CUserMessageScreenTilt::set_command(uint32_t value) {
  _internal_set_command(value);
  // @@protoc_insertion_point(field_set:CUserMessageScreenTilt.command)
}

// optional bool ease_in_out = 2;
inline bool CUserMessageScreenTilt::_internal_has_ease_in_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageScreenTilt::has_ease_in_out() const {
  return _internal_has_ease_in_out();
}
inline void CUserMessageScreenTilt::clear_ease_in_out() {
  _impl_.ease_in_out_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageScreenTilt::_internal_ease_in_out() const {
  return _impl_.ease_in_out_;
}
inline bool CUserMessageScreenTilt::ease_in_out() const {
  // @@protoc_insertion_point(field_get:CUserMessageScreenTilt.ease_in_out)
  return _internal_ease_in_out();
}
inline void CUserMessageScreenTilt::_internal_set_ease_in_out(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.ease_in_out_ = value;
}
inline void CUserMessageScreenTilt::set_ease_in_out(bool value) {
  _internal_set_ease_in_out(value);
  // @@protoc_insertion_point(field_set:CUserMessageScreenTilt.ease_in_out)
}

// optional .CMsgVector angle = 3;
inline bool CUserMessageScreenTilt::_internal_has_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angle_ != nullptr);
  return value;
}
inline bool CUserMessageScreenTilt::has_angle() const {
  return _internal_has_angle();
}
inline const ::CMsgVector& CUserMessageScreenTilt::_internal_angle() const {
  const ::CMsgVector* p = _impl_.angle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMessageScreenTilt::angle() const {
  // @@protoc_insertion_point(field_get:CUserMessageScreenTilt.angle)
  return _internal_angle();
}
inline void CUserMessageScreenTilt::unsafe_arena_set_allocated_angle(
    ::CMsgVector* angle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  _impl_.angle_ = angle;
  if (angle) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMessageScreenTilt.angle)
}
inline ::CMsgVector* CUserMessageScreenTilt::release_angle() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.angle_;
  _impl_.angle_ = 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 ::CMsgVector* CUserMessageScreenTilt::unsafe_arena_release_angle() {
  // @@protoc_insertion_point(field_release:CUserMessageScreenTilt.angle)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMessageScreenTilt::_internal_mutable_angle() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.angle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.angle_ = p;
  }
  return _impl_.angle_;
}
inline ::CMsgVector* CUserMessageScreenTilt::mutable_angle() {
  ::CMsgVector* _msg = _internal_mutable_angle();
  // @@protoc_insertion_point(field_mutable:CUserMessageScreenTilt.angle)
  return _msg;
}
inline void CUserMessageScreenTilt::set_allocated_angle(::CMsgVector* angle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  if (angle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angle));
    if (message_arena != submessage_arena) {
      angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.angle_ = angle;
  // @@protoc_insertion_point(field_set_allocated:CUserMessageScreenTilt.angle)
}

// optional float duration = 4;
inline bool CUserMessageScreenTilt::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageScreenTilt::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageScreenTilt::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageScreenTilt::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageScreenTilt::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageScreenTilt.duration)
  return _internal_duration();
}
inline void CUserMessageScreenTilt::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.duration_ = value;
}
inline void CUserMessageScreenTilt::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageScreenTilt.duration)
}

// optional float time = 5;
inline bool CUserMessageScreenTilt::_internal_has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageScreenTilt::has_time() const {
  return _internal_has_time();
}
inline void CUserMessageScreenTilt::clear_time() {
  _impl_.time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CUserMessageScreenTilt::_internal_time() const {
  return _impl_.time_;
}
inline float CUserMessageScreenTilt::time() const {
  // @@protoc_insertion_point(field_get:CUserMessageScreenTilt.time)
  return _internal_time();
}
inline void CUserMessageScreenTilt::_internal_set_time(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.time_ = value;
}
inline void CUserMessageScreenTilt::set_time(float value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:CUserMessageScreenTilt.time)
}

// -------------------------------------------------------------------

// CUserMessageSayText

// optional int32 playerindex = 1 [default = -1];
inline bool CUserMessageSayText::_internal_has_playerindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageSayText::has_playerindex() const {
  return _internal_has_playerindex();
}
inline void CUserMessageSayText::clear_playerindex() {
  _impl_.playerindex_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageSayText::_internal_playerindex() const {
  return _impl_.playerindex_;
}
inline int32_t CUserMessageSayText::playerindex() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText.playerindex)
  return _internal_playerindex();
}
inline void CUserMessageSayText::_internal_set_playerindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.playerindex_ = value;
}
inline void CUserMessageSayText::set_playerindex(int32_t value) {
  _internal_set_playerindex(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayText.playerindex)
}

// optional string text = 2;
inline bool CUserMessageSayText::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageSayText::has_text() const {
  return _internal_has_text();
}
inline void CUserMessageSayText::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageSayText::text() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText.text)
}
inline std::string* CUserMessageSayText::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText.text)
  return _s;
}
inline const std::string& CUserMessageSayText::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CUserMessageSayText::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText::release_text() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText.text)
}

// optional bool chat = 3;
inline bool CUserMessageSayText::_internal_has_chat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageSayText::has_chat() const {
  return _internal_has_chat();
}
inline void CUserMessageSayText::clear_chat() {
  _impl_.chat_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMessageSayText::_internal_chat() const {
  return _impl_.chat_;
}
inline bool CUserMessageSayText::chat() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText.chat)
  return _internal_chat();
}
inline void CUserMessageSayText::_internal_set_chat(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.chat_ = value;
}
inline void CUserMessageSayText::set_chat(bool value) {
  _internal_set_chat(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayText.chat)
}

// -------------------------------------------------------------------

// CUserMessageSayText2

// optional int32 entityindex = 1 [default = -1];
inline bool CUserMessageSayText2::_internal_has_entityindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_entityindex() const {
  return _internal_has_entityindex();
}
inline void CUserMessageSayText2::clear_entityindex() {
  _impl_.entityindex_ = -1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessageSayText2::_internal_entityindex() const {
  return _impl_.entityindex_;
}
inline int32_t CUserMessageSayText2::entityindex() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.entityindex)
  return _internal_entityindex();
}
inline void CUserMessageSayText2::_internal_set_entityindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.entityindex_ = value;
}
inline void CUserMessageSayText2::set_entityindex(int32_t value) {
  _internal_set_entityindex(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.entityindex)
}

// optional bool chat = 2;
inline bool CUserMessageSayText2::_internal_has_chat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_chat() const {
  return _internal_has_chat();
}
inline void CUserMessageSayText2::clear_chat() {
  _impl_.chat_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CUserMessageSayText2::_internal_chat() const {
  return _impl_.chat_;
}
inline bool CUserMessageSayText2::chat() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.chat)
  return _internal_chat();
}
inline void CUserMessageSayText2::_internal_set_chat(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.chat_ = value;
}
inline void CUserMessageSayText2::set_chat(bool value) {
  _internal_set_chat(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.chat)
}

// optional string messagename = 3;
inline bool CUserMessageSayText2::_internal_has_messagename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_messagename() const {
  return _internal_has_messagename();
}
inline void CUserMessageSayText2::clear_messagename() {
  _impl_.messagename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageSayText2::messagename() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.messagename)
  return _internal_messagename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText2::set_messagename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.messagename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.messagename)
}
inline std::string* CUserMessageSayText2::mutable_messagename() {
  std::string* _s = _internal_mutable_messagename();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText2.messagename)
  return _s;
}
inline const std::string& CUserMessageSayText2::_internal_messagename() const {
  return _impl_.messagename_.Get();
}
inline void CUserMessageSayText2::_internal_set_messagename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.messagename_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::_internal_mutable_messagename() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.messagename_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::release_messagename() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText2.messagename)
  if (!_internal_has_messagename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.messagename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagename_.IsDefault()) {
    _impl_.messagename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText2::set_allocated_messagename(std::string* messagename) {
  if (messagename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagename_.SetAllocated(messagename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagename_.IsDefault()) {
    _impl_.messagename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText2.messagename)
}

// optional string param1 = 4;
inline bool CUserMessageSayText2::_internal_has_param1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_param1() const {
  return _internal_has_param1();
}
inline void CUserMessageSayText2::clear_param1() {
  _impl_.param1_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessageSayText2::param1() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.param1)
  return _internal_param1();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText2::set_param1(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.param1_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.param1)
}
inline std::string* CUserMessageSayText2::mutable_param1() {
  std::string* _s = _internal_mutable_param1();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText2.param1)
  return _s;
}
inline const std::string& CUserMessageSayText2::_internal_param1() const {
  return _impl_.param1_.Get();
}
inline void CUserMessageSayText2::_internal_set_param1(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.param1_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::_internal_mutable_param1() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.param1_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::release_param1() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText2.param1)
  if (!_internal_has_param1()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.param1_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param1_.IsDefault()) {
    _impl_.param1_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText2::set_allocated_param1(std::string* param1) {
  if (param1 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.param1_.SetAllocated(param1, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param1_.IsDefault()) {
    _impl_.param1_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText2.param1)
}

// optional string param2 = 5;
inline bool CUserMessageSayText2::_internal_has_param2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_param2() const {
  return _internal_has_param2();
}
inline void CUserMessageSayText2::clear_param2() {
  _impl_.param2_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CUserMessageSayText2::param2() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.param2)
  return _internal_param2();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText2::set_param2(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.param2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.param2)
}
inline std::string* CUserMessageSayText2::mutable_param2() {
  std::string* _s = _internal_mutable_param2();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText2.param2)
  return _s;
}
inline const std::string& CUserMessageSayText2::_internal_param2() const {
  return _impl_.param2_.Get();
}
inline void CUserMessageSayText2::_internal_set_param2(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.param2_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::_internal_mutable_param2() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.param2_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::release_param2() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText2.param2)
  if (!_internal_has_param2()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.param2_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param2_.IsDefault()) {
    _impl_.param2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText2::set_allocated_param2(std::string* param2) {
  if (param2 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.param2_.SetAllocated(param2, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param2_.IsDefault()) {
    _impl_.param2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText2.param2)
}

// optional string param3 = 6;
inline bool CUserMessageSayText2::_internal_has_param3() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_param3() const {
  return _internal_has_param3();
}
inline void CUserMessageSayText2::clear_param3() {
  _impl_.param3_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CUserMessageSayText2::param3() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.param3)
  return _internal_param3();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText2::set_param3(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.param3_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.param3)
}
inline std::string* CUserMessageSayText2::mutable_param3() {
  std::string* _s = _internal_mutable_param3();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText2.param3)
  return _s;
}
inline const std::string& CUserMessageSayText2::_internal_param3() const {
  return _impl_.param3_.Get();
}
inline void CUserMessageSayText2::_internal_set_param3(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.param3_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::_internal_mutable_param3() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.param3_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::release_param3() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText2.param3)
  if (!_internal_has_param3()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.param3_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param3_.IsDefault()) {
    _impl_.param3_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText2::set_allocated_param3(std::string* param3) {
  if (param3 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.param3_.SetAllocated(param3, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param3_.IsDefault()) {
    _impl_.param3_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText2.param3)
}

// optional string param4 = 7;
inline bool CUserMessageSayText2::_internal_has_param4() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageSayText2::has_param4() const {
  return _internal_has_param4();
}
inline void CUserMessageSayText2::clear_param4() {
  _impl_.param4_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CUserMessageSayText2::param4() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayText2.param4)
  return _internal_param4();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayText2::set_param4(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.param4_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayText2.param4)
}
inline std::string* CUserMessageSayText2::mutable_param4() {
  std::string* _s = _internal_mutable_param4();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayText2.param4)
  return _s;
}
inline const std::string& CUserMessageSayText2::_internal_param4() const {
  return _impl_.param4_.Get();
}
inline void CUserMessageSayText2::_internal_set_param4(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.param4_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::_internal_mutable_param4() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.param4_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayText2::release_param4() {
  // @@protoc_insertion_point(field_release:CUserMessageSayText2.param4)
  if (!_internal_has_param4()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.param4_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param4_.IsDefault()) {
    _impl_.param4_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayText2::set_allocated_param4(std::string* param4) {
  if (param4 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.param4_.SetAllocated(param4, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param4_.IsDefault()) {
    _impl_.param4_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayText2.param4)
}

// -------------------------------------------------------------------

// CUserMessageHudMsg

// optional uint32 channel = 1;
inline bool CUserMessageHudMsg::_internal_has_channel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_channel() const {
  return _internal_has_channel();
}
inline void CUserMessageHudMsg::clear_channel() {
  _impl_.channel_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageHudMsg::_internal_channel() const {
  return _impl_.channel_;
}
inline uint32_t CUserMessageHudMsg::channel() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.channel)
  return _internal_channel();
}
inline void CUserMessageHudMsg::_internal_set_channel(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.channel_ = value;
}
inline void CUserMessageHudMsg::set_channel(uint32_t value) {
  _internal_set_channel(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.channel)
}

// optional float x = 2;
inline bool CUserMessageHudMsg::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_x() const {
  return _internal_has_x();
}
inline void CUserMessageHudMsg::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageHudMsg::_internal_x() const {
  return _impl_.x_;
}
inline float CUserMessageHudMsg::x() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.x)
  return _internal_x();
}
inline void CUserMessageHudMsg::_internal_set_x(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.x_ = value;
}
inline void CUserMessageHudMsg::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.x)
}

// optional float y = 3;
inline bool CUserMessageHudMsg::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_y() const {
  return _internal_has_y();
}
inline void CUserMessageHudMsg::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageHudMsg::_internal_y() const {
  return _impl_.y_;
}
inline float CUserMessageHudMsg::y() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.y)
  return _internal_y();
}
inline void CUserMessageHudMsg::_internal_set_y(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.y_ = value;
}
inline void CUserMessageHudMsg::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.y)
}

// optional fixed32 color1 = 4;
inline bool CUserMessageHudMsg::_internal_has_color1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_color1() const {
  return _internal_has_color1();
}
inline void CUserMessageHudMsg::clear_color1() {
  _impl_.color1_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CUserMessageHudMsg::_internal_color1() const {
  return _impl_.color1_;
}
inline uint32_t CUserMessageHudMsg::color1() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.color1)
  return _internal_color1();
}
inline void CUserMessageHudMsg::_internal_set_color1(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.color1_ = value;
}
inline void CUserMessageHudMsg::set_color1(uint32_t value) {
  _internal_set_color1(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.color1)
}

// optional fixed32 color2 = 5;
inline bool CUserMessageHudMsg::_internal_has_color2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_color2() const {
  return _internal_has_color2();
}
inline void CUserMessageHudMsg::clear_color2() {
  _impl_.color2_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CUserMessageHudMsg::_internal_color2() const {
  return _impl_.color2_;
}
inline uint32_t CUserMessageHudMsg::color2() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.color2)
  return _internal_color2();
}
inline void CUserMessageHudMsg::_internal_set_color2(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.color2_ = value;
}
inline void CUserMessageHudMsg::set_color2(uint32_t value) {
  _internal_set_color2(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.color2)
}

// optional uint32 effect = 6;
inline bool CUserMessageHudMsg::_internal_has_effect() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_effect() const {
  return _internal_has_effect();
}
inline void CUserMessageHudMsg::clear_effect() {
  _impl_.effect_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CUserMessageHudMsg::_internal_effect() const {
  return _impl_.effect_;
}
inline uint32_t CUserMessageHudMsg::effect() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.effect)
  return _internal_effect();
}
inline void CUserMessageHudMsg::_internal_set_effect(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.effect_ = value;
}
inline void CUserMessageHudMsg::set_effect(uint32_t value) {
  _internal_set_effect(value);
  // @@protoc_insertion_point(field_set:CUserMessageHudMsg.effect)
}

// optional string message = 11;
inline bool CUserMessageHudMsg::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageHudMsg::has_message() const {
  return _internal_has_message();
}
inline void CUserMessageHudMsg::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageHudMsg::message() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudMsg.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageHudMsg::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:CUserMessageHudMsg.message)
}
inline std::string* CUserMessageHudMsg::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:CUserMessageHudMsg.message)
  return _s;
}
inline const std::string& CUserMessageHudMsg::_internal_message() const {
  return _impl_.message_.Get();
}
inline void CUserMessageHudMsg::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageHudMsg::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageHudMsg::release_message() {
  // @@protoc_insertion_point(field_release:CUserMessageHudMsg.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 CUserMessageHudMsg::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:CUserMessageHudMsg.message)
}

// -------------------------------------------------------------------

// CUserMessageHudText

// optional string message = 1;
inline bool CUserMessageHudText::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageHudText::has_message() const {
  return _internal_has_message();
}
inline void CUserMessageHudText::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageHudText::message() const {
  // @@protoc_insertion_point(field_get:CUserMessageHudText.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageHudText::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:CUserMessageHudText.message)
}
inline std::string* CUserMessageHudText::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:CUserMessageHudText.message)
  return _s;
}
inline const std::string& CUserMessageHudText::_internal_message() const {
  return _impl_.message_.Get();
}
inline void CUserMessageHudText::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageHudText::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageHudText::release_message() {
  // @@protoc_insertion_point(field_release:CUserMessageHudText.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 CUserMessageHudText::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:CUserMessageHudText.message)
}

// -------------------------------------------------------------------

// CUserMessageTextMsg

// optional uint32 dest = 1;
inline bool CUserMessageTextMsg::_internal_has_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageTextMsg::has_dest() const {
  return _internal_has_dest();
}
inline void CUserMessageTextMsg::clear_dest() {
  _impl_.dest_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageTextMsg::_internal_dest() const {
  return _impl_.dest_;
}
inline uint32_t CUserMessageTextMsg::dest() const {
  // @@protoc_insertion_point(field_get:CUserMessageTextMsg.dest)
  return _internal_dest();
}
inline void CUserMessageTextMsg::_internal_set_dest(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dest_ = value;
}
inline void CUserMessageTextMsg::set_dest(uint32_t value) {
  _internal_set_dest(value);
  // @@protoc_insertion_point(field_set:CUserMessageTextMsg.dest)
}

// repeated string param = 2;
inline int CUserMessageTextMsg::_internal_param_size() const {
  return _impl_.param_.size();
}
inline int CUserMessageTextMsg::param_size() const {
  return _internal_param_size();
}
inline void CUserMessageTextMsg::clear_param() {
  _impl_.param_.Clear();
}
inline std::string* CUserMessageTextMsg::add_param() {
  std::string* _s = _internal_add_param();
  // @@protoc_insertion_point(field_add_mutable:CUserMessageTextMsg.param)
  return _s;
}
inline const std::string& CUserMessageTextMsg::_internal_param(int index) const {
  return _impl_.param_.Get(index);
}
inline const std::string& CUserMessageTextMsg::param(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessageTextMsg.param)
  return _internal_param(index);
}
inline std::string* CUserMessageTextMsg::mutable_param(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessageTextMsg.param)
  return _impl_.param_.Mutable(index);
}
inline void CUserMessageTextMsg::set_param(int index, const std::string& value) {
  _impl_.param_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::set_param(int index, std::string&& value) {
  _impl_.param_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::set_param(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.param_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::set_param(int index, const char* value, size_t size) {
  _impl_.param_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CUserMessageTextMsg.param)
}
inline std::string* CUserMessageTextMsg::_internal_add_param() {
  return _impl_.param_.Add();
}
inline void CUserMessageTextMsg::add_param(const std::string& value) {
  _impl_.param_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::add_param(std::string&& value) {
  _impl_.param_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::add_param(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.param_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CUserMessageTextMsg.param)
}
inline void CUserMessageTextMsg::add_param(const char* value, size_t size) {
  _impl_.param_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CUserMessageTextMsg.param)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CUserMessageTextMsg::param() const {
  // @@protoc_insertion_point(field_list:CUserMessageTextMsg.param)
  return _impl_.param_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CUserMessageTextMsg::mutable_param() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessageTextMsg.param)
  return &_impl_.param_;
}

// -------------------------------------------------------------------

// CUserMessageGameTitle

// -------------------------------------------------------------------

// CUserMessageResetHUD

// -------------------------------------------------------------------

// CUserMessageSendAudio

// optional string soundname = 1;
inline bool CUserMessageSendAudio::_internal_has_soundname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageSendAudio::has_soundname() const {
  return _internal_has_soundname();
}
inline void CUserMessageSendAudio::clear_soundname() {
  _impl_.soundname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageSendAudio::soundname() const {
  // @@protoc_insertion_point(field_get:CUserMessageSendAudio.soundname)
  return _internal_soundname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSendAudio::set_soundname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.soundname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSendAudio.soundname)
}
inline std::string* CUserMessageSendAudio::mutable_soundname() {
  std::string* _s = _internal_mutable_soundname();
  // @@protoc_insertion_point(field_mutable:CUserMessageSendAudio.soundname)
  return _s;
}
inline const std::string& CUserMessageSendAudio::_internal_soundname() const {
  return _impl_.soundname_.Get();
}
inline void CUserMessageSendAudio::_internal_set_soundname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.soundname_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSendAudio::_internal_mutable_soundname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.soundname_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSendAudio::release_soundname() {
  // @@protoc_insertion_point(field_release:CUserMessageSendAudio.soundname)
  if (!_internal_has_soundname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.soundname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.soundname_.IsDefault()) {
    _impl_.soundname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSendAudio::set_allocated_soundname(std::string* soundname) {
  if (soundname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.soundname_.SetAllocated(soundname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.soundname_.IsDefault()) {
    _impl_.soundname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSendAudio.soundname)
}

// optional bool stop = 2;
inline bool CUserMessageSendAudio::_internal_has_stop() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageSendAudio::has_stop() const {
  return _internal_has_stop();
}
inline void CUserMessageSendAudio::clear_stop() {
  _impl_.stop_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMessageSendAudio::_internal_stop() const {
  return _impl_.stop_;
}
inline bool CUserMessageSendAudio::stop() const {
  // @@protoc_insertion_point(field_get:CUserMessageSendAudio.stop)
  return _internal_stop();
}
inline void CUserMessageSendAudio::_internal_set_stop(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.stop_ = value;
}
inline void CUserMessageSendAudio::set_stop(bool value) {
  _internal_set_stop(value);
  // @@protoc_insertion_point(field_set:CUserMessageSendAudio.stop)
}

// -------------------------------------------------------------------

// CUserMessageAudioParameter

// optional uint32 parameter_type = 1;
inline bool CUserMessageAudioParameter::_internal_has_parameter_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageAudioParameter::has_parameter_type() const {
  return _internal_has_parameter_type();
}
inline void CUserMessageAudioParameter::clear_parameter_type() {
  _impl_.parameter_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageAudioParameter::_internal_parameter_type() const {
  return _impl_.parameter_type_;
}
inline uint32_t CUserMessageAudioParameter::parameter_type() const {
  // @@protoc_insertion_point(field_get:CUserMessageAudioParameter.parameter_type)
  return _internal_parameter_type();
}
inline void CUserMessageAudioParameter::_internal_set_parameter_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.parameter_type_ = value;
}
inline void CUserMessageAudioParameter::set_parameter_type(uint32_t value) {
  _internal_set_parameter_type(value);
  // @@protoc_insertion_point(field_set:CUserMessageAudioParameter.parameter_type)
}

// optional uint32 name_hash_code = 2;
inline bool CUserMessageAudioParameter::_internal_has_name_hash_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageAudioParameter::has_name_hash_code() const {
  return _internal_has_name_hash_code();
}
inline void CUserMessageAudioParameter::clear_name_hash_code() {
  _impl_.name_hash_code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageAudioParameter::_internal_name_hash_code() const {
  return _impl_.name_hash_code_;
}
inline uint32_t CUserMessageAudioParameter::name_hash_code() const {
  // @@protoc_insertion_point(field_get:CUserMessageAudioParameter.name_hash_code)
  return _internal_name_hash_code();
}
inline void CUserMessageAudioParameter::_internal_set_name_hash_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_hash_code_ = value;
}
inline void CUserMessageAudioParameter::set_name_hash_code(uint32_t value) {
  _internal_set_name_hash_code(value);
  // @@protoc_insertion_point(field_set:CUserMessageAudioParameter.name_hash_code)
}

// optional float value = 3;
inline bool CUserMessageAudioParameter::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageAudioParameter::has_value() const {
  return _internal_has_value();
}
inline void CUserMessageAudioParameter::clear_value() {
  _impl_.value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageAudioParameter::_internal_value() const {
  return _impl_.value_;
}
inline float CUserMessageAudioParameter::value() const {
  // @@protoc_insertion_point(field_get:CUserMessageAudioParameter.value)
  return _internal_value();
}
inline void CUserMessageAudioParameter::_internal_set_value(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.value_ = value;
}
inline void CUserMessageAudioParameter::set_value(float value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:CUserMessageAudioParameter.value)
}

// optional uint32 int_value = 4;
inline bool CUserMessageAudioParameter::_internal_has_int_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageAudioParameter::has_int_value() const {
  return _internal_has_int_value();
}
inline void CUserMessageAudioParameter::clear_int_value() {
  _impl_.int_value_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CUserMessageAudioParameter::_internal_int_value() const {
  return _impl_.int_value_;
}
inline uint32_t CUserMessageAudioParameter::int_value() const {
  // @@protoc_insertion_point(field_get:CUserMessageAudioParameter.int_value)
  return _internal_int_value();
}
inline void CUserMessageAudioParameter::_internal_set_int_value(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.int_value_ = value;
}
inline void CUserMessageAudioParameter::set_int_value(uint32_t value) {
  _internal_set_int_value(value);
  // @@protoc_insertion_point(field_set:CUserMessageAudioParameter.int_value)
}

// -------------------------------------------------------------------

// CUserMessageVoiceMask

// repeated uint32 gamerules_masks = 1;
inline int CUserMessageVoiceMask::_internal_gamerules_masks_size() const {
  return _impl_.gamerules_masks_.size();
}
inline int CUserMessageVoiceMask::gamerules_masks_size() const {
  return _internal_gamerules_masks_size();
}
inline void CUserMessageVoiceMask::clear_gamerules_masks() {
  _impl_.gamerules_masks_.Clear();
}
inline uint32_t CUserMessageVoiceMask::_internal_gamerules_masks(int index) const {
  return _impl_.gamerules_masks_.Get(index);
}
inline uint32_t CUserMessageVoiceMask::gamerules_masks(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessageVoiceMask.gamerules_masks)
  return _internal_gamerules_masks(index);
}
inline void CUserMessageVoiceMask::set_gamerules_masks(int index, uint32_t value) {
  _impl_.gamerules_masks_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessageVoiceMask.gamerules_masks)
}
inline void CUserMessageVoiceMask::_internal_add_gamerules_masks(uint32_t value) {
  _impl_.gamerules_masks_.Add(value);
}
inline void CUserMessageVoiceMask::add_gamerules_masks(uint32_t value) {
  _internal_add_gamerules_masks(value);
  // @@protoc_insertion_point(field_add:CUserMessageVoiceMask.gamerules_masks)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessageVoiceMask::_internal_gamerules_masks() const {
  return _impl_.gamerules_masks_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessageVoiceMask::gamerules_masks() const {
  // @@protoc_insertion_point(field_list:CUserMessageVoiceMask.gamerules_masks)
  return _internal_gamerules_masks();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessageVoiceMask::_internal_mutable_gamerules_masks() {
  return &_impl_.gamerules_masks_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessageVoiceMask::mutable_gamerules_masks() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessageVoiceMask.gamerules_masks)
  return _internal_mutable_gamerules_masks();
}

// repeated uint32 ban_masks = 2;
inline int CUserMessageVoiceMask::_internal_ban_masks_size() const {
  return _impl_.ban_masks_.size();
}
inline int CUserMessageVoiceMask::ban_masks_size() const {
  return _internal_ban_masks_size();
}
inline void CUserMessageVoiceMask::clear_ban_masks() {
  _impl_.ban_masks_.Clear();
}
inline uint32_t CUserMessageVoiceMask::_internal_ban_masks(int index) const {
  return _impl_.ban_masks_.Get(index);
}
inline uint32_t CUserMessageVoiceMask::ban_masks(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessageVoiceMask.ban_masks)
  return _internal_ban_masks(index);
}
inline void CUserMessageVoiceMask::set_ban_masks(int index, uint32_t value) {
  _impl_.ban_masks_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessageVoiceMask.ban_masks)
}
inline void CUserMessageVoiceMask::_internal_add_ban_masks(uint32_t value) {
  _impl_.ban_masks_.Add(value);
}
inline void CUserMessageVoiceMask::add_ban_masks(uint32_t value) {
  _internal_add_ban_masks(value);
  // @@protoc_insertion_point(field_add:CUserMessageVoiceMask.ban_masks)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessageVoiceMask::_internal_ban_masks() const {
  return _impl_.ban_masks_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessageVoiceMask::ban_masks() const {
  // @@protoc_insertion_point(field_list:CUserMessageVoiceMask.ban_masks)
  return _internal_ban_masks();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessageVoiceMask::_internal_mutable_ban_masks() {
  return &_impl_.ban_masks_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessageVoiceMask::mutable_ban_masks() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessageVoiceMask.ban_masks)
  return _internal_mutable_ban_masks();
}

// optional bool mod_enable = 3;
inline bool CUserMessageVoiceMask::_internal_has_mod_enable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageVoiceMask::has_mod_enable() const {
  return _internal_has_mod_enable();
}
inline void CUserMessageVoiceMask::clear_mod_enable() {
  _impl_.mod_enable_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMessageVoiceMask::_internal_mod_enable() const {
  return _impl_.mod_enable_;
}
inline bool CUserMessageVoiceMask::mod_enable() const {
  // @@protoc_insertion_point(field_get:CUserMessageVoiceMask.mod_enable)
  return _internal_mod_enable();
}
inline void CUserMessageVoiceMask::_internal_set_mod_enable(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mod_enable_ = value;
}
inline void CUserMessageVoiceMask::set_mod_enable(bool value) {
  _internal_set_mod_enable(value);
  // @@protoc_insertion_point(field_set:CUserMessageVoiceMask.mod_enable)
}

// -------------------------------------------------------------------

// CUserMessageRequestState

// -------------------------------------------------------------------

// CUserMessageRumble

// optional int32 index = 1;
inline bool CUserMessageRumble::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageRumble::has_index() const {
  return _internal_has_index();
}
inline void CUserMessageRumble::clear_index() {
  _impl_.index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessageRumble::_internal_index() const {
  return _impl_.index_;
}
inline int32_t CUserMessageRumble::index() const {
  // @@protoc_insertion_point(field_get:CUserMessageRumble.index)
  return _internal_index();
}
inline void CUserMessageRumble::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.index_ = value;
}
inline void CUserMessageRumble::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageRumble.index)
}

// optional int32 data = 2;
inline bool CUserMessageRumble::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageRumble::has_data() const {
  return _internal_has_data();
}
inline void CUserMessageRumble::clear_data() {
  _impl_.data_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageRumble::_internal_data() const {
  return _impl_.data_;
}
inline int32_t CUserMessageRumble::data() const {
  // @@protoc_insertion_point(field_get:CUserMessageRumble.data)
  return _internal_data();
}
inline void CUserMessageRumble::_internal_set_data(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.data_ = value;
}
inline void CUserMessageRumble::set_data(int32_t value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:CUserMessageRumble.data)
}

// optional int32 flags = 3;
inline bool CUserMessageRumble::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageRumble::has_flags() const {
  return _internal_has_flags();
}
inline void CUserMessageRumble::clear_flags() {
  _impl_.flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageRumble::_internal_flags() const {
  return _impl_.flags_;
}
inline int32_t CUserMessageRumble::flags() const {
  // @@protoc_insertion_point(field_get:CUserMessageRumble.flags)
  return _internal_flags();
}
inline void CUserMessageRumble::_internal_set_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.flags_ = value;
}
inline void CUserMessageRumble::set_flags(int32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CUserMessageRumble.flags)
}

// -------------------------------------------------------------------

// CUserMessageSayTextChannel

// optional int32 player = 1;
inline bool CUserMessageSayTextChannel::_internal_has_player() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageSayTextChannel::has_player() const {
  return _internal_has_player();
}
inline void CUserMessageSayTextChannel::clear_player() {
  _impl_.player_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageSayTextChannel::_internal_player() const {
  return _impl_.player_;
}
inline int32_t CUserMessageSayTextChannel::player() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayTextChannel.player)
  return _internal_player();
}
inline void CUserMessageSayTextChannel::_internal_set_player(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.player_ = value;
}
inline void CUserMessageSayTextChannel::set_player(int32_t value) {
  _internal_set_player(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayTextChannel.player)
}

// optional int32 channel = 2;
inline bool CUserMessageSayTextChannel::_internal_has_channel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageSayTextChannel::has_channel() const {
  return _internal_has_channel();
}
inline void CUserMessageSayTextChannel::clear_channel() {
  _impl_.channel_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageSayTextChannel::_internal_channel() const {
  return _impl_.channel_;
}
inline int32_t CUserMessageSayTextChannel::channel() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayTextChannel.channel)
  return _internal_channel();
}
inline void CUserMessageSayTextChannel::_internal_set_channel(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.channel_ = value;
}
inline void CUserMessageSayTextChannel::set_channel(int32_t value) {
  _internal_set_channel(value);
  // @@protoc_insertion_point(field_set:CUserMessageSayTextChannel.channel)
}

// optional string text = 3;
inline bool CUserMessageSayTextChannel::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageSayTextChannel::has_text() const {
  return _internal_has_text();
}
inline void CUserMessageSayTextChannel::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageSayTextChannel::text() const {
  // @@protoc_insertion_point(field_get:CUserMessageSayTextChannel.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageSayTextChannel::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageSayTextChannel.text)
}
inline std::string* CUserMessageSayTextChannel::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CUserMessageSayTextChannel.text)
  return _s;
}
inline const std::string& CUserMessageSayTextChannel::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CUserMessageSayTextChannel::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageSayTextChannel::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageSayTextChannel::release_text() {
  // @@protoc_insertion_point(field_release:CUserMessageSayTextChannel.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageSayTextChannel::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageSayTextChannel.text)
}

// -------------------------------------------------------------------

// CUserMessageColoredText

// optional uint32 color = 1;
inline bool CUserMessageColoredText::_internal_has_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_color() const {
  return _internal_has_color();
}
inline void CUserMessageColoredText::clear_color() {
  _impl_.color_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageColoredText::_internal_color() const {
  return _impl_.color_;
}
inline uint32_t CUserMessageColoredText::color() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.color)
  return _internal_color();
}
inline void CUserMessageColoredText::_internal_set_color(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.color_ = value;
}
inline void CUserMessageColoredText::set_color(uint32_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.color)
}

// optional string text = 2;
inline bool CUserMessageColoredText::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_text() const {
  return _internal_has_text();
}
inline void CUserMessageColoredText::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageColoredText::text() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageColoredText::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.text)
}
inline std::string* CUserMessageColoredText::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CUserMessageColoredText.text)
  return _s;
}
inline const std::string& CUserMessageColoredText::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CUserMessageColoredText::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageColoredText::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageColoredText::release_text() {
  // @@protoc_insertion_point(field_release:CUserMessageColoredText.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageColoredText::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageColoredText.text)
}

// optional bool reset = 3;
inline bool CUserMessageColoredText::_internal_has_reset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_reset() const {
  return _internal_has_reset();
}
inline void CUserMessageColoredText::clear_reset() {
  _impl_.reset_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageColoredText::_internal_reset() const {
  return _impl_.reset_;
}
inline bool CUserMessageColoredText::reset() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.reset)
  return _internal_reset();
}
inline void CUserMessageColoredText::_internal_set_reset(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.reset_ = value;
}
inline void CUserMessageColoredText::set_reset(bool value) {
  _internal_set_reset(value);
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.reset)
}

// optional int32 context_player_slot = 4 [default = -1];
inline bool CUserMessageColoredText::_internal_has_context_player_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_context_player_slot() const {
  return _internal_has_context_player_slot();
}
inline void CUserMessageColoredText::clear_context_player_slot() {
  _impl_.context_player_slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessageColoredText::_internal_context_player_slot() const {
  return _impl_.context_player_slot_;
}
inline int32_t CUserMessageColoredText::context_player_slot() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.context_player_slot)
  return _internal_context_player_slot();
}
inline void CUserMessageColoredText::_internal_set_context_player_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.context_player_slot_ = value;
}
inline void CUserMessageColoredText::set_context_player_slot(int32_t value) {
  _internal_set_context_player_slot(value);
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.context_player_slot)
}

// optional int32 context_value = 5;
inline bool CUserMessageColoredText::_internal_has_context_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_context_value() const {
  return _internal_has_context_value();
}
inline void CUserMessageColoredText::clear_context_value() {
  _impl_.context_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessageColoredText::_internal_context_value() const {
  return _impl_.context_value_;
}
inline int32_t CUserMessageColoredText::context_value() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.context_value)
  return _internal_context_value();
}
inline void CUserMessageColoredText::_internal_set_context_value(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.context_value_ = value;
}
inline void CUserMessageColoredText::set_context_value(int32_t value) {
  _internal_set_context_value(value);
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.context_value)
}

// optional int32 context_team_id = 6;
inline bool CUserMessageColoredText::_internal_has_context_team_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageColoredText::has_context_team_id() const {
  return _internal_has_context_team_id();
}
inline void CUserMessageColoredText::clear_context_team_id() {
  _impl_.context_team_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessageColoredText::_internal_context_team_id() const {
  return _impl_.context_team_id_;
}
inline int32_t CUserMessageColoredText::context_team_id() const {
  // @@protoc_insertion_point(field_get:CUserMessageColoredText.context_team_id)
  return _internal_context_team_id();
}
inline void CUserMessageColoredText::_internal_set_context_team_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.context_team_id_ = value;
}
inline void CUserMessageColoredText::set_context_team_id(int32_t value) {
  _internal_set_context_team_id(value);
  // @@protoc_insertion_point(field_set:CUserMessageColoredText.context_team_id)
}

// -------------------------------------------------------------------

// CUserMessageItemPickup

// optional string itemname = 1;
inline bool CUserMessageItemPickup::_internal_has_itemname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageItemPickup::has_itemname() const {
  return _internal_has_itemname();
}
inline void CUserMessageItemPickup::clear_itemname() {
  _impl_.itemname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageItemPickup::itemname() const {
  // @@protoc_insertion_point(field_get:CUserMessageItemPickup.itemname)
  return _internal_itemname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageItemPickup::set_itemname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.itemname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageItemPickup.itemname)
}
inline std::string* CUserMessageItemPickup::mutable_itemname() {
  std::string* _s = _internal_mutable_itemname();
  // @@protoc_insertion_point(field_mutable:CUserMessageItemPickup.itemname)
  return _s;
}
inline const std::string& CUserMessageItemPickup::_internal_itemname() const {
  return _impl_.itemname_.Get();
}
inline void CUserMessageItemPickup::_internal_set_itemname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.itemname_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageItemPickup::_internal_mutable_itemname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.itemname_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageItemPickup::release_itemname() {
  // @@protoc_insertion_point(field_release:CUserMessageItemPickup.itemname)
  if (!_internal_has_itemname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.itemname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.itemname_.IsDefault()) {
    _impl_.itemname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageItemPickup::set_allocated_itemname(std::string* itemname) {
  if (itemname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.itemname_.SetAllocated(itemname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.itemname_.IsDefault()) {
    _impl_.itemname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageItemPickup.itemname)
}

// -------------------------------------------------------------------

// CUserMessageAmmoDenied

// optional uint32 ammo_id = 1;
inline bool CUserMessageAmmoDenied::_internal_has_ammo_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageAmmoDenied::has_ammo_id() const {
  return _internal_has_ammo_id();
}
inline void CUserMessageAmmoDenied::clear_ammo_id() {
  _impl_.ammo_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessageAmmoDenied::_internal_ammo_id() const {
  return _impl_.ammo_id_;
}
inline uint32_t CUserMessageAmmoDenied::ammo_id() const {
  // @@protoc_insertion_point(field_get:CUserMessageAmmoDenied.ammo_id)
  return _internal_ammo_id();
}
inline void CUserMessageAmmoDenied::_internal_set_ammo_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ammo_id_ = value;
}
inline void CUserMessageAmmoDenied::set_ammo_id(uint32_t value) {
  _internal_set_ammo_id(value);
  // @@protoc_insertion_point(field_set:CUserMessageAmmoDenied.ammo_id)
}

// -------------------------------------------------------------------

// CUserMessageShowMenu

// optional uint32 validslots = 1;
inline bool CUserMessageShowMenu::_internal_has_validslots() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageShowMenu::has_validslots() const {
  return _internal_has_validslots();
}
inline void CUserMessageShowMenu::clear_validslots() {
  _impl_.validslots_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageShowMenu::_internal_validslots() const {
  return _impl_.validslots_;
}
inline uint32_t CUserMessageShowMenu::validslots() const {
  // @@protoc_insertion_point(field_get:CUserMessageShowMenu.validslots)
  return _internal_validslots();
}
inline void CUserMessageShowMenu::_internal_set_validslots(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.validslots_ = value;
}
inline void CUserMessageShowMenu::set_validslots(uint32_t value) {
  _internal_set_validslots(value);
  // @@protoc_insertion_point(field_set:CUserMessageShowMenu.validslots)
}

// optional uint32 displaytime = 2;
inline bool CUserMessageShowMenu::_internal_has_displaytime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageShowMenu::has_displaytime() const {
  return _internal_has_displaytime();
}
inline void CUserMessageShowMenu::clear_displaytime() {
  _impl_.displaytime_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessageShowMenu::_internal_displaytime() const {
  return _impl_.displaytime_;
}
inline uint32_t CUserMessageShowMenu::displaytime() const {
  // @@protoc_insertion_point(field_get:CUserMessageShowMenu.displaytime)
  return _internal_displaytime();
}
inline void CUserMessageShowMenu::_internal_set_displaytime(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.displaytime_ = value;
}
inline void CUserMessageShowMenu::set_displaytime(uint32_t value) {
  _internal_set_displaytime(value);
  // @@protoc_insertion_point(field_set:CUserMessageShowMenu.displaytime)
}

// optional bool needmore = 3;
inline bool CUserMessageShowMenu::_internal_has_needmore() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageShowMenu::has_needmore() const {
  return _internal_has_needmore();
}
inline void CUserMessageShowMenu::clear_needmore() {
  _impl_.needmore_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool CUserMessageShowMenu::_internal_needmore() const {
  return _impl_.needmore_;
}
inline bool CUserMessageShowMenu::needmore() const {
  // @@protoc_insertion_point(field_get:CUserMessageShowMenu.needmore)
  return _internal_needmore();
}
inline void CUserMessageShowMenu::_internal_set_needmore(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.needmore_ = value;
}
inline void CUserMessageShowMenu::set_needmore(bool value) {
  _internal_set_needmore(value);
  // @@protoc_insertion_point(field_set:CUserMessageShowMenu.needmore)
}

// optional string menustring = 4;
inline bool CUserMessageShowMenu::_internal_has_menustring() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageShowMenu::has_menustring() const {
  return _internal_has_menustring();
}
inline void CUserMessageShowMenu::clear_menustring() {
  _impl_.menustring_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageShowMenu::menustring() const {
  // @@protoc_insertion_point(field_get:CUserMessageShowMenu.menustring)
  return _internal_menustring();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageShowMenu::set_menustring(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.menustring_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageShowMenu.menustring)
}
inline std::string* CUserMessageShowMenu::mutable_menustring() {
  std::string* _s = _internal_mutable_menustring();
  // @@protoc_insertion_point(field_mutable:CUserMessageShowMenu.menustring)
  return _s;
}
inline const std::string& CUserMessageShowMenu::_internal_menustring() const {
  return _impl_.menustring_.Get();
}
inline void CUserMessageShowMenu::_internal_set_menustring(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.menustring_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageShowMenu::_internal_mutable_menustring() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.menustring_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageShowMenu::release_menustring() {
  // @@protoc_insertion_point(field_release:CUserMessageShowMenu.menustring)
  if (!_internal_has_menustring()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.menustring_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.menustring_.IsDefault()) {
    _impl_.menustring_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageShowMenu::set_allocated_menustring(std::string* menustring) {
  if (menustring != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.menustring_.SetAllocated(menustring, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.menustring_.IsDefault()) {
    _impl_.menustring_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageShowMenu.menustring)
}

// -------------------------------------------------------------------

// CUserMessageCreditsMsg

// optional .eRollType rolltype = 1 [default = ROLL_NONE];
inline bool CUserMessageCreditsMsg::_internal_has_rolltype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCreditsMsg::has_rolltype() const {
  return _internal_has_rolltype();
}
inline void CUserMessageCreditsMsg::clear_rolltype() {
  _impl_.rolltype_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::eRollType CUserMessageCreditsMsg::_internal_rolltype() const {
  return static_cast< ::eRollType >(_impl_.rolltype_);
}
inline ::eRollType CUserMessageCreditsMsg::rolltype() const {
  // @@protoc_insertion_point(field_get:CUserMessageCreditsMsg.rolltype)
  return _internal_rolltype();
}
inline void CUserMessageCreditsMsg::_internal_set_rolltype(::eRollType value) {
  assert(::eRollType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rolltype_ = value;
}
inline void CUserMessageCreditsMsg::set_rolltype(::eRollType value) {
  _internal_set_rolltype(value);
  // @@protoc_insertion_point(field_set:CUserMessageCreditsMsg.rolltype)
}

// optional float logo_length = 2;
inline bool CUserMessageCreditsMsg::_internal_has_logo_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCreditsMsg::has_logo_length() const {
  return _internal_has_logo_length();
}
inline void CUserMessageCreditsMsg::clear_logo_length() {
  _impl_.logo_length_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMessageCreditsMsg::_internal_logo_length() const {
  return _impl_.logo_length_;
}
inline float CUserMessageCreditsMsg::logo_length() const {
  // @@protoc_insertion_point(field_get:CUserMessageCreditsMsg.logo_length)
  return _internal_logo_length();
}
inline void CUserMessageCreditsMsg::_internal_set_logo_length(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.logo_length_ = value;
}
inline void CUserMessageCreditsMsg::set_logo_length(float value) {
  _internal_set_logo_length(value);
  // @@protoc_insertion_point(field_set:CUserMessageCreditsMsg.logo_length)
}

// -------------------------------------------------------------------

// CEntityMessagePlayJingle

// optional .CEntityMsg entity_msg = 1;
inline bool CEntityMessagePlayJingle::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessagePlayJingle::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessagePlayJingle::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessagePlayJingle::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessagePlayJingle.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessagePlayJingle::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessagePlayJingle.entity_msg)
}
inline ::CEntityMsg* CEntityMessagePlayJingle::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessagePlayJingle::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessagePlayJingle.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessagePlayJingle::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessagePlayJingle::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessagePlayJingle.entity_msg)
  return _msg;
}
inline void CEntityMessagePlayJingle::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessagePlayJingle.entity_msg)
}

// -------------------------------------------------------------------

// CEntityMessageScreenOverlay

// optional bool start_effect = 1;
inline bool CEntityMessageScreenOverlay::_internal_has_start_effect() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CEntityMessageScreenOverlay::has_start_effect() const {
  return _internal_has_start_effect();
}
inline void CEntityMessageScreenOverlay::clear_start_effect() {
  _impl_.start_effect_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CEntityMessageScreenOverlay::_internal_start_effect() const {
  return _impl_.start_effect_;
}
inline bool CEntityMessageScreenOverlay::start_effect() const {
  // @@protoc_insertion_point(field_get:CEntityMessageScreenOverlay.start_effect)
  return _internal_start_effect();
}
inline void CEntityMessageScreenOverlay::_internal_set_start_effect(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.start_effect_ = value;
}
inline void CEntityMessageScreenOverlay::set_start_effect(bool value) {
  _internal_set_start_effect(value);
  // @@protoc_insertion_point(field_set:CEntityMessageScreenOverlay.start_effect)
}

// optional .CEntityMsg entity_msg = 2;
inline bool CEntityMessageScreenOverlay::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessageScreenOverlay::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessageScreenOverlay::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessageScreenOverlay::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessageScreenOverlay.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessageScreenOverlay::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageScreenOverlay.entity_msg)
}
inline ::CEntityMsg* CEntityMessageScreenOverlay::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessageScreenOverlay::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessageScreenOverlay.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessageScreenOverlay::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessageScreenOverlay::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessageScreenOverlay.entity_msg)
  return _msg;
}
inline void CEntityMessageScreenOverlay::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageScreenOverlay.entity_msg)
}

// -------------------------------------------------------------------

// CEntityMessageRemoveAllDecals

// optional bool remove_decals = 1;
inline bool CEntityMessageRemoveAllDecals::_internal_has_remove_decals() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CEntityMessageRemoveAllDecals::has_remove_decals() const {
  return _internal_has_remove_decals();
}
inline void CEntityMessageRemoveAllDecals::clear_remove_decals() {
  _impl_.remove_decals_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CEntityMessageRemoveAllDecals::_internal_remove_decals() const {
  return _impl_.remove_decals_;
}
inline bool CEntityMessageRemoveAllDecals::remove_decals() const {
  // @@protoc_insertion_point(field_get:CEntityMessageRemoveAllDecals.remove_decals)
  return _internal_remove_decals();
}
inline void CEntityMessageRemoveAllDecals::_internal_set_remove_decals(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.remove_decals_ = value;
}
inline void CEntityMessageRemoveAllDecals::set_remove_decals(bool value) {
  _internal_set_remove_decals(value);
  // @@protoc_insertion_point(field_set:CEntityMessageRemoveAllDecals.remove_decals)
}

// optional .CEntityMsg entity_msg = 2;
inline bool CEntityMessageRemoveAllDecals::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessageRemoveAllDecals::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessageRemoveAllDecals::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessageRemoveAllDecals::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessageRemoveAllDecals.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessageRemoveAllDecals::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageRemoveAllDecals.entity_msg)
}
inline ::CEntityMsg* CEntityMessageRemoveAllDecals::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessageRemoveAllDecals::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessageRemoveAllDecals.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessageRemoveAllDecals::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessageRemoveAllDecals::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessageRemoveAllDecals.entity_msg)
  return _msg;
}
inline void CEntityMessageRemoveAllDecals::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageRemoveAllDecals.entity_msg)
}

// -------------------------------------------------------------------

// CEntityMessagePropagateForce

// optional .CMsgVector impulse = 1;
inline bool CEntityMessagePropagateForce::_internal_has_impulse() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.impulse_ != nullptr);
  return value;
}
inline bool CEntityMessagePropagateForce::has_impulse() const {
  return _internal_has_impulse();
}
inline const ::CMsgVector& CEntityMessagePropagateForce::_internal_impulse() const {
  const ::CMsgVector* p = _impl_.impulse_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CEntityMessagePropagateForce::impulse() const {
  // @@protoc_insertion_point(field_get:CEntityMessagePropagateForce.impulse)
  return _internal_impulse();
}
inline void CEntityMessagePropagateForce::unsafe_arena_set_allocated_impulse(
    ::CMsgVector* impulse) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.impulse_);
  }
  _impl_.impulse_ = impulse;
  if (impulse) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessagePropagateForce.impulse)
}
inline ::CMsgVector* CEntityMessagePropagateForce::release_impulse() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.impulse_;
  _impl_.impulse_ = 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 ::CMsgVector* CEntityMessagePropagateForce::unsafe_arena_release_impulse() {
  // @@protoc_insertion_point(field_release:CEntityMessagePropagateForce.impulse)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.impulse_;
  _impl_.impulse_ = nullptr;
  return temp;
}
inline ::CMsgVector* CEntityMessagePropagateForce::_internal_mutable_impulse() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.impulse_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.impulse_ = p;
  }
  return _impl_.impulse_;
}
inline ::CMsgVector* CEntityMessagePropagateForce::mutable_impulse() {
  ::CMsgVector* _msg = _internal_mutable_impulse();
  // @@protoc_insertion_point(field_mutable:CEntityMessagePropagateForce.impulse)
  return _msg;
}
inline void CEntityMessagePropagateForce::set_allocated_impulse(::CMsgVector* impulse) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.impulse_);
  }
  if (impulse) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(impulse));
    if (message_arena != submessage_arena) {
      impulse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, impulse, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.impulse_ = impulse;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessagePropagateForce.impulse)
}

// optional .CEntityMsg entity_msg = 2;
inline bool CEntityMessagePropagateForce::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessagePropagateForce::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessagePropagateForce::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessagePropagateForce::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessagePropagateForce.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessagePropagateForce::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessagePropagateForce.entity_msg)
}
inline ::CEntityMsg* CEntityMessagePropagateForce::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessagePropagateForce::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessagePropagateForce.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessagePropagateForce::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessagePropagateForce::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessagePropagateForce.entity_msg)
  return _msg;
}
inline void CEntityMessagePropagateForce::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessagePropagateForce.entity_msg)
}

// -------------------------------------------------------------------

// CEntityMessageDoSpark

// optional .CMsgVector origin = 1;
inline bool CEntityMessageDoSpark::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CEntityMessageDoSpark::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CEntityMessageDoSpark::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CEntityMessageDoSpark::origin() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.origin)
  return _internal_origin();
}
inline void CEntityMessageDoSpark::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageDoSpark.origin)
}
inline ::CMsgVector* CEntityMessageDoSpark::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = 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 ::CMsgVector* CEntityMessageDoSpark::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CEntityMessageDoSpark.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CEntityMessageDoSpark::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CEntityMessageDoSpark::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CEntityMessageDoSpark.origin)
  return _msg;
}
inline void CEntityMessageDoSpark::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageDoSpark.origin)
}

// optional int32 entityindex = 2 [default = -1];
inline bool CEntityMessageDoSpark::_internal_has_entityindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_entityindex() const {
  return _internal_has_entityindex();
}
inline void CEntityMessageDoSpark::clear_entityindex() {
  _impl_.entityindex_ = -1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CEntityMessageDoSpark::_internal_entityindex() const {
  return _impl_.entityindex_;
}
inline int32_t CEntityMessageDoSpark::entityindex() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.entityindex)
  return _internal_entityindex();
}
inline void CEntityMessageDoSpark::_internal_set_entityindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.entityindex_ = value;
}
inline void CEntityMessageDoSpark::set_entityindex(int32_t value) {
  _internal_set_entityindex(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.entityindex)
}

// optional float radius = 3;
inline bool CEntityMessageDoSpark::_internal_has_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_radius() const {
  return _internal_has_radius();
}
inline void CEntityMessageDoSpark::clear_radius() {
  _impl_.radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CEntityMessageDoSpark::_internal_radius() const {
  return _impl_.radius_;
}
inline float CEntityMessageDoSpark::radius() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.radius)
  return _internal_radius();
}
inline void CEntityMessageDoSpark::_internal_set_radius(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.radius_ = value;
}
inline void CEntityMessageDoSpark::set_radius(float value) {
  _internal_set_radius(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.radius)
}

// optional fixed32 color = 4;
inline bool CEntityMessageDoSpark::_internal_has_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_color() const {
  return _internal_has_color();
}
inline void CEntityMessageDoSpark::clear_color() {
  _impl_.color_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CEntityMessageDoSpark::_internal_color() const {
  return _impl_.color_;
}
inline uint32_t CEntityMessageDoSpark::color() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.color)
  return _internal_color();
}
inline void CEntityMessageDoSpark::_internal_set_color(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.color_ = value;
}
inline void CEntityMessageDoSpark::set_color(uint32_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.color)
}

// optional uint32 beams = 5;
inline bool CEntityMessageDoSpark::_internal_has_beams() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_beams() const {
  return _internal_has_beams();
}
inline void CEntityMessageDoSpark::clear_beams() {
  _impl_.beams_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CEntityMessageDoSpark::_internal_beams() const {
  return _impl_.beams_;
}
inline uint32_t CEntityMessageDoSpark::beams() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.beams)
  return _internal_beams();
}
inline void CEntityMessageDoSpark::_internal_set_beams(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.beams_ = value;
}
inline void CEntityMessageDoSpark::set_beams(uint32_t value) {
  _internal_set_beams(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.beams)
}

// optional float thick = 6;
inline bool CEntityMessageDoSpark::_internal_has_thick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_thick() const {
  return _internal_has_thick();
}
inline void CEntityMessageDoSpark::clear_thick() {
  _impl_.thick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CEntityMessageDoSpark::_internal_thick() const {
  return _impl_.thick_;
}
inline float CEntityMessageDoSpark::thick() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.thick)
  return _internal_thick();
}
inline void CEntityMessageDoSpark::_internal_set_thick(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.thick_ = value;
}
inline void CEntityMessageDoSpark::set_thick(float value) {
  _internal_set_thick(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.thick)
}

// optional float duration = 7;
inline bool CEntityMessageDoSpark::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CEntityMessageDoSpark::has_duration() const {
  return _internal_has_duration();
}
inline void CEntityMessageDoSpark::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CEntityMessageDoSpark::_internal_duration() const {
  return _impl_.duration_;
}
inline float CEntityMessageDoSpark::duration() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.duration)
  return _internal_duration();
}
inline void CEntityMessageDoSpark::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.duration_ = value;
}
inline void CEntityMessageDoSpark::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CEntityMessageDoSpark.duration)
}

// optional .CEntityMsg entity_msg = 8;
inline bool CEntityMessageDoSpark::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessageDoSpark::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessageDoSpark::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessageDoSpark::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessageDoSpark.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessageDoSpark::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageDoSpark.entity_msg)
}
inline ::CEntityMsg* CEntityMessageDoSpark::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessageDoSpark::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessageDoSpark.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessageDoSpark::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessageDoSpark::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessageDoSpark.entity_msg)
  return _msg;
}
inline void CEntityMessageDoSpark::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageDoSpark.entity_msg)
}

// -------------------------------------------------------------------

// CEntityMessageFixAngle

// optional bool relative = 1;
inline bool CEntityMessageFixAngle::_internal_has_relative() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CEntityMessageFixAngle::has_relative() const {
  return _internal_has_relative();
}
inline void CEntityMessageFixAngle::clear_relative() {
  _impl_.relative_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CEntityMessageFixAngle::_internal_relative() const {
  return _impl_.relative_;
}
inline bool CEntityMessageFixAngle::relative() const {
  // @@protoc_insertion_point(field_get:CEntityMessageFixAngle.relative)
  return _internal_relative();
}
inline void CEntityMessageFixAngle::_internal_set_relative(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.relative_ = value;
}
inline void CEntityMessageFixAngle::set_relative(bool value) {
  _internal_set_relative(value);
  // @@protoc_insertion_point(field_set:CEntityMessageFixAngle.relative)
}

// optional .CMsgQAngle angle = 2;
inline bool CEntityMessageFixAngle::_internal_has_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angle_ != nullptr);
  return value;
}
inline bool CEntityMessageFixAngle::has_angle() const {
  return _internal_has_angle();
}
inline const ::CMsgQAngle& CEntityMessageFixAngle::_internal_angle() const {
  const ::CMsgQAngle* p = _impl_.angle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CEntityMessageFixAngle::angle() const {
  // @@protoc_insertion_point(field_get:CEntityMessageFixAngle.angle)
  return _internal_angle();
}
inline void CEntityMessageFixAngle::unsafe_arena_set_allocated_angle(
    ::CMsgQAngle* angle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  _impl_.angle_ = angle;
  if (angle) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageFixAngle.angle)
}
inline ::CMsgQAngle* CEntityMessageFixAngle::release_angle() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = 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 ::CMsgQAngle* CEntityMessageFixAngle::unsafe_arena_release_angle() {
  // @@protoc_insertion_point(field_release:CEntityMessageFixAngle.angle)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CEntityMessageFixAngle::_internal_mutable_angle() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.angle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angle_ = p;
  }
  return _impl_.angle_;
}
inline ::CMsgQAngle* CEntityMessageFixAngle::mutable_angle() {
  ::CMsgQAngle* _msg = _internal_mutable_angle();
  // @@protoc_insertion_point(field_mutable:CEntityMessageFixAngle.angle)
  return _msg;
}
inline void CEntityMessageFixAngle::set_allocated_angle(::CMsgQAngle* angle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  if (angle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angle));
    if (message_arena != submessage_arena) {
      angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.angle_ = angle;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageFixAngle.angle)
}

// optional .CEntityMsg entity_msg = 3;
inline bool CEntityMessageFixAngle::_internal_has_entity_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.entity_msg_ != nullptr);
  return value;
}
inline bool CEntityMessageFixAngle::has_entity_msg() const {
  return _internal_has_entity_msg();
}
inline const ::CEntityMsg& CEntityMessageFixAngle::_internal_entity_msg() const {
  const ::CEntityMsg* p = _impl_.entity_msg_;
  return p != nullptr ? *p : reinterpret_cast<const ::CEntityMsg&>(
      ::_CEntityMsg_default_instance_);
}
inline const ::CEntityMsg& CEntityMessageFixAngle::entity_msg() const {
  // @@protoc_insertion_point(field_get:CEntityMessageFixAngle.entity_msg)
  return _internal_entity_msg();
}
inline void CEntityMessageFixAngle::unsafe_arena_set_allocated_entity_msg(
    ::CEntityMsg* entity_msg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  _impl_.entity_msg_ = entity_msg;
  if (entity_msg) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CEntityMessageFixAngle.entity_msg)
}
inline ::CEntityMsg* CEntityMessageFixAngle::release_entity_msg() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = 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 ::CEntityMsg* CEntityMessageFixAngle::unsafe_arena_release_entity_msg() {
  // @@protoc_insertion_point(field_release:CEntityMessageFixAngle.entity_msg)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CEntityMsg* temp = _impl_.entity_msg_;
  _impl_.entity_msg_ = nullptr;
  return temp;
}
inline ::CEntityMsg* CEntityMessageFixAngle::_internal_mutable_entity_msg() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.entity_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::CEntityMsg>(GetArenaForAllocation());
    _impl_.entity_msg_ = p;
  }
  return _impl_.entity_msg_;
}
inline ::CEntityMsg* CEntityMessageFixAngle::mutable_entity_msg() {
  ::CEntityMsg* _msg = _internal_mutable_entity_msg();
  // @@protoc_insertion_point(field_mutable:CEntityMessageFixAngle.entity_msg)
  return _msg;
}
inline void CEntityMessageFixAngle::set_allocated_entity_msg(::CEntityMsg* entity_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entity_msg_);
  }
  if (entity_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entity_msg));
    if (message_arena != submessage_arena) {
      entity_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entity_msg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.entity_msg_ = entity_msg;
  // @@protoc_insertion_point(field_set_allocated:CEntityMessageFixAngle.entity_msg)
}

// -------------------------------------------------------------------

// CUserMessageCameraTransition_Transition_DataDriven

// optional string filename = 1;
inline bool CUserMessageCameraTransition_Transition_DataDriven::_internal_has_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageCameraTransition_Transition_DataDriven::has_filename() const {
  return _internal_has_filename();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::clear_filename() {
  _impl_.filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageCameraTransition_Transition_DataDriven::filename() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.Transition_DataDriven.filename)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageCameraTransition_Transition_DataDriven::set_filename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageCameraTransition.Transition_DataDriven.filename)
}
inline std::string* CUserMessageCameraTransition_Transition_DataDriven::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:CUserMessageCameraTransition.Transition_DataDriven.filename)
  return _s;
}
inline const std::string& CUserMessageCameraTransition_Transition_DataDriven::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::_internal_set_filename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageCameraTransition_Transition_DataDriven::_internal_mutable_filename() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageCameraTransition_Transition_DataDriven::release_filename() {
  // @@protoc_insertion_point(field_release:CUserMessageCameraTransition.Transition_DataDriven.filename)
  if (!_internal_has_filename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.filename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageCameraTransition_Transition_DataDriven::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageCameraTransition.Transition_DataDriven.filename)
}

// optional int32 attach_ent_index = 2 [default = -1];
inline bool CUserMessageCameraTransition_Transition_DataDriven::_internal_has_attach_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageCameraTransition_Transition_DataDriven::has_attach_ent_index() const {
  return _internal_has_attach_ent_index();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::clear_attach_ent_index() {
  _impl_.attach_ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageCameraTransition_Transition_DataDriven::_internal_attach_ent_index() const {
  return _impl_.attach_ent_index_;
}
inline int32_t CUserMessageCameraTransition_Transition_DataDriven::attach_ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.Transition_DataDriven.attach_ent_index)
  return _internal_attach_ent_index();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::_internal_set_attach_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.attach_ent_index_ = value;
}
inline void CUserMessageCameraTransition_Transition_DataDriven::set_attach_ent_index(int32_t value) {
  _internal_set_attach_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageCameraTransition.Transition_DataDriven.attach_ent_index)
}

// optional float duration = 3;
inline bool CUserMessageCameraTransition_Transition_DataDriven::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCameraTransition_Transition_DataDriven::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageCameraTransition_Transition_DataDriven::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageCameraTransition_Transition_DataDriven::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.Transition_DataDriven.duration)
  return _internal_duration();
}
inline void CUserMessageCameraTransition_Transition_DataDriven::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void CUserMessageCameraTransition_Transition_DataDriven::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageCameraTransition.Transition_DataDriven.duration)
}

// -------------------------------------------------------------------

// CUserMessageCameraTransition

// optional uint32 camera_type = 1;
inline bool CUserMessageCameraTransition::_internal_has_camera_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageCameraTransition::has_camera_type() const {
  return _internal_has_camera_type();
}
inline void CUserMessageCameraTransition::clear_camera_type() {
  _impl_.camera_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageCameraTransition::_internal_camera_type() const {
  return _impl_.camera_type_;
}
inline uint32_t CUserMessageCameraTransition::camera_type() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.camera_type)
  return _internal_camera_type();
}
inline void CUserMessageCameraTransition::_internal_set_camera_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.camera_type_ = value;
}
inline void CUserMessageCameraTransition::set_camera_type(uint32_t value) {
  _internal_set_camera_type(value);
  // @@protoc_insertion_point(field_set:CUserMessageCameraTransition.camera_type)
}

// optional float duration = 2;
inline bool CUserMessageCameraTransition::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageCameraTransition::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMessageCameraTransition::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageCameraTransition::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMessageCameraTransition::duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.duration)
  return _internal_duration();
}
inline void CUserMessageCameraTransition::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.duration_ = value;
}
inline void CUserMessageCameraTransition::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageCameraTransition.duration)
}

// optional .CUserMessageCameraTransition.Transition_DataDriven params_data_driven = 3;
inline bool CUserMessageCameraTransition::_internal_has_params_data_driven() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.params_data_driven_ != nullptr);
  return value;
}
inline bool CUserMessageCameraTransition::has_params_data_driven() const {
  return _internal_has_params_data_driven();
}
inline void CUserMessageCameraTransition::clear_params_data_driven() {
  if (_impl_.params_data_driven_ != nullptr) _impl_.params_data_driven_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CUserMessageCameraTransition_Transition_DataDriven& CUserMessageCameraTransition::_internal_params_data_driven() const {
  const ::CUserMessageCameraTransition_Transition_DataDriven* p = _impl_.params_data_driven_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMessageCameraTransition_Transition_DataDriven&>(
      ::_CUserMessageCameraTransition_Transition_DataDriven_default_instance_);
}
inline const ::CUserMessageCameraTransition_Transition_DataDriven& CUserMessageCameraTransition::params_data_driven() const {
  // @@protoc_insertion_point(field_get:CUserMessageCameraTransition.params_data_driven)
  return _internal_params_data_driven();
}
inline void CUserMessageCameraTransition::unsafe_arena_set_allocated_params_data_driven(
    ::CUserMessageCameraTransition_Transition_DataDriven* params_data_driven) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.params_data_driven_);
  }
  _impl_.params_data_driven_ = params_data_driven;
  if (params_data_driven) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMessageCameraTransition.params_data_driven)
}
inline ::CUserMessageCameraTransition_Transition_DataDriven* CUserMessageCameraTransition::release_params_data_driven() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMessageCameraTransition_Transition_DataDriven* temp = _impl_.params_data_driven_;
  _impl_.params_data_driven_ = 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 ::CUserMessageCameraTransition_Transition_DataDriven* CUserMessageCameraTransition::unsafe_arena_release_params_data_driven() {
  // @@protoc_insertion_point(field_release:CUserMessageCameraTransition.params_data_driven)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMessageCameraTransition_Transition_DataDriven* temp = _impl_.params_data_driven_;
  _impl_.params_data_driven_ = nullptr;
  return temp;
}
inline ::CUserMessageCameraTransition_Transition_DataDriven* CUserMessageCameraTransition::_internal_mutable_params_data_driven() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.params_data_driven_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMessageCameraTransition_Transition_DataDriven>(GetArenaForAllocation());
    _impl_.params_data_driven_ = p;
  }
  return _impl_.params_data_driven_;
}
inline ::CUserMessageCameraTransition_Transition_DataDriven* CUserMessageCameraTransition::mutable_params_data_driven() {
  ::CUserMessageCameraTransition_Transition_DataDriven* _msg = _internal_mutable_params_data_driven();
  // @@protoc_insertion_point(field_mutable:CUserMessageCameraTransition.params_data_driven)
  return _msg;
}
inline void CUserMessageCameraTransition::set_allocated_params_data_driven(::CUserMessageCameraTransition_Transition_DataDriven* params_data_driven) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.params_data_driven_;
  }
  if (params_data_driven) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(params_data_driven);
    if (message_arena != submessage_arena) {
      params_data_driven = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, params_data_driven, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.params_data_driven_ = params_data_driven;
  // @@protoc_insertion_point(field_set_allocated:CUserMessageCameraTransition.params_data_driven)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ReleaseParticleIndex

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_CreateParticle

// optional fixed64 particle_name_index = 1;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_particle_name_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_particle_name_index() const {
  return _internal_has_particle_name_index();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_particle_name_index() {
  _impl_.particle_name_index_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CUserMsg_ParticleManager_CreateParticle::_internal_particle_name_index() const {
  return _impl_.particle_name_index_;
}
inline uint64_t CUserMsg_ParticleManager_CreateParticle::particle_name_index() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.particle_name_index)
  return _internal_particle_name_index();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_particle_name_index(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.particle_name_index_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_particle_name_index(uint64_t value) {
  _internal_set_particle_name_index(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.particle_name_index)
}

// optional int32 attach_type = 2;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_attach_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_attach_type() const {
  return _internal_has_attach_type();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_attach_type() {
  _impl_.attach_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMsg_ParticleManager_CreateParticle::_internal_attach_type() const {
  return _impl_.attach_type_;
}
inline int32_t CUserMsg_ParticleManager_CreateParticle::attach_type() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.attach_type)
  return _internal_attach_type();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_attach_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.attach_type_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_attach_type(int32_t value) {
  _internal_set_attach_type(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.attach_type)
}

// optional uint32 entity_handle = 3 [default = 16777215];
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CUserMsg_ParticleManager_CreateParticle::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_CreateParticle::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.entity_handle)
}

// optional uint32 entity_handle_for_modifiers = 4 [default = 16777215];
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_entity_handle_for_modifiers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_entity_handle_for_modifiers() const {
  return _internal_has_entity_handle_for_modifiers();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_entity_handle_for_modifiers() {
  _impl_.entity_handle_for_modifiers_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CUserMsg_ParticleManager_CreateParticle::_internal_entity_handle_for_modifiers() const {
  return _impl_.entity_handle_for_modifiers_;
}
inline uint32_t CUserMsg_ParticleManager_CreateParticle::entity_handle_for_modifiers() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.entity_handle_for_modifiers)
  return _internal_entity_handle_for_modifiers();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_entity_handle_for_modifiers(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.entity_handle_for_modifiers_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_entity_handle_for_modifiers(uint32_t value) {
  _internal_set_entity_handle_for_modifiers(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.entity_handle_for_modifiers)
}

// optional bool apply_voice_ban_rules = 5;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_apply_voice_ban_rules() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_apply_voice_ban_rules() const {
  return _internal_has_apply_voice_ban_rules();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_apply_voice_ban_rules() {
  _impl_.apply_voice_ban_rules_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_apply_voice_ban_rules() const {
  return _impl_.apply_voice_ban_rules_;
}
inline bool CUserMsg_ParticleManager_CreateParticle::apply_voice_ban_rules() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.apply_voice_ban_rules)
  return _internal_apply_voice_ban_rules();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_apply_voice_ban_rules(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.apply_voice_ban_rules_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_apply_voice_ban_rules(bool value) {
  _internal_set_apply_voice_ban_rules(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.apply_voice_ban_rules)
}

// optional int32 team_behavior = 6;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_team_behavior() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_team_behavior() const {
  return _internal_has_team_behavior();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_team_behavior() {
  _impl_.team_behavior_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMsg_ParticleManager_CreateParticle::_internal_team_behavior() const {
  return _impl_.team_behavior_;
}
inline int32_t CUserMsg_ParticleManager_CreateParticle::team_behavior() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.team_behavior)
  return _internal_team_behavior();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_team_behavior(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.team_behavior_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_team_behavior(int32_t value) {
  _internal_set_team_behavior(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.team_behavior)
}

// optional string control_point_configuration = 7;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_control_point_configuration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_control_point_configuration() const {
  return _internal_has_control_point_configuration();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_control_point_configuration() {
  _impl_.control_point_configuration_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_CreateParticle::control_point_configuration() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.control_point_configuration)
  return _internal_control_point_configuration();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_CreateParticle::set_control_point_configuration(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.control_point_configuration_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.control_point_configuration)
}
inline std::string* CUserMsg_ParticleManager_CreateParticle::mutable_control_point_configuration() {
  std::string* _s = _internal_mutable_control_point_configuration();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.CreateParticle.control_point_configuration)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_CreateParticle::_internal_control_point_configuration() const {
  return _impl_.control_point_configuration_.Get();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_control_point_configuration(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.control_point_configuration_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_CreateParticle::_internal_mutable_control_point_configuration() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.control_point_configuration_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_CreateParticle::release_control_point_configuration() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.CreateParticle.control_point_configuration)
  if (!_internal_has_control_point_configuration()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.control_point_configuration_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.control_point_configuration_.IsDefault()) {
    _impl_.control_point_configuration_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_allocated_control_point_configuration(std::string* control_point_configuration) {
  if (control_point_configuration != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.control_point_configuration_.SetAllocated(control_point_configuration, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.control_point_configuration_.IsDefault()) {
    _impl_.control_point_configuration_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.CreateParticle.control_point_configuration)
}

// optional bool cluster = 8;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_cluster() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_cluster() const {
  return _internal_has_cluster();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_cluster() {
  _impl_.cluster_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_cluster() const {
  return _impl_.cluster_;
}
inline bool CUserMsg_ParticleManager_CreateParticle::cluster() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.cluster)
  return _internal_cluster();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_cluster(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.cluster_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_cluster(bool value) {
  _internal_set_cluster(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.cluster)
}

// optional float endcap_time = 9;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_endcap_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_endcap_time() const {
  return _internal_has_endcap_time();
}
inline void CUserMsg_ParticleManager_CreateParticle::clear_endcap_time() {
  _impl_.endcap_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float CUserMsg_ParticleManager_CreateParticle::_internal_endcap_time() const {
  return _impl_.endcap_time_;
}
inline float CUserMsg_ParticleManager_CreateParticle::endcap_time() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.endcap_time)
  return _internal_endcap_time();
}
inline void CUserMsg_ParticleManager_CreateParticle::_internal_set_endcap_time(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.endcap_time_ = value;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_endcap_time(float value) {
  _internal_set_endcap_time(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreateParticle.endcap_time)
}

// optional .CMsgVector aggregation_position = 10;
inline bool CUserMsg_ParticleManager_CreateParticle::_internal_has_aggregation_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.aggregation_position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_CreateParticle::has_aggregation_position() const {
  return _internal_has_aggregation_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_CreateParticle::_internal_aggregation_position() const {
  const ::CMsgVector* p = _impl_.aggregation_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_CreateParticle::aggregation_position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreateParticle.aggregation_position)
  return _internal_aggregation_position();
}
inline void CUserMsg_ParticleManager_CreateParticle::unsafe_arena_set_allocated_aggregation_position(
    ::CMsgVector* aggregation_position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.aggregation_position_);
  }
  _impl_.aggregation_position_ = aggregation_position;
  if (aggregation_position) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.CreateParticle.aggregation_position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_CreateParticle::release_aggregation_position() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.aggregation_position_;
  _impl_.aggregation_position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_CreateParticle::unsafe_arena_release_aggregation_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.CreateParticle.aggregation_position)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.aggregation_position_;
  _impl_.aggregation_position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_CreateParticle::_internal_mutable_aggregation_position() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.aggregation_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.aggregation_position_ = p;
  }
  return _impl_.aggregation_position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_CreateParticle::mutable_aggregation_position() {
  ::CMsgVector* _msg = _internal_mutable_aggregation_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.CreateParticle.aggregation_position)
  return _msg;
}
inline void CUserMsg_ParticleManager_CreateParticle::set_allocated_aggregation_position(::CMsgVector* aggregation_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.aggregation_position_);
  }
  if (aggregation_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(aggregation_position));
    if (message_arena != submessage_arena) {
      aggregation_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, aggregation_position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.aggregation_position_ = aggregation_position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.CreateParticle.aggregation_position)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_DestroyParticle

// optional bool destroy_immediately = 1;
inline bool CUserMsg_ParticleManager_DestroyParticle::_internal_has_destroy_immediately() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticle::has_destroy_immediately() const {
  return _internal_has_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticle::clear_destroy_immediately() {
  _impl_.destroy_immediately_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_DestroyParticle::_internal_destroy_immediately() const {
  return _impl_.destroy_immediately_;
}
inline bool CUserMsg_ParticleManager_DestroyParticle::destroy_immediately() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticle.destroy_immediately)
  return _internal_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticle::_internal_set_destroy_immediately(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.destroy_immediately_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticle::set_destroy_immediately(bool value) {
  _internal_set_destroy_immediately(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticle.destroy_immediately)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_DestroyParticleInvolving

// optional bool destroy_immediately = 1;
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_has_destroy_immediately() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::has_destroy_immediately() const {
  return _internal_has_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::clear_destroy_immediately() {
  _impl_.destroy_immediately_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_destroy_immediately() const {
  return _impl_.destroy_immediately_;
}
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::destroy_immediately() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleInvolving.destroy_immediately)
  return _internal_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_set_destroy_immediately(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.destroy_immediately_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::set_destroy_immediately(bool value) {
  _internal_set_destroy_immediately(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleInvolving.destroy_immediately)
}

// optional uint32 entity_handle = 3 [default = 16777215];
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleInvolving::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_DestroyParticleInvolving::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleInvolving.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleInvolving::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleInvolving.entity_handle)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_DestroyParticleNamed

// optional fixed64 particle_name_index = 1;
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_has_particle_name_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::has_particle_name_index() const {
  return _internal_has_particle_name_index();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::clear_particle_name_index() {
  _impl_.particle_name_index_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CUserMsg_ParticleManager_DestroyParticleNamed::_internal_particle_name_index() const {
  return _impl_.particle_name_index_;
}
inline uint64_t CUserMsg_ParticleManager_DestroyParticleNamed::particle_name_index() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleNamed.particle_name_index)
  return _internal_particle_name_index();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::_internal_set_particle_name_index(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.particle_name_index_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::set_particle_name_index(uint64_t value) {
  _internal_set_particle_name_index(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleNamed.particle_name_index)
}

// optional uint32 entity_handle = 2 [default = 16777215];
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CUserMsg_ParticleManager_DestroyParticleNamed::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_DestroyParticleNamed::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleNamed.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleNamed.entity_handle)
}

// optional bool destroy_immediately = 3;
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_has_destroy_immediately() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::has_destroy_immediately() const {
  return _internal_has_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::clear_destroy_immediately() {
  _impl_.destroy_immediately_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_destroy_immediately() const {
  return _impl_.destroy_immediately_;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::destroy_immediately() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleNamed.destroy_immediately)
  return _internal_destroy_immediately();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::_internal_set_destroy_immediately(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.destroy_immediately_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::set_destroy_immediately(bool value) {
  _internal_set_destroy_immediately(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleNamed.destroy_immediately)
}

// optional bool play_endcap = 4;
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_has_play_endcap() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::has_play_endcap() const {
  return _internal_has_play_endcap();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::clear_play_endcap() {
  _impl_.play_endcap_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::_internal_play_endcap() const {
  return _impl_.play_endcap_;
}
inline bool CUserMsg_ParticleManager_DestroyParticleNamed::play_endcap() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.DestroyParticleNamed.play_endcap)
  return _internal_play_endcap();
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::_internal_set_play_endcap(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.play_endcap_ = value;
}
inline void CUserMsg_ParticleManager_DestroyParticleNamed::set_play_endcap(bool value) {
  _internal_set_play_endcap(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.DestroyParticleNamed.play_endcap)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticle_OBSOLETE

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.control_point)
}

// optional .CMsgVector position = 2;
inline bool CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::has_position() const {
  return _internal_has_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.position)
  return _internal_position();
}
inline void CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::unsafe_arena_set_allocated_position(
    ::CMsgVector* position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  _impl_.position_ = position;
  if (position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::release_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::_internal_mutable_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.position_ = p;
  }
  return _impl_.position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticle_OBSOLETE::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position));
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.position_ = position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticle_OBSOLETE.position)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.control_point)
}

// optional .CMsgVector forward = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_has_forward() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.forward_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::has_forward() const {
  return _internal_has_forward();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_forward() const {
  const ::CMsgVector* p = _impl_.forward_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::forward() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.forward)
  return _internal_forward();
}
inline void CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::unsafe_arena_set_allocated_forward(
    ::CMsgVector* forward) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forward_);
  }
  _impl_.forward_ = forward;
  if (forward) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.forward)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::release_forward() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.forward_;
  _impl_.forward_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::unsafe_arena_release_forward() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.forward)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.forward_;
  _impl_.forward_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::_internal_mutable_forward() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.forward_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.forward_ = p;
  }
  return _impl_.forward_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::mutable_forward() {
  ::CMsgVector* _msg = _internal_mutable_forward();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.forward)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE::set_allocated_forward(::CMsgVector* forward) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forward_);
  }
  if (forward) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(forward));
    if (message_arena != submessage_arena) {
      forward = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, forward, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.forward_ = forward;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE.forward)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.control_point)
}

// optional .CMsgVector forward = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_has_forward() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.forward_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::has_forward() const {
  return _internal_has_forward();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_forward() const {
  const ::CMsgVector* p = _impl_.forward_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::forward() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.forward)
  return _internal_forward();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_set_allocated_forward(
    ::CMsgVector* forward) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forward_);
  }
  _impl_.forward_ = forward;
  if (forward) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.forward)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::release_forward() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.forward_;
  _impl_.forward_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_release_forward() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.forward)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.forward_;
  _impl_.forward_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_mutable_forward() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.forward_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.forward_ = p;
  }
  return _impl_.forward_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::mutable_forward() {
  ::CMsgVector* _msg = _internal_mutable_forward();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.forward)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::set_allocated_forward(::CMsgVector* forward) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forward_);
  }
  if (forward) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(forward));
    if (message_arena != submessage_arena) {
      forward = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, forward, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.forward_ = forward;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.forward)
}

// optional .CMsgVector deprecated_right = 3;
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_has_deprecated_right() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.deprecated_right_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::has_deprecated_right() const {
  return _internal_has_deprecated_right();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_deprecated_right() const {
  const ::CMsgVector* p = _impl_.deprecated_right_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::deprecated_right() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.deprecated_right)
  return _internal_deprecated_right();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_set_allocated_deprecated_right(
    ::CMsgVector* deprecated_right) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deprecated_right_);
  }
  _impl_.deprecated_right_ = deprecated_right;
  if (deprecated_right) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.deprecated_right)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::release_deprecated_right() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.deprecated_right_;
  _impl_.deprecated_right_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_release_deprecated_right() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.deprecated_right)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.deprecated_right_;
  _impl_.deprecated_right_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_mutable_deprecated_right() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.deprecated_right_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.deprecated_right_ = p;
  }
  return _impl_.deprecated_right_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::mutable_deprecated_right() {
  ::CMsgVector* _msg = _internal_mutable_deprecated_right();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.deprecated_right)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::set_allocated_deprecated_right(::CMsgVector* deprecated_right) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deprecated_right_);
  }
  if (deprecated_right) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(deprecated_right));
    if (message_arena != submessage_arena) {
      deprecated_right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deprecated_right, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.deprecated_right_ = deprecated_right;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.deprecated_right)
}

// optional .CMsgVector up = 4;
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_has_up() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.up_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::has_up() const {
  return _internal_has_up();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_up() const {
  const ::CMsgVector* p = _impl_.up_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::up() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.up)
  return _internal_up();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_set_allocated_up(
    ::CMsgVector* up) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.up_);
  }
  _impl_.up_ = up;
  if (up) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.up)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::release_up() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.up_;
  _impl_.up_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_release_up() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.up)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.up_;
  _impl_.up_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_mutable_up() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.up_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.up_ = p;
  }
  return _impl_.up_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::mutable_up() {
  ::CMsgVector* _msg = _internal_mutable_up();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.up)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::set_allocated_up(::CMsgVector* up) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.up_);
  }
  if (up) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(up));
    if (message_arena != submessage_arena) {
      up = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, up, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.up_ = up;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.up)
}

// optional .CMsgVector left = 5;
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_has_left() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.left_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::has_left() const {
  return _internal_has_left();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_left() const {
  const ::CMsgVector* p = _impl_.left_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::left() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.left)
  return _internal_left();
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_set_allocated_left(
    ::CMsgVector* left) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_);
  }
  _impl_.left_ = left;
  if (left) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.left)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::release_left() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.left_;
  _impl_.left_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::unsafe_arena_release_left() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.left)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.left_;
  _impl_.left_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::_internal_mutable_left() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.left_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.left_ = p;
  }
  return _impl_.left_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::mutable_left() {
  ::CMsgVector* _msg = _internal_mutable_left();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.left)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE::set_allocated_left(::CMsgVector* left) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_);
  }
  if (left) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left));
    if (message_arena != submessage_arena) {
      left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, left, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.left_ = left;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE.left)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleTransform

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleTransform::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleTransform::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleTransform.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleTransform.control_point)
}

// optional .CMsgVector position = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::has_position() const {
  return _internal_has_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleTransform::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleTransform::position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleTransform.position)
  return _internal_position();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::unsafe_arena_set_allocated_position(
    ::CMsgVector* position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  _impl_.position_ = position;
  if (position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleTransform.position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleTransform::release_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleTransform::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleTransform.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleTransform::_internal_mutable_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.position_ = p;
  }
  return _impl_.position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleTransform::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleTransform.position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position));
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.position_ = position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleTransform.position)
}

// optional .CMsgQuaternion orientation = 3;
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::_internal_has_orientation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.orientation_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::has_orientation() const {
  return _internal_has_orientation();
}
inline const ::CMsgQuaternion& CUserMsg_ParticleManager_UpdateParticleTransform::_internal_orientation() const {
  const ::CMsgQuaternion* p = _impl_.orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQuaternion&>(
      ::_CMsgQuaternion_default_instance_);
}
inline const ::CMsgQuaternion& CUserMsg_ParticleManager_UpdateParticleTransform::orientation() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleTransform.orientation)
  return _internal_orientation();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::unsafe_arena_set_allocated_orientation(
    ::CMsgQuaternion* orientation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.orientation_);
  }
  _impl_.orientation_ = orientation;
  if (orientation) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleTransform.orientation)
}
inline ::CMsgQuaternion* CUserMsg_ParticleManager_UpdateParticleTransform::release_orientation() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQuaternion* temp = _impl_.orientation_;
  _impl_.orientation_ = 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 ::CMsgQuaternion* CUserMsg_ParticleManager_UpdateParticleTransform::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleTransform.orientation)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQuaternion* temp = _impl_.orientation_;
  _impl_.orientation_ = nullptr;
  return temp;
}
inline ::CMsgQuaternion* CUserMsg_ParticleManager_UpdateParticleTransform::_internal_mutable_orientation() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQuaternion>(GetArenaForAllocation());
    _impl_.orientation_ = p;
  }
  return _impl_.orientation_;
}
inline ::CMsgQuaternion* CUserMsg_ParticleManager_UpdateParticleTransform::mutable_orientation() {
  ::CMsgQuaternion* _msg = _internal_mutable_orientation();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleTransform.orientation)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::set_allocated_orientation(::CMsgQuaternion* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.orientation_);
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation));
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleTransform.orientation)
}

// optional float interpolation_interval = 4;
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::_internal_has_interpolation_interval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleTransform::has_interpolation_interval() const {
  return _internal_has_interpolation_interval();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::clear_interpolation_interval() {
  _impl_.interpolation_interval_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMsg_ParticleManager_UpdateParticleTransform::_internal_interpolation_interval() const {
  return _impl_.interpolation_interval_;
}
inline float CUserMsg_ParticleManager_UpdateParticleTransform::interpolation_interval() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleTransform.interpolation_interval)
  return _internal_interpolation_interval();
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::_internal_set_interpolation_interval(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.interpolation_interval_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleTransform::set_interpolation_interval(float value) {
  _internal_set_interpolation_interval(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleTransform.interpolation_interval)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleFallback

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleFallback::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleFallback::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleFallback::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleFallback::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleFallback::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleFallback.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleFallback::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleFallback::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleFallback.control_point)
}

// optional .CMsgVector position = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleFallback::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleFallback::has_position() const {
  return _internal_has_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleFallback::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleFallback::position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleFallback.position)
  return _internal_position();
}
inline void CUserMsg_ParticleManager_UpdateParticleFallback::unsafe_arena_set_allocated_position(
    ::CMsgVector* position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  _impl_.position_ = position;
  if (position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleFallback.position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFallback::release_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFallback::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleFallback.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFallback::_internal_mutable_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.position_ = p;
  }
  return _impl_.position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleFallback::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleFallback.position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleFallback::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position));
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.position_ = position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleFallback.position)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleOffset

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleOffset::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleOffset::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOffset.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleOffset.control_point)
}

// optional .CMsgVector origin_offset = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::_internal_has_origin_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_offset_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::has_origin_offset() const {
  return _internal_has_origin_offset();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOffset::_internal_origin_offset() const {
  const ::CMsgVector* p = _impl_.origin_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleOffset::origin_offset() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOffset.origin_offset)
  return _internal_origin_offset();
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::unsafe_arena_set_allocated_origin_offset(
    ::CMsgVector* origin_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_offset_);
  }
  _impl_.origin_offset_ = origin_offset;
  if (origin_offset) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOffset.origin_offset)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOffset::release_origin_offset() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_offset_;
  _impl_.origin_offset_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOffset::unsafe_arena_release_origin_offset() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOffset.origin_offset)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_offset_;
  _impl_.origin_offset_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOffset::_internal_mutable_origin_offset() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_offset_ = p;
  }
  return _impl_.origin_offset_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleOffset::mutable_origin_offset() {
  ::CMsgVector* _msg = _internal_mutable_origin_offset();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOffset.origin_offset)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::set_allocated_origin_offset(::CMsgVector* origin_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_offset_);
  }
  if (origin_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin_offset));
    if (message_arena != submessage_arena) {
      origin_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_offset_ = origin_offset;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOffset.origin_offset)
}

// optional .CMsgQAngle angle_offset = 3;
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::_internal_has_angle_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angle_offset_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleOffset::has_angle_offset() const {
  return _internal_has_angle_offset();
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_UpdateParticleOffset::_internal_angle_offset() const {
  const ::CMsgQAngle* p = _impl_.angle_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_UpdateParticleOffset::angle_offset() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleOffset.angle_offset)
  return _internal_angle_offset();
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::unsafe_arena_set_allocated_angle_offset(
    ::CMsgQAngle* angle_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_offset_);
  }
  _impl_.angle_offset_ = angle_offset;
  if (angle_offset) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleOffset.angle_offset)
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleOffset::release_angle_offset() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angle_offset_;
  _impl_.angle_offset_ = 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 ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleOffset::unsafe_arena_release_angle_offset() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleOffset.angle_offset)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angle_offset_;
  _impl_.angle_offset_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleOffset::_internal_mutable_angle_offset() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.angle_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angle_offset_ = p;
  }
  return _impl_.angle_offset_;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleOffset::mutable_angle_offset() {
  ::CMsgQAngle* _msg = _internal_mutable_angle_offset();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleOffset.angle_offset)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleOffset::set_allocated_angle_offset(::CMsgQAngle* angle_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_offset_);
  }
  if (angle_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angle_offset));
    if (message_arena != submessage_arena) {
      angle_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angle_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.angle_offset_ = angle_offset;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleOffset.angle_offset)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleEnt

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleEnt.control_point)
}

// optional uint32 entity_handle = 2 [default = 16777215];
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CUserMsg_ParticleManager_UpdateParticleEnt::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_UpdateParticleEnt::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleEnt.entity_handle)
}

// optional int32 attach_type = 3;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_attach_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_attach_type() const {
  return _internal_has_attach_type();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::clear_attach_type() {
  _impl_.attach_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::_internal_attach_type() const {
  return _impl_.attach_type_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::attach_type() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.attach_type)
  return _internal_attach_type();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::_internal_set_attach_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.attach_type_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_attach_type(int32_t value) {
  _internal_set_attach_type(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleEnt.attach_type)
}

// optional int32 attachment = 4;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_attachment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_attachment() const {
  return _internal_has_attachment();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::clear_attachment() {
  _impl_.attachment_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::_internal_attachment() const {
  return _impl_.attachment_;
}
inline int32_t CUserMsg_ParticleManager_UpdateParticleEnt::attachment() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.attachment)
  return _internal_attachment();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::_internal_set_attachment(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.attachment_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_attachment(int32_t value) {
  _internal_set_attachment(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleEnt.attachment)
}

// optional .CMsgVector fallback_position = 5;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_fallback_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fallback_position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_fallback_position() const {
  return _internal_has_fallback_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleEnt::_internal_fallback_position() const {
  const ::CMsgVector* p = _impl_.fallback_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleEnt::fallback_position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.fallback_position)
  return _internal_fallback_position();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_set_allocated_fallback_position(
    ::CMsgVector* fallback_position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fallback_position_);
  }
  _impl_.fallback_position_ = fallback_position;
  if (fallback_position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.fallback_position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::release_fallback_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.fallback_position_;
  _impl_.fallback_position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_release_fallback_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleEnt.fallback_position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.fallback_position_;
  _impl_.fallback_position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::_internal_mutable_fallback_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.fallback_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fallback_position_ = p;
  }
  return _impl_.fallback_position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::mutable_fallback_position() {
  ::CMsgVector* _msg = _internal_mutable_fallback_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleEnt.fallback_position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_allocated_fallback_position(::CMsgVector* fallback_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fallback_position_);
  }
  if (fallback_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fallback_position));
    if (message_arena != submessage_arena) {
      fallback_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fallback_position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.fallback_position_ = fallback_position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.fallback_position)
}

// optional bool include_wearables = 6;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_include_wearables() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_include_wearables() const {
  return _internal_has_include_wearables();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::clear_include_wearables() {
  _impl_.include_wearables_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_include_wearables() const {
  return _impl_.include_wearables_;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::include_wearables() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.include_wearables)
  return _internal_include_wearables();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::_internal_set_include_wearables(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.include_wearables_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_include_wearables(bool value) {
  _internal_set_include_wearables(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleEnt.include_wearables)
}

// optional .CMsgVector offset_position = 7;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_offset_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.offset_position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_offset_position() const {
  return _internal_has_offset_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleEnt::_internal_offset_position() const {
  const ::CMsgVector* p = _impl_.offset_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateParticleEnt::offset_position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.offset_position)
  return _internal_offset_position();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_set_allocated_offset_position(
    ::CMsgVector* offset_position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.offset_position_);
  }
  _impl_.offset_position_ = offset_position;
  if (offset_position) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.offset_position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::release_offset_position() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.offset_position_;
  _impl_.offset_position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_release_offset_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleEnt.offset_position)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.offset_position_;
  _impl_.offset_position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::_internal_mutable_offset_position() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.offset_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.offset_position_ = p;
  }
  return _impl_.offset_position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateParticleEnt::mutable_offset_position() {
  ::CMsgVector* _msg = _internal_mutable_offset_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleEnt.offset_position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_allocated_offset_position(::CMsgVector* offset_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.offset_position_);
  }
  if (offset_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(offset_position));
    if (message_arena != submessage_arena) {
      offset_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, offset_position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.offset_position_ = offset_position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.offset_position)
}

// optional .CMsgQAngle offset_angles = 8;
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::_internal_has_offset_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.offset_angles_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleEnt::has_offset_angles() const {
  return _internal_has_offset_angles();
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_UpdateParticleEnt::_internal_offset_angles() const {
  const ::CMsgQAngle* p = _impl_.offset_angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_UpdateParticleEnt::offset_angles() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleEnt.offset_angles)
  return _internal_offset_angles();
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_set_allocated_offset_angles(
    ::CMsgQAngle* offset_angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.offset_angles_);
  }
  _impl_.offset_angles_ = offset_angles;
  if (offset_angles) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.offset_angles)
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleEnt::release_offset_angles() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.offset_angles_;
  _impl_.offset_angles_ = 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 ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleEnt::unsafe_arena_release_offset_angles() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateParticleEnt.offset_angles)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.offset_angles_;
  _impl_.offset_angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleEnt::_internal_mutable_offset_angles() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.offset_angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.offset_angles_ = p;
  }
  return _impl_.offset_angles_;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_UpdateParticleEnt::mutable_offset_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_offset_angles();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateParticleEnt.offset_angles)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateParticleEnt::set_allocated_offset_angles(::CMsgQAngle* offset_angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.offset_angles_);
  }
  if (offset_angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(offset_angles));
    if (message_arena != submessage_arena) {
      offset_angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, offset_angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.offset_angles_ = offset_angles;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateParticleEnt.offset_angles)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleSetFrozen

// optional bool set_frozen = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_has_set_frozen() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::has_set_frozen() const {
  return _internal_has_set_frozen();
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::clear_set_frozen() {
  _impl_.set_frozen_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_set_frozen() const {
  return _impl_.set_frozen_;
}
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::set_frozen() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleSetFrozen.set_frozen)
  return _internal_set_frozen();
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_set_set_frozen(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.set_frozen_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::set_set_frozen(bool value) {
  _internal_set_set_frozen(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleSetFrozen.set_frozen)
}

// optional float transition_duration = 2;
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_has_transition_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleSetFrozen::has_transition_duration() const {
  return _internal_has_transition_duration();
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::clear_transition_duration() {
  _impl_.transition_duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_transition_duration() const {
  return _impl_.transition_duration_;
}
inline float CUserMsg_ParticleManager_UpdateParticleSetFrozen::transition_duration() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleSetFrozen.transition_duration)
  return _internal_transition_duration();
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::_internal_set_transition_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.transition_duration_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleSetFrozen::set_transition_duration(float value) {
  _internal_set_transition_duration(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleSetFrozen.transition_duration)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateParticleShouldDraw

// optional bool should_draw = 1;
inline bool CUserMsg_ParticleManager_UpdateParticleShouldDraw::_internal_has_should_draw() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateParticleShouldDraw::has_should_draw() const {
  return _internal_has_should_draw();
}
inline void CUserMsg_ParticleManager_UpdateParticleShouldDraw::clear_should_draw() {
  _impl_.should_draw_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_UpdateParticleShouldDraw::_internal_should_draw() const {
  return _impl_.should_draw_;
}
inline bool CUserMsg_ParticleManager_UpdateParticleShouldDraw::should_draw() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateParticleShouldDraw.should_draw)
  return _internal_should_draw();
}
inline void CUserMsg_ParticleManager_UpdateParticleShouldDraw::_internal_set_should_draw(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.should_draw_ = value;
}
inline void CUserMsg_ParticleManager_UpdateParticleShouldDraw::set_should_draw(bool value) {
  _internal_set_should_draw(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateParticleShouldDraw.should_draw)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ChangeControlPointAttachment

// optional int32 attachment_old = 1;
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_has_attachment_old() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::has_attachment_old() const {
  return _internal_has_attachment_old();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::clear_attachment_old() {
  _impl_.attachment_old_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_attachment_old() const {
  return _impl_.attachment_old_;
}
inline int32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::attachment_old() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ChangeControlPointAttachment.attachment_old)
  return _internal_attachment_old();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_set_attachment_old(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.attachment_old_ = value;
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::set_attachment_old(int32_t value) {
  _internal_set_attachment_old(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ChangeControlPointAttachment.attachment_old)
}

// optional int32 attachment_new = 2;
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_has_attachment_new() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::has_attachment_new() const {
  return _internal_has_attachment_new();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::clear_attachment_new() {
  _impl_.attachment_new_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_attachment_new() const {
  return _impl_.attachment_new_;
}
inline int32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::attachment_new() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ChangeControlPointAttachment.attachment_new)
  return _internal_attachment_new();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_set_attachment_new(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.attachment_new_ = value;
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::set_attachment_new(int32_t value) {
  _internal_set_attachment_new(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ChangeControlPointAttachment.attachment_new)
}

// optional uint32 entity_handle = 3 [default = 16777215];
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ChangeControlPointAttachment::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_ChangeControlPointAttachment::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ChangeControlPointAttachment.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_ChangeControlPointAttachment::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ChangeControlPointAttachment.entity_handle)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateEntityPosition

// optional uint32 entity_handle = 1 [default = 16777215];
inline bool CUserMsg_ParticleManager_UpdateEntityPosition::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateEntityPosition::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_UpdateEntityPosition::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMsg_ParticleManager_UpdateEntityPosition::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_UpdateEntityPosition::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateEntityPosition.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_UpdateEntityPosition::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_UpdateEntityPosition::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateEntityPosition.entity_handle)
}

// optional .CMsgVector position = 2;
inline bool CUserMsg_ParticleManager_UpdateEntityPosition::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateEntityPosition::has_position() const {
  return _internal_has_position();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateEntityPosition::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateEntityPosition::position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateEntityPosition.position)
  return _internal_position();
}
inline void CUserMsg_ParticleManager_UpdateEntityPosition::unsafe_arena_set_allocated_position(
    ::CMsgVector* position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  _impl_.position_ = position;
  if (position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateEntityPosition.position)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateEntityPosition::release_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateEntityPosition::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateEntityPosition.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateEntityPosition::_internal_mutable_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.position_ = p;
  }
  return _impl_.position_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateEntityPosition::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateEntityPosition.position)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateEntityPosition::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position));
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.position_ = position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateEntityPosition.position)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleFoWProperties

// optional int32 fow_control_point = 1;
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_has_fow_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::has_fow_control_point() const {
  return _internal_has_fow_control_point();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::clear_fow_control_point() {
  _impl_.fow_control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_fow_control_point() const {
  return _impl_.fow_control_point_;
}
inline int32_t CUserMsg_ParticleManager_SetParticleFoWProperties::fow_control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_control_point)
  return _internal_fow_control_point();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_set_fow_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.fow_control_point_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::set_fow_control_point(int32_t value) {
  _internal_set_fow_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_control_point)
}

// optional int32 fow_control_point2 = 2;
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_has_fow_control_point2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::has_fow_control_point2() const {
  return _internal_has_fow_control_point2();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::clear_fow_control_point2() {
  _impl_.fow_control_point2_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_fow_control_point2() const {
  return _impl_.fow_control_point2_;
}
inline int32_t CUserMsg_ParticleManager_SetParticleFoWProperties::fow_control_point2() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_control_point2)
  return _internal_fow_control_point2();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_set_fow_control_point2(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.fow_control_point2_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::set_fow_control_point2(int32_t value) {
  _internal_set_fow_control_point2(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_control_point2)
}

// optional float fow_radius = 3;
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_has_fow_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleFoWProperties::has_fow_radius() const {
  return _internal_has_fow_radius();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::clear_fow_radius() {
  _impl_.fow_radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_fow_radius() const {
  return _impl_.fow_radius_;
}
inline float CUserMsg_ParticleManager_SetParticleFoWProperties::fow_radius() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_radius)
  return _internal_fow_radius();
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::_internal_set_fow_radius(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fow_radius_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleFoWProperties::set_fow_radius(float value) {
  _internal_set_fow_radius(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleFoWProperties.fow_radius)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleShouldCheckFoW

// optional bool check_fow = 1;
inline bool CUserMsg_ParticleManager_SetParticleShouldCheckFoW::_internal_has_check_fow() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleShouldCheckFoW::has_check_fow() const {
  return _internal_has_check_fow();
}
inline void CUserMsg_ParticleManager_SetParticleShouldCheckFoW::clear_check_fow() {
  _impl_.check_fow_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_SetParticleShouldCheckFoW::_internal_check_fow() const {
  return _impl_.check_fow_;
}
inline bool CUserMsg_ParticleManager_SetParticleShouldCheckFoW::check_fow() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleShouldCheckFoW.check_fow)
  return _internal_check_fow();
}
inline void CUserMsg_ParticleManager_SetParticleShouldCheckFoW::_internal_set_check_fow(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.check_fow_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleShouldCheckFoW::set_check_fow(bool value) {
  _internal_set_check_fow(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleShouldCheckFoW.check_fow)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetControlPointModel

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_SetControlPointModel::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetControlPointModel::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_SetControlPointModel::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_SetControlPointModel::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_SetControlPointModel::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetControlPointModel.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_SetControlPointModel::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_SetControlPointModel::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetControlPointModel.control_point)
}

// optional string model_name = 2;
inline bool CUserMsg_ParticleManager_SetControlPointModel::_internal_has_model_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetControlPointModel::has_model_name() const {
  return _internal_has_model_name();
}
inline void CUserMsg_ParticleManager_SetControlPointModel::clear_model_name() {
  _impl_.model_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetControlPointModel::model_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetControlPointModel.model_name)
  return _internal_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetControlPointModel::set_model_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.model_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetControlPointModel.model_name)
}
inline std::string* CUserMsg_ParticleManager_SetControlPointModel::mutable_model_name() {
  std::string* _s = _internal_mutable_model_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetControlPointModel.model_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetControlPointModel::_internal_model_name() const {
  return _impl_.model_name_.Get();
}
inline void CUserMsg_ParticleManager_SetControlPointModel::_internal_set_model_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.model_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetControlPointModel::_internal_mutable_model_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.model_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetControlPointModel::release_model_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetControlPointModel.model_name)
  if (!_internal_has_model_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.model_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetControlPointModel::set_allocated_model_name(std::string* model_name) {
  if (model_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.model_name_.SetAllocated(model_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetControlPointModel.model_name)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetControlPointSnapshot

// optional int32 control_point = 1;
inline bool CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_has_control_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetControlPointSnapshot::has_control_point() const {
  return _internal_has_control_point();
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::clear_control_point() {
  _impl_.control_point_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_control_point() const {
  return _impl_.control_point_;
}
inline int32_t CUserMsg_ParticleManager_SetControlPointSnapshot::control_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetControlPointSnapshot.control_point)
  return _internal_control_point();
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_set_control_point(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.control_point_ = value;
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::set_control_point(int32_t value) {
  _internal_set_control_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetControlPointSnapshot.control_point)
}

// optional string snapshot_name = 2;
inline bool CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_has_snapshot_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetControlPointSnapshot::has_snapshot_name() const {
  return _internal_has_snapshot_name();
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::clear_snapshot_name() {
  _impl_.snapshot_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetControlPointSnapshot::snapshot_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetControlPointSnapshot.snapshot_name)
  return _internal_snapshot_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetControlPointSnapshot::set_snapshot_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.snapshot_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetControlPointSnapshot.snapshot_name)
}
inline std::string* CUserMsg_ParticleManager_SetControlPointSnapshot::mutable_snapshot_name() {
  std::string* _s = _internal_mutable_snapshot_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetControlPointSnapshot.snapshot_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_snapshot_name() const {
  return _impl_.snapshot_name_.Get();
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_set_snapshot_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.snapshot_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetControlPointSnapshot::_internal_mutable_snapshot_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.snapshot_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetControlPointSnapshot::release_snapshot_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetControlPointSnapshot.snapshot_name)
  if (!_internal_has_snapshot_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.snapshot_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshot_name_.IsDefault()) {
    _impl_.snapshot_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetControlPointSnapshot::set_allocated_snapshot_name(std::string* snapshot_name) {
  if (snapshot_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.snapshot_name_.SetAllocated(snapshot_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshot_name_.IsDefault()) {
    _impl_.snapshot_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetControlPointSnapshot.snapshot_name)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleText

// optional string text = 1;
inline bool CUserMsg_ParticleManager_SetParticleText::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleText::has_text() const {
  return _internal_has_text();
}
inline void CUserMsg_ParticleManager_SetParticleText::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetParticleText::text() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleText.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetParticleText::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleText.text)
}
inline std::string* CUserMsg_ParticleManager_SetParticleText::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleText.text)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetParticleText::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CUserMsg_ParticleManager_SetParticleText::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetParticleText::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetParticleText::release_text() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetParticleText.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetParticleText::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetParticleText.text)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetTextureAttribute

// optional string attribute_name = 1;
inline bool CUserMsg_ParticleManager_SetTextureAttribute::_internal_has_attribute_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetTextureAttribute::has_attribute_name() const {
  return _internal_has_attribute_name();
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::clear_attribute_name() {
  _impl_.attribute_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetTextureAttribute::attribute_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetTextureAttribute.attribute_name)
  return _internal_attribute_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetTextureAttribute::set_attribute_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.attribute_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetTextureAttribute.attribute_name)
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::mutable_attribute_name() {
  std::string* _s = _internal_mutable_attribute_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetTextureAttribute.attribute_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetTextureAttribute::_internal_attribute_name() const {
  return _impl_.attribute_name_.Get();
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::_internal_set_attribute_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.attribute_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::_internal_mutable_attribute_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.attribute_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::release_attribute_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetTextureAttribute.attribute_name)
  if (!_internal_has_attribute_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.attribute_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attribute_name_.IsDefault()) {
    _impl_.attribute_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::set_allocated_attribute_name(std::string* attribute_name) {
  if (attribute_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.attribute_name_.SetAllocated(attribute_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attribute_name_.IsDefault()) {
    _impl_.attribute_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetTextureAttribute.attribute_name)
}

// optional string texture_name = 2;
inline bool CUserMsg_ParticleManager_SetTextureAttribute::_internal_has_texture_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetTextureAttribute::has_texture_name() const {
  return _internal_has_texture_name();
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::clear_texture_name() {
  _impl_.texture_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMsg_ParticleManager_SetTextureAttribute::texture_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetTextureAttribute.texture_name)
  return _internal_texture_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetTextureAttribute::set_texture_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.texture_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetTextureAttribute.texture_name)
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::mutable_texture_name() {
  std::string* _s = _internal_mutable_texture_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetTextureAttribute.texture_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetTextureAttribute::_internal_texture_name() const {
  return _impl_.texture_name_.Get();
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::_internal_set_texture_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.texture_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::_internal_mutable_texture_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.texture_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetTextureAttribute::release_texture_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetTextureAttribute.texture_name)
  if (!_internal_has_texture_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.texture_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.texture_name_.IsDefault()) {
    _impl_.texture_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetTextureAttribute::set_allocated_texture_name(std::string* texture_name) {
  if (texture_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.texture_name_.SetAllocated(texture_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.texture_name_.IsDefault()) {
    _impl_.texture_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetTextureAttribute.texture_name)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetSceneObjectGenericFlag

// optional bool flag_value = 1;
inline bool CUserMsg_ParticleManager_SetSceneObjectGenericFlag::_internal_has_flag_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetSceneObjectGenericFlag::has_flag_value() const {
  return _internal_has_flag_value();
}
inline void CUserMsg_ParticleManager_SetSceneObjectGenericFlag::clear_flag_value() {
  _impl_.flag_value_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_SetSceneObjectGenericFlag::_internal_flag_value() const {
  return _impl_.flag_value_;
}
inline bool CUserMsg_ParticleManager_SetSceneObjectGenericFlag::flag_value() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetSceneObjectGenericFlag.flag_value)
  return _internal_flag_value();
}
inline void CUserMsg_ParticleManager_SetSceneObjectGenericFlag::_internal_set_flag_value(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.flag_value_ = value;
}
inline void CUserMsg_ParticleManager_SetSceneObjectGenericFlag::set_flag_value(bool value) {
  _internal_set_flag_value(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetSceneObjectGenericFlag.flag_value)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetSceneObjectTintAndDesat

// optional fixed32 tint = 1;
inline bool CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_has_tint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::has_tint() const {
  return _internal_has_tint();
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::clear_tint() {
  _impl_.tint_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_tint() const {
  return _impl_.tint_;
}
inline uint32_t CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::tint() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetSceneObjectTintAndDesat.tint)
  return _internal_tint();
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_set_tint(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.tint_ = value;
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::set_tint(uint32_t value) {
  _internal_set_tint(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetSceneObjectTintAndDesat.tint)
}

// optional float desat = 2;
inline bool CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_has_desat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::has_desat() const {
  return _internal_has_desat();
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::clear_desat() {
  _impl_.desat_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_desat() const {
  return _impl_.desat_;
}
inline float CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::desat() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetSceneObjectTintAndDesat.desat)
  return _internal_desat();
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::_internal_set_desat(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.desat_ = value;
}
inline void CUserMsg_ParticleManager_SetSceneObjectTintAndDesat::set_desat(float value) {
  _internal_set_desat(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetSceneObjectTintAndDesat.desat)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ParticleSkipToTime

// optional float skip_to_time = 1;
inline bool CUserMsg_ParticleManager_ParticleSkipToTime::_internal_has_skip_to_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ParticleSkipToTime::has_skip_to_time() const {
  return _internal_has_skip_to_time();
}
inline void CUserMsg_ParticleManager_ParticleSkipToTime::clear_skip_to_time() {
  _impl_.skip_to_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMsg_ParticleManager_ParticleSkipToTime::_internal_skip_to_time() const {
  return _impl_.skip_to_time_;
}
inline float CUserMsg_ParticleManager_ParticleSkipToTime::skip_to_time() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ParticleSkipToTime.skip_to_time)
  return _internal_skip_to_time();
}
inline void CUserMsg_ParticleManager_ParticleSkipToTime::_internal_set_skip_to_time(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.skip_to_time_ = value;
}
inline void CUserMsg_ParticleManager_ParticleSkipToTime::set_skip_to_time(float value) {
  _internal_set_skip_to_time(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ParticleSkipToTime.skip_to_time)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ParticleCanFreeze

// optional bool can_freeze = 1;
inline bool CUserMsg_ParticleManager_ParticleCanFreeze::_internal_has_can_freeze() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ParticleCanFreeze::has_can_freeze() const {
  return _internal_has_can_freeze();
}
inline void CUserMsg_ParticleManager_ParticleCanFreeze::clear_can_freeze() {
  _impl_.can_freeze_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_ParticleCanFreeze::_internal_can_freeze() const {
  return _impl_.can_freeze_;
}
inline bool CUserMsg_ParticleManager_ParticleCanFreeze::can_freeze() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ParticleCanFreeze.can_freeze)
  return _internal_can_freeze();
}
inline void CUserMsg_ParticleManager_ParticleCanFreeze::_internal_set_can_freeze(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.can_freeze_ = value;
}
inline void CUserMsg_ParticleManager_ParticleCanFreeze::set_can_freeze(bool value) {
  _internal_set_can_freeze(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ParticleCanFreeze.can_freeze)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ParticleFreezeTransitionOverride

// optional float freeze_transition_override = 1;
inline bool CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::_internal_has_freeze_transition_override() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::has_freeze_transition_override() const {
  return _internal_has_freeze_transition_override();
}
inline void CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::clear_freeze_transition_override() {
  _impl_.freeze_transition_override_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::_internal_freeze_transition_override() const {
  return _impl_.freeze_transition_override_;
}
inline float CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::freeze_transition_override() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ParticleFreezeTransitionOverride.freeze_transition_override)
  return _internal_freeze_transition_override();
}
inline void CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::_internal_set_freeze_transition_override(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.freeze_transition_override_ = value;
}
inline void CUserMsg_ParticleManager_ParticleFreezeTransitionOverride::set_freeze_transition_override(float value) {
  _internal_set_freeze_transition_override(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ParticleFreezeTransitionOverride.freeze_transition_override)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_FreezeParticleInvolving

// optional bool set_frozen = 1;
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_has_set_frozen() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::has_set_frozen() const {
  return _internal_has_set_frozen();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::clear_set_frozen() {
  _impl_.set_frozen_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_set_frozen() const {
  return _impl_.set_frozen_;
}
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::set_frozen() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.FreezeParticleInvolving.set_frozen)
  return _internal_set_frozen();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_set_set_frozen(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.set_frozen_ = value;
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::set_set_frozen(bool value) {
  _internal_set_set_frozen(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.FreezeParticleInvolving.set_frozen)
}

// optional float transition_duration = 2;
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_has_transition_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::has_transition_duration() const {
  return _internal_has_transition_duration();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::clear_transition_duration() {
  _impl_.transition_duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_transition_duration() const {
  return _impl_.transition_duration_;
}
inline float CUserMsg_ParticleManager_FreezeParticleInvolving::transition_duration() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.FreezeParticleInvolving.transition_duration)
  return _internal_transition_duration();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_set_transition_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.transition_duration_ = value;
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::set_transition_duration(float value) {
  _internal_set_transition_duration(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.FreezeParticleInvolving.transition_duration)
}

// optional uint32 entity_handle = 3 [default = 16777215];
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_FreezeParticleInvolving::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_FreezeParticleInvolving::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.FreezeParticleInvolving.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_FreezeParticleInvolving::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.FreezeParticleInvolving.entity_handle)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_AddModellistOverrideElement

// optional string model_name = 1;
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_has_model_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::has_model_name() const {
  return _internal_has_model_name();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::clear_model_name() {
  _impl_.model_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_AddModellistOverrideElement::model_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddModellistOverrideElement.model_name)
  return _internal_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_AddModellistOverrideElement::set_model_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.model_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddModellistOverrideElement.model_name)
}
inline std::string* CUserMsg_ParticleManager_AddModellistOverrideElement::mutable_model_name() {
  std::string* _s = _internal_mutable_model_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddModellistOverrideElement.model_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_model_name() const {
  return _impl_.model_name_.Get();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_set_model_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.model_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_mutable_model_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.model_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddModellistOverrideElement::release_model_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddModellistOverrideElement.model_name)
  if (!_internal_has_model_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.model_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::set_allocated_model_name(std::string* model_name) {
  if (model_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.model_name_.SetAllocated(model_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.model_name_.IsDefault()) {
    _impl_.model_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddModellistOverrideElement.model_name)
}

// optional float spawn_probability = 2;
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_has_spawn_probability() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::has_spawn_probability() const {
  return _internal_has_spawn_probability();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::clear_spawn_probability() {
  _impl_.spawn_probability_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_spawn_probability() const {
  return _impl_.spawn_probability_;
}
inline float CUserMsg_ParticleManager_AddModellistOverrideElement::spawn_probability() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddModellistOverrideElement.spawn_probability)
  return _internal_spawn_probability();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_set_spawn_probability(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.spawn_probability_ = value;
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::set_spawn_probability(float value) {
  _internal_set_spawn_probability(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddModellistOverrideElement.spawn_probability)
}

// optional uint32 groupid = 3;
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_has_groupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddModellistOverrideElement::has_groupid() const {
  return _internal_has_groupid();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::clear_groupid() {
  _impl_.groupid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_groupid() const {
  return _impl_.groupid_;
}
inline uint32_t CUserMsg_ParticleManager_AddModellistOverrideElement::groupid() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddModellistOverrideElement.groupid)
  return _internal_groupid();
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::_internal_set_groupid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.groupid_ = value;
}
inline void CUserMsg_ParticleManager_AddModellistOverrideElement::set_groupid(uint32_t value) {
  _internal_set_groupid(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddModellistOverrideElement.groupid)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_ClearModellistOverride

// optional uint32 groupid = 1;
inline bool CUserMsg_ParticleManager_ClearModellistOverride::_internal_has_groupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_ClearModellistOverride::has_groupid() const {
  return _internal_has_groupid();
}
inline void CUserMsg_ParticleManager_ClearModellistOverride::clear_groupid() {
  _impl_.groupid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMsg_ParticleManager_ClearModellistOverride::_internal_groupid() const {
  return _impl_.groupid_;
}
inline uint32_t CUserMsg_ParticleManager_ClearModellistOverride::groupid() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.ClearModellistOverride.groupid)
  return _internal_groupid();
}
inline void CUserMsg_ParticleManager_ClearModellistOverride::_internal_set_groupid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupid_ = value;
}
inline void CUserMsg_ParticleManager_ClearModellistOverride::set_groupid(uint32_t value) {
  _internal_set_groupid(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.ClearModellistOverride.groupid)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue

// optional uint32 value_name_hash = 1;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_has_value_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::has_value_name_hash() const {
  return _internal_has_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::clear_value_name_hash() {
  _impl_.value_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_value_name_hash() const {
  return _impl_.value_name_hash_;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::value_name_hash() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue.value_name_hash)
  return _internal_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_set_value_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_name_hash_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::set_value_name_hash(uint32_t value) {
  _internal_set_value_name_hash(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue.value_name_hash)
}

// optional float value = 2;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::has_value() const {
  return _internal_has_value();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::clear_value() {
  _impl_.value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_value() const {
  return _impl_.value_;
}
inline float CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::value() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue.value)
  return _internal_value();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::_internal_set_value(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue::set_value(float value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue.value)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue

// optional uint32 value_name_hash = 1;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_has_value_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::has_value_name_hash() const {
  return _internal_has_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::clear_value_name_hash() {
  _impl_.value_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_value_name_hash() const {
  return _impl_.value_name_hash_;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::value_name_hash() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value_name_hash)
  return _internal_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_set_value_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_name_hash_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::set_value_name_hash(uint32_t value) {
  _internal_set_value_name_hash(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value_name_hash)
}

// optional .CMsgVector value = 2;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::has_value() const {
  return _internal_has_value();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_value() const {
  const ::CMsgVector* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::value() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value)
  return _internal_value();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::unsafe_arena_set_allocated_value(
    ::CMsgVector* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value)
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::release_value() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.value_;
  _impl_.value_ = 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 ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::mutable_value() {
  ::CMsgVector* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value)
  return _msg;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue::set_allocated_value(::CMsgVector* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue.value)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue

// optional uint32 value_name_hash = 1;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_has_value_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::has_value_name_hash() const {
  return _internal_has_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::clear_value_name_hash() {
  _impl_.value_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_value_name_hash() const {
  return _impl_.value_name_hash_;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::value_name_hash() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.value_name_hash)
  return _internal_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_set_value_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.value_name_hash_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::set_value_name_hash(uint32_t value) {
  _internal_set_value_name_hash(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.value_name_hash)
}

// optional .CMsgQAngle angles = 2;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_has_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angles_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::has_angles() const {
  return _internal_has_angles();
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_angles() const {
  const ::CMsgQAngle* p = _impl_.angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::angles() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.angles)
  return _internal_angles();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::unsafe_arena_set_allocated_angles(
    ::CMsgQAngle* angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  _impl_.angles_ = angles;
  if (angles) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.angles)
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::release_angles() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = 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 ::CMsgQAngle* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::unsafe_arena_release_angles() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.angles)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_mutable_angles() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angles_ = p;
  }
  return _impl_.angles_;
}
inline ::CMsgQAngle* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::mutable_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_angles();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.angles)
  return _msg;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::set_allocated_angles(::CMsgQAngle* angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  if (angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles));
    if (message_arena != submessage_arena) {
      angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.angles_ = angles;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.angles)
}

// optional .CMsgVector translation = 3;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_has_translation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.translation_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::has_translation() const {
  return _internal_has_translation();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_translation() const {
  const ::CMsgVector* p = _impl_.translation_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::translation() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.translation)
  return _internal_translation();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::unsafe_arena_set_allocated_translation(
    ::CMsgVector* translation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.translation_);
  }
  _impl_.translation_ = translation;
  if (translation) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.translation)
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::release_translation() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.translation_;
  _impl_.translation_ = 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 ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::unsafe_arena_release_translation() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.translation)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.translation_;
  _impl_.translation_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::_internal_mutable_translation() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.translation_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.translation_ = p;
  }
  return _impl_.translation_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::mutable_translation() {
  ::CMsgVector* _msg = _internal_mutable_translation();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.translation)
  return _msg;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue::set_allocated_translation(::CMsgVector* translation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.translation_);
  }
  if (translation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(translation));
    if (message_arena != submessage_arena) {
      translation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, translation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.translation_ = translation;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue.translation)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext

// optional uint32 value_name_hash = 1;
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_has_value_name_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::has_value_name_hash() const {
  return _internal_has_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::clear_value_name_hash() {
  _impl_.value_name_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_value_name_hash() const {
  return _impl_.value_name_hash_;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::value_name_hash() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext.value_name_hash)
  return _internal_value_name_hash();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_set_value_name_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_name_hash_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::set_value_name_hash(uint32_t value) {
  _internal_set_value_name_hash(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext.value_name_hash)
}

// optional uint32 ent_index = 2 [default = 16777215];
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::clear_ent_index() {
  _impl_.ent_index_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline uint32_t CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext.ent_index)
  return _internal_ent_index();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::_internal_set_ent_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ent_index_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext::set_ent_index(uint32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext.ent_index)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleNamedValueContext

// repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.FloatContextValue float_values = 1;
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_float_values_size() const {
  return _impl_.float_values_.size();
}
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::float_values_size() const {
  return _internal_float_values_size();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext::clear_float_values() {
  _impl_.float_values_.Clear();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_float_values(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.float_values)
  return _impl_.float_values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue >*
CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_float_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.float_values)
  return &_impl_.float_values_;
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_float_values(int index) const {
  return _impl_.float_values_.Get(index);
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::float_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.float_values)
  return _internal_float_values(index);
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_add_float_values() {
  return _impl_.float_values_.Add();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::add_float_values() {
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue* _add = _internal_add_float_values();
  // @@protoc_insertion_point(field_add:CUserMsg_ParticleManager.SetParticleNamedValueContext.float_values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_FloatContextValue >&
CUserMsg_ParticleManager_SetParticleNamedValueContext::float_values() const {
  // @@protoc_insertion_point(field_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.float_values)
  return _impl_.float_values_;
}

// repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.VectorContextValue vector_values = 2;
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_vector_values_size() const {
  return _impl_.vector_values_.size();
}
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::vector_values_size() const {
  return _internal_vector_values_size();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext::clear_vector_values() {
  _impl_.vector_values_.Clear();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_vector_values(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.vector_values)
  return _impl_.vector_values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue >*
CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_vector_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.vector_values)
  return &_impl_.vector_values_;
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_vector_values(int index) const {
  return _impl_.vector_values_.Get(index);
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::vector_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.vector_values)
  return _internal_vector_values(index);
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_add_vector_values() {
  return _impl_.vector_values_.Add();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::add_vector_values() {
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue* _add = _internal_add_vector_values();
  // @@protoc_insertion_point(field_add:CUserMsg_ParticleManager.SetParticleNamedValueContext.vector_values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_VectorContextValue >&
CUserMsg_ParticleManager_SetParticleNamedValueContext::vector_values() const {
  // @@protoc_insertion_point(field_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.vector_values)
  return _impl_.vector_values_;
}

// repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.TransformContextValue transform_values = 3;
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_transform_values_size() const {
  return _impl_.transform_values_.size();
}
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::transform_values_size() const {
  return _internal_transform_values_size();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext::clear_transform_values() {
  _impl_.transform_values_.Clear();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_transform_values(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.transform_values)
  return _impl_.transform_values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue >*
CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_transform_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.transform_values)
  return &_impl_.transform_values_;
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_transform_values(int index) const {
  return _impl_.transform_values_.Get(index);
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue& CUserMsg_ParticleManager_SetParticleNamedValueContext::transform_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.transform_values)
  return _internal_transform_values(index);
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_add_transform_values() {
  return _impl_.transform_values_.Add();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* CUserMsg_ParticleManager_SetParticleNamedValueContext::add_transform_values() {
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue* _add = _internal_add_transform_values();
  // @@protoc_insertion_point(field_add:CUserMsg_ParticleManager.SetParticleNamedValueContext.transform_values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_TransformContextValue >&
CUserMsg_ParticleManager_SetParticleNamedValueContext::transform_values() const {
  // @@protoc_insertion_point(field_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.transform_values)
  return _impl_.transform_values_;
}

// repeated .CUserMsg_ParticleManager.SetParticleNamedValueContext.EHandleContext ehandle_values = 4;
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_ehandle_values_size() const {
  return _impl_.ehandle_values_.size();
}
inline int CUserMsg_ParticleManager_SetParticleNamedValueContext::ehandle_values_size() const {
  return _internal_ehandle_values_size();
}
inline void CUserMsg_ParticleManager_SetParticleNamedValueContext::clear_ehandle_values() {
  _impl_.ehandle_values_.Clear();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_ehandle_values(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleNamedValueContext.ehandle_values)
  return _impl_.ehandle_values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext >*
CUserMsg_ParticleManager_SetParticleNamedValueContext::mutable_ehandle_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.ehandle_values)
  return &_impl_.ehandle_values_;
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_ehandle_values(int index) const {
  return _impl_.ehandle_values_.Get(index);
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext& CUserMsg_ParticleManager_SetParticleNamedValueContext::ehandle_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleNamedValueContext.ehandle_values)
  return _internal_ehandle_values(index);
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* CUserMsg_ParticleManager_SetParticleNamedValueContext::_internal_add_ehandle_values() {
  return _impl_.ehandle_values_.Add();
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* CUserMsg_ParticleManager_SetParticleNamedValueContext::add_ehandle_values() {
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext* _add = _internal_add_ehandle_values();
  // @@protoc_insertion_point(field_add:CUserMsg_ParticleManager.SetParticleNamedValueContext.ehandle_values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMsg_ParticleManager_SetParticleNamedValueContext_EHandleContext >&
CUserMsg_ParticleManager_SetParticleNamedValueContext::ehandle_values() const {
  // @@protoc_insertion_point(field_list:CUserMsg_ParticleManager.SetParticleNamedValueContext.ehandle_values)
  return _impl_.ehandle_values_;
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_CreatePhysicsSim

// optional string prop_group_name = 1;
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::_internal_has_prop_group_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::has_prop_group_name() const {
  return _internal_has_prop_group_name();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::clear_prop_group_name() {
  _impl_.prop_group_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_CreatePhysicsSim::prop_group_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreatePhysicsSim.prop_group_name)
  return _internal_prop_group_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_CreatePhysicsSim::set_prop_group_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.prop_group_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreatePhysicsSim.prop_group_name)
}
inline std::string* CUserMsg_ParticleManager_CreatePhysicsSim::mutable_prop_group_name() {
  std::string* _s = _internal_mutable_prop_group_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.CreatePhysicsSim.prop_group_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_CreatePhysicsSim::_internal_prop_group_name() const {
  return _impl_.prop_group_name_.Get();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::_internal_set_prop_group_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.prop_group_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_CreatePhysicsSim::_internal_mutable_prop_group_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.prop_group_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_CreatePhysicsSim::release_prop_group_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.CreatePhysicsSim.prop_group_name)
  if (!_internal_has_prop_group_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.prop_group_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prop_group_name_.IsDefault()) {
    _impl_.prop_group_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::set_allocated_prop_group_name(std::string* prop_group_name) {
  if (prop_group_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.prop_group_name_.SetAllocated(prop_group_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prop_group_name_.IsDefault()) {
    _impl_.prop_group_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.CreatePhysicsSim.prop_group_name)
}

// optional bool use_high_quality_simulation = 2;
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::_internal_has_use_high_quality_simulation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::has_use_high_quality_simulation() const {
  return _internal_has_use_high_quality_simulation();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::clear_use_high_quality_simulation() {
  _impl_.use_high_quality_simulation_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::_internal_use_high_quality_simulation() const {
  return _impl_.use_high_quality_simulation_;
}
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::use_high_quality_simulation() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreatePhysicsSim.use_high_quality_simulation)
  return _internal_use_high_quality_simulation();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::_internal_set_use_high_quality_simulation(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.use_high_quality_simulation_ = value;
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::set_use_high_quality_simulation(bool value) {
  _internal_set_use_high_quality_simulation(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreatePhysicsSim.use_high_quality_simulation)
}

// optional uint32 max_particle_count = 3;
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::_internal_has_max_particle_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_CreatePhysicsSim::has_max_particle_count() const {
  return _internal_has_max_particle_count();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::clear_max_particle_count() {
  _impl_.max_particle_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMsg_ParticleManager_CreatePhysicsSim::_internal_max_particle_count() const {
  return _impl_.max_particle_count_;
}
inline uint32_t CUserMsg_ParticleManager_CreatePhysicsSim::max_particle_count() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.CreatePhysicsSim.max_particle_count)
  return _internal_max_particle_count();
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::_internal_set_max_particle_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_particle_count_ = value;
}
inline void CUserMsg_ParticleManager_CreatePhysicsSim::set_max_particle_count(uint32_t value) {
  _internal_set_max_particle_count(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.CreatePhysicsSim.max_particle_count)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_DestroyPhysicsSim

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetVData

// optional string vdata_name = 1;
inline bool CUserMsg_ParticleManager_SetVData::_internal_has_vdata_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetVData::has_vdata_name() const {
  return _internal_has_vdata_name();
}
inline void CUserMsg_ParticleManager_SetVData::clear_vdata_name() {
  _impl_.vdata_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetVData::vdata_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetVData.vdata_name)
  return _internal_vdata_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetVData::set_vdata_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.vdata_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetVData.vdata_name)
}
inline std::string* CUserMsg_ParticleManager_SetVData::mutable_vdata_name() {
  std::string* _s = _internal_mutable_vdata_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetVData.vdata_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetVData::_internal_vdata_name() const {
  return _impl_.vdata_name_.Get();
}
inline void CUserMsg_ParticleManager_SetVData::_internal_set_vdata_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.vdata_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetVData::_internal_mutable_vdata_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.vdata_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetVData::release_vdata_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetVData.vdata_name)
  if (!_internal_has_vdata_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.vdata_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vdata_name_.IsDefault()) {
    _impl_.vdata_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetVData::set_allocated_vdata_name(std::string* vdata_name) {
  if (vdata_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.vdata_name_.SetAllocated(vdata_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vdata_name_.IsDefault()) {
    _impl_.vdata_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetVData.vdata_name)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetMaterialOverride

// optional string material_name = 1;
inline bool CUserMsg_ParticleManager_SetMaterialOverride::_internal_has_material_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetMaterialOverride::has_material_name() const {
  return _internal_has_material_name();
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::clear_material_name() {
  _impl_.material_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_SetMaterialOverride::material_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetMaterialOverride.material_name)
  return _internal_material_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_SetMaterialOverride::set_material_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.material_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetMaterialOverride.material_name)
}
inline std::string* CUserMsg_ParticleManager_SetMaterialOverride::mutable_material_name() {
  std::string* _s = _internal_mutable_material_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetMaterialOverride.material_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_SetMaterialOverride::_internal_material_name() const {
  return _impl_.material_name_.Get();
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::_internal_set_material_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.material_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetMaterialOverride::_internal_mutable_material_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.material_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_SetMaterialOverride::release_material_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetMaterialOverride.material_name)
  if (!_internal_has_material_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.material_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.material_name_.IsDefault()) {
    _impl_.material_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::set_allocated_material_name(std::string* material_name) {
  if (material_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.material_name_.SetAllocated(material_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.material_name_.IsDefault()) {
    _impl_.material_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetMaterialOverride.material_name)
}

// optional bool include_children = 2;
inline bool CUserMsg_ParticleManager_SetMaterialOverride::_internal_has_include_children() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetMaterialOverride::has_include_children() const {
  return _internal_has_include_children();
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::clear_include_children() {
  _impl_.include_children_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMsg_ParticleManager_SetMaterialOverride::_internal_include_children() const {
  return _impl_.include_children_;
}
inline bool CUserMsg_ParticleManager_SetMaterialOverride::include_children() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetMaterialOverride.include_children)
  return _internal_include_children();
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::_internal_set_include_children(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.include_children_ = value;
}
inline void CUserMsg_ParticleManager_SetMaterialOverride::set_include_children(bool value) {
  _internal_set_include_children(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetMaterialOverride.include_children)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_AddFan

// optional bool active = 1;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_active() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_active() const {
  return _internal_has_active();
}
inline void CUserMsg_ParticleManager_AddFan::clear_active() {
  _impl_.active_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool CUserMsg_ParticleManager_AddFan::_internal_active() const {
  return _impl_.active_;
}
inline bool CUserMsg_ParticleManager_AddFan::active() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.active)
  return _internal_active();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_active(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.active_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_active(bool value) {
  _internal_set_active(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.active)
}

// optional .CMsgVector bounds_mins = 2;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_bounds_mins() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bounds_mins_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_bounds_mins() const {
  return _internal_has_bounds_mins();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::_internal_bounds_mins() const {
  const ::CMsgVector* p = _impl_.bounds_mins_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::bounds_mins() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.bounds_mins)
  return _internal_bounds_mins();
}
inline void CUserMsg_ParticleManager_AddFan::unsafe_arena_set_allocated_bounds_mins(
    ::CMsgVector* bounds_mins) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_mins_);
  }
  _impl_.bounds_mins_ = bounds_mins;
  if (bounds_mins) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.AddFan.bounds_mins)
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::release_bounds_mins() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.bounds_mins_;
  _impl_.bounds_mins_ = 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 ::CMsgVector* CUserMsg_ParticleManager_AddFan::unsafe_arena_release_bounds_mins() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.bounds_mins)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.bounds_mins_;
  _impl_.bounds_mins_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::_internal_mutable_bounds_mins() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.bounds_mins_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.bounds_mins_ = p;
  }
  return _impl_.bounds_mins_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::mutable_bounds_mins() {
  ::CMsgVector* _msg = _internal_mutable_bounds_mins();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.bounds_mins)
  return _msg;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_bounds_mins(::CMsgVector* bounds_mins) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_mins_);
  }
  if (bounds_mins) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bounds_mins));
    if (message_arena != submessage_arena) {
      bounds_mins = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bounds_mins, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.bounds_mins_ = bounds_mins;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.bounds_mins)
}

// optional .CMsgVector bounds_maxs = 3;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_bounds_maxs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bounds_maxs_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_bounds_maxs() const {
  return _internal_has_bounds_maxs();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::_internal_bounds_maxs() const {
  const ::CMsgVector* p = _impl_.bounds_maxs_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::bounds_maxs() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.bounds_maxs)
  return _internal_bounds_maxs();
}
inline void CUserMsg_ParticleManager_AddFan::unsafe_arena_set_allocated_bounds_maxs(
    ::CMsgVector* bounds_maxs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_maxs_);
  }
  _impl_.bounds_maxs_ = bounds_maxs;
  if (bounds_maxs) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.AddFan.bounds_maxs)
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::release_bounds_maxs() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.bounds_maxs_;
  _impl_.bounds_maxs_ = 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 ::CMsgVector* CUserMsg_ParticleManager_AddFan::unsafe_arena_release_bounds_maxs() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.bounds_maxs)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.bounds_maxs_;
  _impl_.bounds_maxs_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::_internal_mutable_bounds_maxs() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.bounds_maxs_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.bounds_maxs_ = p;
  }
  return _impl_.bounds_maxs_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::mutable_bounds_maxs() {
  ::CMsgVector* _msg = _internal_mutable_bounds_maxs();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.bounds_maxs)
  return _msg;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_bounds_maxs(::CMsgVector* bounds_maxs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_maxs_);
  }
  if (bounds_maxs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bounds_maxs));
    if (message_arena != submessage_arena) {
      bounds_maxs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bounds_maxs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.bounds_maxs_ = bounds_maxs;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.bounds_maxs)
}

// optional .CMsgVector fan_origin = 4;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_fan_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_origin_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_fan_origin() const {
  return _internal_has_fan_origin();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::_internal_fan_origin() const {
  const ::CMsgVector* p = _impl_.fan_origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::fan_origin() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.fan_origin)
  return _internal_fan_origin();
}
inline void CUserMsg_ParticleManager_AddFan::unsafe_arena_set_allocated_fan_origin(
    ::CMsgVector* fan_origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_);
  }
  _impl_.fan_origin_ = fan_origin;
  if (fan_origin) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.AddFan.fan_origin)
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::release_fan_origin() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.fan_origin_;
  _impl_.fan_origin_ = 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 ::CMsgVector* CUserMsg_ParticleManager_AddFan::unsafe_arena_release_fan_origin() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.fan_origin)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.fan_origin_;
  _impl_.fan_origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::_internal_mutable_fan_origin() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.fan_origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_origin_ = p;
  }
  return _impl_.fan_origin_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::mutable_fan_origin() {
  ::CMsgVector* _msg = _internal_mutable_fan_origin();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.fan_origin)
  return _msg;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_fan_origin(::CMsgVector* fan_origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_);
  }
  if (fan_origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_origin));
    if (message_arena != submessage_arena) {
      fan_origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.fan_origin_ = fan_origin;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.fan_origin)
}

// optional .CMsgVector fan_origin_offset = 5;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_fan_origin_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_origin_offset_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_fan_origin_offset() const {
  return _internal_has_fan_origin_offset();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::_internal_fan_origin_offset() const {
  const ::CMsgVector* p = _impl_.fan_origin_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::fan_origin_offset() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.fan_origin_offset)
  return _internal_fan_origin_offset();
}
inline void CUserMsg_ParticleManager_AddFan::unsafe_arena_set_allocated_fan_origin_offset(
    ::CMsgVector* fan_origin_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_offset_);
  }
  _impl_.fan_origin_offset_ = fan_origin_offset;
  if (fan_origin_offset) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.AddFan.fan_origin_offset)
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::release_fan_origin_offset() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgVector* temp = _impl_.fan_origin_offset_;
  _impl_.fan_origin_offset_ = 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 ::CMsgVector* CUserMsg_ParticleManager_AddFan::unsafe_arena_release_fan_origin_offset() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.fan_origin_offset)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgVector* temp = _impl_.fan_origin_offset_;
  _impl_.fan_origin_offset_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::_internal_mutable_fan_origin_offset() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.fan_origin_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_origin_offset_ = p;
  }
  return _impl_.fan_origin_offset_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::mutable_fan_origin_offset() {
  ::CMsgVector* _msg = _internal_mutable_fan_origin_offset();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.fan_origin_offset)
  return _msg;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_fan_origin_offset(::CMsgVector* fan_origin_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_offset_);
  }
  if (fan_origin_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_origin_offset));
    if (message_arena != submessage_arena) {
      fan_origin_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_origin_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.fan_origin_offset_ = fan_origin_offset;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.fan_origin_offset)
}

// optional .CMsgVector fan_direction = 6;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_fan_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_direction_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_fan_direction() const {
  return _internal_has_fan_direction();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::_internal_fan_direction() const {
  const ::CMsgVector* p = _impl_.fan_direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_AddFan::fan_direction() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.fan_direction)
  return _internal_fan_direction();
}
inline void CUserMsg_ParticleManager_AddFan::unsafe_arena_set_allocated_fan_direction(
    ::CMsgVector* fan_direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_direction_);
  }
  _impl_.fan_direction_ = fan_direction;
  if (fan_direction) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.AddFan.fan_direction)
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::release_fan_direction() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgVector* temp = _impl_.fan_direction_;
  _impl_.fan_direction_ = 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 ::CMsgVector* CUserMsg_ParticleManager_AddFan::unsafe_arena_release_fan_direction() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.fan_direction)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgVector* temp = _impl_.fan_direction_;
  _impl_.fan_direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::_internal_mutable_fan_direction() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.fan_direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_direction_ = p;
  }
  return _impl_.fan_direction_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_AddFan::mutable_fan_direction() {
  ::CMsgVector* _msg = _internal_mutable_fan_direction();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.fan_direction)
  return _msg;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_fan_direction(::CMsgVector* fan_direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_direction_);
  }
  if (fan_direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_direction));
    if (message_arena != submessage_arena) {
      fan_direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.fan_direction_ = fan_direction;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.fan_direction)
}

// optional float force = 7;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_force() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_force() const {
  return _internal_has_force();
}
inline void CUserMsg_ParticleManager_AddFan::clear_force() {
  _impl_.force_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_force() const {
  return _impl_.force_;
}
inline float CUserMsg_ParticleManager_AddFan::force() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.force)
  return _internal_force();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_force(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.force_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_force(float value) {
  _internal_set_force(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.force)
}

// optional string fan_force_curve = 8;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_fan_force_curve() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_fan_force_curve() const {
  return _internal_has_fan_force_curve();
}
inline void CUserMsg_ParticleManager_AddFan::clear_fan_force_curve() {
  _impl_.fan_force_curve_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_ParticleManager_AddFan::fan_force_curve() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.fan_force_curve)
  return _internal_fan_force_curve();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_AddFan::set_fan_force_curve(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.fan_force_curve_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.fan_force_curve)
}
inline std::string* CUserMsg_ParticleManager_AddFan::mutable_fan_force_curve() {
  std::string* _s = _internal_mutable_fan_force_curve();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.fan_force_curve)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_AddFan::_internal_fan_force_curve() const {
  return _impl_.fan_force_curve_.Get();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_fan_force_curve(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.fan_force_curve_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddFan::_internal_mutable_fan_force_curve() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.fan_force_curve_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddFan::release_fan_force_curve() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.fan_force_curve)
  if (!_internal_has_fan_force_curve()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.fan_force_curve_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fan_force_curve_.IsDefault()) {
    _impl_.fan_force_curve_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_fan_force_curve(std::string* fan_force_curve) {
  if (fan_force_curve != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.fan_force_curve_.SetAllocated(fan_force_curve, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fan_force_curve_.IsDefault()) {
    _impl_.fan_force_curve_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.fan_force_curve)
}

// optional bool falloff = 9;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_falloff() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_falloff() const {
  return _internal_has_falloff();
}
inline void CUserMsg_ParticleManager_AddFan::clear_falloff() {
  _impl_.falloff_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool CUserMsg_ParticleManager_AddFan::_internal_falloff() const {
  return _impl_.falloff_;
}
inline bool CUserMsg_ParticleManager_AddFan::falloff() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.falloff)
  return _internal_falloff();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_falloff(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.falloff_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_falloff(bool value) {
  _internal_set_falloff(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.falloff)
}

// optional bool pull_towards_point = 10;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_pull_towards_point() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_pull_towards_point() const {
  return _internal_has_pull_towards_point();
}
inline void CUserMsg_ParticleManager_AddFan::clear_pull_towards_point() {
  _impl_.pull_towards_point_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CUserMsg_ParticleManager_AddFan::_internal_pull_towards_point() const {
  return _impl_.pull_towards_point_;
}
inline bool CUserMsg_ParticleManager_AddFan::pull_towards_point() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.pull_towards_point)
  return _internal_pull_towards_point();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_pull_towards_point(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.pull_towards_point_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_pull_towards_point(bool value) {
  _internal_set_pull_towards_point(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.pull_towards_point)
}

// optional float curve_min_dist = 11;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_curve_min_dist() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_curve_min_dist() const {
  return _internal_has_curve_min_dist();
}
inline void CUserMsg_ParticleManager_AddFan::clear_curve_min_dist() {
  _impl_.curve_min_dist_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_curve_min_dist() const {
  return _impl_.curve_min_dist_;
}
inline float CUserMsg_ParticleManager_AddFan::curve_min_dist() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.curve_min_dist)
  return _internal_curve_min_dist();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_curve_min_dist(float value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.curve_min_dist_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_curve_min_dist(float value) {
  _internal_set_curve_min_dist(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.curve_min_dist)
}

// optional float curve_max_dist = 12;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_curve_max_dist() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_curve_max_dist() const {
  return _internal_has_curve_max_dist();
}
inline void CUserMsg_ParticleManager_AddFan::clear_curve_max_dist() {
  _impl_.curve_max_dist_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_curve_max_dist() const {
  return _impl_.curve_max_dist_;
}
inline float CUserMsg_ParticleManager_AddFan::curve_max_dist() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.curve_max_dist)
  return _internal_curve_max_dist();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_curve_max_dist(float value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.curve_max_dist_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_curve_max_dist(float value) {
  _internal_set_curve_max_dist(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.curve_max_dist)
}

// optional uint32 fan_type = 13;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_fan_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_fan_type() const {
  return _internal_has_fan_type();
}
inline void CUserMsg_ParticleManager_AddFan::clear_fan_type() {
  _impl_.fan_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CUserMsg_ParticleManager_AddFan::_internal_fan_type() const {
  return _impl_.fan_type_;
}
inline uint32_t CUserMsg_ParticleManager_AddFan::fan_type() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.fan_type)
  return _internal_fan_type();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_fan_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.fan_type_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_fan_type(uint32_t value) {
  _internal_set_fan_type(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.fan_type)
}

// optional float cone_start_radius = 14;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_cone_start_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_cone_start_radius() const {
  return _internal_has_cone_start_radius();
}
inline void CUserMsg_ParticleManager_AddFan::clear_cone_start_radius() {
  _impl_.cone_start_radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_cone_start_radius() const {
  return _impl_.cone_start_radius_;
}
inline float CUserMsg_ParticleManager_AddFan::cone_start_radius() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.cone_start_radius)
  return _internal_cone_start_radius();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_cone_start_radius(float value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.cone_start_radius_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_cone_start_radius(float value) {
  _internal_set_cone_start_radius(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.cone_start_radius)
}

// optional float cone_end_radius = 15;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_cone_end_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_cone_end_radius() const {
  return _internal_has_cone_end_radius();
}
inline void CUserMsg_ParticleManager_AddFan::clear_cone_end_radius() {
  _impl_.cone_end_radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_cone_end_radius() const {
  return _impl_.cone_end_radius_;
}
inline float CUserMsg_ParticleManager_AddFan::cone_end_radius() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.cone_end_radius)
  return _internal_cone_end_radius();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_cone_end_radius(float value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.cone_end_radius_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_cone_end_radius(float value) {
  _internal_set_cone_end_radius(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.cone_end_radius)
}

// optional float cone_length = 16;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_cone_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_cone_length() const {
  return _internal_has_cone_length();
}
inline void CUserMsg_ParticleManager_AddFan::clear_cone_length() {
  _impl_.cone_length_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float CUserMsg_ParticleManager_AddFan::_internal_cone_length() const {
  return _impl_.cone_length_;
}
inline float CUserMsg_ParticleManager_AddFan::cone_length() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.cone_length)
  return _internal_cone_length();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_cone_length(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.cone_length_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_cone_length(float value) {
  _internal_set_cone_length(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.cone_length)
}

// optional uint32 entity_handle = 17 [default = 16777215];
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_entity_handle() const {
  return _internal_has_entity_handle();
}
inline void CUserMsg_ParticleManager_AddFan::clear_entity_handle() {
  _impl_.entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t CUserMsg_ParticleManager_AddFan::_internal_entity_handle() const {
  return _impl_.entity_handle_;
}
inline uint32_t CUserMsg_ParticleManager_AddFan::entity_handle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.entity_handle)
  return _internal_entity_handle();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.entity_handle_ = value;
}
inline void CUserMsg_ParticleManager_AddFan::set_entity_handle(uint32_t value) {
  _internal_set_entity_handle(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.entity_handle)
}

// optional string attachment_name = 18;
inline bool CUserMsg_ParticleManager_AddFan::_internal_has_attachment_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_AddFan::has_attachment_name() const {
  return _internal_has_attachment_name();
}
inline void CUserMsg_ParticleManager_AddFan::clear_attachment_name() {
  _impl_.attachment_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMsg_ParticleManager_AddFan::attachment_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.AddFan.attachment_name)
  return _internal_attachment_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_ParticleManager_AddFan::set_attachment_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.attachment_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.AddFan.attachment_name)
}
inline std::string* CUserMsg_ParticleManager_AddFan::mutable_attachment_name() {
  std::string* _s = _internal_mutable_attachment_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.AddFan.attachment_name)
  return _s;
}
inline const std::string& CUserMsg_ParticleManager_AddFan::_internal_attachment_name() const {
  return _impl_.attachment_name_.Get();
}
inline void CUserMsg_ParticleManager_AddFan::_internal_set_attachment_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.attachment_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddFan::_internal_mutable_attachment_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.attachment_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_ParticleManager_AddFan::release_attachment_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.AddFan.attachment_name)
  if (!_internal_has_attachment_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.attachment_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachment_name_.IsDefault()) {
    _impl_.attachment_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_ParticleManager_AddFan::set_allocated_attachment_name(std::string* attachment_name) {
  if (attachment_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.attachment_name_.SetAllocated(attachment_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachment_name_.IsDefault()) {
    _impl_.attachment_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.AddFan.attachment_name)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_UpdateFan

// optional bool active = 1;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_active() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_active() const {
  return _internal_has_active();
}
inline void CUserMsg_ParticleManager_UpdateFan::clear_active() {
  _impl_.active_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_active() const {
  return _impl_.active_;
}
inline bool CUserMsg_ParticleManager_UpdateFan::active() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.active)
  return _internal_active();
}
inline void CUserMsg_ParticleManager_UpdateFan::_internal_set_active(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.active_ = value;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_active(bool value) {
  _internal_set_active(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateFan.active)
}

// optional .CMsgVector fan_origin = 2;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_fan_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_origin_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_fan_origin() const {
  return _internal_has_fan_origin();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::_internal_fan_origin() const {
  const ::CMsgVector* p = _impl_.fan_origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::fan_origin() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.fan_origin)
  return _internal_fan_origin();
}
inline void CUserMsg_ParticleManager_UpdateFan::unsafe_arena_set_allocated_fan_origin(
    ::CMsgVector* fan_origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_);
  }
  _impl_.fan_origin_ = fan_origin;
  if (fan_origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_origin)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::release_fan_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.fan_origin_;
  _impl_.fan_origin_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::unsafe_arena_release_fan_origin() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateFan.fan_origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.fan_origin_;
  _impl_.fan_origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::_internal_mutable_fan_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.fan_origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_origin_ = p;
  }
  return _impl_.fan_origin_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::mutable_fan_origin() {
  ::CMsgVector* _msg = _internal_mutable_fan_origin();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateFan.fan_origin)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_allocated_fan_origin(::CMsgVector* fan_origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_);
  }
  if (fan_origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_origin));
    if (message_arena != submessage_arena) {
      fan_origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.fan_origin_ = fan_origin;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_origin)
}

// optional .CMsgVector fan_origin_offset = 3;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_fan_origin_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_origin_offset_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_fan_origin_offset() const {
  return _internal_has_fan_origin_offset();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::_internal_fan_origin_offset() const {
  const ::CMsgVector* p = _impl_.fan_origin_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::fan_origin_offset() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.fan_origin_offset)
  return _internal_fan_origin_offset();
}
inline void CUserMsg_ParticleManager_UpdateFan::unsafe_arena_set_allocated_fan_origin_offset(
    ::CMsgVector* fan_origin_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_offset_);
  }
  _impl_.fan_origin_offset_ = fan_origin_offset;
  if (fan_origin_offset) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_origin_offset)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::release_fan_origin_offset() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.fan_origin_offset_;
  _impl_.fan_origin_offset_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::unsafe_arena_release_fan_origin_offset() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateFan.fan_origin_offset)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.fan_origin_offset_;
  _impl_.fan_origin_offset_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::_internal_mutable_fan_origin_offset() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.fan_origin_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_origin_offset_ = p;
  }
  return _impl_.fan_origin_offset_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::mutable_fan_origin_offset() {
  ::CMsgVector* _msg = _internal_mutable_fan_origin_offset();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateFan.fan_origin_offset)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_allocated_fan_origin_offset(::CMsgVector* fan_origin_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_origin_offset_);
  }
  if (fan_origin_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_origin_offset));
    if (message_arena != submessage_arena) {
      fan_origin_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_origin_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.fan_origin_offset_ = fan_origin_offset;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_origin_offset)
}

// optional .CMsgVector fan_direction = 4;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_fan_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fan_direction_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_fan_direction() const {
  return _internal_has_fan_direction();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::_internal_fan_direction() const {
  const ::CMsgVector* p = _impl_.fan_direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::fan_direction() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.fan_direction)
  return _internal_fan_direction();
}
inline void CUserMsg_ParticleManager_UpdateFan::unsafe_arena_set_allocated_fan_direction(
    ::CMsgVector* fan_direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_direction_);
  }
  _impl_.fan_direction_ = fan_direction;
  if (fan_direction) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_direction)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::release_fan_direction() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.fan_direction_;
  _impl_.fan_direction_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::unsafe_arena_release_fan_direction() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateFan.fan_direction)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.fan_direction_;
  _impl_.fan_direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::_internal_mutable_fan_direction() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.fan_direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.fan_direction_ = p;
  }
  return _impl_.fan_direction_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::mutable_fan_direction() {
  ::CMsgVector* _msg = _internal_mutable_fan_direction();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateFan.fan_direction)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_allocated_fan_direction(::CMsgVector* fan_direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fan_direction_);
  }
  if (fan_direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fan_direction));
    if (message_arena != submessage_arena) {
      fan_direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fan_direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fan_direction_ = fan_direction;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateFan.fan_direction)
}

// optional float fan_ramp_ratio = 7;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_fan_ramp_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_fan_ramp_ratio() const {
  return _internal_has_fan_ramp_ratio();
}
inline void CUserMsg_ParticleManager_UpdateFan::clear_fan_ramp_ratio() {
  _impl_.fan_ramp_ratio_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CUserMsg_ParticleManager_UpdateFan::_internal_fan_ramp_ratio() const {
  return _impl_.fan_ramp_ratio_;
}
inline float CUserMsg_ParticleManager_UpdateFan::fan_ramp_ratio() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.fan_ramp_ratio)
  return _internal_fan_ramp_ratio();
}
inline void CUserMsg_ParticleManager_UpdateFan::_internal_set_fan_ramp_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.fan_ramp_ratio_ = value;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_fan_ramp_ratio(float value) {
  _internal_set_fan_ramp_ratio(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.UpdateFan.fan_ramp_ratio)
}

// optional .CMsgVector bounds_mins = 5;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_bounds_mins() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bounds_mins_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_bounds_mins() const {
  return _internal_has_bounds_mins();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::_internal_bounds_mins() const {
  const ::CMsgVector* p = _impl_.bounds_mins_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::bounds_mins() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.bounds_mins)
  return _internal_bounds_mins();
}
inline void CUserMsg_ParticleManager_UpdateFan::unsafe_arena_set_allocated_bounds_mins(
    ::CMsgVector* bounds_mins) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_mins_);
  }
  _impl_.bounds_mins_ = bounds_mins;
  if (bounds_mins) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateFan.bounds_mins)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::release_bounds_mins() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.bounds_mins_;
  _impl_.bounds_mins_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::unsafe_arena_release_bounds_mins() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateFan.bounds_mins)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.bounds_mins_;
  _impl_.bounds_mins_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::_internal_mutable_bounds_mins() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.bounds_mins_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.bounds_mins_ = p;
  }
  return _impl_.bounds_mins_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::mutable_bounds_mins() {
  ::CMsgVector* _msg = _internal_mutable_bounds_mins();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateFan.bounds_mins)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_allocated_bounds_mins(::CMsgVector* bounds_mins) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_mins_);
  }
  if (bounds_mins) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bounds_mins));
    if (message_arena != submessage_arena) {
      bounds_mins = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bounds_mins, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.bounds_mins_ = bounds_mins;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateFan.bounds_mins)
}

// optional .CMsgVector bounds_maxs = 6;
inline bool CUserMsg_ParticleManager_UpdateFan::_internal_has_bounds_maxs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bounds_maxs_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_UpdateFan::has_bounds_maxs() const {
  return _internal_has_bounds_maxs();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::_internal_bounds_maxs() const {
  const ::CMsgVector* p = _impl_.bounds_maxs_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_UpdateFan::bounds_maxs() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.UpdateFan.bounds_maxs)
  return _internal_bounds_maxs();
}
inline void CUserMsg_ParticleManager_UpdateFan::unsafe_arena_set_allocated_bounds_maxs(
    ::CMsgVector* bounds_maxs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_maxs_);
  }
  _impl_.bounds_maxs_ = bounds_maxs;
  if (bounds_maxs) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.UpdateFan.bounds_maxs)
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::release_bounds_maxs() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.bounds_maxs_;
  _impl_.bounds_maxs_ = 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 ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::unsafe_arena_release_bounds_maxs() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.UpdateFan.bounds_maxs)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.bounds_maxs_;
  _impl_.bounds_maxs_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::_internal_mutable_bounds_maxs() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.bounds_maxs_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.bounds_maxs_ = p;
  }
  return _impl_.bounds_maxs_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_UpdateFan::mutable_bounds_maxs() {
  ::CMsgVector* _msg = _internal_mutable_bounds_maxs();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.UpdateFan.bounds_maxs)
  return _msg;
}
inline void CUserMsg_ParticleManager_UpdateFan::set_allocated_bounds_maxs(::CMsgVector* bounds_maxs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bounds_maxs_);
  }
  if (bounds_maxs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bounds_maxs));
    if (message_arena != submessage_arena) {
      bounds_maxs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bounds_maxs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.bounds_maxs_ = bounds_maxs;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.UpdateFan.bounds_maxs)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_RemoveFan

// -------------------------------------------------------------------

// CUserMsg_ParticleManager_SetParticleClusterGrowth

// optional float duration = 1;
inline bool CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleClusterGrowth::has_duration() const {
  return _internal_has_duration();
}
inline void CUserMsg_ParticleManager_SetParticleClusterGrowth::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_duration() const {
  return _impl_.duration_;
}
inline float CUserMsg_ParticleManager_SetParticleClusterGrowth::duration() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleClusterGrowth.duration)
  return _internal_duration();
}
inline void CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_set_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void CUserMsg_ParticleManager_SetParticleClusterGrowth::set_duration(float value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.SetParticleClusterGrowth.duration)
}

// optional .CMsgVector origin = 2;
inline bool CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager_SetParticleClusterGrowth::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMsg_ParticleManager_SetParticleClusterGrowth::origin() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.SetParticleClusterGrowth.origin)
  return _internal_origin();
}
inline void CUserMsg_ParticleManager_SetParticleClusterGrowth::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.SetParticleClusterGrowth.origin)
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleClusterGrowth::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = 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 ::CMsgVector* CUserMsg_ParticleManager_SetParticleClusterGrowth::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.SetParticleClusterGrowth.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleClusterGrowth::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CUserMsg_ParticleManager_SetParticleClusterGrowth::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.SetParticleClusterGrowth.origin)
  return _msg;
}
inline void CUserMsg_ParticleManager_SetParticleClusterGrowth::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.SetParticleClusterGrowth.origin)
}

// -------------------------------------------------------------------

// CUserMsg_ParticleManager

// optional .PARTICLE_MESSAGE type = 1 [default = GAME_PARTICLE_MANAGER_EVENT_CREATE];
inline bool CUserMsg_ParticleManager::_internal_has_type() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager::has_type() const {
  return _internal_has_type();
}
inline void CUserMsg_ParticleManager::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline ::PARTICLE_MESSAGE CUserMsg_ParticleManager::_internal_type() const {
  return static_cast< ::PARTICLE_MESSAGE >(_impl_.type_);
}
inline ::PARTICLE_MESSAGE CUserMsg_ParticleManager::type() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.type)
  return _internal_type();
}
inline void CUserMsg_ParticleManager::_internal_set_type(::PARTICLE_MESSAGE value) {
  assert(::PARTICLE_MESSAGE_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000080u;
  _impl_.type_ = value;
}
inline void CUserMsg_ParticleManager::set_type(::PARTICLE_MESSAGE value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.type)
}

// optional uint32 index = 2;
inline bool CUserMsg_ParticleManager::_internal_has_index() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMsg_ParticleManager::has_index() const {
  return _internal_has_index();
}
inline void CUserMsg_ParticleManager::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline uint32_t CUserMsg_ParticleManager::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t CUserMsg_ParticleManager::index() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.index)
  return _internal_index();
}
inline void CUserMsg_ParticleManager::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000100u;
  _impl_.index_ = value;
}
inline void CUserMsg_ParticleManager::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMsg_ParticleManager.index)
}

// optional .CUserMsg_ParticleManager.ReleaseParticleIndex release_particle_index = 3;
inline bool CUserMsg_ParticleManager::_internal_has_release_particle_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.release_particle_index_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_release_particle_index() const {
  return _internal_has_release_particle_index();
}
inline void CUserMsg_ParticleManager::clear_release_particle_index() {
  if (_impl_.release_particle_index_ != nullptr) _impl_.release_particle_index_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CUserMsg_ParticleManager_ReleaseParticleIndex& CUserMsg_ParticleManager::_internal_release_particle_index() const {
  const ::CUserMsg_ParticleManager_ReleaseParticleIndex* p = _impl_.release_particle_index_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ReleaseParticleIndex&>(
      ::_CUserMsg_ParticleManager_ReleaseParticleIndex_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ReleaseParticleIndex& CUserMsg_ParticleManager::release_particle_index() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.release_particle_index)
  return _internal_release_particle_index();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_release_particle_index(
    ::CUserMsg_ParticleManager_ReleaseParticleIndex* release_particle_index) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.release_particle_index_);
  }
  _impl_.release_particle_index_ = release_particle_index;
  if (release_particle_index) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.release_particle_index)
}
inline ::CUserMsg_ParticleManager_ReleaseParticleIndex* CUserMsg_ParticleManager::release_release_particle_index() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* temp = _impl_.release_particle_index_;
  _impl_.release_particle_index_ = 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 ::CUserMsg_ParticleManager_ReleaseParticleIndex* CUserMsg_ParticleManager::unsafe_arena_release_release_particle_index() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.release_particle_index)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* temp = _impl_.release_particle_index_;
  _impl_.release_particle_index_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ReleaseParticleIndex* CUserMsg_ParticleManager::_internal_mutable_release_particle_index() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.release_particle_index_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ReleaseParticleIndex>(GetArenaForAllocation());
    _impl_.release_particle_index_ = p;
  }
  return _impl_.release_particle_index_;
}
inline ::CUserMsg_ParticleManager_ReleaseParticleIndex* CUserMsg_ParticleManager::mutable_release_particle_index() {
  ::CUserMsg_ParticleManager_ReleaseParticleIndex* _msg = _internal_mutable_release_particle_index();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.release_particle_index)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_release_particle_index(::CUserMsg_ParticleManager_ReleaseParticleIndex* release_particle_index) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.release_particle_index_;
  }
  if (release_particle_index) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(release_particle_index);
    if (message_arena != submessage_arena) {
      release_particle_index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, release_particle_index, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.release_particle_index_ = release_particle_index;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.release_particle_index)
}

// optional .CUserMsg_ParticleManager.CreateParticle create_particle = 4;
inline bool CUserMsg_ParticleManager::_internal_has_create_particle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.create_particle_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_create_particle() const {
  return _internal_has_create_particle();
}
inline void CUserMsg_ParticleManager::clear_create_particle() {
  if (_impl_.create_particle_ != nullptr) _impl_.create_particle_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CUserMsg_ParticleManager_CreateParticle& CUserMsg_ParticleManager::_internal_create_particle() const {
  const ::CUserMsg_ParticleManager_CreateParticle* p = _impl_.create_particle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_CreateParticle&>(
      ::_CUserMsg_ParticleManager_CreateParticle_default_instance_);
}
inline const ::CUserMsg_ParticleManager_CreateParticle& CUserMsg_ParticleManager::create_particle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.create_particle)
  return _internal_create_particle();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_create_particle(
    ::CUserMsg_ParticleManager_CreateParticle* create_particle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_particle_);
  }
  _impl_.create_particle_ = create_particle;
  if (create_particle) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.create_particle)
}
inline ::CUserMsg_ParticleManager_CreateParticle* CUserMsg_ParticleManager::release_create_particle() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CUserMsg_ParticleManager_CreateParticle* temp = _impl_.create_particle_;
  _impl_.create_particle_ = 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 ::CUserMsg_ParticleManager_CreateParticle* CUserMsg_ParticleManager::unsafe_arena_release_create_particle() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.create_particle)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CUserMsg_ParticleManager_CreateParticle* temp = _impl_.create_particle_;
  _impl_.create_particle_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_CreateParticle* CUserMsg_ParticleManager::_internal_mutable_create_particle() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.create_particle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_CreateParticle>(GetArenaForAllocation());
    _impl_.create_particle_ = p;
  }
  return _impl_.create_particle_;
}
inline ::CUserMsg_ParticleManager_CreateParticle* CUserMsg_ParticleManager::mutable_create_particle() {
  ::CUserMsg_ParticleManager_CreateParticle* _msg = _internal_mutable_create_particle();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.create_particle)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_create_particle(::CUserMsg_ParticleManager_CreateParticle* create_particle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.create_particle_;
  }
  if (create_particle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(create_particle);
    if (message_arena != submessage_arena) {
      create_particle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_particle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.create_particle_ = create_particle;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.create_particle)
}

// optional .CUserMsg_ParticleManager.DestroyParticle destroy_particle = 5;
inline bool CUserMsg_ParticleManager::_internal_has_destroy_particle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.destroy_particle_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_destroy_particle() const {
  return _internal_has_destroy_particle();
}
inline void CUserMsg_ParticleManager::clear_destroy_particle() {
  if (_impl_.destroy_particle_ != nullptr) _impl_.destroy_particle_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::CUserMsg_ParticleManager_DestroyParticle& CUserMsg_ParticleManager::_internal_destroy_particle() const {
  const ::CUserMsg_ParticleManager_DestroyParticle* p = _impl_.destroy_particle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_DestroyParticle&>(
      ::_CUserMsg_ParticleManager_DestroyParticle_default_instance_);
}
inline const ::CUserMsg_ParticleManager_DestroyParticle& CUserMsg_ParticleManager::destroy_particle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.destroy_particle)
  return _internal_destroy_particle();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_destroy_particle(
    ::CUserMsg_ParticleManager_DestroyParticle* destroy_particle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.destroy_particle_);
  }
  _impl_.destroy_particle_ = destroy_particle;
  if (destroy_particle) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.destroy_particle)
}
inline ::CUserMsg_ParticleManager_DestroyParticle* CUserMsg_ParticleManager::release_destroy_particle() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CUserMsg_ParticleManager_DestroyParticle* temp = _impl_.destroy_particle_;
  _impl_.destroy_particle_ = 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 ::CUserMsg_ParticleManager_DestroyParticle* CUserMsg_ParticleManager::unsafe_arena_release_destroy_particle() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.destroy_particle)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CUserMsg_ParticleManager_DestroyParticle* temp = _impl_.destroy_particle_;
  _impl_.destroy_particle_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_DestroyParticle* CUserMsg_ParticleManager::_internal_mutable_destroy_particle() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.destroy_particle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticle>(GetArenaForAllocation());
    _impl_.destroy_particle_ = p;
  }
  return _impl_.destroy_particle_;
}
inline ::CUserMsg_ParticleManager_DestroyParticle* CUserMsg_ParticleManager::mutable_destroy_particle() {
  ::CUserMsg_ParticleManager_DestroyParticle* _msg = _internal_mutable_destroy_particle();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.destroy_particle)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_destroy_particle(::CUserMsg_ParticleManager_DestroyParticle* destroy_particle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.destroy_particle_;
  }
  if (destroy_particle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(destroy_particle);
    if (message_arena != submessage_arena) {
      destroy_particle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, destroy_particle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.destroy_particle_ = destroy_particle;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.destroy_particle)
}

// optional .CUserMsg_ParticleManager.DestroyParticleInvolving destroy_particle_involving = 6;
inline bool CUserMsg_ParticleManager::_internal_has_destroy_particle_involving() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.destroy_particle_involving_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_destroy_particle_involving() const {
  return _internal_has_destroy_particle_involving();
}
inline void CUserMsg_ParticleManager::clear_destroy_particle_involving() {
  if (_impl_.destroy_particle_involving_ != nullptr) _impl_.destroy_particle_involving_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::CUserMsg_ParticleManager_DestroyParticleInvolving& CUserMsg_ParticleManager::_internal_destroy_particle_involving() const {
  const ::CUserMsg_ParticleManager_DestroyParticleInvolving* p = _impl_.destroy_particle_involving_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_DestroyParticleInvolving&>(
      ::_CUserMsg_ParticleManager_DestroyParticleInvolving_default_instance_);
}
inline const ::CUserMsg_ParticleManager_DestroyParticleInvolving& CUserMsg_ParticleManager::destroy_particle_involving() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.destroy_particle_involving)
  return _internal_destroy_particle_involving();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_destroy_particle_involving(
    ::CUserMsg_ParticleManager_DestroyParticleInvolving* destroy_particle_involving) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.destroy_particle_involving_);
  }
  _impl_.destroy_particle_involving_ = destroy_particle_involving;
  if (destroy_particle_involving) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.destroy_particle_involving)
}
inline ::CUserMsg_ParticleManager_DestroyParticleInvolving* CUserMsg_ParticleManager::release_destroy_particle_involving() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* temp = _impl_.destroy_particle_involving_;
  _impl_.destroy_particle_involving_ = 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 ::CUserMsg_ParticleManager_DestroyParticleInvolving* CUserMsg_ParticleManager::unsafe_arena_release_destroy_particle_involving() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.destroy_particle_involving)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* temp = _impl_.destroy_particle_involving_;
  _impl_.destroy_particle_involving_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_DestroyParticleInvolving* CUserMsg_ParticleManager::_internal_mutable_destroy_particle_involving() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.destroy_particle_involving_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticleInvolving>(GetArenaForAllocation());
    _impl_.destroy_particle_involving_ = p;
  }
  return _impl_.destroy_particle_involving_;
}
inline ::CUserMsg_ParticleManager_DestroyParticleInvolving* CUserMsg_ParticleManager::mutable_destroy_particle_involving() {
  ::CUserMsg_ParticleManager_DestroyParticleInvolving* _msg = _internal_mutable_destroy_particle_involving();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.destroy_particle_involving)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_destroy_particle_involving(::CUserMsg_ParticleManager_DestroyParticleInvolving* destroy_particle_involving) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.destroy_particle_involving_;
  }
  if (destroy_particle_involving) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(destroy_particle_involving);
    if (message_arena != submessage_arena) {
      destroy_particle_involving = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, destroy_particle_involving, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.destroy_particle_involving_ = destroy_particle_involving;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.destroy_particle_involving)
}

// optional .CUserMsg_ParticleManager.UpdateParticle_OBSOLETE update_particle = 7;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle() const {
  return _internal_has_update_particle();
}
inline void CUserMsg_ParticleManager::clear_update_particle() {
  if (_impl_.update_particle_ != nullptr) _impl_.update_particle_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& CUserMsg_ParticleManager::_internal_update_particle() const {
  const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* p = _impl_.update_particle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE&>(
      ::_CUserMsg_ParticleManager_UpdateParticle_OBSOLETE_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE& CUserMsg_ParticleManager::update_particle() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle)
  return _internal_update_particle();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle(
    ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* update_particle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_);
  }
  _impl_.update_particle_ = update_particle;
  if (update_particle) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle)
}
inline ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* CUserMsg_ParticleManager::release_update_particle() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* temp = _impl_.update_particle_;
  _impl_.update_particle_ = 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 ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* CUserMsg_ParticleManager::unsafe_arena_release_update_particle() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* temp = _impl_.update_particle_;
  _impl_.update_particle_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* CUserMsg_ParticleManager::_internal_mutable_update_particle() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.update_particle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE>(GetArenaForAllocation());
    _impl_.update_particle_ = p;
  }
  return _impl_.update_particle_;
}
inline ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* CUserMsg_ParticleManager::mutable_update_particle() {
  ::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* _msg = _internal_mutable_update_particle();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle(::CUserMsg_ParticleManager_UpdateParticle_OBSOLETE* update_particle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_;
  }
  if (update_particle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle);
    if (message_arena != submessage_arena) {
      update_particle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.update_particle_ = update_particle;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle)
}

// optional .CUserMsg_ParticleManager.UpdateParticleFwd_OBSOLETE update_particle_fwd = 8;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_fwd() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_fwd_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_fwd() const {
  return _internal_has_update_particle_fwd();
}
inline void CUserMsg_ParticleManager::clear_update_particle_fwd() {
  if (_impl_.update_particle_fwd_ != nullptr) _impl_.update_particle_fwd_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& CUserMsg_ParticleManager::_internal_update_particle_fwd() const {
  const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* p = _impl_.update_particle_fwd_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE&>(
      ::_CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE& CUserMsg_ParticleManager::update_particle_fwd() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_fwd)
  return _internal_update_particle_fwd();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_fwd(
    ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* update_particle_fwd) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_fwd_);
  }
  _impl_.update_particle_fwd_ = update_particle_fwd;
  if (update_particle_fwd) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_fwd)
}
inline ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* CUserMsg_ParticleManager::release_update_particle_fwd() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* temp = _impl_.update_particle_fwd_;
  _impl_.update_particle_fwd_ = 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 ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_fwd() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_fwd)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* temp = _impl_.update_particle_fwd_;
  _impl_.update_particle_fwd_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* CUserMsg_ParticleManager::_internal_mutable_update_particle_fwd() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.update_particle_fwd_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE>(GetArenaForAllocation());
    _impl_.update_particle_fwd_ = p;
  }
  return _impl_.update_particle_fwd_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* CUserMsg_ParticleManager::mutable_update_particle_fwd() {
  ::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* _msg = _internal_mutable_update_particle_fwd();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_fwd)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_fwd(::CUserMsg_ParticleManager_UpdateParticleFwd_OBSOLETE* update_particle_fwd) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_fwd_;
  }
  if (update_particle_fwd) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_fwd);
    if (message_arena != submessage_arena) {
      update_particle_fwd = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_fwd, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.update_particle_fwd_ = update_particle_fwd;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_fwd)
}

// optional .CUserMsg_ParticleManager.UpdateParticleOrient_OBSOLETE update_particle_orient = 9;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_orient() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_orient_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_orient() const {
  return _internal_has_update_particle_orient();
}
inline void CUserMsg_ParticleManager::clear_update_particle_orient() {
  if (_impl_.update_particle_orient_ != nullptr) _impl_.update_particle_orient_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& CUserMsg_ParticleManager::_internal_update_particle_orient() const {
  const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* p = _impl_.update_particle_orient_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE&>(
      ::_CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE& CUserMsg_ParticleManager::update_particle_orient() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_orient)
  return _internal_update_particle_orient();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_orient(
    ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* update_particle_orient) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_orient_);
  }
  _impl_.update_particle_orient_ = update_particle_orient;
  if (update_particle_orient) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_orient)
}
inline ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* CUserMsg_ParticleManager::release_update_particle_orient() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* temp = _impl_.update_particle_orient_;
  _impl_.update_particle_orient_ = 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 ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_orient() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_orient)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* temp = _impl_.update_particle_orient_;
  _impl_.update_particle_orient_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* CUserMsg_ParticleManager::_internal_mutable_update_particle_orient() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.update_particle_orient_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE>(GetArenaForAllocation());
    _impl_.update_particle_orient_ = p;
  }
  return _impl_.update_particle_orient_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* CUserMsg_ParticleManager::mutable_update_particle_orient() {
  ::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* _msg = _internal_mutable_update_particle_orient();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_orient)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_orient(::CUserMsg_ParticleManager_UpdateParticleOrient_OBSOLETE* update_particle_orient) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_orient_;
  }
  if (update_particle_orient) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_orient);
    if (message_arena != submessage_arena) {
      update_particle_orient = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_orient, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.update_particle_orient_ = update_particle_orient;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_orient)
}

// optional .CUserMsg_ParticleManager.UpdateParticleFallback update_particle_fallback = 10;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_fallback() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_fallback_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_fallback() const {
  return _internal_has_update_particle_fallback();
}
inline void CUserMsg_ParticleManager::clear_update_particle_fallback() {
  if (_impl_.update_particle_fallback_ != nullptr) _impl_.update_particle_fallback_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleFallback& CUserMsg_ParticleManager::_internal_update_particle_fallback() const {
  const ::CUserMsg_ParticleManager_UpdateParticleFallback* p = _impl_.update_particle_fallback_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleFallback&>(
      ::_CUserMsg_ParticleManager_UpdateParticleFallback_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleFallback& CUserMsg_ParticleManager::update_particle_fallback() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_fallback)
  return _internal_update_particle_fallback();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_fallback(
    ::CUserMsg_ParticleManager_UpdateParticleFallback* update_particle_fallback) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_fallback_);
  }
  _impl_.update_particle_fallback_ = update_particle_fallback;
  if (update_particle_fallback) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_fallback)
}
inline ::CUserMsg_ParticleManager_UpdateParticleFallback* CUserMsg_ParticleManager::release_update_particle_fallback() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::CUserMsg_ParticleManager_UpdateParticleFallback* temp = _impl_.update_particle_fallback_;
  _impl_.update_particle_fallback_ = 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 ::CUserMsg_ParticleManager_UpdateParticleFallback* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_fallback() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_fallback)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::CUserMsg_ParticleManager_UpdateParticleFallback* temp = _impl_.update_particle_fallback_;
  _impl_.update_particle_fallback_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleFallback* CUserMsg_ParticleManager::_internal_mutable_update_particle_fallback() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.update_particle_fallback_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleFallback>(GetArenaForAllocation());
    _impl_.update_particle_fallback_ = p;
  }
  return _impl_.update_particle_fallback_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleFallback* CUserMsg_ParticleManager::mutable_update_particle_fallback() {
  ::CUserMsg_ParticleManager_UpdateParticleFallback* _msg = _internal_mutable_update_particle_fallback();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_fallback)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_fallback(::CUserMsg_ParticleManager_UpdateParticleFallback* update_particle_fallback) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_fallback_;
  }
  if (update_particle_fallback) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_fallback);
    if (message_arena != submessage_arena) {
      update_particle_fallback = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_fallback, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.update_particle_fallback_ = update_particle_fallback;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_fallback)
}

// optional .CUserMsg_ParticleManager.UpdateParticleOffset update_particle_offset = 11;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_offset_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_offset() const {
  return _internal_has_update_particle_offset();
}
inline void CUserMsg_ParticleManager::clear_update_particle_offset() {
  if (_impl_.update_particle_offset_ != nullptr) _impl_.update_particle_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleOffset& CUserMsg_ParticleManager::_internal_update_particle_offset() const {
  const ::CUserMsg_ParticleManager_UpdateParticleOffset* p = _impl_.update_particle_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleOffset&>(
      ::_CUserMsg_ParticleManager_UpdateParticleOffset_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleOffset& CUserMsg_ParticleManager::update_particle_offset() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_offset)
  return _internal_update_particle_offset();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_offset(
    ::CUserMsg_ParticleManager_UpdateParticleOffset* update_particle_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_offset_);
  }
  _impl_.update_particle_offset_ = update_particle_offset;
  if (update_particle_offset) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_offset)
}
inline ::CUserMsg_ParticleManager_UpdateParticleOffset* CUserMsg_ParticleManager::release_update_particle_offset() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::CUserMsg_ParticleManager_UpdateParticleOffset* temp = _impl_.update_particle_offset_;
  _impl_.update_particle_offset_ = 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 ::CUserMsg_ParticleManager_UpdateParticleOffset* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_offset() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_offset)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::CUserMsg_ParticleManager_UpdateParticleOffset* temp = _impl_.update_particle_offset_;
  _impl_.update_particle_offset_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleOffset* CUserMsg_ParticleManager::_internal_mutable_update_particle_offset() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.update_particle_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleOffset>(GetArenaForAllocation());
    _impl_.update_particle_offset_ = p;
  }
  return _impl_.update_particle_offset_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleOffset* CUserMsg_ParticleManager::mutable_update_particle_offset() {
  ::CUserMsg_ParticleManager_UpdateParticleOffset* _msg = _internal_mutable_update_particle_offset();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_offset)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_offset(::CUserMsg_ParticleManager_UpdateParticleOffset* update_particle_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_offset_;
  }
  if (update_particle_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_offset);
    if (message_arena != submessage_arena) {
      update_particle_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.update_particle_offset_ = update_particle_offset;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_offset)
}

// optional .CUserMsg_ParticleManager.UpdateParticleEnt update_particle_ent = 12;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_ent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_ent_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_ent() const {
  return _internal_has_update_particle_ent();
}
inline void CUserMsg_ParticleManager::clear_update_particle_ent() {
  if (_impl_.update_particle_ent_ != nullptr) _impl_.update_particle_ent_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleEnt& CUserMsg_ParticleManager::_internal_update_particle_ent() const {
  const ::CUserMsg_ParticleManager_UpdateParticleEnt* p = _impl_.update_particle_ent_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleEnt&>(
      ::_CUserMsg_ParticleManager_UpdateParticleEnt_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleEnt& CUserMsg_ParticleManager::update_particle_ent() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_ent)
  return _internal_update_particle_ent();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_ent(
    ::CUserMsg_ParticleManager_UpdateParticleEnt* update_particle_ent) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_ent_);
  }
  _impl_.update_particle_ent_ = update_particle_ent;
  if (update_particle_ent) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_ent)
}
inline ::CUserMsg_ParticleManager_UpdateParticleEnt* CUserMsg_ParticleManager::release_update_particle_ent() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::CUserMsg_ParticleManager_UpdateParticleEnt* temp = _impl_.update_particle_ent_;
  _impl_.update_particle_ent_ = 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 ::CUserMsg_ParticleManager_UpdateParticleEnt* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_ent() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_ent)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::CUserMsg_ParticleManager_UpdateParticleEnt* temp = _impl_.update_particle_ent_;
  _impl_.update_particle_ent_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleEnt* CUserMsg_ParticleManager::_internal_mutable_update_particle_ent() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.update_particle_ent_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleEnt>(GetArenaForAllocation());
    _impl_.update_particle_ent_ = p;
  }
  return _impl_.update_particle_ent_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleEnt* CUserMsg_ParticleManager::mutable_update_particle_ent() {
  ::CUserMsg_ParticleManager_UpdateParticleEnt* _msg = _internal_mutable_update_particle_ent();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_ent)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_ent(::CUserMsg_ParticleManager_UpdateParticleEnt* update_particle_ent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_ent_;
  }
  if (update_particle_ent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_ent);
    if (message_arena != submessage_arena) {
      update_particle_ent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_ent, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.update_particle_ent_ = update_particle_ent;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_ent)
}

// optional .CUserMsg_ParticleManager.UpdateParticleShouldDraw update_particle_should_draw = 14;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_should_draw() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_should_draw_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_should_draw() const {
  return _internal_has_update_particle_should_draw();
}
inline void CUserMsg_ParticleManager::clear_update_particle_should_draw() {
  if (_impl_.update_particle_should_draw_ != nullptr) _impl_.update_particle_should_draw_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw& CUserMsg_ParticleManager::_internal_update_particle_should_draw() const {
  const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* p = _impl_.update_particle_should_draw_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw&>(
      ::_CUserMsg_ParticleManager_UpdateParticleShouldDraw_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleShouldDraw& CUserMsg_ParticleManager::update_particle_should_draw() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_should_draw)
  return _internal_update_particle_should_draw();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_should_draw(
    ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* update_particle_should_draw) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_should_draw_);
  }
  _impl_.update_particle_should_draw_ = update_particle_should_draw;
  if (update_particle_should_draw) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_should_draw)
}
inline ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* CUserMsg_ParticleManager::release_update_particle_should_draw() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* temp = _impl_.update_particle_should_draw_;
  _impl_.update_particle_should_draw_ = 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 ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_should_draw() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_should_draw)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* temp = _impl_.update_particle_should_draw_;
  _impl_.update_particle_should_draw_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* CUserMsg_ParticleManager::_internal_mutable_update_particle_should_draw() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.update_particle_should_draw_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleShouldDraw>(GetArenaForAllocation());
    _impl_.update_particle_should_draw_ = p;
  }
  return _impl_.update_particle_should_draw_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* CUserMsg_ParticleManager::mutable_update_particle_should_draw() {
  ::CUserMsg_ParticleManager_UpdateParticleShouldDraw* _msg = _internal_mutable_update_particle_should_draw();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_should_draw)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_should_draw(::CUserMsg_ParticleManager_UpdateParticleShouldDraw* update_particle_should_draw) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_should_draw_;
  }
  if (update_particle_should_draw) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_should_draw);
    if (message_arena != submessage_arena) {
      update_particle_should_draw = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_should_draw, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.update_particle_should_draw_ = update_particle_should_draw;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_should_draw)
}

// optional .CUserMsg_ParticleManager.UpdateParticleSetFrozen update_particle_set_frozen = 15;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_set_frozen() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_set_frozen_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_set_frozen() const {
  return _internal_has_update_particle_set_frozen();
}
inline void CUserMsg_ParticleManager::clear_update_particle_set_frozen() {
  if (_impl_.update_particle_set_frozen_ != nullptr) _impl_.update_particle_set_frozen_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen& CUserMsg_ParticleManager::_internal_update_particle_set_frozen() const {
  const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* p = _impl_.update_particle_set_frozen_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen&>(
      ::_CUserMsg_ParticleManager_UpdateParticleSetFrozen_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleSetFrozen& CUserMsg_ParticleManager::update_particle_set_frozen() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_set_frozen)
  return _internal_update_particle_set_frozen();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_set_frozen(
    ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* update_particle_set_frozen) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_set_frozen_);
  }
  _impl_.update_particle_set_frozen_ = update_particle_set_frozen;
  if (update_particle_set_frozen) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_set_frozen)
}
inline ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* CUserMsg_ParticleManager::release_update_particle_set_frozen() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* temp = _impl_.update_particle_set_frozen_;
  _impl_.update_particle_set_frozen_ = 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 ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_set_frozen() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_set_frozen)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* temp = _impl_.update_particle_set_frozen_;
  _impl_.update_particle_set_frozen_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* CUserMsg_ParticleManager::_internal_mutable_update_particle_set_frozen() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.update_particle_set_frozen_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleSetFrozen>(GetArenaForAllocation());
    _impl_.update_particle_set_frozen_ = p;
  }
  return _impl_.update_particle_set_frozen_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* CUserMsg_ParticleManager::mutable_update_particle_set_frozen() {
  ::CUserMsg_ParticleManager_UpdateParticleSetFrozen* _msg = _internal_mutable_update_particle_set_frozen();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_set_frozen)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_set_frozen(::CUserMsg_ParticleManager_UpdateParticleSetFrozen* update_particle_set_frozen) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_set_frozen_;
  }
  if (update_particle_set_frozen) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_set_frozen);
    if (message_arena != submessage_arena) {
      update_particle_set_frozen = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_set_frozen, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.update_particle_set_frozen_ = update_particle_set_frozen;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_set_frozen)
}

// optional .CUserMsg_ParticleManager.ChangeControlPointAttachment change_control_point_attachment = 16;
inline bool CUserMsg_ParticleManager::_internal_has_change_control_point_attachment() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.change_control_point_attachment_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_change_control_point_attachment() const {
  return _internal_has_change_control_point_attachment();
}
inline void CUserMsg_ParticleManager::clear_change_control_point_attachment() {
  if (_impl_.change_control_point_attachment_ != nullptr) _impl_.change_control_point_attachment_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::CUserMsg_ParticleManager_ChangeControlPointAttachment& CUserMsg_ParticleManager::_internal_change_control_point_attachment() const {
  const ::CUserMsg_ParticleManager_ChangeControlPointAttachment* p = _impl_.change_control_point_attachment_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ChangeControlPointAttachment&>(
      ::_CUserMsg_ParticleManager_ChangeControlPointAttachment_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ChangeControlPointAttachment& CUserMsg_ParticleManager::change_control_point_attachment() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.change_control_point_attachment)
  return _internal_change_control_point_attachment();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_change_control_point_attachment(
    ::CUserMsg_ParticleManager_ChangeControlPointAttachment* change_control_point_attachment) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.change_control_point_attachment_);
  }
  _impl_.change_control_point_attachment_ = change_control_point_attachment;
  if (change_control_point_attachment) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.change_control_point_attachment)
}
inline ::CUserMsg_ParticleManager_ChangeControlPointAttachment* CUserMsg_ParticleManager::release_change_control_point_attachment() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* temp = _impl_.change_control_point_attachment_;
  _impl_.change_control_point_attachment_ = 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 ::CUserMsg_ParticleManager_ChangeControlPointAttachment* CUserMsg_ParticleManager::unsafe_arena_release_change_control_point_attachment() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.change_control_point_attachment)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* temp = _impl_.change_control_point_attachment_;
  _impl_.change_control_point_attachment_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ChangeControlPointAttachment* CUserMsg_ParticleManager::_internal_mutable_change_control_point_attachment() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.change_control_point_attachment_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ChangeControlPointAttachment>(GetArenaForAllocation());
    _impl_.change_control_point_attachment_ = p;
  }
  return _impl_.change_control_point_attachment_;
}
inline ::CUserMsg_ParticleManager_ChangeControlPointAttachment* CUserMsg_ParticleManager::mutable_change_control_point_attachment() {
  ::CUserMsg_ParticleManager_ChangeControlPointAttachment* _msg = _internal_mutable_change_control_point_attachment();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.change_control_point_attachment)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_change_control_point_attachment(::CUserMsg_ParticleManager_ChangeControlPointAttachment* change_control_point_attachment) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.change_control_point_attachment_;
  }
  if (change_control_point_attachment) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(change_control_point_attachment);
    if (message_arena != submessage_arena) {
      change_control_point_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, change_control_point_attachment, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.change_control_point_attachment_ = change_control_point_attachment;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.change_control_point_attachment)
}

// optional .CUserMsg_ParticleManager.UpdateEntityPosition update_entity_position = 17;
inline bool CUserMsg_ParticleManager::_internal_has_update_entity_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_entity_position_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_entity_position() const {
  return _internal_has_update_entity_position();
}
inline void CUserMsg_ParticleManager::clear_update_entity_position() {
  if (_impl_.update_entity_position_ != nullptr) _impl_.update_entity_position_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::CUserMsg_ParticleManager_UpdateEntityPosition& CUserMsg_ParticleManager::_internal_update_entity_position() const {
  const ::CUserMsg_ParticleManager_UpdateEntityPosition* p = _impl_.update_entity_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateEntityPosition&>(
      ::_CUserMsg_ParticleManager_UpdateEntityPosition_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateEntityPosition& CUserMsg_ParticleManager::update_entity_position() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_entity_position)
  return _internal_update_entity_position();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_entity_position(
    ::CUserMsg_ParticleManager_UpdateEntityPosition* update_entity_position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_entity_position_);
  }
  _impl_.update_entity_position_ = update_entity_position;
  if (update_entity_position) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_entity_position)
}
inline ::CUserMsg_ParticleManager_UpdateEntityPosition* CUserMsg_ParticleManager::release_update_entity_position() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::CUserMsg_ParticleManager_UpdateEntityPosition* temp = _impl_.update_entity_position_;
  _impl_.update_entity_position_ = 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 ::CUserMsg_ParticleManager_UpdateEntityPosition* CUserMsg_ParticleManager::unsafe_arena_release_update_entity_position() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_entity_position)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::CUserMsg_ParticleManager_UpdateEntityPosition* temp = _impl_.update_entity_position_;
  _impl_.update_entity_position_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateEntityPosition* CUserMsg_ParticleManager::_internal_mutable_update_entity_position() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.update_entity_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateEntityPosition>(GetArenaForAllocation());
    _impl_.update_entity_position_ = p;
  }
  return _impl_.update_entity_position_;
}
inline ::CUserMsg_ParticleManager_UpdateEntityPosition* CUserMsg_ParticleManager::mutable_update_entity_position() {
  ::CUserMsg_ParticleManager_UpdateEntityPosition* _msg = _internal_mutable_update_entity_position();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_entity_position)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_entity_position(::CUserMsg_ParticleManager_UpdateEntityPosition* update_entity_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_entity_position_;
  }
  if (update_entity_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_entity_position);
    if (message_arena != submessage_arena) {
      update_entity_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_entity_position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.update_entity_position_ = update_entity_position;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_entity_position)
}

// optional .CUserMsg_ParticleManager.SetParticleFoWProperties set_particle_fow_properties = 18;
inline bool CUserMsg_ParticleManager::_internal_has_set_particle_fow_properties() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_particle_fow_properties_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_particle_fow_properties() const {
  return _internal_has_set_particle_fow_properties();
}
inline void CUserMsg_ParticleManager::clear_set_particle_fow_properties() {
  if (_impl_.set_particle_fow_properties_ != nullptr) _impl_.set_particle_fow_properties_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::CUserMsg_ParticleManager_SetParticleFoWProperties& CUserMsg_ParticleManager::_internal_set_particle_fow_properties() const {
  const ::CUserMsg_ParticleManager_SetParticleFoWProperties* p = _impl_.set_particle_fow_properties_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetParticleFoWProperties&>(
      ::_CUserMsg_ParticleManager_SetParticleFoWProperties_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetParticleFoWProperties& CUserMsg_ParticleManager::set_particle_fow_properties() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_particle_fow_properties)
  return _internal_set_particle_fow_properties();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_particle_fow_properties(
    ::CUserMsg_ParticleManager_SetParticleFoWProperties* set_particle_fow_properties) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_particle_fow_properties_);
  }
  _impl_.set_particle_fow_properties_ = set_particle_fow_properties;
  if (set_particle_fow_properties) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_particle_fow_properties)
}
inline ::CUserMsg_ParticleManager_SetParticleFoWProperties* CUserMsg_ParticleManager::release_set_particle_fow_properties() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* temp = _impl_.set_particle_fow_properties_;
  _impl_.set_particle_fow_properties_ = 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 ::CUserMsg_ParticleManager_SetParticleFoWProperties* CUserMsg_ParticleManager::unsafe_arena_release_set_particle_fow_properties() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_particle_fow_properties)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* temp = _impl_.set_particle_fow_properties_;
  _impl_.set_particle_fow_properties_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetParticleFoWProperties* CUserMsg_ParticleManager::_internal_mutable_set_particle_fow_properties() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.set_particle_fow_properties_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleFoWProperties>(GetArenaForAllocation());
    _impl_.set_particle_fow_properties_ = p;
  }
  return _impl_.set_particle_fow_properties_;
}
inline ::CUserMsg_ParticleManager_SetParticleFoWProperties* CUserMsg_ParticleManager::mutable_set_particle_fow_properties() {
  ::CUserMsg_ParticleManager_SetParticleFoWProperties* _msg = _internal_mutable_set_particle_fow_properties();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_particle_fow_properties)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_particle_fow_properties(::CUserMsg_ParticleManager_SetParticleFoWProperties* set_particle_fow_properties) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_particle_fow_properties_;
  }
  if (set_particle_fow_properties) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_particle_fow_properties);
    if (message_arena != submessage_arena) {
      set_particle_fow_properties = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_particle_fow_properties, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.set_particle_fow_properties_ = set_particle_fow_properties;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_particle_fow_properties)
}

// optional .CUserMsg_ParticleManager.SetParticleText set_particle_text = 19;
inline bool CUserMsg_ParticleManager::_internal_has_set_particle_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_particle_text_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_particle_text() const {
  return _internal_has_set_particle_text();
}
inline void CUserMsg_ParticleManager::clear_set_particle_text() {
  if (_impl_.set_particle_text_ != nullptr) _impl_.set_particle_text_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::CUserMsg_ParticleManager_SetParticleText& CUserMsg_ParticleManager::_internal_set_particle_text() const {
  const ::CUserMsg_ParticleManager_SetParticleText* p = _impl_.set_particle_text_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetParticleText&>(
      ::_CUserMsg_ParticleManager_SetParticleText_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetParticleText& CUserMsg_ParticleManager::set_particle_text() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_particle_text)
  return _internal_set_particle_text();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_particle_text(
    ::CUserMsg_ParticleManager_SetParticleText* set_particle_text) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_particle_text_);
  }
  _impl_.set_particle_text_ = set_particle_text;
  if (set_particle_text) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_particle_text)
}
inline ::CUserMsg_ParticleManager_SetParticleText* CUserMsg_ParticleManager::release_set_particle_text() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::CUserMsg_ParticleManager_SetParticleText* temp = _impl_.set_particle_text_;
  _impl_.set_particle_text_ = 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 ::CUserMsg_ParticleManager_SetParticleText* CUserMsg_ParticleManager::unsafe_arena_release_set_particle_text() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_particle_text)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::CUserMsg_ParticleManager_SetParticleText* temp = _impl_.set_particle_text_;
  _impl_.set_particle_text_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetParticleText* CUserMsg_ParticleManager::_internal_mutable_set_particle_text() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.set_particle_text_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleText>(GetArenaForAllocation());
    _impl_.set_particle_text_ = p;
  }
  return _impl_.set_particle_text_;
}
inline ::CUserMsg_ParticleManager_SetParticleText* CUserMsg_ParticleManager::mutable_set_particle_text() {
  ::CUserMsg_ParticleManager_SetParticleText* _msg = _internal_mutable_set_particle_text();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_particle_text)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_particle_text(::CUserMsg_ParticleManager_SetParticleText* set_particle_text) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_particle_text_;
  }
  if (set_particle_text) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_particle_text);
    if (message_arena != submessage_arena) {
      set_particle_text = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_particle_text, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.set_particle_text_ = set_particle_text;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_particle_text)
}

// optional .CUserMsg_ParticleManager.SetParticleShouldCheckFoW set_particle_should_check_fow = 20;
inline bool CUserMsg_ParticleManager::_internal_has_set_particle_should_check_fow() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_particle_should_check_fow_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_particle_should_check_fow() const {
  return _internal_has_set_particle_should_check_fow();
}
inline void CUserMsg_ParticleManager::clear_set_particle_should_check_fow() {
  if (_impl_.set_particle_should_check_fow_ != nullptr) _impl_.set_particle_should_check_fow_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW& CUserMsg_ParticleManager::_internal_set_particle_should_check_fow() const {
  const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* p = _impl_.set_particle_should_check_fow_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW&>(
      ::_CUserMsg_ParticleManager_SetParticleShouldCheckFoW_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW& CUserMsg_ParticleManager::set_particle_should_check_fow() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_particle_should_check_fow)
  return _internal_set_particle_should_check_fow();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_particle_should_check_fow(
    ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* set_particle_should_check_fow) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_particle_should_check_fow_);
  }
  _impl_.set_particle_should_check_fow_ = set_particle_should_check_fow;
  if (set_particle_should_check_fow) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_particle_should_check_fow)
}
inline ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* CUserMsg_ParticleManager::release_set_particle_should_check_fow() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* temp = _impl_.set_particle_should_check_fow_;
  _impl_.set_particle_should_check_fow_ = 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 ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* CUserMsg_ParticleManager::unsafe_arena_release_set_particle_should_check_fow() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_particle_should_check_fow)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* temp = _impl_.set_particle_should_check_fow_;
  _impl_.set_particle_should_check_fow_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* CUserMsg_ParticleManager::_internal_mutable_set_particle_should_check_fow() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.set_particle_should_check_fow_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleShouldCheckFoW>(GetArenaForAllocation());
    _impl_.set_particle_should_check_fow_ = p;
  }
  return _impl_.set_particle_should_check_fow_;
}
inline ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* CUserMsg_ParticleManager::mutable_set_particle_should_check_fow() {
  ::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* _msg = _internal_mutable_set_particle_should_check_fow();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_particle_should_check_fow)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_particle_should_check_fow(::CUserMsg_ParticleManager_SetParticleShouldCheckFoW* set_particle_should_check_fow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_particle_should_check_fow_;
  }
  if (set_particle_should_check_fow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_particle_should_check_fow);
    if (message_arena != submessage_arena) {
      set_particle_should_check_fow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_particle_should_check_fow, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.set_particle_should_check_fow_ = set_particle_should_check_fow;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_particle_should_check_fow)
}

// optional .CUserMsg_ParticleManager.SetControlPointModel set_control_point_model = 21;
inline bool CUserMsg_ParticleManager::_internal_has_set_control_point_model() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_control_point_model_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_control_point_model() const {
  return _internal_has_set_control_point_model();
}
inline void CUserMsg_ParticleManager::clear_set_control_point_model() {
  if (_impl_.set_control_point_model_ != nullptr) _impl_.set_control_point_model_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::CUserMsg_ParticleManager_SetControlPointModel& CUserMsg_ParticleManager::_internal_set_control_point_model() const {
  const ::CUserMsg_ParticleManager_SetControlPointModel* p = _impl_.set_control_point_model_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetControlPointModel&>(
      ::_CUserMsg_ParticleManager_SetControlPointModel_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetControlPointModel& CUserMsg_ParticleManager::set_control_point_model() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_control_point_model)
  return _internal_set_control_point_model();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_control_point_model(
    ::CUserMsg_ParticleManager_SetControlPointModel* set_control_point_model) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_control_point_model_);
  }
  _impl_.set_control_point_model_ = set_control_point_model;
  if (set_control_point_model) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_control_point_model)
}
inline ::CUserMsg_ParticleManager_SetControlPointModel* CUserMsg_ParticleManager::release_set_control_point_model() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::CUserMsg_ParticleManager_SetControlPointModel* temp = _impl_.set_control_point_model_;
  _impl_.set_control_point_model_ = 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 ::CUserMsg_ParticleManager_SetControlPointModel* CUserMsg_ParticleManager::unsafe_arena_release_set_control_point_model() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_control_point_model)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::CUserMsg_ParticleManager_SetControlPointModel* temp = _impl_.set_control_point_model_;
  _impl_.set_control_point_model_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetControlPointModel* CUserMsg_ParticleManager::_internal_mutable_set_control_point_model() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.set_control_point_model_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetControlPointModel>(GetArenaForAllocation());
    _impl_.set_control_point_model_ = p;
  }
  return _impl_.set_control_point_model_;
}
inline ::CUserMsg_ParticleManager_SetControlPointModel* CUserMsg_ParticleManager::mutable_set_control_point_model() {
  ::CUserMsg_ParticleManager_SetControlPointModel* _msg = _internal_mutable_set_control_point_model();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_control_point_model)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_control_point_model(::CUserMsg_ParticleManager_SetControlPointModel* set_control_point_model) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_control_point_model_;
  }
  if (set_control_point_model) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_control_point_model);
    if (message_arena != submessage_arena) {
      set_control_point_model = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_control_point_model, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.set_control_point_model_ = set_control_point_model;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_control_point_model)
}

// optional .CUserMsg_ParticleManager.SetControlPointSnapshot set_control_point_snapshot = 22;
inline bool CUserMsg_ParticleManager::_internal_has_set_control_point_snapshot() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_control_point_snapshot_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_control_point_snapshot() const {
  return _internal_has_set_control_point_snapshot();
}
inline void CUserMsg_ParticleManager::clear_set_control_point_snapshot() {
  if (_impl_.set_control_point_snapshot_ != nullptr) _impl_.set_control_point_snapshot_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::CUserMsg_ParticleManager_SetControlPointSnapshot& CUserMsg_ParticleManager::_internal_set_control_point_snapshot() const {
  const ::CUserMsg_ParticleManager_SetControlPointSnapshot* p = _impl_.set_control_point_snapshot_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetControlPointSnapshot&>(
      ::_CUserMsg_ParticleManager_SetControlPointSnapshot_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetControlPointSnapshot& CUserMsg_ParticleManager::set_control_point_snapshot() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_control_point_snapshot)
  return _internal_set_control_point_snapshot();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_control_point_snapshot(
    ::CUserMsg_ParticleManager_SetControlPointSnapshot* set_control_point_snapshot) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_control_point_snapshot_);
  }
  _impl_.set_control_point_snapshot_ = set_control_point_snapshot;
  if (set_control_point_snapshot) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_control_point_snapshot)
}
inline ::CUserMsg_ParticleManager_SetControlPointSnapshot* CUserMsg_ParticleManager::release_set_control_point_snapshot() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* temp = _impl_.set_control_point_snapshot_;
  _impl_.set_control_point_snapshot_ = 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 ::CUserMsg_ParticleManager_SetControlPointSnapshot* CUserMsg_ParticleManager::unsafe_arena_release_set_control_point_snapshot() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_control_point_snapshot)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* temp = _impl_.set_control_point_snapshot_;
  _impl_.set_control_point_snapshot_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetControlPointSnapshot* CUserMsg_ParticleManager::_internal_mutable_set_control_point_snapshot() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.set_control_point_snapshot_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetControlPointSnapshot>(GetArenaForAllocation());
    _impl_.set_control_point_snapshot_ = p;
  }
  return _impl_.set_control_point_snapshot_;
}
inline ::CUserMsg_ParticleManager_SetControlPointSnapshot* CUserMsg_ParticleManager::mutable_set_control_point_snapshot() {
  ::CUserMsg_ParticleManager_SetControlPointSnapshot* _msg = _internal_mutable_set_control_point_snapshot();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_control_point_snapshot)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_control_point_snapshot(::CUserMsg_ParticleManager_SetControlPointSnapshot* set_control_point_snapshot) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_control_point_snapshot_;
  }
  if (set_control_point_snapshot) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_control_point_snapshot);
    if (message_arena != submessage_arena) {
      set_control_point_snapshot = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_control_point_snapshot, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.set_control_point_snapshot_ = set_control_point_snapshot;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_control_point_snapshot)
}

// optional .CUserMsg_ParticleManager.SetTextureAttribute set_texture_attribute = 23;
inline bool CUserMsg_ParticleManager::_internal_has_set_texture_attribute() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_texture_attribute_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_texture_attribute() const {
  return _internal_has_set_texture_attribute();
}
inline void CUserMsg_ParticleManager::clear_set_texture_attribute() {
  if (_impl_.set_texture_attribute_ != nullptr) _impl_.set_texture_attribute_->Clear();
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const ::CUserMsg_ParticleManager_SetTextureAttribute& CUserMsg_ParticleManager::_internal_set_texture_attribute() const {
  const ::CUserMsg_ParticleManager_SetTextureAttribute* p = _impl_.set_texture_attribute_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetTextureAttribute&>(
      ::_CUserMsg_ParticleManager_SetTextureAttribute_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetTextureAttribute& CUserMsg_ParticleManager::set_texture_attribute() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_texture_attribute)
  return _internal_set_texture_attribute();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_texture_attribute(
    ::CUserMsg_ParticleManager_SetTextureAttribute* set_texture_attribute) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_texture_attribute_);
  }
  _impl_.set_texture_attribute_ = set_texture_attribute;
  if (set_texture_attribute) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_texture_attribute)
}
inline ::CUserMsg_ParticleManager_SetTextureAttribute* CUserMsg_ParticleManager::release_set_texture_attribute() {
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::CUserMsg_ParticleManager_SetTextureAttribute* temp = _impl_.set_texture_attribute_;
  _impl_.set_texture_attribute_ = 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 ::CUserMsg_ParticleManager_SetTextureAttribute* CUserMsg_ParticleManager::unsafe_arena_release_set_texture_attribute() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_texture_attribute)
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::CUserMsg_ParticleManager_SetTextureAttribute* temp = _impl_.set_texture_attribute_;
  _impl_.set_texture_attribute_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetTextureAttribute* CUserMsg_ParticleManager::_internal_mutable_set_texture_attribute() {
  _impl_._has_bits_[0] |= 0x00080000u;
  if (_impl_.set_texture_attribute_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetTextureAttribute>(GetArenaForAllocation());
    _impl_.set_texture_attribute_ = p;
  }
  return _impl_.set_texture_attribute_;
}
inline ::CUserMsg_ParticleManager_SetTextureAttribute* CUserMsg_ParticleManager::mutable_set_texture_attribute() {
  ::CUserMsg_ParticleManager_SetTextureAttribute* _msg = _internal_mutable_set_texture_attribute();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_texture_attribute)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_texture_attribute(::CUserMsg_ParticleManager_SetTextureAttribute* set_texture_attribute) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_texture_attribute_;
  }
  if (set_texture_attribute) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_texture_attribute);
    if (message_arena != submessage_arena) {
      set_texture_attribute = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_texture_attribute, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.set_texture_attribute_ = set_texture_attribute;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_texture_attribute)
}

// optional .CUserMsg_ParticleManager.SetSceneObjectGenericFlag set_scene_object_generic_flag = 24;
inline bool CUserMsg_ParticleManager::_internal_has_set_scene_object_generic_flag() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_scene_object_generic_flag_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_scene_object_generic_flag() const {
  return _internal_has_set_scene_object_generic_flag();
}
inline void CUserMsg_ParticleManager::clear_set_scene_object_generic_flag() {
  if (_impl_.set_scene_object_generic_flag_ != nullptr) _impl_.set_scene_object_generic_flag_->Clear();
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag& CUserMsg_ParticleManager::_internal_set_scene_object_generic_flag() const {
  const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* p = _impl_.set_scene_object_generic_flag_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag&>(
      ::_CUserMsg_ParticleManager_SetSceneObjectGenericFlag_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag& CUserMsg_ParticleManager::set_scene_object_generic_flag() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_scene_object_generic_flag)
  return _internal_set_scene_object_generic_flag();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_scene_object_generic_flag(
    ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* set_scene_object_generic_flag) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_scene_object_generic_flag_);
  }
  _impl_.set_scene_object_generic_flag_ = set_scene_object_generic_flag;
  if (set_scene_object_generic_flag) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_scene_object_generic_flag)
}
inline ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* CUserMsg_ParticleManager::release_set_scene_object_generic_flag() {
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* temp = _impl_.set_scene_object_generic_flag_;
  _impl_.set_scene_object_generic_flag_ = 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 ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* CUserMsg_ParticleManager::unsafe_arena_release_set_scene_object_generic_flag() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_scene_object_generic_flag)
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* temp = _impl_.set_scene_object_generic_flag_;
  _impl_.set_scene_object_generic_flag_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* CUserMsg_ParticleManager::_internal_mutable_set_scene_object_generic_flag() {
  _impl_._has_bits_[0] |= 0x00100000u;
  if (_impl_.set_scene_object_generic_flag_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetSceneObjectGenericFlag>(GetArenaForAllocation());
    _impl_.set_scene_object_generic_flag_ = p;
  }
  return _impl_.set_scene_object_generic_flag_;
}
inline ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* CUserMsg_ParticleManager::mutable_set_scene_object_generic_flag() {
  ::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* _msg = _internal_mutable_set_scene_object_generic_flag();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_scene_object_generic_flag)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_scene_object_generic_flag(::CUserMsg_ParticleManager_SetSceneObjectGenericFlag* set_scene_object_generic_flag) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_scene_object_generic_flag_;
  }
  if (set_scene_object_generic_flag) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_scene_object_generic_flag);
    if (message_arena != submessage_arena) {
      set_scene_object_generic_flag = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_scene_object_generic_flag, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.set_scene_object_generic_flag_ = set_scene_object_generic_flag;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_scene_object_generic_flag)
}

// optional .CUserMsg_ParticleManager.SetSceneObjectTintAndDesat set_scene_object_tint_and_desat = 25;
inline bool CUserMsg_ParticleManager::_internal_has_set_scene_object_tint_and_desat() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_scene_object_tint_and_desat_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_scene_object_tint_and_desat() const {
  return _internal_has_set_scene_object_tint_and_desat();
}
inline void CUserMsg_ParticleManager::clear_set_scene_object_tint_and_desat() {
  if (_impl_.set_scene_object_tint_and_desat_ != nullptr) _impl_.set_scene_object_tint_and_desat_->Clear();
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& CUserMsg_ParticleManager::_internal_set_scene_object_tint_and_desat() const {
  const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* p = _impl_.set_scene_object_tint_and_desat_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat&>(
      ::_CUserMsg_ParticleManager_SetSceneObjectTintAndDesat_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat& CUserMsg_ParticleManager::set_scene_object_tint_and_desat() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_scene_object_tint_and_desat)
  return _internal_set_scene_object_tint_and_desat();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_scene_object_tint_and_desat(
    ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* set_scene_object_tint_and_desat) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_scene_object_tint_and_desat_);
  }
  _impl_.set_scene_object_tint_and_desat_ = set_scene_object_tint_and_desat;
  if (set_scene_object_tint_and_desat) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_scene_object_tint_and_desat)
}
inline ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* CUserMsg_ParticleManager::release_set_scene_object_tint_and_desat() {
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* temp = _impl_.set_scene_object_tint_and_desat_;
  _impl_.set_scene_object_tint_and_desat_ = 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 ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* CUserMsg_ParticleManager::unsafe_arena_release_set_scene_object_tint_and_desat() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_scene_object_tint_and_desat)
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* temp = _impl_.set_scene_object_tint_and_desat_;
  _impl_.set_scene_object_tint_and_desat_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* CUserMsg_ParticleManager::_internal_mutable_set_scene_object_tint_and_desat() {
  _impl_._has_bits_[0] |= 0x00200000u;
  if (_impl_.set_scene_object_tint_and_desat_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat>(GetArenaForAllocation());
    _impl_.set_scene_object_tint_and_desat_ = p;
  }
  return _impl_.set_scene_object_tint_and_desat_;
}
inline ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* CUserMsg_ParticleManager::mutable_set_scene_object_tint_and_desat() {
  ::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* _msg = _internal_mutable_set_scene_object_tint_and_desat();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_scene_object_tint_and_desat)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_scene_object_tint_and_desat(::CUserMsg_ParticleManager_SetSceneObjectTintAndDesat* set_scene_object_tint_and_desat) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_scene_object_tint_and_desat_;
  }
  if (set_scene_object_tint_and_desat) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_scene_object_tint_and_desat);
    if (message_arena != submessage_arena) {
      set_scene_object_tint_and_desat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_scene_object_tint_and_desat, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.set_scene_object_tint_and_desat_ = set_scene_object_tint_and_desat;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_scene_object_tint_and_desat)
}

// optional .CUserMsg_ParticleManager.DestroyParticleNamed destroy_particle_named = 26;
inline bool CUserMsg_ParticleManager::_internal_has_destroy_particle_named() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.destroy_particle_named_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_destroy_particle_named() const {
  return _internal_has_destroy_particle_named();
}
inline void CUserMsg_ParticleManager::clear_destroy_particle_named() {
  if (_impl_.destroy_particle_named_ != nullptr) _impl_.destroy_particle_named_->Clear();
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline const ::CUserMsg_ParticleManager_DestroyParticleNamed& CUserMsg_ParticleManager::_internal_destroy_particle_named() const {
  const ::CUserMsg_ParticleManager_DestroyParticleNamed* p = _impl_.destroy_particle_named_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_DestroyParticleNamed&>(
      ::_CUserMsg_ParticleManager_DestroyParticleNamed_default_instance_);
}
inline const ::CUserMsg_ParticleManager_DestroyParticleNamed& CUserMsg_ParticleManager::destroy_particle_named() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.destroy_particle_named)
  return _internal_destroy_particle_named();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_destroy_particle_named(
    ::CUserMsg_ParticleManager_DestroyParticleNamed* destroy_particle_named) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.destroy_particle_named_);
  }
  _impl_.destroy_particle_named_ = destroy_particle_named;
  if (destroy_particle_named) {
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.destroy_particle_named)
}
inline ::CUserMsg_ParticleManager_DestroyParticleNamed* CUserMsg_ParticleManager::release_destroy_particle_named() {
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::CUserMsg_ParticleManager_DestroyParticleNamed* temp = _impl_.destroy_particle_named_;
  _impl_.destroy_particle_named_ = 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 ::CUserMsg_ParticleManager_DestroyParticleNamed* CUserMsg_ParticleManager::unsafe_arena_release_destroy_particle_named() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.destroy_particle_named)
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::CUserMsg_ParticleManager_DestroyParticleNamed* temp = _impl_.destroy_particle_named_;
  _impl_.destroy_particle_named_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_DestroyParticleNamed* CUserMsg_ParticleManager::_internal_mutable_destroy_particle_named() {
  _impl_._has_bits_[0] |= 0x00400000u;
  if (_impl_.destroy_particle_named_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyParticleNamed>(GetArenaForAllocation());
    _impl_.destroy_particle_named_ = p;
  }
  return _impl_.destroy_particle_named_;
}
inline ::CUserMsg_ParticleManager_DestroyParticleNamed* CUserMsg_ParticleManager::mutable_destroy_particle_named() {
  ::CUserMsg_ParticleManager_DestroyParticleNamed* _msg = _internal_mutable_destroy_particle_named();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.destroy_particle_named)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_destroy_particle_named(::CUserMsg_ParticleManager_DestroyParticleNamed* destroy_particle_named) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.destroy_particle_named_;
  }
  if (destroy_particle_named) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(destroy_particle_named);
    if (message_arena != submessage_arena) {
      destroy_particle_named = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, destroy_particle_named, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  _impl_.destroy_particle_named_ = destroy_particle_named;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.destroy_particle_named)
}

// optional .CUserMsg_ParticleManager.ParticleSkipToTime particle_skip_to_time = 27;
inline bool CUserMsg_ParticleManager::_internal_has_particle_skip_to_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.particle_skip_to_time_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_particle_skip_to_time() const {
  return _internal_has_particle_skip_to_time();
}
inline void CUserMsg_ParticleManager::clear_particle_skip_to_time() {
  if (_impl_.particle_skip_to_time_ != nullptr) _impl_.particle_skip_to_time_->Clear();
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline const ::CUserMsg_ParticleManager_ParticleSkipToTime& CUserMsg_ParticleManager::_internal_particle_skip_to_time() const {
  const ::CUserMsg_ParticleManager_ParticleSkipToTime* p = _impl_.particle_skip_to_time_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ParticleSkipToTime&>(
      ::_CUserMsg_ParticleManager_ParticleSkipToTime_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ParticleSkipToTime& CUserMsg_ParticleManager::particle_skip_to_time() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.particle_skip_to_time)
  return _internal_particle_skip_to_time();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_particle_skip_to_time(
    ::CUserMsg_ParticleManager_ParticleSkipToTime* particle_skip_to_time) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.particle_skip_to_time_);
  }
  _impl_.particle_skip_to_time_ = particle_skip_to_time;
  if (particle_skip_to_time) {
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.particle_skip_to_time)
}
inline ::CUserMsg_ParticleManager_ParticleSkipToTime* CUserMsg_ParticleManager::release_particle_skip_to_time() {
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::CUserMsg_ParticleManager_ParticleSkipToTime* temp = _impl_.particle_skip_to_time_;
  _impl_.particle_skip_to_time_ = 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 ::CUserMsg_ParticleManager_ParticleSkipToTime* CUserMsg_ParticleManager::unsafe_arena_release_particle_skip_to_time() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.particle_skip_to_time)
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::CUserMsg_ParticleManager_ParticleSkipToTime* temp = _impl_.particle_skip_to_time_;
  _impl_.particle_skip_to_time_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ParticleSkipToTime* CUserMsg_ParticleManager::_internal_mutable_particle_skip_to_time() {
  _impl_._has_bits_[0] |= 0x00800000u;
  if (_impl_.particle_skip_to_time_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleSkipToTime>(GetArenaForAllocation());
    _impl_.particle_skip_to_time_ = p;
  }
  return _impl_.particle_skip_to_time_;
}
inline ::CUserMsg_ParticleManager_ParticleSkipToTime* CUserMsg_ParticleManager::mutable_particle_skip_to_time() {
  ::CUserMsg_ParticleManager_ParticleSkipToTime* _msg = _internal_mutable_particle_skip_to_time();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.particle_skip_to_time)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_particle_skip_to_time(::CUserMsg_ParticleManager_ParticleSkipToTime* particle_skip_to_time) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.particle_skip_to_time_;
  }
  if (particle_skip_to_time) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(particle_skip_to_time);
    if (message_arena != submessage_arena) {
      particle_skip_to_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, particle_skip_to_time, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  _impl_.particle_skip_to_time_ = particle_skip_to_time;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.particle_skip_to_time)
}

// optional .CUserMsg_ParticleManager.ParticleCanFreeze particle_can_freeze = 28;
inline bool CUserMsg_ParticleManager::_internal_has_particle_can_freeze() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.particle_can_freeze_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_particle_can_freeze() const {
  return _internal_has_particle_can_freeze();
}
inline void CUserMsg_ParticleManager::clear_particle_can_freeze() {
  if (_impl_.particle_can_freeze_ != nullptr) _impl_.particle_can_freeze_->Clear();
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline const ::CUserMsg_ParticleManager_ParticleCanFreeze& CUserMsg_ParticleManager::_internal_particle_can_freeze() const {
  const ::CUserMsg_ParticleManager_ParticleCanFreeze* p = _impl_.particle_can_freeze_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ParticleCanFreeze&>(
      ::_CUserMsg_ParticleManager_ParticleCanFreeze_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ParticleCanFreeze& CUserMsg_ParticleManager::particle_can_freeze() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.particle_can_freeze)
  return _internal_particle_can_freeze();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_particle_can_freeze(
    ::CUserMsg_ParticleManager_ParticleCanFreeze* particle_can_freeze) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.particle_can_freeze_);
  }
  _impl_.particle_can_freeze_ = particle_can_freeze;
  if (particle_can_freeze) {
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.particle_can_freeze)
}
inline ::CUserMsg_ParticleManager_ParticleCanFreeze* CUserMsg_ParticleManager::release_particle_can_freeze() {
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::CUserMsg_ParticleManager_ParticleCanFreeze* temp = _impl_.particle_can_freeze_;
  _impl_.particle_can_freeze_ = 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 ::CUserMsg_ParticleManager_ParticleCanFreeze* CUserMsg_ParticleManager::unsafe_arena_release_particle_can_freeze() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.particle_can_freeze)
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::CUserMsg_ParticleManager_ParticleCanFreeze* temp = _impl_.particle_can_freeze_;
  _impl_.particle_can_freeze_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ParticleCanFreeze* CUserMsg_ParticleManager::_internal_mutable_particle_can_freeze() {
  _impl_._has_bits_[0] |= 0x01000000u;
  if (_impl_.particle_can_freeze_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleCanFreeze>(GetArenaForAllocation());
    _impl_.particle_can_freeze_ = p;
  }
  return _impl_.particle_can_freeze_;
}
inline ::CUserMsg_ParticleManager_ParticleCanFreeze* CUserMsg_ParticleManager::mutable_particle_can_freeze() {
  ::CUserMsg_ParticleManager_ParticleCanFreeze* _msg = _internal_mutable_particle_can_freeze();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.particle_can_freeze)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_particle_can_freeze(::CUserMsg_ParticleManager_ParticleCanFreeze* particle_can_freeze) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.particle_can_freeze_;
  }
  if (particle_can_freeze) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(particle_can_freeze);
    if (message_arena != submessage_arena) {
      particle_can_freeze = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, particle_can_freeze, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  _impl_.particle_can_freeze_ = particle_can_freeze;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.particle_can_freeze)
}

// optional .CUserMsg_ParticleManager.SetParticleNamedValueContext set_named_value_context = 29;
inline bool CUserMsg_ParticleManager::_internal_has_set_named_value_context() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_named_value_context_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_named_value_context() const {
  return _internal_has_set_named_value_context();
}
inline void CUserMsg_ParticleManager::clear_set_named_value_context() {
  if (_impl_.set_named_value_context_ != nullptr) _impl_.set_named_value_context_->Clear();
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext& CUserMsg_ParticleManager::_internal_set_named_value_context() const {
  const ::CUserMsg_ParticleManager_SetParticleNamedValueContext* p = _impl_.set_named_value_context_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetParticleNamedValueContext&>(
      ::_CUserMsg_ParticleManager_SetParticleNamedValueContext_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetParticleNamedValueContext& CUserMsg_ParticleManager::set_named_value_context() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_named_value_context)
  return _internal_set_named_value_context();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_named_value_context(
    ::CUserMsg_ParticleManager_SetParticleNamedValueContext* set_named_value_context) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_named_value_context_);
  }
  _impl_.set_named_value_context_ = set_named_value_context;
  if (set_named_value_context) {
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_named_value_context)
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext* CUserMsg_ParticleManager::release_set_named_value_context() {
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* temp = _impl_.set_named_value_context_;
  _impl_.set_named_value_context_ = 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 ::CUserMsg_ParticleManager_SetParticleNamedValueContext* CUserMsg_ParticleManager::unsafe_arena_release_set_named_value_context() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_named_value_context)
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* temp = _impl_.set_named_value_context_;
  _impl_.set_named_value_context_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext* CUserMsg_ParticleManager::_internal_mutable_set_named_value_context() {
  _impl_._has_bits_[0] |= 0x02000000u;
  if (_impl_.set_named_value_context_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleNamedValueContext>(GetArenaForAllocation());
    _impl_.set_named_value_context_ = p;
  }
  return _impl_.set_named_value_context_;
}
inline ::CUserMsg_ParticleManager_SetParticleNamedValueContext* CUserMsg_ParticleManager::mutable_set_named_value_context() {
  ::CUserMsg_ParticleManager_SetParticleNamedValueContext* _msg = _internal_mutable_set_named_value_context();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_named_value_context)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_named_value_context(::CUserMsg_ParticleManager_SetParticleNamedValueContext* set_named_value_context) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_named_value_context_;
  }
  if (set_named_value_context) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_named_value_context);
    if (message_arena != submessage_arena) {
      set_named_value_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_named_value_context, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  _impl_.set_named_value_context_ = set_named_value_context;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_named_value_context)
}

// optional .CUserMsg_ParticleManager.UpdateParticleTransform update_particle_transform = 30;
inline bool CUserMsg_ParticleManager::_internal_has_update_particle_transform() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_particle_transform_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_particle_transform() const {
  return _internal_has_update_particle_transform();
}
inline void CUserMsg_ParticleManager::clear_update_particle_transform() {
  if (_impl_.update_particle_transform_ != nullptr) _impl_.update_particle_transform_->Clear();
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline const ::CUserMsg_ParticleManager_UpdateParticleTransform& CUserMsg_ParticleManager::_internal_update_particle_transform() const {
  const ::CUserMsg_ParticleManager_UpdateParticleTransform* p = _impl_.update_particle_transform_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateParticleTransform&>(
      ::_CUserMsg_ParticleManager_UpdateParticleTransform_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateParticleTransform& CUserMsg_ParticleManager::update_particle_transform() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_particle_transform)
  return _internal_update_particle_transform();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_particle_transform(
    ::CUserMsg_ParticleManager_UpdateParticleTransform* update_particle_transform) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_particle_transform_);
  }
  _impl_.update_particle_transform_ = update_particle_transform;
  if (update_particle_transform) {
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_particle_transform)
}
inline ::CUserMsg_ParticleManager_UpdateParticleTransform* CUserMsg_ParticleManager::release_update_particle_transform() {
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::CUserMsg_ParticleManager_UpdateParticleTransform* temp = _impl_.update_particle_transform_;
  _impl_.update_particle_transform_ = 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 ::CUserMsg_ParticleManager_UpdateParticleTransform* CUserMsg_ParticleManager::unsafe_arena_release_update_particle_transform() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_particle_transform)
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::CUserMsg_ParticleManager_UpdateParticleTransform* temp = _impl_.update_particle_transform_;
  _impl_.update_particle_transform_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateParticleTransform* CUserMsg_ParticleManager::_internal_mutable_update_particle_transform() {
  _impl_._has_bits_[0] |= 0x04000000u;
  if (_impl_.update_particle_transform_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateParticleTransform>(GetArenaForAllocation());
    _impl_.update_particle_transform_ = p;
  }
  return _impl_.update_particle_transform_;
}
inline ::CUserMsg_ParticleManager_UpdateParticleTransform* CUserMsg_ParticleManager::mutable_update_particle_transform() {
  ::CUserMsg_ParticleManager_UpdateParticleTransform* _msg = _internal_mutable_update_particle_transform();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_particle_transform)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_particle_transform(::CUserMsg_ParticleManager_UpdateParticleTransform* update_particle_transform) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_particle_transform_;
  }
  if (update_particle_transform) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_particle_transform);
    if (message_arena != submessage_arena) {
      update_particle_transform = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_particle_transform, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  _impl_.update_particle_transform_ = update_particle_transform;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_particle_transform)
}

// optional .CUserMsg_ParticleManager.ParticleFreezeTransitionOverride particle_freeze_transition_override = 31;
inline bool CUserMsg_ParticleManager::_internal_has_particle_freeze_transition_override() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.particle_freeze_transition_override_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_particle_freeze_transition_override() const {
  return _internal_has_particle_freeze_transition_override();
}
inline void CUserMsg_ParticleManager::clear_particle_freeze_transition_override() {
  if (_impl_.particle_freeze_transition_override_ != nullptr) _impl_.particle_freeze_transition_override_->Clear();
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& CUserMsg_ParticleManager::_internal_particle_freeze_transition_override() const {
  const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* p = _impl_.particle_freeze_transition_override_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride&>(
      ::_CUserMsg_ParticleManager_ParticleFreezeTransitionOverride_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride& CUserMsg_ParticleManager::particle_freeze_transition_override() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.particle_freeze_transition_override)
  return _internal_particle_freeze_transition_override();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_particle_freeze_transition_override(
    ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* particle_freeze_transition_override) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.particle_freeze_transition_override_);
  }
  _impl_.particle_freeze_transition_override_ = particle_freeze_transition_override;
  if (particle_freeze_transition_override) {
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.particle_freeze_transition_override)
}
inline ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* CUserMsg_ParticleManager::release_particle_freeze_transition_override() {
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* temp = _impl_.particle_freeze_transition_override_;
  _impl_.particle_freeze_transition_override_ = 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 ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* CUserMsg_ParticleManager::unsafe_arena_release_particle_freeze_transition_override() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.particle_freeze_transition_override)
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* temp = _impl_.particle_freeze_transition_override_;
  _impl_.particle_freeze_transition_override_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* CUserMsg_ParticleManager::_internal_mutable_particle_freeze_transition_override() {
  _impl_._has_bits_[0] |= 0x08000000u;
  if (_impl_.particle_freeze_transition_override_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride>(GetArenaForAllocation());
    _impl_.particle_freeze_transition_override_ = p;
  }
  return _impl_.particle_freeze_transition_override_;
}
inline ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* CUserMsg_ParticleManager::mutable_particle_freeze_transition_override() {
  ::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* _msg = _internal_mutable_particle_freeze_transition_override();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.particle_freeze_transition_override)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_particle_freeze_transition_override(::CUserMsg_ParticleManager_ParticleFreezeTransitionOverride* particle_freeze_transition_override) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.particle_freeze_transition_override_;
  }
  if (particle_freeze_transition_override) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(particle_freeze_transition_override);
    if (message_arena != submessage_arena) {
      particle_freeze_transition_override = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, particle_freeze_transition_override, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  _impl_.particle_freeze_transition_override_ = particle_freeze_transition_override;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.particle_freeze_transition_override)
}

// optional .CUserMsg_ParticleManager.FreezeParticleInvolving freeze_particle_involving = 32;
inline bool CUserMsg_ParticleManager::_internal_has_freeze_particle_involving() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.freeze_particle_involving_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_freeze_particle_involving() const {
  return _internal_has_freeze_particle_involving();
}
inline void CUserMsg_ParticleManager::clear_freeze_particle_involving() {
  if (_impl_.freeze_particle_involving_ != nullptr) _impl_.freeze_particle_involving_->Clear();
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline const ::CUserMsg_ParticleManager_FreezeParticleInvolving& CUserMsg_ParticleManager::_internal_freeze_particle_involving() const {
  const ::CUserMsg_ParticleManager_FreezeParticleInvolving* p = _impl_.freeze_particle_involving_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_FreezeParticleInvolving&>(
      ::_CUserMsg_ParticleManager_FreezeParticleInvolving_default_instance_);
}
inline const ::CUserMsg_ParticleManager_FreezeParticleInvolving& CUserMsg_ParticleManager::freeze_particle_involving() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.freeze_particle_involving)
  return _internal_freeze_particle_involving();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_freeze_particle_involving(
    ::CUserMsg_ParticleManager_FreezeParticleInvolving* freeze_particle_involving) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.freeze_particle_involving_);
  }
  _impl_.freeze_particle_involving_ = freeze_particle_involving;
  if (freeze_particle_involving) {
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.freeze_particle_involving)
}
inline ::CUserMsg_ParticleManager_FreezeParticleInvolving* CUserMsg_ParticleManager::release_freeze_particle_involving() {
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* temp = _impl_.freeze_particle_involving_;
  _impl_.freeze_particle_involving_ = 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 ::CUserMsg_ParticleManager_FreezeParticleInvolving* CUserMsg_ParticleManager::unsafe_arena_release_freeze_particle_involving() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.freeze_particle_involving)
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* temp = _impl_.freeze_particle_involving_;
  _impl_.freeze_particle_involving_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_FreezeParticleInvolving* CUserMsg_ParticleManager::_internal_mutable_freeze_particle_involving() {
  _impl_._has_bits_[0] |= 0x10000000u;
  if (_impl_.freeze_particle_involving_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_FreezeParticleInvolving>(GetArenaForAllocation());
    _impl_.freeze_particle_involving_ = p;
  }
  return _impl_.freeze_particle_involving_;
}
inline ::CUserMsg_ParticleManager_FreezeParticleInvolving* CUserMsg_ParticleManager::mutable_freeze_particle_involving() {
  ::CUserMsg_ParticleManager_FreezeParticleInvolving* _msg = _internal_mutable_freeze_particle_involving();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.freeze_particle_involving)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_freeze_particle_involving(::CUserMsg_ParticleManager_FreezeParticleInvolving* freeze_particle_involving) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.freeze_particle_involving_;
  }
  if (freeze_particle_involving) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(freeze_particle_involving);
    if (message_arena != submessage_arena) {
      freeze_particle_involving = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, freeze_particle_involving, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  _impl_.freeze_particle_involving_ = freeze_particle_involving;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.freeze_particle_involving)
}

// optional .CUserMsg_ParticleManager.AddModellistOverrideElement add_modellist_override_element = 33;
inline bool CUserMsg_ParticleManager::_internal_has_add_modellist_override_element() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.add_modellist_override_element_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_add_modellist_override_element() const {
  return _internal_has_add_modellist_override_element();
}
inline void CUserMsg_ParticleManager::clear_add_modellist_override_element() {
  if (_impl_.add_modellist_override_element_ != nullptr) _impl_.add_modellist_override_element_->Clear();
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline const ::CUserMsg_ParticleManager_AddModellistOverrideElement& CUserMsg_ParticleManager::_internal_add_modellist_override_element() const {
  const ::CUserMsg_ParticleManager_AddModellistOverrideElement* p = _impl_.add_modellist_override_element_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_AddModellistOverrideElement&>(
      ::_CUserMsg_ParticleManager_AddModellistOverrideElement_default_instance_);
}
inline const ::CUserMsg_ParticleManager_AddModellistOverrideElement& CUserMsg_ParticleManager::add_modellist_override_element() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.add_modellist_override_element)
  return _internal_add_modellist_override_element();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_add_modellist_override_element(
    ::CUserMsg_ParticleManager_AddModellistOverrideElement* add_modellist_override_element) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.add_modellist_override_element_);
  }
  _impl_.add_modellist_override_element_ = add_modellist_override_element;
  if (add_modellist_override_element) {
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.add_modellist_override_element)
}
inline ::CUserMsg_ParticleManager_AddModellistOverrideElement* CUserMsg_ParticleManager::release_add_modellist_override_element() {
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* temp = _impl_.add_modellist_override_element_;
  _impl_.add_modellist_override_element_ = 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 ::CUserMsg_ParticleManager_AddModellistOverrideElement* CUserMsg_ParticleManager::unsafe_arena_release_add_modellist_override_element() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.add_modellist_override_element)
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* temp = _impl_.add_modellist_override_element_;
  _impl_.add_modellist_override_element_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_AddModellistOverrideElement* CUserMsg_ParticleManager::_internal_mutable_add_modellist_override_element() {
  _impl_._has_bits_[0] |= 0x20000000u;
  if (_impl_.add_modellist_override_element_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_AddModellistOverrideElement>(GetArenaForAllocation());
    _impl_.add_modellist_override_element_ = p;
  }
  return _impl_.add_modellist_override_element_;
}
inline ::CUserMsg_ParticleManager_AddModellistOverrideElement* CUserMsg_ParticleManager::mutable_add_modellist_override_element() {
  ::CUserMsg_ParticleManager_AddModellistOverrideElement* _msg = _internal_mutable_add_modellist_override_element();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.add_modellist_override_element)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_add_modellist_override_element(::CUserMsg_ParticleManager_AddModellistOverrideElement* add_modellist_override_element) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.add_modellist_override_element_;
  }
  if (add_modellist_override_element) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(add_modellist_override_element);
    if (message_arena != submessage_arena) {
      add_modellist_override_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, add_modellist_override_element, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  _impl_.add_modellist_override_element_ = add_modellist_override_element;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.add_modellist_override_element)
}

// optional .CUserMsg_ParticleManager.ClearModellistOverride clear_modellist_override = 34;
inline bool CUserMsg_ParticleManager::_internal_has_clear_modellist_override() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.clear_modellist_override_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_clear_modellist_override() const {
  return _internal_has_clear_modellist_override();
}
inline void CUserMsg_ParticleManager::clear_clear_modellist_override() {
  if (_impl_.clear_modellist_override_ != nullptr) _impl_.clear_modellist_override_->Clear();
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline const ::CUserMsg_ParticleManager_ClearModellistOverride& CUserMsg_ParticleManager::_internal_clear_modellist_override() const {
  const ::CUserMsg_ParticleManager_ClearModellistOverride* p = _impl_.clear_modellist_override_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_ClearModellistOverride&>(
      ::_CUserMsg_ParticleManager_ClearModellistOverride_default_instance_);
}
inline const ::CUserMsg_ParticleManager_ClearModellistOverride& CUserMsg_ParticleManager::clear_modellist_override() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.clear_modellist_override)
  return _internal_clear_modellist_override();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_clear_modellist_override(
    ::CUserMsg_ParticleManager_ClearModellistOverride* clear_modellist_override) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clear_modellist_override_);
  }
  _impl_.clear_modellist_override_ = clear_modellist_override;
  if (clear_modellist_override) {
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.clear_modellist_override)
}
inline ::CUserMsg_ParticleManager_ClearModellistOverride* CUserMsg_ParticleManager::release_clear_modellist_override() {
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::CUserMsg_ParticleManager_ClearModellistOverride* temp = _impl_.clear_modellist_override_;
  _impl_.clear_modellist_override_ = 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 ::CUserMsg_ParticleManager_ClearModellistOverride* CUserMsg_ParticleManager::unsafe_arena_release_clear_modellist_override() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.clear_modellist_override)
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::CUserMsg_ParticleManager_ClearModellistOverride* temp = _impl_.clear_modellist_override_;
  _impl_.clear_modellist_override_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_ClearModellistOverride* CUserMsg_ParticleManager::_internal_mutable_clear_modellist_override() {
  _impl_._has_bits_[0] |= 0x40000000u;
  if (_impl_.clear_modellist_override_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_ClearModellistOverride>(GetArenaForAllocation());
    _impl_.clear_modellist_override_ = p;
  }
  return _impl_.clear_modellist_override_;
}
inline ::CUserMsg_ParticleManager_ClearModellistOverride* CUserMsg_ParticleManager::mutable_clear_modellist_override() {
  ::CUserMsg_ParticleManager_ClearModellistOverride* _msg = _internal_mutable_clear_modellist_override();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.clear_modellist_override)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_clear_modellist_override(::CUserMsg_ParticleManager_ClearModellistOverride* clear_modellist_override) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.clear_modellist_override_;
  }
  if (clear_modellist_override) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clear_modellist_override);
    if (message_arena != submessage_arena) {
      clear_modellist_override = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, clear_modellist_override, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  _impl_.clear_modellist_override_ = clear_modellist_override;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.clear_modellist_override)
}

// optional .CUserMsg_ParticleManager.CreatePhysicsSim create_physics_sim = 35;
inline bool CUserMsg_ParticleManager::_internal_has_create_physics_sim() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.create_physics_sim_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_create_physics_sim() const {
  return _internal_has_create_physics_sim();
}
inline void CUserMsg_ParticleManager::clear_create_physics_sim() {
  if (_impl_.create_physics_sim_ != nullptr) _impl_.create_physics_sim_->Clear();
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline const ::CUserMsg_ParticleManager_CreatePhysicsSim& CUserMsg_ParticleManager::_internal_create_physics_sim() const {
  const ::CUserMsg_ParticleManager_CreatePhysicsSim* p = _impl_.create_physics_sim_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_CreatePhysicsSim&>(
      ::_CUserMsg_ParticleManager_CreatePhysicsSim_default_instance_);
}
inline const ::CUserMsg_ParticleManager_CreatePhysicsSim& CUserMsg_ParticleManager::create_physics_sim() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.create_physics_sim)
  return _internal_create_physics_sim();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_create_physics_sim(
    ::CUserMsg_ParticleManager_CreatePhysicsSim* create_physics_sim) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.create_physics_sim_);
  }
  _impl_.create_physics_sim_ = create_physics_sim;
  if (create_physics_sim) {
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.create_physics_sim)
}
inline ::CUserMsg_ParticleManager_CreatePhysicsSim* CUserMsg_ParticleManager::release_create_physics_sim() {
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::CUserMsg_ParticleManager_CreatePhysicsSim* temp = _impl_.create_physics_sim_;
  _impl_.create_physics_sim_ = 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 ::CUserMsg_ParticleManager_CreatePhysicsSim* CUserMsg_ParticleManager::unsafe_arena_release_create_physics_sim() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.create_physics_sim)
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::CUserMsg_ParticleManager_CreatePhysicsSim* temp = _impl_.create_physics_sim_;
  _impl_.create_physics_sim_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_CreatePhysicsSim* CUserMsg_ParticleManager::_internal_mutable_create_physics_sim() {
  _impl_._has_bits_[0] |= 0x80000000u;
  if (_impl_.create_physics_sim_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_CreatePhysicsSim>(GetArenaForAllocation());
    _impl_.create_physics_sim_ = p;
  }
  return _impl_.create_physics_sim_;
}
inline ::CUserMsg_ParticleManager_CreatePhysicsSim* CUserMsg_ParticleManager::mutable_create_physics_sim() {
  ::CUserMsg_ParticleManager_CreatePhysicsSim* _msg = _internal_mutable_create_physics_sim();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.create_physics_sim)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_create_physics_sim(::CUserMsg_ParticleManager_CreatePhysicsSim* create_physics_sim) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.create_physics_sim_;
  }
  if (create_physics_sim) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(create_physics_sim);
    if (message_arena != submessage_arena) {
      create_physics_sim = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_physics_sim, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  _impl_.create_physics_sim_ = create_physics_sim;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.create_physics_sim)
}

// optional .CUserMsg_ParticleManager.DestroyPhysicsSim destroy_physics_sim = 36;
inline bool CUserMsg_ParticleManager::_internal_has_destroy_physics_sim() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.destroy_physics_sim_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_destroy_physics_sim() const {
  return _internal_has_destroy_physics_sim();
}
inline void CUserMsg_ParticleManager::clear_destroy_physics_sim() {
  if (_impl_.destroy_physics_sim_ != nullptr) _impl_.destroy_physics_sim_->Clear();
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline const ::CUserMsg_ParticleManager_DestroyPhysicsSim& CUserMsg_ParticleManager::_internal_destroy_physics_sim() const {
  const ::CUserMsg_ParticleManager_DestroyPhysicsSim* p = _impl_.destroy_physics_sim_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_DestroyPhysicsSim&>(
      ::_CUserMsg_ParticleManager_DestroyPhysicsSim_default_instance_);
}
inline const ::CUserMsg_ParticleManager_DestroyPhysicsSim& CUserMsg_ParticleManager::destroy_physics_sim() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.destroy_physics_sim)
  return _internal_destroy_physics_sim();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_destroy_physics_sim(
    ::CUserMsg_ParticleManager_DestroyPhysicsSim* destroy_physics_sim) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.destroy_physics_sim_);
  }
  _impl_.destroy_physics_sim_ = destroy_physics_sim;
  if (destroy_physics_sim) {
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.destroy_physics_sim)
}
inline ::CUserMsg_ParticleManager_DestroyPhysicsSim* CUserMsg_ParticleManager::release_destroy_physics_sim() {
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* temp = _impl_.destroy_physics_sim_;
  _impl_.destroy_physics_sim_ = 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 ::CUserMsg_ParticleManager_DestroyPhysicsSim* CUserMsg_ParticleManager::unsafe_arena_release_destroy_physics_sim() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.destroy_physics_sim)
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* temp = _impl_.destroy_physics_sim_;
  _impl_.destroy_physics_sim_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_DestroyPhysicsSim* CUserMsg_ParticleManager::_internal_mutable_destroy_physics_sim() {
  _impl_._has_bits_[1] |= 0x00000001u;
  if (_impl_.destroy_physics_sim_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_DestroyPhysicsSim>(GetArenaForAllocation());
    _impl_.destroy_physics_sim_ = p;
  }
  return _impl_.destroy_physics_sim_;
}
inline ::CUserMsg_ParticleManager_DestroyPhysicsSim* CUserMsg_ParticleManager::mutable_destroy_physics_sim() {
  ::CUserMsg_ParticleManager_DestroyPhysicsSim* _msg = _internal_mutable_destroy_physics_sim();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.destroy_physics_sim)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_destroy_physics_sim(::CUserMsg_ParticleManager_DestroyPhysicsSim* destroy_physics_sim) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.destroy_physics_sim_;
  }
  if (destroy_physics_sim) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(destroy_physics_sim);
    if (message_arena != submessage_arena) {
      destroy_physics_sim = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, destroy_physics_sim, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  _impl_.destroy_physics_sim_ = destroy_physics_sim;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.destroy_physics_sim)
}

// optional .CUserMsg_ParticleManager.SetVData set_vdata = 37;
inline bool CUserMsg_ParticleManager::_internal_has_set_vdata() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_vdata_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_vdata() const {
  return _internal_has_set_vdata();
}
inline void CUserMsg_ParticleManager::clear_set_vdata() {
  if (_impl_.set_vdata_ != nullptr) _impl_.set_vdata_->Clear();
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline const ::CUserMsg_ParticleManager_SetVData& CUserMsg_ParticleManager::_internal_set_vdata() const {
  const ::CUserMsg_ParticleManager_SetVData* p = _impl_.set_vdata_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetVData&>(
      ::_CUserMsg_ParticleManager_SetVData_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetVData& CUserMsg_ParticleManager::set_vdata() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_vdata)
  return _internal_set_vdata();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_vdata(
    ::CUserMsg_ParticleManager_SetVData* set_vdata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_vdata_);
  }
  _impl_.set_vdata_ = set_vdata;
  if (set_vdata) {
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_vdata)
}
inline ::CUserMsg_ParticleManager_SetVData* CUserMsg_ParticleManager::release_set_vdata() {
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::CUserMsg_ParticleManager_SetVData* temp = _impl_.set_vdata_;
  _impl_.set_vdata_ = 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 ::CUserMsg_ParticleManager_SetVData* CUserMsg_ParticleManager::unsafe_arena_release_set_vdata() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_vdata)
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::CUserMsg_ParticleManager_SetVData* temp = _impl_.set_vdata_;
  _impl_.set_vdata_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetVData* CUserMsg_ParticleManager::_internal_mutable_set_vdata() {
  _impl_._has_bits_[1] |= 0x00000002u;
  if (_impl_.set_vdata_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetVData>(GetArenaForAllocation());
    _impl_.set_vdata_ = p;
  }
  return _impl_.set_vdata_;
}
inline ::CUserMsg_ParticleManager_SetVData* CUserMsg_ParticleManager::mutable_set_vdata() {
  ::CUserMsg_ParticleManager_SetVData* _msg = _internal_mutable_set_vdata();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_vdata)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_vdata(::CUserMsg_ParticleManager_SetVData* set_vdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_vdata_;
  }
  if (set_vdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_vdata);
    if (message_arena != submessage_arena) {
      set_vdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_vdata, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  _impl_.set_vdata_ = set_vdata;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_vdata)
}

// optional .CUserMsg_ParticleManager.SetMaterialOverride set_material_override = 38;
inline bool CUserMsg_ParticleManager::_internal_has_set_material_override() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_material_override_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_material_override() const {
  return _internal_has_set_material_override();
}
inline void CUserMsg_ParticleManager::clear_set_material_override() {
  if (_impl_.set_material_override_ != nullptr) _impl_.set_material_override_->Clear();
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline const ::CUserMsg_ParticleManager_SetMaterialOverride& CUserMsg_ParticleManager::_internal_set_material_override() const {
  const ::CUserMsg_ParticleManager_SetMaterialOverride* p = _impl_.set_material_override_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetMaterialOverride&>(
      ::_CUserMsg_ParticleManager_SetMaterialOverride_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetMaterialOverride& CUserMsg_ParticleManager::set_material_override() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_material_override)
  return _internal_set_material_override();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_material_override(
    ::CUserMsg_ParticleManager_SetMaterialOverride* set_material_override) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_material_override_);
  }
  _impl_.set_material_override_ = set_material_override;
  if (set_material_override) {
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_material_override)
}
inline ::CUserMsg_ParticleManager_SetMaterialOverride* CUserMsg_ParticleManager::release_set_material_override() {
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::CUserMsg_ParticleManager_SetMaterialOverride* temp = _impl_.set_material_override_;
  _impl_.set_material_override_ = 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 ::CUserMsg_ParticleManager_SetMaterialOverride* CUserMsg_ParticleManager::unsafe_arena_release_set_material_override() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_material_override)
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::CUserMsg_ParticleManager_SetMaterialOverride* temp = _impl_.set_material_override_;
  _impl_.set_material_override_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetMaterialOverride* CUserMsg_ParticleManager::_internal_mutable_set_material_override() {
  _impl_._has_bits_[1] |= 0x00000004u;
  if (_impl_.set_material_override_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetMaterialOverride>(GetArenaForAllocation());
    _impl_.set_material_override_ = p;
  }
  return _impl_.set_material_override_;
}
inline ::CUserMsg_ParticleManager_SetMaterialOverride* CUserMsg_ParticleManager::mutable_set_material_override() {
  ::CUserMsg_ParticleManager_SetMaterialOverride* _msg = _internal_mutable_set_material_override();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_material_override)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_material_override(::CUserMsg_ParticleManager_SetMaterialOverride* set_material_override) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_material_override_;
  }
  if (set_material_override) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_material_override);
    if (message_arena != submessage_arena) {
      set_material_override = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_material_override, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  _impl_.set_material_override_ = set_material_override;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_material_override)
}

// optional .CUserMsg_ParticleManager.AddFan add_fan = 39;
inline bool CUserMsg_ParticleManager::_internal_has_add_fan() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.add_fan_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_add_fan() const {
  return _internal_has_add_fan();
}
inline void CUserMsg_ParticleManager::clear_add_fan() {
  if (_impl_.add_fan_ != nullptr) _impl_.add_fan_->Clear();
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline const ::CUserMsg_ParticleManager_AddFan& CUserMsg_ParticleManager::_internal_add_fan() const {
  const ::CUserMsg_ParticleManager_AddFan* p = _impl_.add_fan_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_AddFan&>(
      ::_CUserMsg_ParticleManager_AddFan_default_instance_);
}
inline const ::CUserMsg_ParticleManager_AddFan& CUserMsg_ParticleManager::add_fan() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.add_fan)
  return _internal_add_fan();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_add_fan(
    ::CUserMsg_ParticleManager_AddFan* add_fan) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.add_fan_);
  }
  _impl_.add_fan_ = add_fan;
  if (add_fan) {
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.add_fan)
}
inline ::CUserMsg_ParticleManager_AddFan* CUserMsg_ParticleManager::release_add_fan() {
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::CUserMsg_ParticleManager_AddFan* temp = _impl_.add_fan_;
  _impl_.add_fan_ = 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 ::CUserMsg_ParticleManager_AddFan* CUserMsg_ParticleManager::unsafe_arena_release_add_fan() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.add_fan)
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::CUserMsg_ParticleManager_AddFan* temp = _impl_.add_fan_;
  _impl_.add_fan_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_AddFan* CUserMsg_ParticleManager::_internal_mutable_add_fan() {
  _impl_._has_bits_[1] |= 0x00000008u;
  if (_impl_.add_fan_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_AddFan>(GetArenaForAllocation());
    _impl_.add_fan_ = p;
  }
  return _impl_.add_fan_;
}
inline ::CUserMsg_ParticleManager_AddFan* CUserMsg_ParticleManager::mutable_add_fan() {
  ::CUserMsg_ParticleManager_AddFan* _msg = _internal_mutable_add_fan();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.add_fan)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_add_fan(::CUserMsg_ParticleManager_AddFan* add_fan) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.add_fan_;
  }
  if (add_fan) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(add_fan);
    if (message_arena != submessage_arena) {
      add_fan = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, add_fan, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  _impl_.add_fan_ = add_fan;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.add_fan)
}

// optional .CUserMsg_ParticleManager.UpdateFan update_fan = 40;
inline bool CUserMsg_ParticleManager::_internal_has_update_fan() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_fan_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_update_fan() const {
  return _internal_has_update_fan();
}
inline void CUserMsg_ParticleManager::clear_update_fan() {
  if (_impl_.update_fan_ != nullptr) _impl_.update_fan_->Clear();
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline const ::CUserMsg_ParticleManager_UpdateFan& CUserMsg_ParticleManager::_internal_update_fan() const {
  const ::CUserMsg_ParticleManager_UpdateFan* p = _impl_.update_fan_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_UpdateFan&>(
      ::_CUserMsg_ParticleManager_UpdateFan_default_instance_);
}
inline const ::CUserMsg_ParticleManager_UpdateFan& CUserMsg_ParticleManager::update_fan() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.update_fan)
  return _internal_update_fan();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_update_fan(
    ::CUserMsg_ParticleManager_UpdateFan* update_fan) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_fan_);
  }
  _impl_.update_fan_ = update_fan;
  if (update_fan) {
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.update_fan)
}
inline ::CUserMsg_ParticleManager_UpdateFan* CUserMsg_ParticleManager::release_update_fan() {
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::CUserMsg_ParticleManager_UpdateFan* temp = _impl_.update_fan_;
  _impl_.update_fan_ = 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 ::CUserMsg_ParticleManager_UpdateFan* CUserMsg_ParticleManager::unsafe_arena_release_update_fan() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.update_fan)
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::CUserMsg_ParticleManager_UpdateFan* temp = _impl_.update_fan_;
  _impl_.update_fan_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_UpdateFan* CUserMsg_ParticleManager::_internal_mutable_update_fan() {
  _impl_._has_bits_[1] |= 0x00000010u;
  if (_impl_.update_fan_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_UpdateFan>(GetArenaForAllocation());
    _impl_.update_fan_ = p;
  }
  return _impl_.update_fan_;
}
inline ::CUserMsg_ParticleManager_UpdateFan* CUserMsg_ParticleManager::mutable_update_fan() {
  ::CUserMsg_ParticleManager_UpdateFan* _msg = _internal_mutable_update_fan();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.update_fan)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_update_fan(::CUserMsg_ParticleManager_UpdateFan* update_fan) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.update_fan_;
  }
  if (update_fan) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(update_fan);
    if (message_arena != submessage_arena) {
      update_fan = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_fan, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  _impl_.update_fan_ = update_fan;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.update_fan)
}

// optional .CUserMsg_ParticleManager.SetParticleClusterGrowth set_particle_cluster_growth = 41;
inline bool CUserMsg_ParticleManager::_internal_has_set_particle_cluster_growth() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.set_particle_cluster_growth_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_set_particle_cluster_growth() const {
  return _internal_has_set_particle_cluster_growth();
}
inline void CUserMsg_ParticleManager::clear_set_particle_cluster_growth() {
  if (_impl_.set_particle_cluster_growth_ != nullptr) _impl_.set_particle_cluster_growth_->Clear();
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline const ::CUserMsg_ParticleManager_SetParticleClusterGrowth& CUserMsg_ParticleManager::_internal_set_particle_cluster_growth() const {
  const ::CUserMsg_ParticleManager_SetParticleClusterGrowth* p = _impl_.set_particle_cluster_growth_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_SetParticleClusterGrowth&>(
      ::_CUserMsg_ParticleManager_SetParticleClusterGrowth_default_instance_);
}
inline const ::CUserMsg_ParticleManager_SetParticleClusterGrowth& CUserMsg_ParticleManager::set_particle_cluster_growth() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.set_particle_cluster_growth)
  return _internal_set_particle_cluster_growth();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_set_particle_cluster_growth(
    ::CUserMsg_ParticleManager_SetParticleClusterGrowth* set_particle_cluster_growth) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_particle_cluster_growth_);
  }
  _impl_.set_particle_cluster_growth_ = set_particle_cluster_growth;
  if (set_particle_cluster_growth) {
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.set_particle_cluster_growth)
}
inline ::CUserMsg_ParticleManager_SetParticleClusterGrowth* CUserMsg_ParticleManager::release_set_particle_cluster_growth() {
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* temp = _impl_.set_particle_cluster_growth_;
  _impl_.set_particle_cluster_growth_ = 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 ::CUserMsg_ParticleManager_SetParticleClusterGrowth* CUserMsg_ParticleManager::unsafe_arena_release_set_particle_cluster_growth() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.set_particle_cluster_growth)
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* temp = _impl_.set_particle_cluster_growth_;
  _impl_.set_particle_cluster_growth_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_SetParticleClusterGrowth* CUserMsg_ParticleManager::_internal_mutable_set_particle_cluster_growth() {
  _impl_._has_bits_[1] |= 0x00000020u;
  if (_impl_.set_particle_cluster_growth_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_SetParticleClusterGrowth>(GetArenaForAllocation());
    _impl_.set_particle_cluster_growth_ = p;
  }
  return _impl_.set_particle_cluster_growth_;
}
inline ::CUserMsg_ParticleManager_SetParticleClusterGrowth* CUserMsg_ParticleManager::mutable_set_particle_cluster_growth() {
  ::CUserMsg_ParticleManager_SetParticleClusterGrowth* _msg = _internal_mutable_set_particle_cluster_growth();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.set_particle_cluster_growth)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_set_particle_cluster_growth(::CUserMsg_ParticleManager_SetParticleClusterGrowth* set_particle_cluster_growth) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.set_particle_cluster_growth_;
  }
  if (set_particle_cluster_growth) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_particle_cluster_growth);
    if (message_arena != submessage_arena) {
      set_particle_cluster_growth = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, set_particle_cluster_growth, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  _impl_.set_particle_cluster_growth_ = set_particle_cluster_growth;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.set_particle_cluster_growth)
}

// optional .CUserMsg_ParticleManager.RemoveFan remove_fan = 42;
inline bool CUserMsg_ParticleManager::_internal_has_remove_fan() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remove_fan_ != nullptr);
  return value;
}
inline bool CUserMsg_ParticleManager::has_remove_fan() const {
  return _internal_has_remove_fan();
}
inline void CUserMsg_ParticleManager::clear_remove_fan() {
  if (_impl_.remove_fan_ != nullptr) _impl_.remove_fan_->Clear();
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline const ::CUserMsg_ParticleManager_RemoveFan& CUserMsg_ParticleManager::_internal_remove_fan() const {
  const ::CUserMsg_ParticleManager_RemoveFan* p = _impl_.remove_fan_;
  return p != nullptr ? *p : reinterpret_cast<const ::CUserMsg_ParticleManager_RemoveFan&>(
      ::_CUserMsg_ParticleManager_RemoveFan_default_instance_);
}
inline const ::CUserMsg_ParticleManager_RemoveFan& CUserMsg_ParticleManager::remove_fan() const {
  // @@protoc_insertion_point(field_get:CUserMsg_ParticleManager.remove_fan)
  return _internal_remove_fan();
}
inline void CUserMsg_ParticleManager::unsafe_arena_set_allocated_remove_fan(
    ::CUserMsg_ParticleManager_RemoveFan* remove_fan) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remove_fan_);
  }
  _impl_.remove_fan_ = remove_fan;
  if (remove_fan) {
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMsg_ParticleManager.remove_fan)
}
inline ::CUserMsg_ParticleManager_RemoveFan* CUserMsg_ParticleManager::release_remove_fan() {
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::CUserMsg_ParticleManager_RemoveFan* temp = _impl_.remove_fan_;
  _impl_.remove_fan_ = 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 ::CUserMsg_ParticleManager_RemoveFan* CUserMsg_ParticleManager::unsafe_arena_release_remove_fan() {
  // @@protoc_insertion_point(field_release:CUserMsg_ParticleManager.remove_fan)
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::CUserMsg_ParticleManager_RemoveFan* temp = _impl_.remove_fan_;
  _impl_.remove_fan_ = nullptr;
  return temp;
}
inline ::CUserMsg_ParticleManager_RemoveFan* CUserMsg_ParticleManager::_internal_mutable_remove_fan() {
  _impl_._has_bits_[1] |= 0x00000040u;
  if (_impl_.remove_fan_ == nullptr) {
    auto* p = CreateMaybeMessage<::CUserMsg_ParticleManager_RemoveFan>(GetArenaForAllocation());
    _impl_.remove_fan_ = p;
  }
  return _impl_.remove_fan_;
}
inline ::CUserMsg_ParticleManager_RemoveFan* CUserMsg_ParticleManager::mutable_remove_fan() {
  ::CUserMsg_ParticleManager_RemoveFan* _msg = _internal_mutable_remove_fan();
  // @@protoc_insertion_point(field_mutable:CUserMsg_ParticleManager.remove_fan)
  return _msg;
}
inline void CUserMsg_ParticleManager::set_allocated_remove_fan(::CUserMsg_ParticleManager_RemoveFan* remove_fan) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remove_fan_;
  }
  if (remove_fan) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remove_fan);
    if (message_arena != submessage_arena) {
      remove_fan = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remove_fan, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  _impl_.remove_fan_ = remove_fan;
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_ParticleManager.remove_fan)
}

// -------------------------------------------------------------------

// CUserMsg_HudError

// optional int32 order_id = 1;
inline bool CUserMsg_HudError::_internal_has_order_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_HudError::has_order_id() const {
  return _internal_has_order_id();
}
inline void CUserMsg_HudError::clear_order_id() {
  _impl_.order_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMsg_HudError::_internal_order_id() const {
  return _impl_.order_id_;
}
inline int32_t CUserMsg_HudError::order_id() const {
  // @@protoc_insertion_point(field_get:CUserMsg_HudError.order_id)
  return _internal_order_id();
}
inline void CUserMsg_HudError::_internal_set_order_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.order_id_ = value;
}
inline void CUserMsg_HudError::set_order_id(int32_t value) {
  _internal_set_order_id(value);
  // @@protoc_insertion_point(field_set:CUserMsg_HudError.order_id)
}

// -------------------------------------------------------------------

// CUserMsg_CustomGameEvent

// optional string event_name = 1;
inline bool CUserMsg_CustomGameEvent::_internal_has_event_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMsg_CustomGameEvent::has_event_name() const {
  return _internal_has_event_name();
}
inline void CUserMsg_CustomGameEvent::clear_event_name() {
  _impl_.event_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMsg_CustomGameEvent::event_name() const {
  // @@protoc_insertion_point(field_get:CUserMsg_CustomGameEvent.event_name)
  return _internal_event_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_CustomGameEvent::set_event_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.event_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_CustomGameEvent.event_name)
}
inline std::string* CUserMsg_CustomGameEvent::mutable_event_name() {
  std::string* _s = _internal_mutable_event_name();
  // @@protoc_insertion_point(field_mutable:CUserMsg_CustomGameEvent.event_name)
  return _s;
}
inline const std::string& CUserMsg_CustomGameEvent::_internal_event_name() const {
  return _impl_.event_name_.Get();
}
inline void CUserMsg_CustomGameEvent::_internal_set_event_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.event_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_CustomGameEvent::_internal_mutable_event_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.event_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_CustomGameEvent::release_event_name() {
  // @@protoc_insertion_point(field_release:CUserMsg_CustomGameEvent.event_name)
  if (!_internal_has_event_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.event_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_name_.IsDefault()) {
    _impl_.event_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_CustomGameEvent::set_allocated_event_name(std::string* event_name) {
  if (event_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.event_name_.SetAllocated(event_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_name_.IsDefault()) {
    _impl_.event_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_CustomGameEvent.event_name)
}

// optional bytes data = 2;
inline bool CUserMsg_CustomGameEvent::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMsg_CustomGameEvent::has_data() const {
  return _internal_has_data();
}
inline void CUserMsg_CustomGameEvent::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMsg_CustomGameEvent::data() const {
  // @@protoc_insertion_point(field_get:CUserMsg_CustomGameEvent.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMsg_CustomGameEvent::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMsg_CustomGameEvent.data)
}
inline std::string* CUserMsg_CustomGameEvent::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CUserMsg_CustomGameEvent.data)
  return _s;
}
inline const std::string& CUserMsg_CustomGameEvent::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CUserMsg_CustomGameEvent::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMsg_CustomGameEvent::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMsg_CustomGameEvent::release_data() {
  // @@protoc_insertion_point(field_release:CUserMsg_CustomGameEvent.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMsg_CustomGameEvent::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMsg_CustomGameEvent.data)
}

// -------------------------------------------------------------------

// CUserMessageHapticsManagerPulse

// optional int32 hand_id = 1;
inline bool CUserMessageHapticsManagerPulse::_internal_has_hand_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerPulse::has_hand_id() const {
  return _internal_has_hand_id();
}
inline void CUserMessageHapticsManagerPulse::clear_hand_id() {
  _impl_.hand_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessageHapticsManagerPulse::_internal_hand_id() const {
  return _impl_.hand_id_;
}
inline int32_t CUserMessageHapticsManagerPulse::hand_id() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerPulse.hand_id)
  return _internal_hand_id();
}
inline void CUserMessageHapticsManagerPulse::_internal_set_hand_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hand_id_ = value;
}
inline void CUserMessageHapticsManagerPulse::set_hand_id(int32_t value) {
  _internal_set_hand_id(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerPulse.hand_id)
}

// optional float effect_amplitude = 2;
inline bool CUserMessageHapticsManagerPulse::_internal_has_effect_amplitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerPulse::has_effect_amplitude() const {
  return _internal_has_effect_amplitude();
}
inline void CUserMessageHapticsManagerPulse::clear_effect_amplitude() {
  _impl_.effect_amplitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CUserMessageHapticsManagerPulse::_internal_effect_amplitude() const {
  return _impl_.effect_amplitude_;
}
inline float CUserMessageHapticsManagerPulse::effect_amplitude() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerPulse.effect_amplitude)
  return _internal_effect_amplitude();
}
inline void CUserMessageHapticsManagerPulse::_internal_set_effect_amplitude(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.effect_amplitude_ = value;
}
inline void CUserMessageHapticsManagerPulse::set_effect_amplitude(float value) {
  _internal_set_effect_amplitude(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerPulse.effect_amplitude)
}

// optional float effect_frequency = 3;
inline bool CUserMessageHapticsManagerPulse::_internal_has_effect_frequency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerPulse::has_effect_frequency() const {
  return _internal_has_effect_frequency();
}
inline void CUserMessageHapticsManagerPulse::clear_effect_frequency() {
  _impl_.effect_frequency_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageHapticsManagerPulse::_internal_effect_frequency() const {
  return _impl_.effect_frequency_;
}
inline float CUserMessageHapticsManagerPulse::effect_frequency() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerPulse.effect_frequency)
  return _internal_effect_frequency();
}
inline void CUserMessageHapticsManagerPulse::_internal_set_effect_frequency(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.effect_frequency_ = value;
}
inline void CUserMessageHapticsManagerPulse::set_effect_frequency(float value) {
  _internal_set_effect_frequency(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerPulse.effect_frequency)
}

// optional float effect_duration = 4;
inline bool CUserMessageHapticsManagerPulse::_internal_has_effect_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerPulse::has_effect_duration() const {
  return _internal_has_effect_duration();
}
inline void CUserMessageHapticsManagerPulse::clear_effect_duration() {
  _impl_.effect_duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CUserMessageHapticsManagerPulse::_internal_effect_duration() const {
  return _impl_.effect_duration_;
}
inline float CUserMessageHapticsManagerPulse::effect_duration() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerPulse.effect_duration)
  return _internal_effect_duration();
}
inline void CUserMessageHapticsManagerPulse::_internal_set_effect_duration(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.effect_duration_ = value;
}
inline void CUserMessageHapticsManagerPulse::set_effect_duration(float value) {
  _internal_set_effect_duration(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerPulse.effect_duration)
}

// -------------------------------------------------------------------

// CUserMessageHapticsManagerEffect

// optional int32 hand_id = 1;
inline bool CUserMessageHapticsManagerEffect::_internal_has_hand_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerEffect::has_hand_id() const {
  return _internal_has_hand_id();
}
inline void CUserMessageHapticsManagerEffect::clear_hand_id() {
  _impl_.hand_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessageHapticsManagerEffect::_internal_hand_id() const {
  return _impl_.hand_id_;
}
inline int32_t CUserMessageHapticsManagerEffect::hand_id() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerEffect.hand_id)
  return _internal_hand_id();
}
inline void CUserMessageHapticsManagerEffect::_internal_set_hand_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hand_id_ = value;
}
inline void CUserMessageHapticsManagerEffect::set_hand_id(int32_t value) {
  _internal_set_hand_id(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerEffect.hand_id)
}

// optional uint32 effect_name_hash_code = 2;
inline bool CUserMessageHapticsManagerEffect::_internal_has_effect_name_hash_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerEffect::has_effect_name_hash_code() const {
  return _internal_has_effect_name_hash_code();
}
inline void CUserMessageHapticsManagerEffect::clear_effect_name_hash_code() {
  _impl_.effect_name_hash_code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessageHapticsManagerEffect::_internal_effect_name_hash_code() const {
  return _impl_.effect_name_hash_code_;
}
inline uint32_t CUserMessageHapticsManagerEffect::effect_name_hash_code() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerEffect.effect_name_hash_code)
  return _internal_effect_name_hash_code();
}
inline void CUserMessageHapticsManagerEffect::_internal_set_effect_name_hash_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.effect_name_hash_code_ = value;
}
inline void CUserMessageHapticsManagerEffect::set_effect_name_hash_code(uint32_t value) {
  _internal_set_effect_name_hash_code(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerEffect.effect_name_hash_code)
}

// optional float effect_scale = 3;
inline bool CUserMessageHapticsManagerEffect::_internal_has_effect_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageHapticsManagerEffect::has_effect_scale() const {
  return _internal_has_effect_scale();
}
inline void CUserMessageHapticsManagerEffect::clear_effect_scale() {
  _impl_.effect_scale_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessageHapticsManagerEffect::_internal_effect_scale() const {
  return _impl_.effect_scale_;
}
inline float CUserMessageHapticsManagerEffect::effect_scale() const {
  // @@protoc_insertion_point(field_get:CUserMessageHapticsManagerEffect.effect_scale)
  return _internal_effect_scale();
}
inline void CUserMessageHapticsManagerEffect::_internal_set_effect_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.effect_scale_ = value;
}
inline void CUserMessageHapticsManagerEffect::set_effect_scale(float value) {
  _internal_set_effect_scale(value);
  // @@protoc_insertion_point(field_set:CUserMessageHapticsManagerEffect.effect_scale)
}

// -------------------------------------------------------------------

// CUserMessageAnimStateGraphState

// optional int32 entity_index = 1;
inline bool CUserMessageAnimStateGraphState::_internal_has_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageAnimStateGraphState::has_entity_index() const {
  return _internal_has_entity_index();
}
inline void CUserMessageAnimStateGraphState::clear_entity_index() {
  _impl_.entity_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageAnimStateGraphState::_internal_entity_index() const {
  return _impl_.entity_index_;
}
inline int32_t CUserMessageAnimStateGraphState::entity_index() const {
  // @@protoc_insertion_point(field_get:CUserMessageAnimStateGraphState.entity_index)
  return _internal_entity_index();
}
inline void CUserMessageAnimStateGraphState::_internal_set_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.entity_index_ = value;
}
inline void CUserMessageAnimStateGraphState::set_entity_index(int32_t value) {
  _internal_set_entity_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageAnimStateGraphState.entity_index)
}

// optional bytes data = 2;
inline bool CUserMessageAnimStateGraphState::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageAnimStateGraphState::has_data() const {
  return _internal_has_data();
}
inline void CUserMessageAnimStateGraphState::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageAnimStateGraphState::data() const {
  // @@protoc_insertion_point(field_get:CUserMessageAnimStateGraphState.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageAnimStateGraphState::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageAnimStateGraphState.data)
}
inline std::string* CUserMessageAnimStateGraphState::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CUserMessageAnimStateGraphState.data)
  return _s;
}
inline const std::string& CUserMessageAnimStateGraphState::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CUserMessageAnimStateGraphState::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageAnimStateGraphState::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageAnimStateGraphState::release_data() {
  // @@protoc_insertion_point(field_release:CUserMessageAnimStateGraphState.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageAnimStateGraphState::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageAnimStateGraphState.data)
}

// -------------------------------------------------------------------

// CUserMessageUpdateCssClasses

// optional int32 target_world_panel = 1;
inline bool CUserMessageUpdateCssClasses::_internal_has_target_world_panel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageUpdateCssClasses::has_target_world_panel() const {
  return _internal_has_target_world_panel();
}
inline void CUserMessageUpdateCssClasses::clear_target_world_panel() {
  _impl_.target_world_panel_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageUpdateCssClasses::_internal_target_world_panel() const {
  return _impl_.target_world_panel_;
}
inline int32_t CUserMessageUpdateCssClasses::target_world_panel() const {
  // @@protoc_insertion_point(field_get:CUserMessageUpdateCssClasses.target_world_panel)
  return _internal_target_world_panel();
}
inline void CUserMessageUpdateCssClasses::_internal_set_target_world_panel(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.target_world_panel_ = value;
}
inline void CUserMessageUpdateCssClasses::set_target_world_panel(int32_t value) {
  _internal_set_target_world_panel(value);
  // @@protoc_insertion_point(field_set:CUserMessageUpdateCssClasses.target_world_panel)
}

// optional string css_classes = 2;
inline bool CUserMessageUpdateCssClasses::_internal_has_css_classes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageUpdateCssClasses::has_css_classes() const {
  return _internal_has_css_classes();
}
inline void CUserMessageUpdateCssClasses::clear_css_classes() {
  _impl_.css_classes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageUpdateCssClasses::css_classes() const {
  // @@protoc_insertion_point(field_get:CUserMessageUpdateCssClasses.css_classes)
  return _internal_css_classes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageUpdateCssClasses::set_css_classes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.css_classes_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageUpdateCssClasses.css_classes)
}
inline std::string* CUserMessageUpdateCssClasses::mutable_css_classes() {
  std::string* _s = _internal_mutable_css_classes();
  // @@protoc_insertion_point(field_mutable:CUserMessageUpdateCssClasses.css_classes)
  return _s;
}
inline const std::string& CUserMessageUpdateCssClasses::_internal_css_classes() const {
  return _impl_.css_classes_.Get();
}
inline void CUserMessageUpdateCssClasses::_internal_set_css_classes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.css_classes_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageUpdateCssClasses::_internal_mutable_css_classes() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.css_classes_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageUpdateCssClasses::release_css_classes() {
  // @@protoc_insertion_point(field_release:CUserMessageUpdateCssClasses.css_classes)
  if (!_internal_has_css_classes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.css_classes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.css_classes_.IsDefault()) {
    _impl_.css_classes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageUpdateCssClasses::set_allocated_css_classes(std::string* css_classes) {
  if (css_classes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.css_classes_.SetAllocated(css_classes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.css_classes_.IsDefault()) {
    _impl_.css_classes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageUpdateCssClasses.css_classes)
}

// optional bool is_add = 3;
inline bool CUserMessageUpdateCssClasses::_internal_has_is_add() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageUpdateCssClasses::has_is_add() const {
  return _internal_has_is_add();
}
inline void CUserMessageUpdateCssClasses::clear_is_add() {
  _impl_.is_add_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CUserMessageUpdateCssClasses::_internal_is_add() const {
  return _impl_.is_add_;
}
inline bool CUserMessageUpdateCssClasses::is_add() const {
  // @@protoc_insertion_point(field_get:CUserMessageUpdateCssClasses.is_add)
  return _internal_is_add();
}
inline void CUserMessageUpdateCssClasses::_internal_set_is_add(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.is_add_ = value;
}
inline void CUserMessageUpdateCssClasses::set_is_add(bool value) {
  _internal_set_is_add(value);
  // @@protoc_insertion_point(field_set:CUserMessageUpdateCssClasses.is_add)
}

// -------------------------------------------------------------------

// CUserMessageServerFrameTime

// optional float frame_time = 1;
inline bool CUserMessageServerFrameTime::_internal_has_frame_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageServerFrameTime::has_frame_time() const {
  return _internal_has_frame_time();
}
inline void CUserMessageServerFrameTime::clear_frame_time() {
  _impl_.frame_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMessageServerFrameTime::_internal_frame_time() const {
  return _impl_.frame_time_;
}
inline float CUserMessageServerFrameTime::frame_time() const {
  // @@protoc_insertion_point(field_get:CUserMessageServerFrameTime.frame_time)
  return _internal_frame_time();
}
inline void CUserMessageServerFrameTime::_internal_set_frame_time(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.frame_time_ = value;
}
inline void CUserMessageServerFrameTime::set_frame_time(float value) {
  _internal_set_frame_time(value);
  // @@protoc_insertion_point(field_set:CUserMessageServerFrameTime.frame_time)
}

// -------------------------------------------------------------------

// CUserMessageLagCompensationError

// optional float distance = 1;
inline bool CUserMessageLagCompensationError::_internal_has_distance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageLagCompensationError::has_distance() const {
  return _internal_has_distance();
}
inline void CUserMessageLagCompensationError::clear_distance() {
  _impl_.distance_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CUserMessageLagCompensationError::_internal_distance() const {
  return _impl_.distance_;
}
inline float CUserMessageLagCompensationError::distance() const {
  // @@protoc_insertion_point(field_get:CUserMessageLagCompensationError.distance)
  return _internal_distance();
}
inline void CUserMessageLagCompensationError::_internal_set_distance(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.distance_ = value;
}
inline void CUserMessageLagCompensationError::set_distance(float value) {
  _internal_set_distance(value);
  // @@protoc_insertion_point(field_set:CUserMessageLagCompensationError.distance)
}

// -------------------------------------------------------------------

// CUserMessageRequestDllStatus

// optional string dll_action = 1;
inline bool CUserMessageRequestDllStatus::_internal_has_dll_action() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageRequestDllStatus::has_dll_action() const {
  return _internal_has_dll_action();
}
inline void CUserMessageRequestDllStatus::clear_dll_action() {
  _impl_.dll_action_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageRequestDllStatus::dll_action() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDllStatus.dll_action)
  return _internal_dll_action();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageRequestDllStatus::set_dll_action(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.dll_action_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageRequestDllStatus.dll_action)
}
inline std::string* CUserMessageRequestDllStatus::mutable_dll_action() {
  std::string* _s = _internal_mutable_dll_action();
  // @@protoc_insertion_point(field_mutable:CUserMessageRequestDllStatus.dll_action)
  return _s;
}
inline const std::string& CUserMessageRequestDllStatus::_internal_dll_action() const {
  return _impl_.dll_action_.Get();
}
inline void CUserMessageRequestDllStatus::_internal_set_dll_action(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dll_action_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDllStatus::_internal_mutable_dll_action() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.dll_action_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDllStatus::release_dll_action() {
  // @@protoc_insertion_point(field_release:CUserMessageRequestDllStatus.dll_action)
  if (!_internal_has_dll_action()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.dll_action_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dll_action_.IsDefault()) {
    _impl_.dll_action_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageRequestDllStatus::set_allocated_dll_action(std::string* dll_action) {
  if (dll_action != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.dll_action_.SetAllocated(dll_action, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dll_action_.IsDefault()) {
    _impl_.dll_action_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageRequestDllStatus.dll_action)
}

// optional bool full_report = 2;
inline bool CUserMessageRequestDllStatus::_internal_has_full_report() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageRequestDllStatus::has_full_report() const {
  return _internal_has_full_report();
}
inline void CUserMessageRequestDllStatus::clear_full_report() {
  _impl_.full_report_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CUserMessageRequestDllStatus::_internal_full_report() const {
  return _impl_.full_report_;
}
inline bool CUserMessageRequestDllStatus::full_report() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDllStatus.full_report)
  return _internal_full_report();
}
inline void CUserMessageRequestDllStatus::_internal_set_full_report(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.full_report_ = value;
}
inline void CUserMessageRequestDllStatus::set_full_report(bool value) {
  _internal_set_full_report(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDllStatus.full_report)
}

// -------------------------------------------------------------------

// CUserMessageRequestUtilAction

// optional int32 util1 = 2;
inline bool CUserMessageRequestUtilAction::_internal_has_util1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageRequestUtilAction::has_util1() const {
  return _internal_has_util1();
}
inline void CUserMessageRequestUtilAction::clear_util1() {
  _impl_.util1_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessageRequestUtilAction::_internal_util1() const {
  return _impl_.util1_;
}
inline int32_t CUserMessageRequestUtilAction::util1() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestUtilAction.util1)
  return _internal_util1();
}
inline void CUserMessageRequestUtilAction::_internal_set_util1(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.util1_ = value;
}
inline void CUserMessageRequestUtilAction::set_util1(int32_t value) {
  _internal_set_util1(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestUtilAction.util1)
}

// optional int32 util2 = 3;
inline bool CUserMessageRequestUtilAction::_internal_has_util2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageRequestUtilAction::has_util2() const {
  return _internal_has_util2();
}
inline void CUserMessageRequestUtilAction::clear_util2() {
  _impl_.util2_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageRequestUtilAction::_internal_util2() const {
  return _impl_.util2_;
}
inline int32_t CUserMessageRequestUtilAction::util2() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestUtilAction.util2)
  return _internal_util2();
}
inline void CUserMessageRequestUtilAction::_internal_set_util2(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.util2_ = value;
}
inline void CUserMessageRequestUtilAction::set_util2(int32_t value) {
  _internal_set_util2(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestUtilAction.util2)
}

// optional int32 util3 = 4;
inline bool CUserMessageRequestUtilAction::_internal_has_util3() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageRequestUtilAction::has_util3() const {
  return _internal_has_util3();
}
inline void CUserMessageRequestUtilAction::clear_util3() {
  _impl_.util3_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageRequestUtilAction::_internal_util3() const {
  return _impl_.util3_;
}
inline int32_t CUserMessageRequestUtilAction::util3() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestUtilAction.util3)
  return _internal_util3();
}
inline void CUserMessageRequestUtilAction::_internal_set_util3(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.util3_ = value;
}
inline void CUserMessageRequestUtilAction::set_util3(int32_t value) {
  _internal_set_util3(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestUtilAction.util3)
}

// optional int32 util4 = 5;
inline bool CUserMessageRequestUtilAction::_internal_has_util4() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageRequestUtilAction::has_util4() const {
  return _internal_has_util4();
}
inline void CUserMessageRequestUtilAction::clear_util4() {
  _impl_.util4_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessageRequestUtilAction::_internal_util4() const {
  return _impl_.util4_;
}
inline int32_t CUserMessageRequestUtilAction::util4() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestUtilAction.util4)
  return _internal_util4();
}
inline void CUserMessageRequestUtilAction::_internal_set_util4(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.util4_ = value;
}
inline void CUserMessageRequestUtilAction::set_util4(int32_t value) {
  _internal_set_util4(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestUtilAction.util4)
}

// optional int32 util5 = 6;
inline bool CUserMessageRequestUtilAction::_internal_has_util5() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageRequestUtilAction::has_util5() const {
  return _internal_has_util5();
}
inline void CUserMessageRequestUtilAction::clear_util5() {
  _impl_.util5_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessageRequestUtilAction::_internal_util5() const {
  return _impl_.util5_;
}
inline int32_t CUserMessageRequestUtilAction::util5() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestUtilAction.util5)
  return _internal_util5();
}
inline void CUserMessageRequestUtilAction::_internal_set_util5(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.util5_ = value;
}
inline void CUserMessageRequestUtilAction::set_util5(int32_t value) {
  _internal_set_util5(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestUtilAction.util5)
}

// -------------------------------------------------------------------

// CUserMessage_UtilMsg_Response_ItemDetail

// optional int32 index = 1;
inline bool CUserMessage_UtilMsg_Response_ItemDetail::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response_ItemDetail::has_index() const {
  return _internal_has_index();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::clear_index() {
  _impl_.index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::_internal_index() const {
  return _impl_.index_;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::index() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.ItemDetail.index)
  return _internal_index();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.index_ = value;
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.ItemDetail.index)
}

// optional int32 hash = 2;
inline bool CUserMessage_UtilMsg_Response_ItemDetail::_internal_has_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response_ItemDetail::has_hash() const {
  return _internal_has_hash();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::clear_hash() {
  _impl_.hash_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::_internal_hash() const {
  return _impl_.hash_;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::hash() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.ItemDetail.hash)
  return _internal_hash();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::_internal_set_hash(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.hash_ = value;
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::set_hash(int32_t value) {
  _internal_set_hash(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.ItemDetail.hash)
}

// optional int32 crc = 3;
inline bool CUserMessage_UtilMsg_Response_ItemDetail::_internal_has_crc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response_ItemDetail::has_crc() const {
  return _internal_has_crc();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::clear_crc() {
  _impl_.crc_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::_internal_crc() const {
  return _impl_.crc_;
}
inline int32_t CUserMessage_UtilMsg_Response_ItemDetail::crc() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.ItemDetail.crc)
  return _internal_crc();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::_internal_set_crc(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.crc_ = value;
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::set_crc(int32_t value) {
  _internal_set_crc(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.ItemDetail.crc)
}

// optional string name = 4;
inline bool CUserMessage_UtilMsg_Response_ItemDetail::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response_ItemDetail::has_name() const {
  return _internal_has_name();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_UtilMsg_Response_ItemDetail::name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.ItemDetail.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_UtilMsg_Response_ItemDetail::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:CUserMessage_UtilMsg_Response.ItemDetail.name)
}
inline std::string* CUserMessage_UtilMsg_Response_ItemDetail::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_UtilMsg_Response.ItemDetail.name)
  return _s;
}
inline const std::string& CUserMessage_UtilMsg_Response_ItemDetail::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CUserMessage_UtilMsg_Response_ItemDetail::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_UtilMsg_Response_ItemDetail::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_UtilMsg_Response_ItemDetail::release_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_UtilMsg_Response.ItemDetail.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 CUserMessage_UtilMsg_Response_ItemDetail::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:CUserMessage_UtilMsg_Response.ItemDetail.name)
}

// -------------------------------------------------------------------

// CUserMessage_UtilMsg_Response

// optional fixed32 crc = 1;
inline bool CUserMessage_UtilMsg_Response::_internal_has_crc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_crc() const {
  return _internal_has_crc();
}
inline void CUserMessage_UtilMsg_Response::clear_crc() {
  _impl_.crc_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessage_UtilMsg_Response::_internal_crc() const {
  return _impl_.crc_;
}
inline uint32_t CUserMessage_UtilMsg_Response::crc() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.crc)
  return _internal_crc();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_crc(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.crc_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_crc(uint32_t value) {
  _internal_set_crc(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.crc)
}

// optional int32 item_count = 2;
inline bool CUserMessage_UtilMsg_Response::_internal_has_item_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_item_count() const {
  return _internal_has_item_count();
}
inline void CUserMessage_UtilMsg_Response::clear_item_count() {
  _impl_.item_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_item_count() const {
  return _impl_.item_count_;
}
inline int32_t CUserMessage_UtilMsg_Response::item_count() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.item_count)
  return _internal_item_count();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_item_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_count_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_item_count(int32_t value) {
  _internal_set_item_count(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.item_count)
}

// optional fixed32 crc2 = 3;
inline bool CUserMessage_UtilMsg_Response::_internal_has_crc2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_crc2() const {
  return _internal_has_crc2();
}
inline void CUserMessage_UtilMsg_Response::clear_crc2() {
  _impl_.crc2_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessage_UtilMsg_Response::_internal_crc2() const {
  return _impl_.crc2_;
}
inline uint32_t CUserMessage_UtilMsg_Response::crc2() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.crc2)
  return _internal_crc2();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_crc2(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.crc2_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_crc2(uint32_t value) {
  _internal_set_crc2(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.crc2)
}

// optional int32 item_count2 = 4;
inline bool CUserMessage_UtilMsg_Response::_internal_has_item_count2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_item_count2() const {
  return _internal_has_item_count2();
}
inline void CUserMessage_UtilMsg_Response::clear_item_count2() {
  _impl_.item_count2_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_item_count2() const {
  return _impl_.item_count2_;
}
inline int32_t CUserMessage_UtilMsg_Response::item_count2() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.item_count2)
  return _internal_item_count2();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_item_count2(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.item_count2_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_item_count2(int32_t value) {
  _internal_set_item_count2(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.item_count2)
}

// repeated int32 crc_part = 5;
inline int CUserMessage_UtilMsg_Response::_internal_crc_part_size() const {
  return _impl_.crc_part_.size();
}
inline int CUserMessage_UtilMsg_Response::crc_part_size() const {
  return _internal_crc_part_size();
}
inline void CUserMessage_UtilMsg_Response::clear_crc_part() {
  _impl_.crc_part_.Clear();
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_crc_part(int index) const {
  return _impl_.crc_part_.Get(index);
}
inline int32_t CUserMessage_UtilMsg_Response::crc_part(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.crc_part)
  return _internal_crc_part(index);
}
inline void CUserMessage_UtilMsg_Response::set_crc_part(int index, int32_t value) {
  _impl_.crc_part_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.crc_part)
}
inline void CUserMessage_UtilMsg_Response::_internal_add_crc_part(int32_t value) {
  _impl_.crc_part_.Add(value);
}
inline void CUserMessage_UtilMsg_Response::add_crc_part(int32_t value) {
  _internal_add_crc_part(value);
  // @@protoc_insertion_point(field_add:CUserMessage_UtilMsg_Response.crc_part)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_UtilMsg_Response::_internal_crc_part() const {
  return _impl_.crc_part_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_UtilMsg_Response::crc_part() const {
  // @@protoc_insertion_point(field_list:CUserMessage_UtilMsg_Response.crc_part)
  return _internal_crc_part();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_UtilMsg_Response::_internal_mutable_crc_part() {
  return &_impl_.crc_part_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_UtilMsg_Response::mutable_crc_part() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_UtilMsg_Response.crc_part)
  return _internal_mutable_crc_part();
}

// repeated int32 crc_part2 = 6;
inline int CUserMessage_UtilMsg_Response::_internal_crc_part2_size() const {
  return _impl_.crc_part2_.size();
}
inline int CUserMessage_UtilMsg_Response::crc_part2_size() const {
  return _internal_crc_part2_size();
}
inline void CUserMessage_UtilMsg_Response::clear_crc_part2() {
  _impl_.crc_part2_.Clear();
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_crc_part2(int index) const {
  return _impl_.crc_part2_.Get(index);
}
inline int32_t CUserMessage_UtilMsg_Response::crc_part2(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.crc_part2)
  return _internal_crc_part2(index);
}
inline void CUserMessage_UtilMsg_Response::set_crc_part2(int index, int32_t value) {
  _impl_.crc_part2_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.crc_part2)
}
inline void CUserMessage_UtilMsg_Response::_internal_add_crc_part2(int32_t value) {
  _impl_.crc_part2_.Add(value);
}
inline void CUserMessage_UtilMsg_Response::add_crc_part2(int32_t value) {
  _internal_add_crc_part2(value);
  // @@protoc_insertion_point(field_add:CUserMessage_UtilMsg_Response.crc_part2)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_UtilMsg_Response::_internal_crc_part2() const {
  return _impl_.crc_part2_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_UtilMsg_Response::crc_part2() const {
  // @@protoc_insertion_point(field_list:CUserMessage_UtilMsg_Response.crc_part2)
  return _internal_crc_part2();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_UtilMsg_Response::_internal_mutable_crc_part2() {
  return &_impl_.crc_part2_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_UtilMsg_Response::mutable_crc_part2() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_UtilMsg_Response.crc_part2)
  return _internal_mutable_crc_part2();
}

// optional int32 client_timestamp = 7;
inline bool CUserMessage_UtilMsg_Response::_internal_has_client_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_client_timestamp() const {
  return _internal_has_client_timestamp();
}
inline void CUserMessage_UtilMsg_Response::clear_client_timestamp() {
  _impl_.client_timestamp_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_client_timestamp() const {
  return _impl_.client_timestamp_;
}
inline int32_t CUserMessage_UtilMsg_Response::client_timestamp() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.client_timestamp)
  return _internal_client_timestamp();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_client_timestamp(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.client_timestamp_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_client_timestamp(int32_t value) {
  _internal_set_client_timestamp(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.client_timestamp)
}

// optional int32 platform = 8;
inline bool CUserMessage_UtilMsg_Response::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_platform() const {
  return _internal_has_platform();
}
inline void CUserMessage_UtilMsg_Response::clear_platform() {
  _impl_.platform_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_platform() const {
  return _impl_.platform_;
}
inline int32_t CUserMessage_UtilMsg_Response::platform() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.platform)
  return _internal_platform();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_platform(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.platform_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_platform(int32_t value) {
  _internal_set_platform(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.platform)
}

// repeated .CUserMessage_UtilMsg_Response.ItemDetail itemdetails = 9;
inline int CUserMessage_UtilMsg_Response::_internal_itemdetails_size() const {
  return _impl_.itemdetails_.size();
}
inline int CUserMessage_UtilMsg_Response::itemdetails_size() const {
  return _internal_itemdetails_size();
}
inline void CUserMessage_UtilMsg_Response::clear_itemdetails() {
  _impl_.itemdetails_.Clear();
}
inline ::CUserMessage_UtilMsg_Response_ItemDetail* CUserMessage_UtilMsg_Response::mutable_itemdetails(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_UtilMsg_Response.itemdetails)
  return _impl_.itemdetails_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_UtilMsg_Response_ItemDetail >*
CUserMessage_UtilMsg_Response::mutable_itemdetails() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_UtilMsg_Response.itemdetails)
  return &_impl_.itemdetails_;
}
inline const ::CUserMessage_UtilMsg_Response_ItemDetail& CUserMessage_UtilMsg_Response::_internal_itemdetails(int index) const {
  return _impl_.itemdetails_.Get(index);
}
inline const ::CUserMessage_UtilMsg_Response_ItemDetail& CUserMessage_UtilMsg_Response::itemdetails(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.itemdetails)
  return _internal_itemdetails(index);
}
inline ::CUserMessage_UtilMsg_Response_ItemDetail* CUserMessage_UtilMsg_Response::_internal_add_itemdetails() {
  return _impl_.itemdetails_.Add();
}
inline ::CUserMessage_UtilMsg_Response_ItemDetail* CUserMessage_UtilMsg_Response::add_itemdetails() {
  ::CUserMessage_UtilMsg_Response_ItemDetail* _add = _internal_add_itemdetails();
  // @@protoc_insertion_point(field_add:CUserMessage_UtilMsg_Response.itemdetails)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_UtilMsg_Response_ItemDetail >&
CUserMessage_UtilMsg_Response::itemdetails() const {
  // @@protoc_insertion_point(field_list:CUserMessage_UtilMsg_Response.itemdetails)
  return _impl_.itemdetails_;
}

// optional int32 itemgroup = 10;
inline bool CUserMessage_UtilMsg_Response::_internal_has_itemgroup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_itemgroup() const {
  return _internal_has_itemgroup();
}
inline void CUserMessage_UtilMsg_Response::clear_itemgroup() {
  _impl_.itemgroup_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_itemgroup() const {
  return _impl_.itemgroup_;
}
inline int32_t CUserMessage_UtilMsg_Response::itemgroup() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.itemgroup)
  return _internal_itemgroup();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_itemgroup(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.itemgroup_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_itemgroup(int32_t value) {
  _internal_set_itemgroup(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.itemgroup)
}

// optional int32 total_count = 11;
inline bool CUserMessage_UtilMsg_Response::_internal_has_total_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_total_count() const {
  return _internal_has_total_count();
}
inline void CUserMessage_UtilMsg_Response::clear_total_count() {
  _impl_.total_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_total_count() const {
  return _impl_.total_count_;
}
inline int32_t CUserMessage_UtilMsg_Response::total_count() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.total_count)
  return _internal_total_count();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_total_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.total_count_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_total_count(int32_t value) {
  _internal_set_total_count(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.total_count)
}

// optional int32 total_count2 = 12;
inline bool CUserMessage_UtilMsg_Response::_internal_has_total_count2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMessage_UtilMsg_Response::has_total_count2() const {
  return _internal_has_total_count2();
}
inline void CUserMessage_UtilMsg_Response::clear_total_count2() {
  _impl_.total_count2_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CUserMessage_UtilMsg_Response::_internal_total_count2() const {
  return _impl_.total_count2_;
}
inline int32_t CUserMessage_UtilMsg_Response::total_count2() const {
  // @@protoc_insertion_point(field_get:CUserMessage_UtilMsg_Response.total_count2)
  return _internal_total_count2();
}
inline void CUserMessage_UtilMsg_Response::_internal_set_total_count2(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.total_count2_ = value;
}
inline void CUserMessage_UtilMsg_Response::set_total_count2(int32_t value) {
  _internal_set_total_count2(value);
  // @@protoc_insertion_point(field_set:CUserMessage_UtilMsg_Response.total_count2)
}

// -------------------------------------------------------------------

// CUserMessage_DllStatus_CVDiagnostic

// optional uint32 id = 1;
inline bool CUserMessage_DllStatus_CVDiagnostic::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CVDiagnostic::has_id() const {
  return _internal_has_id();
}
inline void CUserMessage_DllStatus_CVDiagnostic::clear_id() {
  _impl_.id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessage_DllStatus_CVDiagnostic::_internal_id() const {
  return _impl_.id_;
}
inline uint32_t CUserMessage_DllStatus_CVDiagnostic::id() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CVDiagnostic.id)
  return _internal_id();
}
inline void CUserMessage_DllStatus_CVDiagnostic::_internal_set_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_ = value;
}
inline void CUserMessage_DllStatus_CVDiagnostic::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CVDiagnostic.id)
}

// optional uint32 extended = 2;
inline bool CUserMessage_DllStatus_CVDiagnostic::_internal_has_extended() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CVDiagnostic::has_extended() const {
  return _internal_has_extended();
}
inline void CUserMessage_DllStatus_CVDiagnostic::clear_extended() {
  _impl_.extended_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessage_DllStatus_CVDiagnostic::_internal_extended() const {
  return _impl_.extended_;
}
inline uint32_t CUserMessage_DllStatus_CVDiagnostic::extended() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CVDiagnostic.extended)
  return _internal_extended();
}
inline void CUserMessage_DllStatus_CVDiagnostic::_internal_set_extended(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.extended_ = value;
}
inline void CUserMessage_DllStatus_CVDiagnostic::set_extended(uint32_t value) {
  _internal_set_extended(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CVDiagnostic.extended)
}

// optional uint64 value = 3;
inline bool CUserMessage_DllStatus_CVDiagnostic::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CVDiagnostic::has_value() const {
  return _internal_has_value();
}
inline void CUserMessage_DllStatus_CVDiagnostic::clear_value() {
  _impl_.value_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CUserMessage_DllStatus_CVDiagnostic::_internal_value() const {
  return _impl_.value_;
}
inline uint64_t CUserMessage_DllStatus_CVDiagnostic::value() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CVDiagnostic.value)
  return _internal_value();
}
inline void CUserMessage_DllStatus_CVDiagnostic::_internal_set_value(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.value_ = value;
}
inline void CUserMessage_DllStatus_CVDiagnostic::set_value(uint64_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CVDiagnostic.value)
}

// optional string string_value = 4;
inline bool CUserMessage_DllStatus_CVDiagnostic::_internal_has_string_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CVDiagnostic::has_string_value() const {
  return _internal_has_string_value();
}
inline void CUserMessage_DllStatus_CVDiagnostic::clear_string_value() {
  _impl_.string_value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_DllStatus_CVDiagnostic::string_value() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CVDiagnostic.string_value)
  return _internal_string_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_DllStatus_CVDiagnostic::set_string_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.string_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CVDiagnostic.string_value)
}
inline std::string* CUserMessage_DllStatus_CVDiagnostic::mutable_string_value() {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.CVDiagnostic.string_value)
  return _s;
}
inline const std::string& CUserMessage_DllStatus_CVDiagnostic::_internal_string_value() const {
  return _impl_.string_value_.Get();
}
inline void CUserMessage_DllStatus_CVDiagnostic::_internal_set_string_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.string_value_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus_CVDiagnostic::_internal_mutable_string_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.string_value_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus_CVDiagnostic::release_string_value() {
  // @@protoc_insertion_point(field_release:CUserMessage_DllStatus.CVDiagnostic.string_value)
  if (!_internal_has_string_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 CUserMessage_DllStatus_CVDiagnostic::set_allocated_string_value(std::string* string_value) {
  if (string_value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:CUserMessage_DllStatus.CVDiagnostic.string_value)
}

// -------------------------------------------------------------------

// CUserMessage_DllStatus_CModule

// optional uint64 base_addr = 1;
inline bool CUserMessage_DllStatus_CModule::_internal_has_base_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CModule::has_base_addr() const {
  return _internal_has_base_addr();
}
inline void CUserMessage_DllStatus_CModule::clear_base_addr() {
  _impl_.base_addr_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CUserMessage_DllStatus_CModule::_internal_base_addr() const {
  return _impl_.base_addr_;
}
inline uint64_t CUserMessage_DllStatus_CModule::base_addr() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CModule.base_addr)
  return _internal_base_addr();
}
inline void CUserMessage_DllStatus_CModule::_internal_set_base_addr(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.base_addr_ = value;
}
inline void CUserMessage_DllStatus_CModule::set_base_addr(uint64_t value) {
  _internal_set_base_addr(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CModule.base_addr)
}

// optional string name = 2;
inline bool CUserMessage_DllStatus_CModule::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CModule::has_name() const {
  return _internal_has_name();
}
inline void CUserMessage_DllStatus_CModule::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_DllStatus_CModule::name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CModule.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_DllStatus_CModule::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:CUserMessage_DllStatus.CModule.name)
}
inline std::string* CUserMessage_DllStatus_CModule::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.CModule.name)
  return _s;
}
inline const std::string& CUserMessage_DllStatus_CModule::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CUserMessage_DllStatus_CModule::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus_CModule::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus_CModule::release_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_DllStatus.CModule.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 CUserMessage_DllStatus_CModule::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:CUserMessage_DllStatus.CModule.name)
}

// optional uint32 size = 3;
inline bool CUserMessage_DllStatus_CModule::_internal_has_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CModule::has_size() const {
  return _internal_has_size();
}
inline void CUserMessage_DllStatus_CModule::clear_size() {
  _impl_.size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessage_DllStatus_CModule::_internal_size() const {
  return _impl_.size_;
}
inline uint32_t CUserMessage_DllStatus_CModule::size() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CModule.size)
  return _internal_size();
}
inline void CUserMessage_DllStatus_CModule::_internal_set_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.size_ = value;
}
inline void CUserMessage_DllStatus_CModule::set_size(uint32_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CModule.size)
}

// optional uint32 timestamp = 4;
inline bool CUserMessage_DllStatus_CModule::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus_CModule::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void CUserMessage_DllStatus_CModule::clear_timestamp() {
  _impl_.timestamp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CUserMessage_DllStatus_CModule::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint32_t CUserMessage_DllStatus_CModule::timestamp() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.CModule.timestamp)
  return _internal_timestamp();
}
inline void CUserMessage_DllStatus_CModule::_internal_set_timestamp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.timestamp_ = value;
}
inline void CUserMessage_DllStatus_CModule::set_timestamp(uint32_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.CModule.timestamp)
}

// -------------------------------------------------------------------

// CUserMessage_DllStatus

// optional string file_report = 1;
inline bool CUserMessage_DllStatus::_internal_has_file_report() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_file_report() const {
  return _internal_has_file_report();
}
inline void CUserMessage_DllStatus::clear_file_report() {
  _impl_.file_report_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_DllStatus::file_report() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.file_report)
  return _internal_file_report();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_DllStatus::set_file_report(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.file_report_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.file_report)
}
inline std::string* CUserMessage_DllStatus::mutable_file_report() {
  std::string* _s = _internal_mutable_file_report();
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.file_report)
  return _s;
}
inline const std::string& CUserMessage_DllStatus::_internal_file_report() const {
  return _impl_.file_report_.Get();
}
inline void CUserMessage_DllStatus::_internal_set_file_report(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.file_report_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus::_internal_mutable_file_report() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.file_report_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus::release_file_report() {
  // @@protoc_insertion_point(field_release:CUserMessage_DllStatus.file_report)
  if (!_internal_has_file_report()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.file_report_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.file_report_.IsDefault()) {
    _impl_.file_report_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_DllStatus::set_allocated_file_report(std::string* file_report) {
  if (file_report != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.file_report_.SetAllocated(file_report, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.file_report_.IsDefault()) {
    _impl_.file_report_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_DllStatus.file_report)
}

// optional string command_line = 2;
inline bool CUserMessage_DllStatus::_internal_has_command_line() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_command_line() const {
  return _internal_has_command_line();
}
inline void CUserMessage_DllStatus::clear_command_line() {
  _impl_.command_line_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessage_DllStatus::command_line() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.command_line)
  return _internal_command_line();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_DllStatus::set_command_line(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.command_line_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.command_line)
}
inline std::string* CUserMessage_DllStatus::mutable_command_line() {
  std::string* _s = _internal_mutable_command_line();
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.command_line)
  return _s;
}
inline const std::string& CUserMessage_DllStatus::_internal_command_line() const {
  return _impl_.command_line_.Get();
}
inline void CUserMessage_DllStatus::_internal_set_command_line(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.command_line_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus::_internal_mutable_command_line() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.command_line_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_DllStatus::release_command_line() {
  // @@protoc_insertion_point(field_release:CUserMessage_DllStatus.command_line)
  if (!_internal_has_command_line()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.command_line_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.command_line_.IsDefault()) {
    _impl_.command_line_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_DllStatus::set_allocated_command_line(std::string* command_line) {
  if (command_line != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.command_line_.SetAllocated(command_line, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.command_line_.IsDefault()) {
    _impl_.command_line_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_DllStatus.command_line)
}

// optional uint32 total_files = 3;
inline bool CUserMessage_DllStatus::_internal_has_total_files() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_total_files() const {
  return _internal_has_total_files();
}
inline void CUserMessage_DllStatus::clear_total_files() {
  _impl_.total_files_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CUserMessage_DllStatus::_internal_total_files() const {
  return _impl_.total_files_;
}
inline uint32_t CUserMessage_DllStatus::total_files() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.total_files)
  return _internal_total_files();
}
inline void CUserMessage_DllStatus::_internal_set_total_files(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.total_files_ = value;
}
inline void CUserMessage_DllStatus::set_total_files(uint32_t value) {
  _internal_set_total_files(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.total_files)
}

// optional uint32 process_id = 4;
inline bool CUserMessage_DllStatus::_internal_has_process_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_process_id() const {
  return _internal_has_process_id();
}
inline void CUserMessage_DllStatus::clear_process_id() {
  _impl_.process_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CUserMessage_DllStatus::_internal_process_id() const {
  return _impl_.process_id_;
}
inline uint32_t CUserMessage_DllStatus::process_id() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.process_id)
  return _internal_process_id();
}
inline void CUserMessage_DllStatus::_internal_set_process_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.process_id_ = value;
}
inline void CUserMessage_DllStatus::set_process_id(uint32_t value) {
  _internal_set_process_id(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.process_id)
}

// optional int32 osversion = 5;
inline bool CUserMessage_DllStatus::_internal_has_osversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_osversion() const {
  return _internal_has_osversion();
}
inline void CUserMessage_DllStatus::clear_osversion() {
  _impl_.osversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessage_DllStatus::_internal_osversion() const {
  return _impl_.osversion_;
}
inline int32_t CUserMessage_DllStatus::osversion() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.osversion)
  return _internal_osversion();
}
inline void CUserMessage_DllStatus::_internal_set_osversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.osversion_ = value;
}
inline void CUserMessage_DllStatus::set_osversion(int32_t value) {
  _internal_set_osversion(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.osversion)
}

// optional uint64 client_time = 6;
inline bool CUserMessage_DllStatus::_internal_has_client_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_DllStatus::has_client_time() const {
  return _internal_has_client_time();
}
inline void CUserMessage_DllStatus::clear_client_time() {
  _impl_.client_time_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CUserMessage_DllStatus::_internal_client_time() const {
  return _impl_.client_time_;
}
inline uint64_t CUserMessage_DllStatus::client_time() const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.client_time)
  return _internal_client_time();
}
inline void CUserMessage_DllStatus::_internal_set_client_time(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.client_time_ = value;
}
inline void CUserMessage_DllStatus::set_client_time(uint64_t value) {
  _internal_set_client_time(value);
  // @@protoc_insertion_point(field_set:CUserMessage_DllStatus.client_time)
}

// repeated .CUserMessage_DllStatus.CVDiagnostic diagnostics = 7;
inline int CUserMessage_DllStatus::_internal_diagnostics_size() const {
  return _impl_.diagnostics_.size();
}
inline int CUserMessage_DllStatus::diagnostics_size() const {
  return _internal_diagnostics_size();
}
inline void CUserMessage_DllStatus::clear_diagnostics() {
  _impl_.diagnostics_.Clear();
}
inline ::CUserMessage_DllStatus_CVDiagnostic* CUserMessage_DllStatus::mutable_diagnostics(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.diagnostics)
  return _impl_.diagnostics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CVDiagnostic >*
CUserMessage_DllStatus::mutable_diagnostics() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_DllStatus.diagnostics)
  return &_impl_.diagnostics_;
}
inline const ::CUserMessage_DllStatus_CVDiagnostic& CUserMessage_DllStatus::_internal_diagnostics(int index) const {
  return _impl_.diagnostics_.Get(index);
}
inline const ::CUserMessage_DllStatus_CVDiagnostic& CUserMessage_DllStatus::diagnostics(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.diagnostics)
  return _internal_diagnostics(index);
}
inline ::CUserMessage_DllStatus_CVDiagnostic* CUserMessage_DllStatus::_internal_add_diagnostics() {
  return _impl_.diagnostics_.Add();
}
inline ::CUserMessage_DllStatus_CVDiagnostic* CUserMessage_DllStatus::add_diagnostics() {
  ::CUserMessage_DllStatus_CVDiagnostic* _add = _internal_add_diagnostics();
  // @@protoc_insertion_point(field_add:CUserMessage_DllStatus.diagnostics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CVDiagnostic >&
CUserMessage_DllStatus::diagnostics() const {
  // @@protoc_insertion_point(field_list:CUserMessage_DllStatus.diagnostics)
  return _impl_.diagnostics_;
}

// repeated .CUserMessage_DllStatus.CModule modules = 8;
inline int CUserMessage_DllStatus::_internal_modules_size() const {
  return _impl_.modules_.size();
}
inline int CUserMessage_DllStatus::modules_size() const {
  return _internal_modules_size();
}
inline void CUserMessage_DllStatus::clear_modules() {
  _impl_.modules_.Clear();
}
inline ::CUserMessage_DllStatus_CModule* CUserMessage_DllStatus::mutable_modules(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_DllStatus.modules)
  return _impl_.modules_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CModule >*
CUserMessage_DllStatus::mutable_modules() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_DllStatus.modules)
  return &_impl_.modules_;
}
inline const ::CUserMessage_DllStatus_CModule& CUserMessage_DllStatus::_internal_modules(int index) const {
  return _impl_.modules_.Get(index);
}
inline const ::CUserMessage_DllStatus_CModule& CUserMessage_DllStatus::modules(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_DllStatus.modules)
  return _internal_modules(index);
}
inline ::CUserMessage_DllStatus_CModule* CUserMessage_DllStatus::_internal_add_modules() {
  return _impl_.modules_.Add();
}
inline ::CUserMessage_DllStatus_CModule* CUserMessage_DllStatus::add_modules() {
  ::CUserMessage_DllStatus_CModule* _add = _internal_add_modules();
  // @@protoc_insertion_point(field_add:CUserMessage_DllStatus.modules)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_DllStatus_CModule >&
CUserMessage_DllStatus::modules() const {
  // @@protoc_insertion_point(field_list:CUserMessage_DllStatus.modules)
  return _impl_.modules_;
}

// -------------------------------------------------------------------

// CUserMessageRequestInventory

// optional int32 inventory = 1;
inline bool CUserMessageRequestInventory::_internal_has_inventory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageRequestInventory::has_inventory() const {
  return _internal_has_inventory();
}
inline void CUserMessageRequestInventory::clear_inventory() {
  _impl_.inventory_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessageRequestInventory::_internal_inventory() const {
  return _impl_.inventory_;
}
inline int32_t CUserMessageRequestInventory::inventory() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestInventory.inventory)
  return _internal_inventory();
}
inline void CUserMessageRequestInventory::_internal_set_inventory(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.inventory_ = value;
}
inline void CUserMessageRequestInventory::set_inventory(int32_t value) {
  _internal_set_inventory(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestInventory.inventory)
}

// optional int32 offset = 2;
inline bool CUserMessageRequestInventory::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageRequestInventory::has_offset() const {
  return _internal_has_offset();
}
inline void CUserMessageRequestInventory::clear_offset() {
  _impl_.offset_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessageRequestInventory::_internal_offset() const {
  return _impl_.offset_;
}
inline int32_t CUserMessageRequestInventory::offset() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestInventory.offset)
  return _internal_offset();
}
inline void CUserMessageRequestInventory::_internal_set_offset(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.offset_ = value;
}
inline void CUserMessageRequestInventory::set_offset(int32_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestInventory.offset)
}

// optional int32 options = 3;
inline bool CUserMessageRequestInventory::_internal_has_options() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageRequestInventory::has_options() const {
  return _internal_has_options();
}
inline void CUserMessageRequestInventory::clear_options() {
  _impl_.options_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessageRequestInventory::_internal_options() const {
  return _impl_.options_;
}
inline int32_t CUserMessageRequestInventory::options() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestInventory.options)
  return _internal_options();
}
inline void CUserMessageRequestInventory::_internal_set_options(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.options_ = value;
}
inline void CUserMessageRequestInventory::set_options(int32_t value) {
  _internal_set_options(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestInventory.options)
}

// -------------------------------------------------------------------

// CUserMessage_Inventory_Response_InventoryDetail

// optional int32 index = 1;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_index() const {
  return _internal_has_index();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_index() {
  _impl_.index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::_internal_index() const {
  return _impl_.index_;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::index() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.index)
  return _internal_index();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.index_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.index)
}

// optional int64 primary = 2;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_primary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_primary() const {
  return _internal_has_primary();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_primary() {
  _impl_.primary_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::_internal_primary() const {
  return _impl_.primary_;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::primary() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.primary)
  return _internal_primary();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_primary(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.primary_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_primary(int64_t value) {
  _internal_set_primary(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.primary)
}

// optional int64 offset = 3;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_offset() const {
  return _internal_has_offset();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_offset() {
  _impl_.offset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::_internal_offset() const {
  return _impl_.offset_;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::offset() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.offset)
  return _internal_offset();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_offset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.offset_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.offset)
}

// optional int64 first = 4;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_first() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_first() const {
  return _internal_has_first();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_first() {
  _impl_.first_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::_internal_first() const {
  return _impl_.first_;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::first() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.first)
  return _internal_first();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_first(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.first_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_first(int64_t value) {
  _internal_set_first(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.first)
}

// optional int64 base = 5;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_base() const {
  return _internal_has_base();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_base() {
  _impl_.base_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::_internal_base() const {
  return _impl_.base_;
}
inline int64_t CUserMessage_Inventory_Response_InventoryDetail::base() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.base)
  return _internal_base();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_base(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.base_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_base(int64_t value) {
  _internal_set_base(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.base)
}

// optional string name = 6;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_name() const {
  return _internal_has_name();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_Inventory_Response_InventoryDetail::name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Inventory_Response_InventoryDetail::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:CUserMessage_Inventory_Response.InventoryDetail.name)
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Inventory_Response.InventoryDetail.name)
  return _s;
}
inline const std::string& CUserMessage_Inventory_Response_InventoryDetail::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::release_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_Inventory_Response.InventoryDetail.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 CUserMessage_Inventory_Response_InventoryDetail::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:CUserMessage_Inventory_Response.InventoryDetail.name)
}

// optional string base_name = 7;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_base_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_base_name() const {
  return _internal_has_base_name();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_base_name() {
  _impl_.base_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessage_Inventory_Response_InventoryDetail::base_name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.base_name)
  return _internal_base_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Inventory_Response_InventoryDetail::set_base_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.base_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.base_name)
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::mutable_base_name() {
  std::string* _s = _internal_mutable_base_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Inventory_Response.InventoryDetail.base_name)
  return _s;
}
inline const std::string& CUserMessage_Inventory_Response_InventoryDetail::_internal_base_name() const {
  return _impl_.base_name_.Get();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_base_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.base_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::_internal_mutable_base_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.base_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Inventory_Response_InventoryDetail::release_base_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_Inventory_Response.InventoryDetail.base_name)
  if (!_internal_has_base_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.base_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.base_name_.IsDefault()) {
    _impl_.base_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_allocated_base_name(std::string* base_name) {
  if (base_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.base_name_.SetAllocated(base_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.base_name_.IsDefault()) {
    _impl_.base_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_Inventory_Response.InventoryDetail.base_name)
}

// optional int32 base_detail = 8;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_base_detail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_base_detail() const {
  return _internal_has_base_detail();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_base_detail() {
  _impl_.base_detail_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::_internal_base_detail() const {
  return _impl_.base_detail_;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::base_detail() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.base_detail)
  return _internal_base_detail();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_base_detail(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.base_detail_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_base_detail(int32_t value) {
  _internal_set_base_detail(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.base_detail)
}

// optional int32 base_time = 9;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_base_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_base_time() const {
  return _internal_has_base_time();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_base_time() {
  _impl_.base_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::_internal_base_time() const {
  return _impl_.base_time_;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::base_time() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.base_time)
  return _internal_base_time();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_base_time(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.base_time_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_base_time(int32_t value) {
  _internal_set_base_time(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.base_time)
}

// optional int32 base_hash = 10;
inline bool CUserMessage_Inventory_Response_InventoryDetail::_internal_has_base_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response_InventoryDetail::has_base_hash() const {
  return _internal_has_base_hash();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::clear_base_hash() {
  _impl_.base_hash_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::_internal_base_hash() const {
  return _impl_.base_hash_;
}
inline int32_t CUserMessage_Inventory_Response_InventoryDetail::base_hash() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.InventoryDetail.base_hash)
  return _internal_base_hash();
}
inline void CUserMessage_Inventory_Response_InventoryDetail::_internal_set_base_hash(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.base_hash_ = value;
}
inline void CUserMessage_Inventory_Response_InventoryDetail::set_base_hash(int32_t value) {
  _internal_set_base_hash(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.InventoryDetail.base_hash)
}

// -------------------------------------------------------------------

// CUserMessage_Inventory_Response

// optional fixed32 crc = 1;
inline bool CUserMessage_Inventory_Response::_internal_has_crc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_crc() const {
  return _internal_has_crc();
}
inline void CUserMessage_Inventory_Response::clear_crc() {
  _impl_.crc_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CUserMessage_Inventory_Response::_internal_crc() const {
  return _impl_.crc_;
}
inline uint32_t CUserMessage_Inventory_Response::crc() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.crc)
  return _internal_crc();
}
inline void CUserMessage_Inventory_Response::_internal_set_crc(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.crc_ = value;
}
inline void CUserMessage_Inventory_Response::set_crc(uint32_t value) {
  _internal_set_crc(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.crc)
}

// optional int32 item_count = 2;
inline bool CUserMessage_Inventory_Response::_internal_has_item_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_item_count() const {
  return _internal_has_item_count();
}
inline void CUserMessage_Inventory_Response::clear_item_count() {
  _impl_.item_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_item_count() const {
  return _impl_.item_count_;
}
inline int32_t CUserMessage_Inventory_Response::item_count() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.item_count)
  return _internal_item_count();
}
inline void CUserMessage_Inventory_Response::_internal_set_item_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.item_count_ = value;
}
inline void CUserMessage_Inventory_Response::set_item_count(int32_t value) {
  _internal_set_item_count(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.item_count)
}

// optional int32 osversion = 5;
inline bool CUserMessage_Inventory_Response::_internal_has_osversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_osversion() const {
  return _internal_has_osversion();
}
inline void CUserMessage_Inventory_Response::clear_osversion() {
  _impl_.osversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_osversion() const {
  return _impl_.osversion_;
}
inline int32_t CUserMessage_Inventory_Response::osversion() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.osversion)
  return _internal_osversion();
}
inline void CUserMessage_Inventory_Response::_internal_set_osversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.osversion_ = value;
}
inline void CUserMessage_Inventory_Response::set_osversion(int32_t value) {
  _internal_set_osversion(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.osversion)
}

// optional int32 perf_time = 6;
inline bool CUserMessage_Inventory_Response::_internal_has_perf_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_perf_time() const {
  return _internal_has_perf_time();
}
inline void CUserMessage_Inventory_Response::clear_perf_time() {
  _impl_.perf_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_perf_time() const {
  return _impl_.perf_time_;
}
inline int32_t CUserMessage_Inventory_Response::perf_time() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.perf_time)
  return _internal_perf_time();
}
inline void CUserMessage_Inventory_Response::_internal_set_perf_time(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.perf_time_ = value;
}
inline void CUserMessage_Inventory_Response::set_perf_time(int32_t value) {
  _internal_set_perf_time(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.perf_time)
}

// optional int32 client_timestamp = 7;
inline bool CUserMessage_Inventory_Response::_internal_has_client_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_client_timestamp() const {
  return _internal_has_client_timestamp();
}
inline void CUserMessage_Inventory_Response::clear_client_timestamp() {
  _impl_.client_timestamp_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_client_timestamp() const {
  return _impl_.client_timestamp_;
}
inline int32_t CUserMessage_Inventory_Response::client_timestamp() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.client_timestamp)
  return _internal_client_timestamp();
}
inline void CUserMessage_Inventory_Response::_internal_set_client_timestamp(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.client_timestamp_ = value;
}
inline void CUserMessage_Inventory_Response::set_client_timestamp(int32_t value) {
  _internal_set_client_timestamp(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.client_timestamp)
}

// optional int32 platform = 8;
inline bool CUserMessage_Inventory_Response::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_platform() const {
  return _internal_has_platform();
}
inline void CUserMessage_Inventory_Response::clear_platform() {
  _impl_.platform_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_platform() const {
  return _impl_.platform_;
}
inline int32_t CUserMessage_Inventory_Response::platform() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.platform)
  return _internal_platform();
}
inline void CUserMessage_Inventory_Response::_internal_set_platform(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.platform_ = value;
}
inline void CUserMessage_Inventory_Response::set_platform(int32_t value) {
  _internal_set_platform(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.platform)
}

// repeated .CUserMessage_Inventory_Response.InventoryDetail inventories = 9;
inline int CUserMessage_Inventory_Response::_internal_inventories_size() const {
  return _impl_.inventories_.size();
}
inline int CUserMessage_Inventory_Response::inventories_size() const {
  return _internal_inventories_size();
}
inline void CUserMessage_Inventory_Response::clear_inventories() {
  _impl_.inventories_.Clear();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::mutable_inventories(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_Inventory_Response.inventories)
  return _impl_.inventories_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
CUserMessage_Inventory_Response::mutable_inventories() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_Inventory_Response.inventories)
  return &_impl_.inventories_;
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::_internal_inventories(int index) const {
  return _impl_.inventories_.Get(index);
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::inventories(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.inventories)
  return _internal_inventories(index);
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::_internal_add_inventories() {
  return _impl_.inventories_.Add();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::add_inventories() {
  ::CUserMessage_Inventory_Response_InventoryDetail* _add = _internal_add_inventories();
  // @@protoc_insertion_point(field_add:CUserMessage_Inventory_Response.inventories)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
CUserMessage_Inventory_Response::inventories() const {
  // @@protoc_insertion_point(field_list:CUserMessage_Inventory_Response.inventories)
  return _impl_.inventories_;
}

// repeated .CUserMessage_Inventory_Response.InventoryDetail inventories2 = 10;
inline int CUserMessage_Inventory_Response::_internal_inventories2_size() const {
  return _impl_.inventories2_.size();
}
inline int CUserMessage_Inventory_Response::inventories2_size() const {
  return _internal_inventories2_size();
}
inline void CUserMessage_Inventory_Response::clear_inventories2() {
  _impl_.inventories2_.Clear();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::mutable_inventories2(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_Inventory_Response.inventories2)
  return _impl_.inventories2_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
CUserMessage_Inventory_Response::mutable_inventories2() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_Inventory_Response.inventories2)
  return &_impl_.inventories2_;
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::_internal_inventories2(int index) const {
  return _impl_.inventories2_.Get(index);
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::inventories2(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.inventories2)
  return _internal_inventories2(index);
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::_internal_add_inventories2() {
  return _impl_.inventories2_.Add();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::add_inventories2() {
  ::CUserMessage_Inventory_Response_InventoryDetail* _add = _internal_add_inventories2();
  // @@protoc_insertion_point(field_add:CUserMessage_Inventory_Response.inventories2)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
CUserMessage_Inventory_Response::inventories2() const {
  // @@protoc_insertion_point(field_list:CUserMessage_Inventory_Response.inventories2)
  return _impl_.inventories2_;
}

// repeated .CUserMessage_Inventory_Response.InventoryDetail inventories3 = 14;
inline int CUserMessage_Inventory_Response::_internal_inventories3_size() const {
  return _impl_.inventories3_.size();
}
inline int CUserMessage_Inventory_Response::inventories3_size() const {
  return _internal_inventories3_size();
}
inline void CUserMessage_Inventory_Response::clear_inventories3() {
  _impl_.inventories3_.Clear();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::mutable_inventories3(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_Inventory_Response.inventories3)
  return _impl_.inventories3_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >*
CUserMessage_Inventory_Response::mutable_inventories3() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_Inventory_Response.inventories3)
  return &_impl_.inventories3_;
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::_internal_inventories3(int index) const {
  return _impl_.inventories3_.Get(index);
}
inline const ::CUserMessage_Inventory_Response_InventoryDetail& CUserMessage_Inventory_Response::inventories3(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.inventories3)
  return _internal_inventories3(index);
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::_internal_add_inventories3() {
  return _impl_.inventories3_.Add();
}
inline ::CUserMessage_Inventory_Response_InventoryDetail* CUserMessage_Inventory_Response::add_inventories3() {
  ::CUserMessage_Inventory_Response_InventoryDetail* _add = _internal_add_inventories3();
  // @@protoc_insertion_point(field_add:CUserMessage_Inventory_Response.inventories3)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Inventory_Response_InventoryDetail >&
CUserMessage_Inventory_Response::inventories3() const {
  // @@protoc_insertion_point(field_list:CUserMessage_Inventory_Response.inventories3)
  return _impl_.inventories3_;
}

// optional int32 inv_type = 11;
inline bool CUserMessage_Inventory_Response::_internal_has_inv_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_inv_type() const {
  return _internal_has_inv_type();
}
inline void CUserMessage_Inventory_Response::clear_inv_type() {
  _impl_.inv_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_inv_type() const {
  return _impl_.inv_type_;
}
inline int32_t CUserMessage_Inventory_Response::inv_type() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.inv_type)
  return _internal_inv_type();
}
inline void CUserMessage_Inventory_Response::_internal_set_inv_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.inv_type_ = value;
}
inline void CUserMessage_Inventory_Response::set_inv_type(int32_t value) {
  _internal_set_inv_type(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.inv_type)
}

// optional int32 build_version = 12;
inline bool CUserMessage_Inventory_Response::_internal_has_build_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_build_version() const {
  return _internal_has_build_version();
}
inline void CUserMessage_Inventory_Response::clear_build_version() {
  _impl_.build_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_build_version() const {
  return _impl_.build_version_;
}
inline int32_t CUserMessage_Inventory_Response::build_version() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.build_version)
  return _internal_build_version();
}
inline void CUserMessage_Inventory_Response::_internal_set_build_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.build_version_ = value;
}
inline void CUserMessage_Inventory_Response::set_build_version(int32_t value) {
  _internal_set_build_version(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.build_version)
}

// optional int32 instance = 13;
inline bool CUserMessage_Inventory_Response::_internal_has_instance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_instance() const {
  return _internal_has_instance();
}
inline void CUserMessage_Inventory_Response::clear_instance() {
  _impl_.instance_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CUserMessage_Inventory_Response::_internal_instance() const {
  return _impl_.instance_;
}
inline int32_t CUserMessage_Inventory_Response::instance() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.instance)
  return _internal_instance();
}
inline void CUserMessage_Inventory_Response::_internal_set_instance(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.instance_ = value;
}
inline void CUserMessage_Inventory_Response::set_instance(int32_t value) {
  _internal_set_instance(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.instance)
}

// optional int64 start_time = 15;
inline bool CUserMessage_Inventory_Response::_internal_has_start_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMessage_Inventory_Response::has_start_time() const {
  return _internal_has_start_time();
}
inline void CUserMessage_Inventory_Response::clear_start_time() {
  _impl_.start_time_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t CUserMessage_Inventory_Response::_internal_start_time() const {
  return _impl_.start_time_;
}
inline int64_t CUserMessage_Inventory_Response::start_time() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Inventory_Response.start_time)
  return _internal_start_time();
}
inline void CUserMessage_Inventory_Response::_internal_set_start_time(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.start_time_ = value;
}
inline void CUserMessage_Inventory_Response::set_start_time(int64_t value) {
  _internal_set_start_time(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Inventory_Response.start_time)
}

// -------------------------------------------------------------------

// CUserMessageRequestDiagnostic_Diagnostic

// optional int32 index = 1;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_index() const {
  return _internal_has_index();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_index() {
  _impl_.index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::_internal_index() const {
  return _impl_.index_;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::index() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.index)
  return _internal_index();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.index_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.index)
}

// optional int64 offset = 2;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_offset() const {
  return _internal_has_offset();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_offset() {
  _impl_.offset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::_internal_offset() const {
  return _impl_.offset_;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::offset() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.offset)
  return _internal_offset();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_offset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.offset_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.offset)
}

// optional int32 param = 3;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_param() const {
  return _internal_has_param();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_param() {
  _impl_.param_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::_internal_param() const {
  return _impl_.param_;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::param() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.param)
  return _internal_param();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_param(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.param_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_param(int32_t value) {
  _internal_set_param(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.param)
}

// optional int32 length = 4;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_length() const {
  return _internal_has_length();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_length() {
  _impl_.length_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::_internal_length() const {
  return _impl_.length_;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::length() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.length)
  return _internal_length();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_length(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.length_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_length(int32_t value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.length)
}

// optional int32 type = 5;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_type() const {
  return _internal_has_type();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::_internal_type() const {
  return _impl_.type_;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::type() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.type)
  return _internal_type();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.type_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.type)
}

// optional int64 base = 6;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_base() const {
  return _internal_has_base();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_base() {
  _impl_.base_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::_internal_base() const {
  return _impl_.base_;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::base() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.base)
  return _internal_base();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_base(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.base_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_base(int64_t value) {
  _internal_set_base(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.base)
}

// optional int64 range = 7;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_range() const {
  return _internal_has_range();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_range() {
  _impl_.range_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::_internal_range() const {
  return _impl_.range_;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::range() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.range)
  return _internal_range();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_range(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.range_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_range(int64_t value) {
  _internal_set_range(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.range)
}

// optional int64 extent = 8;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_extent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_extent() const {
  return _internal_has_extent();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_extent() {
  _impl_.extent_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::_internal_extent() const {
  return _impl_.extent_;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::extent() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.extent)
  return _internal_extent();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_extent(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.extent_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_extent(int64_t value) {
  _internal_set_extent(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.extent)
}

// optional int64 detail = 9;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_detail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_detail() const {
  return _internal_has_detail();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_detail() {
  _impl_.detail_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::_internal_detail() const {
  return _impl_.detail_;
}
inline int64_t CUserMessageRequestDiagnostic_Diagnostic::detail() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.detail)
  return _internal_detail();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_detail(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.detail_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_detail(int64_t value) {
  _internal_set_detail(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.detail)
}

// optional string name = 10;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_name() const {
  return _internal_has_name();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::name() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageRequestDiagnostic_Diagnostic::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:CUserMessageRequestDiagnostic.Diagnostic.name)
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CUserMessageRequestDiagnostic.Diagnostic.name)
  return _s;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::release_name() {
  // @@protoc_insertion_point(field_release:CUserMessageRequestDiagnostic.Diagnostic.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 CUserMessageRequestDiagnostic_Diagnostic::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:CUserMessageRequestDiagnostic.Diagnostic.name)
}

// optional string alias = 11;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_alias() const {
  return _internal_has_alias();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_alias() {
  _impl_.alias_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::alias() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.alias)
  return _internal_alias();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageRequestDiagnostic_Diagnostic::set_alias(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.alias_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.alias)
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::mutable_alias() {
  std::string* _s = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:CUserMessageRequestDiagnostic.Diagnostic.alias)
  return _s;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::_internal_alias() const {
  return _impl_.alias_.Get();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_alias(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.alias_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::_internal_mutable_alias() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.alias_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::release_alias() {
  // @@protoc_insertion_point(field_release:CUserMessageRequestDiagnostic.Diagnostic.alias)
  if (!_internal_has_alias()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.alias_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alias_.IsDefault()) {
    _impl_.alias_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_allocated_alias(std::string* alias) {
  if (alias != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.alias_.SetAllocated(alias, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alias_.IsDefault()) {
    _impl_.alias_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageRequestDiagnostic.Diagnostic.alias)
}

// optional bytes vardetail = 12;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_vardetail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_vardetail() const {
  return _internal_has_vardetail();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_vardetail() {
  _impl_.vardetail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::vardetail() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.vardetail)
  return _internal_vardetail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessageRequestDiagnostic_Diagnostic::set_vardetail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.vardetail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.vardetail)
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::mutable_vardetail() {
  std::string* _s = _internal_mutable_vardetail();
  // @@protoc_insertion_point(field_mutable:CUserMessageRequestDiagnostic.Diagnostic.vardetail)
  return _s;
}
inline const std::string& CUserMessageRequestDiagnostic_Diagnostic::_internal_vardetail() const {
  return _impl_.vardetail_.Get();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_vardetail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.vardetail_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::_internal_mutable_vardetail() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.vardetail_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessageRequestDiagnostic_Diagnostic::release_vardetail() {
  // @@protoc_insertion_point(field_release:CUserMessageRequestDiagnostic.Diagnostic.vardetail)
  if (!_internal_has_vardetail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.vardetail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vardetail_.IsDefault()) {
    _impl_.vardetail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_allocated_vardetail(std::string* vardetail) {
  if (vardetail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.vardetail_.SetAllocated(vardetail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vardetail_.IsDefault()) {
    _impl_.vardetail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessageRequestDiagnostic.Diagnostic.vardetail)
}

// optional int32 context = 13;
inline bool CUserMessageRequestDiagnostic_Diagnostic::_internal_has_context() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CUserMessageRequestDiagnostic_Diagnostic::has_context() const {
  return _internal_has_context();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::clear_context() {
  _impl_.context_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::_internal_context() const {
  return _impl_.context_;
}
inline int32_t CUserMessageRequestDiagnostic_Diagnostic::context() const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.Diagnostic.context)
  return _internal_context();
}
inline void CUserMessageRequestDiagnostic_Diagnostic::_internal_set_context(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.context_ = value;
}
inline void CUserMessageRequestDiagnostic_Diagnostic::set_context(int32_t value) {
  _internal_set_context(value);
  // @@protoc_insertion_point(field_set:CUserMessageRequestDiagnostic.Diagnostic.context)
}

// -------------------------------------------------------------------

// CUserMessageRequestDiagnostic

// repeated .CUserMessageRequestDiagnostic.Diagnostic diagnostics = 1;
inline int CUserMessageRequestDiagnostic::_internal_diagnostics_size() const {
  return _impl_.diagnostics_.size();
}
inline int CUserMessageRequestDiagnostic::diagnostics_size() const {
  return _internal_diagnostics_size();
}
inline void CUserMessageRequestDiagnostic::clear_diagnostics() {
  _impl_.diagnostics_.Clear();
}
inline ::CUserMessageRequestDiagnostic_Diagnostic* CUserMessageRequestDiagnostic::mutable_diagnostics(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessageRequestDiagnostic.diagnostics)
  return _impl_.diagnostics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessageRequestDiagnostic_Diagnostic >*
CUserMessageRequestDiagnostic::mutable_diagnostics() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessageRequestDiagnostic.diagnostics)
  return &_impl_.diagnostics_;
}
inline const ::CUserMessageRequestDiagnostic_Diagnostic& CUserMessageRequestDiagnostic::_internal_diagnostics(int index) const {
  return _impl_.diagnostics_.Get(index);
}
inline const ::CUserMessageRequestDiagnostic_Diagnostic& CUserMessageRequestDiagnostic::diagnostics(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessageRequestDiagnostic.diagnostics)
  return _internal_diagnostics(index);
}
inline ::CUserMessageRequestDiagnostic_Diagnostic* CUserMessageRequestDiagnostic::_internal_add_diagnostics() {
  return _impl_.diagnostics_.Add();
}
inline ::CUserMessageRequestDiagnostic_Diagnostic* CUserMessageRequestDiagnostic::add_diagnostics() {
  ::CUserMessageRequestDiagnostic_Diagnostic* _add = _internal_add_diagnostics();
  // @@protoc_insertion_point(field_add:CUserMessageRequestDiagnostic.diagnostics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessageRequestDiagnostic_Diagnostic >&
CUserMessageRequestDiagnostic::diagnostics() const {
  // @@protoc_insertion_point(field_list:CUserMessageRequestDiagnostic.diagnostics)
  return _impl_.diagnostics_;
}

// -------------------------------------------------------------------

// CUserMessage_Diagnostic_Response_Diagnostic

// optional int32 index = 1;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_index() const {
  return _internal_has_index();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_index() {
  _impl_.index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_index() const {
  return _impl_.index_;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::index() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.index)
  return _internal_index();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.index_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.index)
}

// optional int64 offset = 2;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_offset() const {
  return _internal_has_offset();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_offset() {
  _impl_.offset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_offset() const {
  return _impl_.offset_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::offset() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.offset)
  return _internal_offset();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_offset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.offset_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.offset)
}

// optional int32 param = 3;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_param() const {
  return _internal_has_param();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_param() {
  _impl_.param_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_param() const {
  return _impl_.param_;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::param() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.param)
  return _internal_param();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_param(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.param_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_param(int32_t value) {
  _internal_set_param(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.param)
}

// optional int32 length = 4;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_length() const {
  return _internal_has_length();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_length() {
  _impl_.length_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_length() const {
  return _impl_.length_;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::length() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.length)
  return _internal_length();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_length(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.length_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_length(int32_t value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.length)
}

// optional bytes detail = 5;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_detail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_detail() const {
  return _internal_has_detail();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_detail() {
  _impl_.detail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::detail() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.detail)
  return _internal_detail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Diagnostic_Response_Diagnostic::set_detail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.detail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.detail)
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::mutable_detail() {
  std::string* _s = _internal_mutable_detail();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Diagnostic_Response.Diagnostic.detail)
  return _s;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::_internal_detail() const {
  return _impl_.detail_.Get();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_detail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.detail_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::_internal_mutable_detail() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.detail_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::release_detail() {
  // @@protoc_insertion_point(field_release:CUserMessage_Diagnostic_Response.Diagnostic.detail)
  if (!_internal_has_detail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.detail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.detail_.IsDefault()) {
    _impl_.detail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_allocated_detail(std::string* detail) {
  if (detail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.detail_.SetAllocated(detail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.detail_.IsDefault()) {
    _impl_.detail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_Diagnostic_Response.Diagnostic.detail)
}

// optional int64 base = 6;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_base() const {
  return _internal_has_base();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_base() {
  _impl_.base_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_base() const {
  return _impl_.base_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::base() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.base)
  return _internal_base();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_base(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.base_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_base(int64_t value) {
  _internal_set_base(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.base)
}

// optional int64 range = 7;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_range() const {
  return _internal_has_range();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_range() {
  _impl_.range_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_range() const {
  return _impl_.range_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::range() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.range)
  return _internal_range();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_range(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.range_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_range(int64_t value) {
  _internal_set_range(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.range)
}

// optional int32 type = 8;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_type() const {
  return _internal_has_type();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_type() const {
  return _impl_.type_;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::type() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.type)
  return _internal_type();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.type_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.type)
}

// optional string name = 10;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_name() const {
  return _internal_has_name();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Diagnostic_Response_Diagnostic::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.name)
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Diagnostic_Response.Diagnostic.name)
  return _s;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::release_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_Diagnostic_Response.Diagnostic.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 CUserMessage_Diagnostic_Response_Diagnostic::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:CUserMessage_Diagnostic_Response.Diagnostic.name)
}

// optional string alias = 11;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_alias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_alias() const {
  return _internal_has_alias();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_alias() {
  _impl_.alias_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::alias() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.alias)
  return _internal_alias();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Diagnostic_Response_Diagnostic::set_alias(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.alias_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.alias)
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::mutable_alias() {
  std::string* _s = _internal_mutable_alias();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Diagnostic_Response.Diagnostic.alias)
  return _s;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::_internal_alias() const {
  return _impl_.alias_.Get();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_alias(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.alias_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::_internal_mutable_alias() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.alias_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::release_alias() {
  // @@protoc_insertion_point(field_release:CUserMessage_Diagnostic_Response.Diagnostic.alias)
  if (!_internal_has_alias()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.alias_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alias_.IsDefault()) {
    _impl_.alias_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_allocated_alias(std::string* alias) {
  if (alias != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.alias_.SetAllocated(alias, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alias_.IsDefault()) {
    _impl_.alias_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_Diagnostic_Response.Diagnostic.alias)
}

// optional bytes backup = 12;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_backup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_backup() const {
  return _internal_has_backup();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_backup() {
  _impl_.backup_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::backup() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.backup)
  return _internal_backup();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_Diagnostic_Response_Diagnostic::set_backup(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.backup_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.backup)
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::mutable_backup() {
  std::string* _s = _internal_mutable_backup();
  // @@protoc_insertion_point(field_mutable:CUserMessage_Diagnostic_Response.Diagnostic.backup)
  return _s;
}
inline const std::string& CUserMessage_Diagnostic_Response_Diagnostic::_internal_backup() const {
  return _impl_.backup_.Get();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_backup(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.backup_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::_internal_mutable_backup() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.backup_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_Diagnostic_Response_Diagnostic::release_backup() {
  // @@protoc_insertion_point(field_release:CUserMessage_Diagnostic_Response.Diagnostic.backup)
  if (!_internal_has_backup()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.backup_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.backup_.IsDefault()) {
    _impl_.backup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_allocated_backup(std::string* backup) {
  if (backup != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.backup_.SetAllocated(backup, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.backup_.IsDefault()) {
    _impl_.backup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_Diagnostic_Response.Diagnostic.backup)
}

// optional int32 context = 13;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_context() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_context() const {
  return _internal_has_context();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_context() {
  _impl_.context_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_context() const {
  return _impl_.context_;
}
inline int32_t CUserMessage_Diagnostic_Response_Diagnostic::context() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.context)
  return _internal_context();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_context(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.context_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_context(int32_t value) {
  _internal_set_context(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.context)
}

// optional int64 control = 14;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_control() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_control() const {
  return _internal_has_control();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_control() {
  _impl_.control_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_control() const {
  return _impl_.control_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::control() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.control)
  return _internal_control();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_control(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.control_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_control(int64_t value) {
  _internal_set_control(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.control)
}

// optional int64 augment = 15;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_augment() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_augment() const {
  return _internal_has_augment();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_augment() {
  _impl_.augment_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_augment() const {
  return _impl_.augment_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::augment() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.augment)
  return _internal_augment();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_augment(int64_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.augment_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_augment(int64_t value) {
  _internal_set_augment(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.augment)
}

// optional int64 placebo = 16;
inline bool CUserMessage_Diagnostic_Response_Diagnostic::_internal_has_placebo() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response_Diagnostic::has_placebo() const {
  return _internal_has_placebo();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::clear_placebo() {
  _impl_.placebo_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::_internal_placebo() const {
  return _impl_.placebo_;
}
inline int64_t CUserMessage_Diagnostic_Response_Diagnostic::placebo() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.Diagnostic.placebo)
  return _internal_placebo();
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::_internal_set_placebo(int64_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.placebo_ = value;
}
inline void CUserMessage_Diagnostic_Response_Diagnostic::set_placebo(int64_t value) {
  _internal_set_placebo(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.Diagnostic.placebo)
}

// -------------------------------------------------------------------

// CUserMessage_Diagnostic_Response

// repeated .CUserMessage_Diagnostic_Response.Diagnostic diagnostics = 1;
inline int CUserMessage_Diagnostic_Response::_internal_diagnostics_size() const {
  return _impl_.diagnostics_.size();
}
inline int CUserMessage_Diagnostic_Response::diagnostics_size() const {
  return _internal_diagnostics_size();
}
inline void CUserMessage_Diagnostic_Response::clear_diagnostics() {
  _impl_.diagnostics_.Clear();
}
inline ::CUserMessage_Diagnostic_Response_Diagnostic* CUserMessage_Diagnostic_Response::mutable_diagnostics(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_Diagnostic_Response.diagnostics)
  return _impl_.diagnostics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Diagnostic_Response_Diagnostic >*
CUserMessage_Diagnostic_Response::mutable_diagnostics() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_Diagnostic_Response.diagnostics)
  return &_impl_.diagnostics_;
}
inline const ::CUserMessage_Diagnostic_Response_Diagnostic& CUserMessage_Diagnostic_Response::_internal_diagnostics(int index) const {
  return _impl_.diagnostics_.Get(index);
}
inline const ::CUserMessage_Diagnostic_Response_Diagnostic& CUserMessage_Diagnostic_Response::diagnostics(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.diagnostics)
  return _internal_diagnostics(index);
}
inline ::CUserMessage_Diagnostic_Response_Diagnostic* CUserMessage_Diagnostic_Response::_internal_add_diagnostics() {
  return _impl_.diagnostics_.Add();
}
inline ::CUserMessage_Diagnostic_Response_Diagnostic* CUserMessage_Diagnostic_Response::add_diagnostics() {
  ::CUserMessage_Diagnostic_Response_Diagnostic* _add = _internal_add_diagnostics();
  // @@protoc_insertion_point(field_add:CUserMessage_Diagnostic_Response.diagnostics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_Diagnostic_Response_Diagnostic >&
CUserMessage_Diagnostic_Response::diagnostics() const {
  // @@protoc_insertion_point(field_list:CUserMessage_Diagnostic_Response.diagnostics)
  return _impl_.diagnostics_;
}

// optional int32 build_version = 2;
inline bool CUserMessage_Diagnostic_Response::_internal_has_build_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response::has_build_version() const {
  return _internal_has_build_version();
}
inline void CUserMessage_Diagnostic_Response::clear_build_version() {
  _impl_.build_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CUserMessage_Diagnostic_Response::_internal_build_version() const {
  return _impl_.build_version_;
}
inline int32_t CUserMessage_Diagnostic_Response::build_version() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.build_version)
  return _internal_build_version();
}
inline void CUserMessage_Diagnostic_Response::_internal_set_build_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.build_version_ = value;
}
inline void CUserMessage_Diagnostic_Response::set_build_version(int32_t value) {
  _internal_set_build_version(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.build_version)
}

// optional int32 instance = 3;
inline bool CUserMessage_Diagnostic_Response::_internal_has_instance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response::has_instance() const {
  return _internal_has_instance();
}
inline void CUserMessage_Diagnostic_Response::clear_instance() {
  _impl_.instance_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CUserMessage_Diagnostic_Response::_internal_instance() const {
  return _impl_.instance_;
}
inline int32_t CUserMessage_Diagnostic_Response::instance() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.instance)
  return _internal_instance();
}
inline void CUserMessage_Diagnostic_Response::_internal_set_instance(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.instance_ = value;
}
inline void CUserMessage_Diagnostic_Response::set_instance(int32_t value) {
  _internal_set_instance(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.instance)
}

// optional int64 start_time = 4;
inline bool CUserMessage_Diagnostic_Response::_internal_has_start_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response::has_start_time() const {
  return _internal_has_start_time();
}
inline void CUserMessage_Diagnostic_Response::clear_start_time() {
  _impl_.start_time_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t CUserMessage_Diagnostic_Response::_internal_start_time() const {
  return _impl_.start_time_;
}
inline int64_t CUserMessage_Diagnostic_Response::start_time() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.start_time)
  return _internal_start_time();
}
inline void CUserMessage_Diagnostic_Response::_internal_set_start_time(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.start_time_ = value;
}
inline void CUserMessage_Diagnostic_Response::set_start_time(int64_t value) {
  _internal_set_start_time(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.start_time)
}

// optional int32 osversion = 5;
inline bool CUserMessage_Diagnostic_Response::_internal_has_osversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response::has_osversion() const {
  return _internal_has_osversion();
}
inline void CUserMessage_Diagnostic_Response::clear_osversion() {
  _impl_.osversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_Diagnostic_Response::_internal_osversion() const {
  return _impl_.osversion_;
}
inline int32_t CUserMessage_Diagnostic_Response::osversion() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.osversion)
  return _internal_osversion();
}
inline void CUserMessage_Diagnostic_Response::_internal_set_osversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.osversion_ = value;
}
inline void CUserMessage_Diagnostic_Response::set_osversion(int32_t value) {
  _internal_set_osversion(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.osversion)
}

// optional int32 platform = 6;
inline bool CUserMessage_Diagnostic_Response::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_Diagnostic_Response::has_platform() const {
  return _internal_has_platform();
}
inline void CUserMessage_Diagnostic_Response::clear_platform() {
  _impl_.platform_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessage_Diagnostic_Response::_internal_platform() const {
  return _impl_.platform_;
}
inline int32_t CUserMessage_Diagnostic_Response::platform() const {
  // @@protoc_insertion_point(field_get:CUserMessage_Diagnostic_Response.platform)
  return _internal_platform();
}
inline void CUserMessage_Diagnostic_Response::_internal_set_platform(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.platform_ = value;
}
inline void CUserMessage_Diagnostic_Response::set_platform(int32_t value) {
  _internal_set_platform(value);
  // @@protoc_insertion_point(field_set:CUserMessage_Diagnostic_Response.platform)
}

// -------------------------------------------------------------------

// CUserMessage_ExtraUserData

// optional int32 item = 1;
inline bool CUserMessage_ExtraUserData::_internal_has_item() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_ExtraUserData::has_item() const {
  return _internal_has_item();
}
inline void CUserMessage_ExtraUserData::clear_item() {
  _impl_.item_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CUserMessage_ExtraUserData::_internal_item() const {
  return _impl_.item_;
}
inline int32_t CUserMessage_ExtraUserData::item() const {
  // @@protoc_insertion_point(field_get:CUserMessage_ExtraUserData.item)
  return _internal_item();
}
inline void CUserMessage_ExtraUserData::_internal_set_item(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.item_ = value;
}
inline void CUserMessage_ExtraUserData::set_item(int32_t value) {
  _internal_set_item(value);
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.item)
}

// optional int64 value1 = 2;
inline bool CUserMessage_ExtraUserData::_internal_has_value1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_ExtraUserData::has_value1() const {
  return _internal_has_value1();
}
inline void CUserMessage_ExtraUserData::clear_value1() {
  _impl_.value1_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t CUserMessage_ExtraUserData::_internal_value1() const {
  return _impl_.value1_;
}
inline int64_t CUserMessage_ExtraUserData::value1() const {
  // @@protoc_insertion_point(field_get:CUserMessage_ExtraUserData.value1)
  return _internal_value1();
}
inline void CUserMessage_ExtraUserData::_internal_set_value1(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value1_ = value;
}
inline void CUserMessage_ExtraUserData::set_value1(int64_t value) {
  _internal_set_value1(value);
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.value1)
}

// optional int64 value2 = 3;
inline bool CUserMessage_ExtraUserData::_internal_has_value2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_ExtraUserData::has_value2() const {
  return _internal_has_value2();
}
inline void CUserMessage_ExtraUserData::clear_value2() {
  _impl_.value2_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t CUserMessage_ExtraUserData::_internal_value2() const {
  return _impl_.value2_;
}
inline int64_t CUserMessage_ExtraUserData::value2() const {
  // @@protoc_insertion_point(field_get:CUserMessage_ExtraUserData.value2)
  return _internal_value2();
}
inline void CUserMessage_ExtraUserData::_internal_set_value2(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value2_ = value;
}
inline void CUserMessage_ExtraUserData::set_value2(int64_t value) {
  _internal_set_value2(value);
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.value2)
}

// repeated bytes detail1 = 4;
inline int CUserMessage_ExtraUserData::_internal_detail1_size() const {
  return _impl_.detail1_.size();
}
inline int CUserMessage_ExtraUserData::detail1_size() const {
  return _internal_detail1_size();
}
inline void CUserMessage_ExtraUserData::clear_detail1() {
  _impl_.detail1_.Clear();
}
inline std::string* CUserMessage_ExtraUserData::add_detail1() {
  std::string* _s = _internal_add_detail1();
  // @@protoc_insertion_point(field_add_mutable:CUserMessage_ExtraUserData.detail1)
  return _s;
}
inline const std::string& CUserMessage_ExtraUserData::_internal_detail1(int index) const {
  return _impl_.detail1_.Get(index);
}
inline const std::string& CUserMessage_ExtraUserData::detail1(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_ExtraUserData.detail1)
  return _internal_detail1(index);
}
inline std::string* CUserMessage_ExtraUserData::mutable_detail1(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_ExtraUserData.detail1)
  return _impl_.detail1_.Mutable(index);
}
inline void CUserMessage_ExtraUserData::set_detail1(int index, const std::string& value) {
  _impl_.detail1_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::set_detail1(int index, std::string&& value) {
  _impl_.detail1_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::set_detail1(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.detail1_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::set_detail1(int index, const void* value, size_t size) {
  _impl_.detail1_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CUserMessage_ExtraUserData.detail1)
}
inline std::string* CUserMessage_ExtraUserData::_internal_add_detail1() {
  return _impl_.detail1_.Add();
}
inline void CUserMessage_ExtraUserData::add_detail1(const std::string& value) {
  _impl_.detail1_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::add_detail1(std::string&& value) {
  _impl_.detail1_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::add_detail1(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.detail1_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CUserMessage_ExtraUserData.detail1)
}
inline void CUserMessage_ExtraUserData::add_detail1(const void* value, size_t size) {
  _impl_.detail1_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CUserMessage_ExtraUserData.detail1)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CUserMessage_ExtraUserData::detail1() const {
  // @@protoc_insertion_point(field_list:CUserMessage_ExtraUserData.detail1)
  return _impl_.detail1_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CUserMessage_ExtraUserData::mutable_detail1() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_ExtraUserData.detail1)
  return &_impl_.detail1_;
}

// repeated bytes detail2 = 5;
inline int CUserMessage_ExtraUserData::_internal_detail2_size() const {
  return _impl_.detail2_.size();
}
inline int CUserMessage_ExtraUserData::detail2_size() const {
  return _internal_detail2_size();
}
inline void CUserMessage_ExtraUserData::clear_detail2() {
  _impl_.detail2_.Clear();
}
inline std::string* CUserMessage_ExtraUserData::add_detail2() {
  std::string* _s = _internal_add_detail2();
  // @@protoc_insertion_point(field_add_mutable:CUserMessage_ExtraUserData.detail2)
  return _s;
}
inline const std::string& CUserMessage_ExtraUserData::_internal_detail2(int index) const {
  return _impl_.detail2_.Get(index);
}
inline const std::string& CUserMessage_ExtraUserData::detail2(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_ExtraUserData.detail2)
  return _internal_detail2(index);
}
inline std::string* CUserMessage_ExtraUserData::mutable_detail2(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_ExtraUserData.detail2)
  return _impl_.detail2_.Mutable(index);
}
inline void CUserMessage_ExtraUserData::set_detail2(int index, const std::string& value) {
  _impl_.detail2_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::set_detail2(int index, std::string&& value) {
  _impl_.detail2_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::set_detail2(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.detail2_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::set_detail2(int index, const void* value, size_t size) {
  _impl_.detail2_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CUserMessage_ExtraUserData.detail2)
}
inline std::string* CUserMessage_ExtraUserData::_internal_add_detail2() {
  return _impl_.detail2_.Add();
}
inline void CUserMessage_ExtraUserData::add_detail2(const std::string& value) {
  _impl_.detail2_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::add_detail2(std::string&& value) {
  _impl_.detail2_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::add_detail2(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.detail2_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CUserMessage_ExtraUserData.detail2)
}
inline void CUserMessage_ExtraUserData::add_detail2(const void* value, size_t size) {
  _impl_.detail2_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CUserMessage_ExtraUserData.detail2)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CUserMessage_ExtraUserData::detail2() const {
  // @@protoc_insertion_point(field_list:CUserMessage_ExtraUserData.detail2)
  return _impl_.detail2_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CUserMessage_ExtraUserData::mutable_detail2() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_ExtraUserData.detail2)
  return &_impl_.detail2_;
}

// -------------------------------------------------------------------

// CUserMessage_NotifyResponseFound_Criteria

// optional uint32 name_symbol = 1;
inline bool CUserMessage_NotifyResponseFound_Criteria::_internal_has_name_symbol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound_Criteria::has_name_symbol() const {
  return _internal_has_name_symbol();
}
inline void CUserMessage_NotifyResponseFound_Criteria::clear_name_symbol() {
  _impl_.name_symbol_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CUserMessage_NotifyResponseFound_Criteria::_internal_name_symbol() const {
  return _impl_.name_symbol_;
}
inline uint32_t CUserMessage_NotifyResponseFound_Criteria::name_symbol() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.Criteria.name_symbol)
  return _internal_name_symbol();
}
inline void CUserMessage_NotifyResponseFound_Criteria::_internal_set_name_symbol(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_symbol_ = value;
}
inline void CUserMessage_NotifyResponseFound_Criteria::set_name_symbol(uint32_t value) {
  _internal_set_name_symbol(value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.Criteria.name_symbol)
}

// optional string value = 2;
inline bool CUserMessage_NotifyResponseFound_Criteria::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound_Criteria::has_value() const {
  return _internal_has_value();
}
inline void CUserMessage_NotifyResponseFound_Criteria::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_NotifyResponseFound_Criteria::value() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.Criteria.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_NotifyResponseFound_Criteria::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.Criteria.value)
}
inline std::string* CUserMessage_NotifyResponseFound_Criteria::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:CUserMessage_NotifyResponseFound.Criteria.value)
  return _s;
}
inline const std::string& CUserMessage_NotifyResponseFound_Criteria::_internal_value() const {
  return _impl_.value_.Get();
}
inline void CUserMessage_NotifyResponseFound_Criteria::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound_Criteria::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound_Criteria::release_value() {
  // @@protoc_insertion_point(field_release:CUserMessage_NotifyResponseFound.Criteria.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 CUserMessage_NotifyResponseFound_Criteria::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:CUserMessage_NotifyResponseFound.Criteria.value)
}

// -------------------------------------------------------------------

// CUserMessage_NotifyResponseFound

// optional int32 ent_index = 1 [default = -1];
inline bool CUserMessage_NotifyResponseFound::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMessage_NotifyResponseFound::clear_ent_index() {
  _impl_.ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessage_NotifyResponseFound::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline int32_t CUserMessage_NotifyResponseFound::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.ent_index)
  return _internal_ent_index();
}
inline void CUserMessage_NotifyResponseFound::_internal_set_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.ent_index_ = value;
}
inline void CUserMessage_NotifyResponseFound::set_ent_index(int32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.ent_index)
}

// optional string rule_name = 2;
inline bool CUserMessage_NotifyResponseFound::_internal_has_rule_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound::has_rule_name() const {
  return _internal_has_rule_name();
}
inline void CUserMessage_NotifyResponseFound::clear_rule_name() {
  _impl_.rule_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_NotifyResponseFound::rule_name() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.rule_name)
  return _internal_rule_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_NotifyResponseFound::set_rule_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.rule_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.rule_name)
}
inline std::string* CUserMessage_NotifyResponseFound::mutable_rule_name() {
  std::string* _s = _internal_mutable_rule_name();
  // @@protoc_insertion_point(field_mutable:CUserMessage_NotifyResponseFound.rule_name)
  return _s;
}
inline const std::string& CUserMessage_NotifyResponseFound::_internal_rule_name() const {
  return _impl_.rule_name_.Get();
}
inline void CUserMessage_NotifyResponseFound::_internal_set_rule_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rule_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::_internal_mutable_rule_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.rule_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::release_rule_name() {
  // @@protoc_insertion_point(field_release:CUserMessage_NotifyResponseFound.rule_name)
  if (!_internal_has_rule_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.rule_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rule_name_.IsDefault()) {
    _impl_.rule_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_NotifyResponseFound::set_allocated_rule_name(std::string* rule_name) {
  if (rule_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.rule_name_.SetAllocated(rule_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rule_name_.IsDefault()) {
    _impl_.rule_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_NotifyResponseFound.rule_name)
}

// optional string response_value = 3;
inline bool CUserMessage_NotifyResponseFound::_internal_has_response_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound::has_response_value() const {
  return _internal_has_response_value();
}
inline void CUserMessage_NotifyResponseFound::clear_response_value() {
  _impl_.response_value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CUserMessage_NotifyResponseFound::response_value() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.response_value)
  return _internal_response_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_NotifyResponseFound::set_response_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.response_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.response_value)
}
inline std::string* CUserMessage_NotifyResponseFound::mutable_response_value() {
  std::string* _s = _internal_mutable_response_value();
  // @@protoc_insertion_point(field_mutable:CUserMessage_NotifyResponseFound.response_value)
  return _s;
}
inline const std::string& CUserMessage_NotifyResponseFound::_internal_response_value() const {
  return _impl_.response_value_.Get();
}
inline void CUserMessage_NotifyResponseFound::_internal_set_response_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.response_value_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::_internal_mutable_response_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.response_value_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::release_response_value() {
  // @@protoc_insertion_point(field_release:CUserMessage_NotifyResponseFound.response_value)
  if (!_internal_has_response_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.response_value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_value_.IsDefault()) {
    _impl_.response_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_NotifyResponseFound::set_allocated_response_value(std::string* response_value) {
  if (response_value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.response_value_.SetAllocated(response_value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_value_.IsDefault()) {
    _impl_.response_value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_NotifyResponseFound.response_value)
}

// optional string response_concept = 4;
inline bool CUserMessage_NotifyResponseFound::_internal_has_response_concept() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound::has_response_concept() const {
  return _internal_has_response_concept();
}
inline void CUserMessage_NotifyResponseFound::clear_response_concept() {
  _impl_.response_concept_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CUserMessage_NotifyResponseFound::response_concept() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.response_concept)
  return _internal_response_concept();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_NotifyResponseFound::set_response_concept(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.response_concept_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.response_concept)
}
inline std::string* CUserMessage_NotifyResponseFound::mutable_response_concept() {
  std::string* _s = _internal_mutable_response_concept();
  // @@protoc_insertion_point(field_mutable:CUserMessage_NotifyResponseFound.response_concept)
  return _s;
}
inline const std::string& CUserMessage_NotifyResponseFound::_internal_response_concept() const {
  return _impl_.response_concept_.Get();
}
inline void CUserMessage_NotifyResponseFound::_internal_set_response_concept(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.response_concept_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::_internal_mutable_response_concept() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.response_concept_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_NotifyResponseFound::release_response_concept() {
  // @@protoc_insertion_point(field_release:CUserMessage_NotifyResponseFound.response_concept)
  if (!_internal_has_response_concept()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.response_concept_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_concept_.IsDefault()) {
    _impl_.response_concept_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_NotifyResponseFound::set_allocated_response_concept(std::string* response_concept) {
  if (response_concept != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.response_concept_.SetAllocated(response_concept, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_concept_.IsDefault()) {
    _impl_.response_concept_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_NotifyResponseFound.response_concept)
}

// repeated .CUserMessage_NotifyResponseFound.Criteria criteria = 5;
inline int CUserMessage_NotifyResponseFound::_internal_criteria_size() const {
  return _impl_.criteria_.size();
}
inline int CUserMessage_NotifyResponseFound::criteria_size() const {
  return _internal_criteria_size();
}
inline void CUserMessage_NotifyResponseFound::clear_criteria() {
  _impl_.criteria_.Clear();
}
inline ::CUserMessage_NotifyResponseFound_Criteria* CUserMessage_NotifyResponseFound::mutable_criteria(int index) {
  // @@protoc_insertion_point(field_mutable:CUserMessage_NotifyResponseFound.criteria)
  return _impl_.criteria_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_NotifyResponseFound_Criteria >*
CUserMessage_NotifyResponseFound::mutable_criteria() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.criteria)
  return &_impl_.criteria_;
}
inline const ::CUserMessage_NotifyResponseFound_Criteria& CUserMessage_NotifyResponseFound::_internal_criteria(int index) const {
  return _impl_.criteria_.Get(index);
}
inline const ::CUserMessage_NotifyResponseFound_Criteria& CUserMessage_NotifyResponseFound::criteria(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.criteria)
  return _internal_criteria(index);
}
inline ::CUserMessage_NotifyResponseFound_Criteria* CUserMessage_NotifyResponseFound::_internal_add_criteria() {
  return _impl_.criteria_.Add();
}
inline ::CUserMessage_NotifyResponseFound_Criteria* CUserMessage_NotifyResponseFound::add_criteria() {
  ::CUserMessage_NotifyResponseFound_Criteria* _add = _internal_add_criteria();
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.criteria)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CUserMessage_NotifyResponseFound_Criteria >&
CUserMessage_NotifyResponseFound::criteria() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.criteria)
  return _impl_.criteria_;
}

// repeated uint32 int_criteria_names = 6 [packed = true];
inline int CUserMessage_NotifyResponseFound::_internal_int_criteria_names_size() const {
  return _impl_.int_criteria_names_.size();
}
inline int CUserMessage_NotifyResponseFound::int_criteria_names_size() const {
  return _internal_int_criteria_names_size();
}
inline void CUserMessage_NotifyResponseFound::clear_int_criteria_names() {
  _impl_.int_criteria_names_.Clear();
}
inline uint32_t CUserMessage_NotifyResponseFound::_internal_int_criteria_names(int index) const {
  return _impl_.int_criteria_names_.Get(index);
}
inline uint32_t CUserMessage_NotifyResponseFound::int_criteria_names(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.int_criteria_names)
  return _internal_int_criteria_names(index);
}
inline void CUserMessage_NotifyResponseFound::set_int_criteria_names(int index, uint32_t value) {
  _impl_.int_criteria_names_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.int_criteria_names)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_int_criteria_names(uint32_t value) {
  _impl_.int_criteria_names_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_int_criteria_names(uint32_t value) {
  _internal_add_int_criteria_names(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.int_criteria_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::_internal_int_criteria_names() const {
  return _impl_.int_criteria_names_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::int_criteria_names() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.int_criteria_names)
  return _internal_int_criteria_names();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::_internal_mutable_int_criteria_names() {
  return &_impl_.int_criteria_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::mutable_int_criteria_names() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.int_criteria_names)
  return _internal_mutable_int_criteria_names();
}

// repeated int32 int_criteria_values = 7 [packed = true];
inline int CUserMessage_NotifyResponseFound::_internal_int_criteria_values_size() const {
  return _impl_.int_criteria_values_.size();
}
inline int CUserMessage_NotifyResponseFound::int_criteria_values_size() const {
  return _internal_int_criteria_values_size();
}
inline void CUserMessage_NotifyResponseFound::clear_int_criteria_values() {
  _impl_.int_criteria_values_.Clear();
}
inline int32_t CUserMessage_NotifyResponseFound::_internal_int_criteria_values(int index) const {
  return _impl_.int_criteria_values_.Get(index);
}
inline int32_t CUserMessage_NotifyResponseFound::int_criteria_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.int_criteria_values)
  return _internal_int_criteria_values(index);
}
inline void CUserMessage_NotifyResponseFound::set_int_criteria_values(int index, int32_t value) {
  _impl_.int_criteria_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.int_criteria_values)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_int_criteria_values(int32_t value) {
  _impl_.int_criteria_values_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_int_criteria_values(int32_t value) {
  _internal_add_int_criteria_values(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.int_criteria_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_NotifyResponseFound::_internal_int_criteria_values() const {
  return _impl_.int_criteria_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_NotifyResponseFound::int_criteria_values() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.int_criteria_values)
  return _internal_int_criteria_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_NotifyResponseFound::_internal_mutable_int_criteria_values() {
  return &_impl_.int_criteria_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_NotifyResponseFound::mutable_int_criteria_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.int_criteria_values)
  return _internal_mutable_int_criteria_values();
}

// repeated uint32 float_criteria_names = 8 [packed = true];
inline int CUserMessage_NotifyResponseFound::_internal_float_criteria_names_size() const {
  return _impl_.float_criteria_names_.size();
}
inline int CUserMessage_NotifyResponseFound::float_criteria_names_size() const {
  return _internal_float_criteria_names_size();
}
inline void CUserMessage_NotifyResponseFound::clear_float_criteria_names() {
  _impl_.float_criteria_names_.Clear();
}
inline uint32_t CUserMessage_NotifyResponseFound::_internal_float_criteria_names(int index) const {
  return _impl_.float_criteria_names_.Get(index);
}
inline uint32_t CUserMessage_NotifyResponseFound::float_criteria_names(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.float_criteria_names)
  return _internal_float_criteria_names(index);
}
inline void CUserMessage_NotifyResponseFound::set_float_criteria_names(int index, uint32_t value) {
  _impl_.float_criteria_names_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.float_criteria_names)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_float_criteria_names(uint32_t value) {
  _impl_.float_criteria_names_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_float_criteria_names(uint32_t value) {
  _internal_add_float_criteria_names(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.float_criteria_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::_internal_float_criteria_names() const {
  return _impl_.float_criteria_names_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::float_criteria_names() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.float_criteria_names)
  return _internal_float_criteria_names();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::_internal_mutable_float_criteria_names() {
  return &_impl_.float_criteria_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::mutable_float_criteria_names() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.float_criteria_names)
  return _internal_mutable_float_criteria_names();
}

// repeated float float_criteria_values = 9;
inline int CUserMessage_NotifyResponseFound::_internal_float_criteria_values_size() const {
  return _impl_.float_criteria_values_.size();
}
inline int CUserMessage_NotifyResponseFound::float_criteria_values_size() const {
  return _internal_float_criteria_values_size();
}
inline void CUserMessage_NotifyResponseFound::clear_float_criteria_values() {
  _impl_.float_criteria_values_.Clear();
}
inline float CUserMessage_NotifyResponseFound::_internal_float_criteria_values(int index) const {
  return _impl_.float_criteria_values_.Get(index);
}
inline float CUserMessage_NotifyResponseFound::float_criteria_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.float_criteria_values)
  return _internal_float_criteria_values(index);
}
inline void CUserMessage_NotifyResponseFound::set_float_criteria_values(int index, float value) {
  _impl_.float_criteria_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.float_criteria_values)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_float_criteria_values(float value) {
  _impl_.float_criteria_values_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_float_criteria_values(float value) {
  _internal_add_float_criteria_values(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.float_criteria_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CUserMessage_NotifyResponseFound::_internal_float_criteria_values() const {
  return _impl_.float_criteria_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CUserMessage_NotifyResponseFound::float_criteria_values() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.float_criteria_values)
  return _internal_float_criteria_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CUserMessage_NotifyResponseFound::_internal_mutable_float_criteria_values() {
  return &_impl_.float_criteria_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CUserMessage_NotifyResponseFound::mutable_float_criteria_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.float_criteria_values)
  return _internal_mutable_float_criteria_values();
}

// repeated uint32 symbol_criteria_names = 10 [packed = true];
inline int CUserMessage_NotifyResponseFound::_internal_symbol_criteria_names_size() const {
  return _impl_.symbol_criteria_names_.size();
}
inline int CUserMessage_NotifyResponseFound::symbol_criteria_names_size() const {
  return _internal_symbol_criteria_names_size();
}
inline void CUserMessage_NotifyResponseFound::clear_symbol_criteria_names() {
  _impl_.symbol_criteria_names_.Clear();
}
inline uint32_t CUserMessage_NotifyResponseFound::_internal_symbol_criteria_names(int index) const {
  return _impl_.symbol_criteria_names_.Get(index);
}
inline uint32_t CUserMessage_NotifyResponseFound::symbol_criteria_names(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.symbol_criteria_names)
  return _internal_symbol_criteria_names(index);
}
inline void CUserMessage_NotifyResponseFound::set_symbol_criteria_names(int index, uint32_t value) {
  _impl_.symbol_criteria_names_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.symbol_criteria_names)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_symbol_criteria_names(uint32_t value) {
  _impl_.symbol_criteria_names_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_symbol_criteria_names(uint32_t value) {
  _internal_add_symbol_criteria_names(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.symbol_criteria_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::_internal_symbol_criteria_names() const {
  return _impl_.symbol_criteria_names_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::symbol_criteria_names() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.symbol_criteria_names)
  return _internal_symbol_criteria_names();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::_internal_mutable_symbol_criteria_names() {
  return &_impl_.symbol_criteria_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::mutable_symbol_criteria_names() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.symbol_criteria_names)
  return _internal_mutable_symbol_criteria_names();
}

// repeated uint32 symbol_criteria_values = 11 [packed = true];
inline int CUserMessage_NotifyResponseFound::_internal_symbol_criteria_values_size() const {
  return _impl_.symbol_criteria_values_.size();
}
inline int CUserMessage_NotifyResponseFound::symbol_criteria_values_size() const {
  return _internal_symbol_criteria_values_size();
}
inline void CUserMessage_NotifyResponseFound::clear_symbol_criteria_values() {
  _impl_.symbol_criteria_values_.Clear();
}
inline uint32_t CUserMessage_NotifyResponseFound::_internal_symbol_criteria_values(int index) const {
  return _impl_.symbol_criteria_values_.Get(index);
}
inline uint32_t CUserMessage_NotifyResponseFound::symbol_criteria_values(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.symbol_criteria_values)
  return _internal_symbol_criteria_values(index);
}
inline void CUserMessage_NotifyResponseFound::set_symbol_criteria_values(int index, uint32_t value) {
  _impl_.symbol_criteria_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.symbol_criteria_values)
}
inline void CUserMessage_NotifyResponseFound::_internal_add_symbol_criteria_values(uint32_t value) {
  _impl_.symbol_criteria_values_.Add(value);
}
inline void CUserMessage_NotifyResponseFound::add_symbol_criteria_values(uint32_t value) {
  _internal_add_symbol_criteria_values(value);
  // @@protoc_insertion_point(field_add:CUserMessage_NotifyResponseFound.symbol_criteria_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::_internal_symbol_criteria_values() const {
  return _impl_.symbol_criteria_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CUserMessage_NotifyResponseFound::symbol_criteria_values() const {
  // @@protoc_insertion_point(field_list:CUserMessage_NotifyResponseFound.symbol_criteria_values)
  return _internal_symbol_criteria_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::_internal_mutable_symbol_criteria_values() {
  return &_impl_.symbol_criteria_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CUserMessage_NotifyResponseFound::mutable_symbol_criteria_values() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_NotifyResponseFound.symbol_criteria_values)
  return _internal_mutable_symbol_criteria_values();
}

// optional int32 speak_result = 12;
inline bool CUserMessage_NotifyResponseFound::_internal_has_speak_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_NotifyResponseFound::has_speak_result() const {
  return _internal_has_speak_result();
}
inline void CUserMessage_NotifyResponseFound::clear_speak_result() {
  _impl_.speak_result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_NotifyResponseFound::_internal_speak_result() const {
  return _impl_.speak_result_;
}
inline int32_t CUserMessage_NotifyResponseFound::speak_result() const {
  // @@protoc_insertion_point(field_get:CUserMessage_NotifyResponseFound.speak_result)
  return _internal_speak_result();
}
inline void CUserMessage_NotifyResponseFound::_internal_set_speak_result(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.speak_result_ = value;
}
inline void CUserMessage_NotifyResponseFound::set_speak_result(int32_t value) {
  _internal_set_speak_result(value);
  // @@protoc_insertion_point(field_set:CUserMessage_NotifyResponseFound.speak_result)
}

// -------------------------------------------------------------------

// CUserMessage_PlayResponseConditional

// optional int32 ent_index = 1 [default = -1];
inline bool CUserMessage_PlayResponseConditional::_internal_has_ent_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CUserMessage_PlayResponseConditional::has_ent_index() const {
  return _internal_has_ent_index();
}
inline void CUserMessage_PlayResponseConditional::clear_ent_index() {
  _impl_.ent_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CUserMessage_PlayResponseConditional::_internal_ent_index() const {
  return _impl_.ent_index_;
}
inline int32_t CUserMessage_PlayResponseConditional::ent_index() const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.ent_index)
  return _internal_ent_index();
}
inline void CUserMessage_PlayResponseConditional::_internal_set_ent_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.ent_index_ = value;
}
inline void CUserMessage_PlayResponseConditional::set_ent_index(int32_t value) {
  _internal_set_ent_index(value);
  // @@protoc_insertion_point(field_set:CUserMessage_PlayResponseConditional.ent_index)
}

// repeated int32 player_slots = 2;
inline int CUserMessage_PlayResponseConditional::_internal_player_slots_size() const {
  return _impl_.player_slots_.size();
}
inline int CUserMessage_PlayResponseConditional::player_slots_size() const {
  return _internal_player_slots_size();
}
inline void CUserMessage_PlayResponseConditional::clear_player_slots() {
  _impl_.player_slots_.Clear();
}
inline int32_t CUserMessage_PlayResponseConditional::_internal_player_slots(int index) const {
  return _impl_.player_slots_.Get(index);
}
inline int32_t CUserMessage_PlayResponseConditional::player_slots(int index) const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.player_slots)
  return _internal_player_slots(index);
}
inline void CUserMessage_PlayResponseConditional::set_player_slots(int index, int32_t value) {
  _impl_.player_slots_.Set(index, value);
  // @@protoc_insertion_point(field_set:CUserMessage_PlayResponseConditional.player_slots)
}
inline void CUserMessage_PlayResponseConditional::_internal_add_player_slots(int32_t value) {
  _impl_.player_slots_.Add(value);
}
inline void CUserMessage_PlayResponseConditional::add_player_slots(int32_t value) {
  _internal_add_player_slots(value);
  // @@protoc_insertion_point(field_add:CUserMessage_PlayResponseConditional.player_slots)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_PlayResponseConditional::_internal_player_slots() const {
  return _impl_.player_slots_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CUserMessage_PlayResponseConditional::player_slots() const {
  // @@protoc_insertion_point(field_list:CUserMessage_PlayResponseConditional.player_slots)
  return _internal_player_slots();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_PlayResponseConditional::_internal_mutable_player_slots() {
  return &_impl_.player_slots_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CUserMessage_PlayResponseConditional::mutable_player_slots() {
  // @@protoc_insertion_point(field_mutable_list:CUserMessage_PlayResponseConditional.player_slots)
  return _internal_mutable_player_slots();
}

// optional string response = 3;
inline bool CUserMessage_PlayResponseConditional::_internal_has_response() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CUserMessage_PlayResponseConditional::has_response() const {
  return _internal_has_response();
}
inline void CUserMessage_PlayResponseConditional::clear_response() {
  _impl_.response_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CUserMessage_PlayResponseConditional::response() const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.response)
  return _internal_response();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CUserMessage_PlayResponseConditional::set_response(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.response_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CUserMessage_PlayResponseConditional.response)
}
inline std::string* CUserMessage_PlayResponseConditional::mutable_response() {
  std::string* _s = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:CUserMessage_PlayResponseConditional.response)
  return _s;
}
inline const std::string& CUserMessage_PlayResponseConditional::_internal_response() const {
  return _impl_.response_.Get();
}
inline void CUserMessage_PlayResponseConditional::_internal_set_response(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.response_.Set(value, GetArenaForAllocation());
}
inline std::string* CUserMessage_PlayResponseConditional::_internal_mutable_response() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.response_.Mutable(GetArenaForAllocation());
}
inline std::string* CUserMessage_PlayResponseConditional::release_response() {
  // @@protoc_insertion_point(field_release:CUserMessage_PlayResponseConditional.response)
  if (!_internal_has_response()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.response_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_.IsDefault()) {
    _impl_.response_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CUserMessage_PlayResponseConditional::set_allocated_response(std::string* response) {
  if (response != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.response_.SetAllocated(response, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.response_.IsDefault()) {
    _impl_.response_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_PlayResponseConditional.response)
}

// optional .CMsgVector ent_origin = 4;
inline bool CUserMessage_PlayResponseConditional::_internal_has_ent_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ent_origin_ != nullptr);
  return value;
}
inline bool CUserMessage_PlayResponseConditional::has_ent_origin() const {
  return _internal_has_ent_origin();
}
inline const ::CMsgVector& CUserMessage_PlayResponseConditional::_internal_ent_origin() const {
  const ::CMsgVector* p = _impl_.ent_origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CUserMessage_PlayResponseConditional::ent_origin() const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.ent_origin)
  return _internal_ent_origin();
}
inline void CUserMessage_PlayResponseConditional::unsafe_arena_set_allocated_ent_origin(
    ::CMsgVector* ent_origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ent_origin_);
  }
  _impl_.ent_origin_ = ent_origin;
  if (ent_origin) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CUserMessage_PlayResponseConditional.ent_origin)
}
inline ::CMsgVector* CUserMessage_PlayResponseConditional::release_ent_origin() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.ent_origin_;
  _impl_.ent_origin_ = 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 ::CMsgVector* CUserMessage_PlayResponseConditional::unsafe_arena_release_ent_origin() {
  // @@protoc_insertion_point(field_release:CUserMessage_PlayResponseConditional.ent_origin)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.ent_origin_;
  _impl_.ent_origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CUserMessage_PlayResponseConditional::_internal_mutable_ent_origin() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.ent_origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.ent_origin_ = p;
  }
  return _impl_.ent_origin_;
}
inline ::CMsgVector* CUserMessage_PlayResponseConditional::mutable_ent_origin() {
  ::CMsgVector* _msg = _internal_mutable_ent_origin();
  // @@protoc_insertion_point(field_mutable:CUserMessage_PlayResponseConditional.ent_origin)
  return _msg;
}
inline void CUserMessage_PlayResponseConditional::set_allocated_ent_origin(::CMsgVector* ent_origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ent_origin_);
  }
  if (ent_origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ent_origin));
    if (message_arena != submessage_arena) {
      ent_origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ent_origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.ent_origin_ = ent_origin;
  // @@protoc_insertion_point(field_set_allocated:CUserMessage_PlayResponseConditional.ent_origin)
}

// optional float pre_delay = 5;
inline bool CUserMessage_PlayResponseConditional::_internal_has_pre_delay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CUserMessage_PlayResponseConditional::has_pre_delay() const {
  return _internal_has_pre_delay();
}
inline void CUserMessage_PlayResponseConditional::clear_pre_delay() {
  _impl_.pre_delay_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CUserMessage_PlayResponseConditional::_internal_pre_delay() const {
  return _impl_.pre_delay_;
}
inline float CUserMessage_PlayResponseConditional::pre_delay() const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.pre_delay)
  return _internal_pre_delay();
}
inline void CUserMessage_PlayResponseConditional::_internal_set_pre_delay(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.pre_delay_ = value;
}
inline void CUserMessage_PlayResponseConditional::set_pre_delay(float value) {
  _internal_set_pre_delay(value);
  // @@protoc_insertion_point(field_set:CUserMessage_PlayResponseConditional.pre_delay)
}

// optional int32 mix_priority = 6;
inline bool CUserMessage_PlayResponseConditional::_internal_has_mix_priority() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CUserMessage_PlayResponseConditional::has_mix_priority() const {
  return _internal_has_mix_priority();
}
inline void CUserMessage_PlayResponseConditional::clear_mix_priority() {
  _impl_.mix_priority_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CUserMessage_PlayResponseConditional::_internal_mix_priority() const {
  return _impl_.mix_priority_;
}
inline int32_t CUserMessage_PlayResponseConditional::mix_priority() const {
  // @@protoc_insertion_point(field_get:CUserMessage_PlayResponseConditional.mix_priority)
  return _internal_mix_priority();
}
inline void CUserMessage_PlayResponseConditional::_internal_set_mix_priority(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mix_priority_ = value;
}
inline void CUserMessage_PlayResponseConditional::set_mix_priority(int32_t value) {
  _internal_set_mix_priority(value);
  // @@protoc_insertion_point(field_set:CUserMessage_PlayResponseConditional.mix_priority)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::EBaseUserMessages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EBaseUserMessages>() {
  return ::EBaseUserMessages_descriptor();
}
template <> struct is_proto_enum< ::EBaseEntityMessages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EBaseEntityMessages>() {
  return ::EBaseEntityMessages_descriptor();
}
template <> struct is_proto_enum< ::eRollType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::eRollType>() {
  return ::eRollType_descriptor();
}
template <> struct is_proto_enum< ::PARTICLE_MESSAGE> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PARTICLE_MESSAGE>() {
  return ::PARTICLE_MESSAGE_descriptor();
}
template <> struct is_proto_enum< ::EHapticPulseType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EHapticPulseType>() {
  return ::EHapticPulseType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_usermessages_2eproto
