first run

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CBasePattern.cpp

@@ -0,0 +1,58 @@
+#include "CBasePattern.hpp"
+
+#include <Common/MemoryEngine.hpp>
+
+CBasePattern::CBasePattern( const char* szPatternName , const char* szPattern , const char* szDll , uint32_t Offset , eBasePatternSearchType Type )
+{
+	PatternName = szPatternName;
+	Pattern = szPattern;
+	Dll = szDll;
+	dwOffset = Offset;
+	m_Type = Type;
+}
+
+auto CBasePattern::Search( bool SkipError ) -> bool
+{
+	if ( m_Type != eBasePatternSearchType::SEARCH_TYPE_PROC )
+	{
+		pFunction = FindPattern( Dll , Pattern , dwOffset );
+
+		if ( !pFunction )
+		{
+			if ( !SkipError )
+				DEV_LOG( "[error] CBasePattern: %s\n" , PatternName );
+
+			return false;
+		}
+	}
+
+	if ( m_Type == eBasePatternSearchType::SEARCH_TYPE_PTR )
+		pFunction = reinterpret_cast<PVOID>( *reinterpret_cast<intptr_t*>( pFunction ) );
+	else if ( m_Type == eBasePatternSearchType::SEARCH_TYPE_CALL )
+		pFunction = GetCallAddress( reinterpret_cast<intptr_t>( pFunction ) );
+	else if ( m_Type == eBasePatternSearchType::SEARCH_TYPE_PTR2 )
+		pFunction = GetPtrAddress<PVOID>( (intptr_t)pFunction );
+	else if ( m_Type == eBasePatternSearchType::SEARCH_TYPE_PROC )
+		pFunction = GetProcAddress( GetModuleHandleA( Dll ) , Pattern );
+
+#if LOG_SDK_PATTERN == 1
+	DEV_LOG( "[+] CBasePattern: %s -> %p\n" , PatternName , pFunction );
+#endif
+
+	return true;
+}
+
+auto CBasePattern::GetPatternName() -> const char*
+{
+	return PatternName;
+}
+
+auto CBasePattern::GetDllName() -> const char*
+{
+	return Dll;
+}
+
+auto CBasePattern::GetFunction() -> PVOID
+{
+	return pFunction;
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CBasePattern.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+enum eBasePatternSearchType : int32_t
+{
+	SEARCH_TYPE_NONE ,
+	SEARCH_TYPE_PTR ,
+	SEARCH_TYPE_CALL ,
+	SEARCH_TYPE_PTR2 ,
+	SEARCH_TYPE_PROC
+};
+
+class IBasePattern
+{
+public:
+	virtual bool Search( bool SkipError ) = 0;
+	virtual PVOID GetFunction() = 0;
+	virtual const char* GetPatternName() = 0;
+	virtual const char* GetDllName() = 0;
+};
+
+class CBasePattern final : public IBasePattern
+{
+public:
+	CBasePattern( const char* szPatternName , const char* szPattern , const char* szDll , uint32_t Offset = 0 , eBasePatternSearchType Type = eBasePatternSearchType::SEARCH_TYPE_NONE );
+
+public:
+	virtual bool Search( bool SkipError = false ) override;
+	virtual PVOID GetFunction() override;
+	virtual const char* GetPatternName() override;
+	virtual const char* GetDllName() override;
+
+private:
+	// !!! std::string_view crash on vmprotect !!!
+	const char* PatternName = nullptr;
+	const char* Pattern = nullptr;
+	const char* Dll = nullptr;
+
+private:
+	PVOID pFunction = nullptr;
+	uint32_t dwOffset = 0;
+	eBasePatternSearchType m_Type = eBasePatternSearchType::SEARCH_TYPE_NONE;
+};
+
+#define DECLARATE_CS2_FUNCTION(Ret,Name,Decl,InterfaceSearch,DeclFn,ParamCall)\
+	Ret Name Decl\
+	{\
+		using Fn = Ret ( __fastcall* ) DeclFn;\
+		Fn Original = reinterpret_cast<Fn>( ##InterfaceSearch##_Search::##Name##Fn.GetFunction() );\
+		return Original##ParamCall##;\
+	}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CHook_Loader.cpp

@@ -0,0 +1,123 @@
+#include "CHook_Loader.hpp"
+
+#include <Common/MemoryEngine.hpp>
+#include <MinHook/MinHook.h>
+
+#include <CS2/SDK/SDK.hpp>
+
+#include <CS2/Hook/Hook_SOCacheSubscribed.hpp>
+#include <CS2/Hook/Hook_Present.hpp>
+#include <CS2/Hook/Hook_ResizeBuffers.hpp>
+#include <CS2/Hook/Hook_CreateSwapChain.hpp>
+#include <CS2/Hook/Hook_MouseInputEnabled.hpp>
+#include <CS2/Hook/Hook_FireEventClientSide.hpp>
+#include <CS2/Hook/Hook_OnAddEntity.hpp>
+#include <CS2/Hook/Hook_OnRemoveEntity.hpp>
+#include <CS2/Hook/Hook_FrameStageNotify.hpp>
+#include <CS2/Hook/Hook_GetMatricesForView.hpp>
+#include <CS2/Hook/Hook_CreateMove.hpp>
+#include <CS2/Hook/Hook_OnClientOutput.hpp>
+#include <CS2/Hook/Hook_ParseMessage.hpp>
+#include <CS2/Hook/Hook_IsRelativeMouseMode.hpp>
+#include <CS2/Hook/Hook_UpdateInPVS.hpp>
+#include <CS2/Hook/Hook_AntiTamper.hpp>
+
+static CHook_Loader g_CHook_Loader{};
+
+auto CHook_Loader::InitalizeMH() -> bool
+{
+	return MH_Initialize() == MH_OK;
+}
+
+auto CHook_Loader::InstallFirstHook() -> bool
+{
+	m_Hooks =
+	{
+#if DISABLE_INVENTORY == 0
+		{ { XorStr( "Hook::SOCacheSubscribed" ) , XorStr( "48 89 6C 24 ? 56 48 83 EC ? 8B 41 ? 49 8B E8" ) , CLIENT_DLL } , &Hook_SOCacheSubscribed , reinterpret_cast<LPVOID*>( &SOCacheSubscribed_o ) },
+#endif
+	};
+
+	return InstallHooks();
+}
+
+auto CHook_Loader::InstallSecondHook() -> bool
+{
+	m_Hooks =
+	{
+		/*
+		sub_180095150 -> PresentOverlay
+		sub_18008ED80(*(_QWORD *)(v4 + 64), sub_180095150, &qword_180162258, 1, "DXGISwapChain_Present");
+		*/
+		{ { XorStr( "Hook::PresentOverlay" ) , XorStr( "48 89 5C 24 ? 48 89 6C 24 ? 56 57 41 54 41 56 41 57 48 83 EC ? 41 8B E8" ) , GAMEOVERLAYRENDER64_DLL } , &Hook_Present , reinterpret_cast<LPVOID*>( &Present_o ) },
+		/*
+		sub_180095520 -> ResizeBuffers
+		sub_18008ED80(*(_QWORD *)(v4 + 104), sub_180095520, &qword_180162260, 1, "DXGISwapChain_ResizeBuffers");
+		*/
+		{ { XorStr( "Hook::ResizeBuffers" ) , XorStr( "48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 48 89 7C 24 ? 41 54 41 56 41 57 48 83 EC ? 44 8B E2" ) , GAMEOVERLAYRENDER64_DLL } , &Hook_ResizeBuffers , reinterpret_cast<LPVOID*>( &ResizeBuffers_o ) },
+		/*
+		sub_1800AA7B0("IWrapDXGIFactory::CreateSwapChain called\n");
+		*/
+		{ { XorStr( "Hook::CreateSwapChain" ) , XorStr( "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 20 48 8B F9 49 8B F1 48 8D ? ? ? ? ? 49 8B D8 48 8B EA E8 ? ? ? ? 48 8D ? ? ? ? ? E8 ? ? ? ? 48 8D ? ? ? ? ? E8 ? ? ? ? 48 8D ? ? ? ? ? E8 ? ? ? ? 48 8B ? ? ? ? ? 4C 8B CE 4C 8B C3 48 8B D5 48 8B CF FF D0 8B D8 85 C0 78 18 48 85 F6 74 13 48 83 3E 00 74 0D 48 8B D5 48 8B CE E8 ? ? ? ? 8B C3 48 8B 5C 24 30 48 8B 6C 24 38 48 8B 74 24 40 48 83 C4 20 5F C3 CC CC CC CC CC CC CC CC 48 83 EC 38 48 8B 01 4C 8D 44 24 40" ) , GAMEOVERLAYRENDER64_DLL } , &Hook_CreateSwapChain , reinterpret_cast<LPVOID*>( &CreateSwapChain_o ) } ,
+		{ { XorStr( "Hook::MouseInputEnabled" ) , XorStr( "40 53 48 83 EC 20 80 B9 ? ? ? ? ? 48 8B D9 75 78" ) , CLIENT_DLL } , &Hook_MouseInputEnabled , reinterpret_cast<LPVOID*>( &MouseInputEnabled_o ) },
+		{ { XorStr( "Hook::FireEventClientSide" ) , XorStr( "48 89 5C 24 20 57 41 54 41 56 48 83 EC 30" ) , CLIENT_DLL } , &Hook_FireEventClientSide , reinterpret_cast<LPVOID*>( &FireEventClientSide_o ) },
+		{ { XorStr( "Hook::OnAddEntity" ) , XorStr( "48 89 74 24 10 57 48 83 EC 20 41 B9 FF 7F 00 00 41 8B C0 41 23 C1 48 8B F2 41 83 F8 FF 48 8B F9 44 0F 45 C8 41 81 F9 00 40 00 00 73 0D" ) , CLIENT_DLL } , &Hook_OnAddEntity , reinterpret_cast<LPVOID*>( &OnAddEntity_o ) },
+		{ { XorStr( "Hook::OnRemoveEntity" ) , XorStr( "48 89 74 24 10 57 48 83 EC 20 41 B9 FF 7F 00 00 41 8B C0 41 23 C1 48 8B F2 41 83 F8 FF 48 8B F9 44 0F 45 C8 41 81 F9 00 40 00 00 73 08" ) , CLIENT_DLL } , &Hook_OnRemoveEntity , reinterpret_cast<LPVOID*>( &OnRemoveEntity_o ) },
+		{ { XorStr( "Hook::FrameStageNotify" ) , XorStr( "48 89 5C 24 ? 57 48 81 EC ? ? ? ? 48 8B F9 8B DA" ) , CLIENT_DLL } , &Hook_FrameStageNotify , reinterpret_cast<LPVOID*>( &FrameStageNotify_o ) },
+		{ { XorStr( "Hook::GetMatricesForView" ) , XorStr( "40 53 48 81 EC ? ? ? ? 49 8B C1" ) , CLIENT_DLL } , &Hook_GetMatricesForView , reinterpret_cast<LPVOID*>( &GetMatricesForView_o ) },
+		{ { XorStr( "Hook::CreateMove" ) , XorStr( "85 D2 0F 85 ? ? ? ? 48 8B C4 44 88 40 18" ) , CLIENT_DLL } , &Hook_CreateMove , reinterpret_cast<LPVOID*>( &CreateMove_o ) },
+		{ { XorStr( "Hook::SerializePartialToArray" ) , XorStr( "48 89 5C 24 ? 55 56 57 48 81 EC ? ? ? ? 48 8B 05 ? ? ? ? 48 33 C4 48 89 84 24 ? ? ? ? 49 63 F0" ) , CLIENT_DLL } , &Hook_MessageLite_SerializePartialToArray , reinterpret_cast<LPVOID*>( &MessageLite_SerializePartialToArray_o ) },
+		{ { XorStr( "Hook::OnClientOutput" ) , XorStr( "48 89 5C 24 18 55 56 57 41 54 41 56 48 83 EC 70" ) , ENGINE2_DLL } , &Hook_OnClientOutput , reinterpret_cast<LPVOID*>( &OnClientOutput_o ) },
+		{ { XorStr( "Hook::CDemoRecorder" ) , XorStr( "40 56 57 41 57 48 83 EC ? 4C 8B F9" ) , ENGINE2_DLL } , &Hook_CDemoRecorder , reinterpret_cast<LPVOID*>( &CDemoRecorder_o ) },
+		{ { XorStr( "Hook::IsRelativeMouseMode" ) , XorStr( "48 89 6C 24 ? 48 89 74 24 ? 48 89 7C 24 ? 41 56 48 83 EC ? 0F B6 F2" ) , INPUTSYSTEM_DLL } , &Hook_IsRelativeMouseMode , reinterpret_cast<LPVOID*>( &IsRelativeMouseMode_o ) },
+		{ { XorStr( "Hook::UpdateInPVS" ) , XorStr( "48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 48 8B 01 8B F2 48 8B D9 FF 90 ? ? ? ? 33 FF" ) , CLIENT_DLL } , &Hook_UpdateInPVS , reinterpret_cast<LPVOID*>( &UpdateInPVS_o ) },
+		{ { XorStr( "Hook::AntiTamper" ) , XorStr( "40 53 48 83 EC 50 48 89 6C 24 60 48 8B E9 48 89 74" ) , CLIENT_DLL } , &Hook_AntiTamper , reinterpret_cast<LPVOID*>( &AntiTamper_o ) },
+	};
+
+	return InstallHooks();
+}
+
+auto CHook_Loader::InstallHooks() -> bool
+{
+	for ( auto& Hook : m_Hooks )
+	{
+		while ( !GetModuleHandleA( Hook.m_Pattern.GetDllName() ) )
+			   Sleep( 1 );
+
+		if ( !Hook.m_Pattern.Search( Hook.m_bSkipError ) )
+		{
+			if ( !Hook.m_bSkipError )
+				DEV_LOG( "[error] Hook #1 -> '%s'\n" , Hook.m_Pattern.GetPatternName() );
+
+			if ( !Hook.m_bSkipIfNotFound )
+				return false;
+			else
+				continue;
+		}
+
+		auto Status = MH_CreateHook( Hook.m_Pattern.GetFunction() , Hook.m_pDetour , Hook.m_pOriginal );
+
+		if ( Status != MH_OK )
+		{
+			DEV_LOG( "[error] Hook #2 [%i] -> '%s'\n" , Status , Hook.m_Pattern.GetPatternName() );
+			return false;
+		}
+	}
+
+	MH_EnableHook( MH_ALL_HOOKS );
+
+	m_Hooks.clear();
+
+	return true;
+}
+
+auto CHook_Loader::DestroyHooks() -> void
+{
+	MH_DisableHook( MH_ALL_HOOKS );
+	MH_Uninitialize();
+}
+
+auto GetHook_Loader() -> CHook_Loader*
+{
+	return &g_CHook_Loader;
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CHook_Loader.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Common/Common.hpp>
+#include <vector>
+
+#include <CS2/CBasePattern.hpp>
+
+struct HookData_t
+{
+	CBasePattern m_Pattern;
+	LPVOID m_pDetour = nullptr;
+	LPVOID* m_pOriginal = nullptr;
+	bool m_bSkipIfNotFound = false;
+	bool m_bSkipError = false;
+};
+
+class CHook_Loader final
+{
+public:
+	auto InitalizeMH() -> bool;
+
+public:
+	auto InstallFirstHook() -> bool;
+	auto InstallSecondHook() -> bool;
+
+private:
+	auto InstallHooks() -> bool;
+
+public:
+	auto DestroyHooks() -> void;
+
+private:
+	std::vector<HookData_t> m_Hooks = {};
+};
+
+auto GetHook_Loader() -> CHook_Loader*;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CSDK_Loader.cpp

@@ -0,0 +1,91 @@
+#include "CSDK_Loader.hpp"
+
+#include <CS2/SDK/SDK.hpp>
+#include <CS2/SDK/Interface/IEngineToClient.hpp>
+#include <CS2/SDK/Interface/CGameEntitySystem.hpp>
+#include <CS2/SDK/Interface/CShemaSystemSDK.hpp>
+#include <CS2/SDK/Interface/CSource2Client.hpp>
+
+#include <CS2/SDK/CSchemaOffset.hpp>
+#include <CS2/SDK/Types/CEntityData.hpp>
+#include <CS2/SDK/Econ/CEconItemSystem.hpp>
+#include <CS2/SDK/Econ/CEconItemSchema.hpp>
+#include <CS2/SDK/Cstrike15/CCSInventoryManager.hpp>
+#include <CS2/SDK/Cstrike15/CCSPlayerInventory.hpp>
+
+#include <Common/Helpers/ModuleLoaderHelper.hpp>
+
+#define RETURN_FALSE_IF_INTERFACE_ERROR(Interface)\
+if ( !Interface )\
+{\
+	DEV_LOG( "[error] Interface::%s\n" , #Interface );\
+	return false;\
+}
+
+static CSDK_Loader g_SDK_Loader{};
+
+auto CSDK_Loader::LoadSDK() -> bool
+{
+	// Wait for module load:
+	if ( !IsModuleLoad( NAVSYSTEM_DLL ) )
+		return false;
+
+	// Log SDK:
+#if LOG_SDK == 1
+	DEV_LOG( "[+] CSDK_Loader::LoadSDK:\n\n" );
+#endif
+
+	// Interfaces:
+	auto pEngineToClient = SDK::Interfaces::EngineToClient();
+	auto pGameEntitySystem = SDK::Interfaces::GameEntitySystem();
+	auto pSchemaSystem = SDK::Interfaces::SchemaSystem();
+	auto pSource2Client = SDK::Interfaces::Source2Client();
+	auto pLocalize = SDK::Interfaces::Localize();
+	auto pBaseFileSystem = SDK::Interfaces::BaseFileSystem();
+
+	// Return if error #1
+	RETURN_FALSE_IF_INTERFACE_ERROR( pEngineToClient );
+	RETURN_FALSE_IF_INTERFACE_ERROR( pGameEntitySystem );
+	RETURN_FALSE_IF_INTERFACE_ERROR( pSchemaSystem );
+	RETURN_FALSE_IF_INTERFACE_ERROR( pSource2Client );
+	RETURN_FALSE_IF_INTERFACE_ERROR( pLocalize );
+	RETURN_FALSE_IF_INTERFACE_ERROR( pBaseFileSystem );
+
+	// Log:
+#if LOG_SDK == 1
+	DEV_LOG( "\n" );
+#endif
+
+	// Log:
+#if LOG_SDK == 1
+	DEV_LOG( "[+] pEngineToClient: %p\n" , pEngineToClient );
+	DEV_LOG( "[+] pGameEntitySystem: %p\n" , pGameEntitySystem );
+	DEV_LOG( "[+] pSchemaSystem: %p\n" , pSchemaSystem );
+	DEV_LOG( "[+] pSource2Client: %p\n" , pSource2Client );
+	DEV_LOG( "[+] pLocalize: %p\n" , pLocalize );
+	DEV_LOG( "[+] pBaseFileSystem: %p\n" , pBaseFileSystem );
+#endif
+
+#if LOG_SDK == 1
+	DEV_LOG( "\n" );
+
+	DEV_LOG( "CCSInventoryManager::Get: %p\n" , CCSInventoryManager::Get() );
+	DEV_LOG( "CCSPlayerInventory::Get: %p\n" , CCSPlayerInventory::Get() );
+	DEV_LOG( "CSource2Client::GetEconItemSchema: %p\n" , pSource2Client->GetEconItemSystem()->GetEconItemSchema() );
+
+	DEV_LOG( "GetSortedItemDefinitionMap: %p\n" , &pSource2Client->GetEconItemSystem()->GetEconItemSchema()->GetSortedItemDefinitionMap() );
+	DEV_LOG( "GetPaintKits: %p\n" , &pSource2Client->GetEconItemSystem()->GetEconItemSchema()->GetPaintKits() );
+	DEV_LOG( "GetMusicKitDefinitions: %p\n" , &pSource2Client->GetEconItemSystem()->GetEconItemSchema()->GetMusicKitDefinitions() );
+
+	DEV_LOG( "\n" );
+#endif
+
+	GetSchemaOffset()->Init();
+
+	return true;
+}
+
+auto GetSDK_Loader() -> CSDK_Loader*
+{
+	return &g_SDK_Loader;
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/CSDK_Loader.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class CSDK_Loader final
+{
+public:
+	auto LoadSDK() -> bool;
+};
+
+auto GetSDK_Loader() -> CSDK_Loader*;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_AntiTamper.cpp

@@ -0,0 +1,6 @@
+#include "Hook_AntiTamper.hpp"
+
+auto Hook_AntiTamper( void* Src , int a2 , __int64 a3 , int a4 ) -> bool
+{
+	return false;
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_AntiTamper.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+auto Hook_AntiTamper( void* Src , int a2 , __int64 a3 , int a4 ) -> bool;
+
+using AntiTamper_t = decltype( &Hook_AntiTamper );
+inline AntiTamper_t AntiTamper_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_CreateMove.cpp

@@ -0,0 +1,48 @@
+#include "Hook_CreateMove.hpp"
+
+#include <CS2/SDK/SDK.hpp>
+#include <CS2/SDK/Interface/IEngineToClient.hpp>
+#include <CS2/SDK/Update/CCSGOInput.hpp>
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+#include <GameClient/CL_Players.hpp>
+#include <GameClient/CL_Bypass.hpp>
+
+auto Hook_CreateMove( CCSGOInput* pCCSGOInput , uint32_t split_screen_index , char a3 ) -> bool
+{
+	auto Result = false;
+
+	if ( auto* pLocalPlayerController = GetCL_Players()->GetLocalPlayerController(); pLocalPlayerController )
+	{
+		Result = CreateMove_o( pCCSGOInput , split_screen_index , a3 );
+		const auto pUserCmd = pCCSGOInput->GetUserCmd( pLocalPlayerController );
+
+		if ( !pUserCmd )
+			return Result;
+
+		if ( SDK::Interfaces::EngineToClient()->IsInGame() && GetCL_Players()->GetLocalPlayerPawn() )
+		{
+			GetCL_Bypass()->PreClientCreateMove( pUserCmd );
+			GetAndromedaClient()->OnCreateMove( pCCSGOInput , pUserCmd );
+			GetCL_Bypass()->PostClientCreateMove( pCCSGOInput , pUserCmd );
+		}
+	}
+
+	return Result;
+}
+
+auto Hook_MessageLite_SerializePartialToArray( google::protobuf::Message* pMsg , void* out_buffer , int size ) -> bool
+{
+#if DISABLE_PROTOBUF == 0
+	const google::protobuf::Descriptor* descriptor = pMsg->GetDescriptor();
+	const std::string message_name = descriptor->name();
+
+	if ( message_name == XorStr( "CBaseUserCmdPB" ) )
+	{
+		GetCL_Bypass()->OnCBaseUserCmdPB( reinterpret_cast<CBaseUserCmdPB*>( pMsg ) );
+	}
+#endif
+
+	return MessageLite_SerializePartialToArray_o( pMsg , out_buffer , size );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_CreateMove.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+#include <CS2/SDK/Network/CNetworkMessages.hpp>
+
+class CCSGOInput;
+
+auto Hook_CreateMove( CCSGOInput* pInput , uint32_t split_screen_index , char a3 ) -> bool;
+
+using CreateMove_t = decltype( &Hook_CreateMove );
+inline CreateMove_t CreateMove_o = nullptr;
+
+auto Hook_MessageLite_SerializePartialToArray( google::protobuf::Message* pMsg , void* out_buffer , int size ) -> bool;
+
+using MessageLite_SerializePartialToArray_t = decltype( &Hook_MessageLite_SerializePartialToArray );
+inline MessageLite_SerializePartialToArray_t MessageLite_SerializePartialToArray_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_CreateSwapChain.cpp

@@ -0,0 +1,10 @@
+#include "Hook_CreateSwapChain.hpp"
+
+#include <AndromedaClient/CAndromedaGUI.hpp>
+
+auto WINAPI Hook_CreateSwapChain( IDXGIFactory* pFactory , IUnknown* pDevice , DXGI_SWAP_CHAIN_DESC* pDesc , IDXGISwapChain** ppSwapChain )->HRESULT
+{
+	GetAndromedaGUI()->ClearRenderTargetView();
+
+	return CreateSwapChain_o( pFactory , pDevice , pDesc , ppSwapChain );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_CreateSwapChain.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <Common/Common.hpp>
+#include <d3d11.h>
+
+auto WINAPI Hook_CreateSwapChain( IDXGIFactory* pFactory , IUnknown* pDevice , DXGI_SWAP_CHAIN_DESC* pDesc , IDXGISwapChain** ppSwapChain )->HRESULT;
+
+using CreateSwapChain_t = decltype( &Hook_CreateSwapChain );
+inline CreateSwapChain_t CreateSwapChain_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_FireEventClientSide.cpp

@@ -0,0 +1,10 @@
+#include "Hook_FireEventClientSide.hpp"
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+auto Hook_FireEventClientSide( IGameEventManager2* pGameEventManager2 , IGameEvent* pGameEvent ) -> bool
+{
+	GetAndromedaClient()->OnFireEventClientSide( pGameEvent );
+
+	return FireEventClientSide_o( pGameEventManager2 , pGameEvent );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_FireEventClientSide.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <common/Common.hpp>
+
+class IGameEventManager2;
+class IGameEvent;
+
+auto Hook_FireEventClientSide( IGameEventManager2* pGameEventManager2 , IGameEvent* pGameEvent ) -> bool;
+
+using FireEventClientSide_t = decltype( &Hook_FireEventClientSide );
+inline FireEventClientSide_t FireEventClientSide_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_FrameStageNotify.cpp

@@ -0,0 +1,10 @@
+#include "Hook_FrameStageNotify.hpp"
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+auto Hook_FrameStageNotify( CSource2Client* pCSource2Client , int FrameStage ) -> void
+{
+	GetAndromedaClient()->OnFrameStageNotify( FrameStage );
+
+	return FrameStageNotify_o( pCSource2Client , FrameStage );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_FrameStageNotify.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class CSource2Client;
+
+auto Hook_FrameStageNotify( CSource2Client* pCSource2Client , int FrameStage ) -> void;
+
+using FrameStageNotify_t = decltype( &Hook_FrameStageNotify );
+inline FrameStageNotify_t FrameStageNotify_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_GetMatricesForView.cpp

@@ -0,0 +1,16 @@
+#include "Hook_GetMatricesForView.hpp"
+
+#include <CS2/SDK/Math/Math.hpp>
+
+#include <AndromedaClient/Features/CVisual/CVisual.hpp>
+
+auto Hook_GetMatricesForView( void* rcx , void* view ,
+                              VMatrix* pWorldToView ,
+                              VMatrix* pViewToProjection ,
+                              VMatrix* pWorldToProjection ,
+                              VMatrix* pWorldToPixels ) -> void
+{
+    GetMatricesForView_o( rcx , view , pWorldToView , pViewToProjection , pWorldToProjection , pWorldToPixels );
+
+    GetVisual()->CalculateBoundingBoxes();
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_GetMatricesForView.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class VMatrix;
+
+auto Hook_GetMatricesForView( void* rcx , void* view ,
+                              VMatrix* pWorldToView ,
+                              VMatrix* pViewToProjection ,
+                              VMatrix* pWorldToProjection ,
+                              VMatrix* pWorldToPixels ) -> void;
+
+using GetMatricesForView_t = decltype( &Hook_GetMatricesForView );
+inline GetMatricesForView_t GetMatricesForView_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_IsRelativeMouseMode.cpp

@@ -0,0 +1,13 @@
+#include "Hook_IsRelativeMouseMode.hpp"
+
+#include <AndromedaClient/CAndromedaGUI.hpp>
+
+auto Hook_IsRelativeMouseMode( CInputSystem* pInputSystem , bool Active ) -> void
+{
+	GetAndromedaGUI()->m_bMainActive = Active;
+
+	if ( GetAndromedaGUI()->IsVisible() )
+		return IsRelativeMouseMode_o( pInputSystem , false );
+
+	return IsRelativeMouseMode_o( pInputSystem , Active );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_IsRelativeMouseMode.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class CInputSystem;
+
+auto Hook_IsRelativeMouseMode( CInputSystem* pInputSystem , bool Active ) -> void;
+
+using IsRelativeMouseMode_t = decltype( &Hook_IsRelativeMouseMode );
+inline IsRelativeMouseMode_t IsRelativeMouseMode_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_MouseInputEnabled.cpp

@@ -0,0 +1,11 @@
+#include "Hook_MouseInputEnabled.hpp"
+
+#include <AndromedaClient/CAndromedaGUI.hpp>
+
+auto Hook_MouseInputEnabled( void* RCX ) -> bool
+{
+	if ( GetAndromedaGUI()->IsVisible() )
+		return false;
+
+	return MouseInputEnabled_o( RCX );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_MouseInputEnabled.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+auto Hook_MouseInputEnabled( void* RCX ) -> bool;
+
+using MouseInputEnabled_t = decltype( &Hook_MouseInputEnabled );
+inline MouseInputEnabled_t MouseInputEnabled_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnAddEntity.cpp

@@ -0,0 +1,10 @@
+#include "Hook_OnAddEntity.hpp"
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+auto Hook_OnAddEntity( CGameEntitySystem* pCGameEntitySystem , CEntityInstance* pInst , CHandle handle ) -> void
+{
+	GetAndromedaClient()->OnAddEntity( pInst , handle );
+
+	return OnAddEntity_o( pCGameEntitySystem , pInst , handle );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnAddEntity.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+#include <CS2/SDK/Types/CHandle.hpp>
+
+class CGameEntitySystem;
+class CEntityInstance;
+
+auto Hook_OnAddEntity( CGameEntitySystem* pCGameEntitySystem , CEntityInstance* pInst , CHandle handle ) -> void;
+
+using OnAddEntity_t = decltype( &Hook_OnAddEntity );
+inline OnAddEntity_t OnAddEntity_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnClientOutput.cpp

@@ -0,0 +1,12 @@
+#include "Hook_OnClientOutput.hpp"
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+#include <AndromedaClient/Render/CRenderStackSystem.hpp>
+
+auto Hook_OnClientOutput( void* a1 , void* a2 , void* a3 , void* a4 ) -> void
+{
+	GetAndromedaClient()->OnClientOutput();
+	GetRenderStackSystem()->OnClientOutput();
+
+	return OnClientOutput_o( a1 , a2 , a3 , a4 );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnClientOutput.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+auto Hook_OnClientOutput( void* a1 , void* a2 , void* a3 , void* a4 ) -> void;
+
+using OnClientOutput_t = decltype( &Hook_OnClientOutput );
+inline OnClientOutput_t OnClientOutput_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnRemoveEntity.cpp

@@ -0,0 +1,10 @@
+#include "Hook_OnRemoveEntity.hpp"
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+auto Hook_OnRemoveEntity( CGameEntitySystem* pCGameEntitySystem , CEntityInstance* pInst , CHandle handle ) -> void
+{
+	GetAndromedaClient()->OnRemoveEntity( pInst , handle );
+
+	return OnRemoveEntity_o( pCGameEntitySystem , pInst , handle );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_OnRemoveEntity.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+#include <CS2/SDK/Types/CHandle.hpp>
+
+class CGameEntitySystem;
+class CEntityInstance;
+
+auto Hook_OnRemoveEntity( CGameEntitySystem* pCGameEntitySystem , CEntityInstance* pInst , CHandle handle ) -> void;
+
+using OnRemoveEntity_t = decltype( &Hook_OnRemoveEntity );
+inline OnRemoveEntity_t OnRemoveEntity_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_ParseMessage.cpp

@@ -0,0 +1,40 @@
+#include "Hook_ParseMessage.hpp"
+
+#include <CS2/SDK/SDK.hpp>
+#include <CS2/SDK/Interface/CSoundOpSystem.hpp>
+#include <CS2/SDK/Network/CNetworkMessages.hpp>
+#include <CS2/SDK/Math/Vector3.hpp>
+
+#include <CS2/Protobuf/gameevents.pb.h>
+
+#include <AndromedaClient/CAndromedaClient.hpp>
+
+auto Hook_CDemoRecorder( CDemoRecorder* pDemoRecorder , CNetworkSerializerPB* pSerializer , CNetMessagePB* pNetMessage ) -> bool
+{
+	if ( pSerializer->messageID == GE_SosStartSoundEvent )
+	{
+		CMsgSosStartSoundEvent* pMessage = reinterpret_cast<CMsgSosStartSoundEvent*>( (PBYTE)pNetMessage + 0x28 );
+
+		if ( pMessage )
+		{
+			std::string SoundName = "null";
+			Vector3 SoundPos;
+			auto SourceEntityIndex = 0;
+
+			if ( pMessage->has_source_entity_index() )
+				SourceEntityIndex = pMessage->source_entity_index();
+
+			if ( pMessage->has_packed_params() && pMessage->packed_params().size() >= 19 && pMessage->packed_params().data() )
+				SoundPos = *(Vector3*)( pMessage->packed_params().data() + 7 );
+
+			const char* szSoundEventName = SDK::Interfaces::SoundOpSystem()->GetCSoundEventManager()->GetSoundEventName( pMessage->soundevent_hash() );
+
+			if ( szSoundEventName )
+				SoundName = szSoundEventName;
+
+			DEV_LOG( "StartSoundEvent: %i , %s\n" , SourceEntityIndex , SoundName.c_str() );
+		}
+	}
+
+	return CDemoRecorder_o( pDemoRecorder , pSerializer , pNetMessage );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_ParseMessage.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class CDemoRecorder;
+class CNetworkSerializerPB;
+class CNetMessagePB;
+
+auto Hook_CDemoRecorder( CDemoRecorder* pDemoRecorder , CNetworkSerializerPB* pSerializer , CNetMessagePB* pNetMessage ) -> bool;
+
+using CDemoRecorder_t = decltype( &Hook_CDemoRecorder );
+inline CDemoRecorder_t CDemoRecorder_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_Present.cpp

@@ -0,0 +1,10 @@
+#include "Hook_Present.hpp"
+
+#include <AndromedaClient/CAndromedaGUI.hpp>
+
+auto Hook_Present( IDXGISwapChain* pSwapChain , UINT SyncInterval , UINT Flags ) -> HRESULT
+{
+	GetAndromedaGUI()->OnPresent( pSwapChain );
+
+	return Present_o( pSwapChain , SyncInterval , Flags );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_Present.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <Common/Common.hpp>
+#include <d3d11.h>
+
+auto Hook_Present( IDXGISwapChain* pSwapChain , UINT SyncInterval , UINT Flags ) -> HRESULT;
+
+using Present_t = decltype( &Hook_Present );
+inline Present_t Present_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_ResizeBuffers.cpp

@@ -0,0 +1,10 @@
+#include "Hook_ResizeBuffers.hpp"
+
+#include <AndromedaClient/CAndromedaGUI.hpp>
+
+auto Hook_ResizeBuffers( IDXGISwapChain* pSwapChain , UINT BufferCount , UINT Width , UINT Height , DXGI_FORMAT NewFormat , UINT SwapChainFlags ) -> HRESULT
+{
+	GetAndromedaGUI()->OnResizeBuffers( pSwapChain );
+
+	return ResizeBuffers_o( pSwapChain , BufferCount , Width , Height , NewFormat , SwapChainFlags );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_ResizeBuffers.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <Common/Common.hpp>
+#include <d3d11.h>
+
+auto Hook_ResizeBuffers( IDXGISwapChain* pSwapChain , UINT BufferCount , UINT Width , UINT Height , DXGI_FORMAT NewFormat , UINT SwapChainFlags ) -> HRESULT;
+
+using ResizeBuffers_t = decltype( &Hook_ResizeBuffers );
+inline ResizeBuffers_t ResizeBuffers_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_SOCacheSubscribed.cpp

@@ -0,0 +1,15 @@
+#include "Hook_SOCacheSubscribed.hpp"
+
+#include <CS2/SDK/Cstrike15/CCSPlayerInventory.hpp>
+
+auto Hook_SOCacheSubscribed( CCSPlayerInventory* pCSPlayerInventory , GCSDK::SOID_t owner , int64_t unk ) -> void*
+{
+	auto pResult = SOCacheSubscribed_o( pCSPlayerInventory , owner , unk );
+
+	if ( pCSPlayerInventory->GetOwner().m_type == owner.m_type && pCSPlayerInventory->GetOwner().m_id == owner.m_id )
+	{
+		
+	}
+
+	return pResult;
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_SOCacheSubscribed.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+#include <CS2/SDK/GCSDK/GCSDKTypes/SOID_t.hpp>
+
+class CCSPlayerInventory;
+
+auto Hook_SOCacheSubscribed( CCSPlayerInventory* pCSPlayerInventory , GCSDK::SOID_t owner , int64_t unk ) -> void*;
+
+using SOCacheSubscribed_t = decltype( &Hook_SOCacheSubscribed );
+inline SOCacheSubscribed_t SOCacheSubscribed_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_UpdateInPVS.cpp

@@ -0,0 +1,10 @@
+#include "Hook_UpdateInPVS.hpp"
+
+#include <CS2/SDK/Types/CEntityData.hpp>
+
+auto Hook_UpdateInPVS( CEntityInstance* pEntityInstance , int unk0 ) -> bool
+{
+	return true;
+
+	//return UpdateInPVS_o( pEntityInstance , unk0 );
+}

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Hook/Hook_UpdateInPVS.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Common/Common.hpp>
+
+class CEntityInstance;
+
+auto Hook_UpdateInPVS( CEntityInstance* pEntityInstance , int unk0 ) -> bool;
+
+using UpdateInPVS_t = decltype( &Hook_UpdateInPVS );
+inline UpdateInPVS_t UpdateInPVS_o = nullptr;

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/cs_prediction_events.pb.cc

@@ -0,0 +1,704 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: cs_prediction_events.proto
+
+#include "cs_prediction_events.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR CCSPredictionEvent_DamageTag::CCSPredictionEvent_DamageTag(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.flinch_mod_small_)*/0
+  , /*decltype(_impl_.flinch_mod_large_)*/0
+  , /*decltype(_impl_.friendly_fire_damage_reduction_ratio_)*/0} {}
+struct CCSPredictionEvent_DamageTagDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CCSPredictionEvent_DamageTagDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CCSPredictionEvent_DamageTagDefaultTypeInternal() {}
+  union {
+    CCSPredictionEvent_DamageTag _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CCSPredictionEvent_DamageTagDefaultTypeInternal _CCSPredictionEvent_DamageTag_default_instance_;
+PROTOBUF_CONSTEXPR CCSPredictionEvent_AddAimPunch::CCSPredictionEvent_AddAimPunch(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.punch_angle_)*/nullptr
+  , /*decltype(_impl_.when_tick_)*/0u
+  , /*decltype(_impl_.when_tick_frac_)*/0} {}
+struct CCSPredictionEvent_AddAimPunchDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CCSPredictionEvent_AddAimPunchDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CCSPredictionEvent_AddAimPunchDefaultTypeInternal() {}
+  union {
+    CCSPredictionEvent_AddAimPunch _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CCSPredictionEvent_AddAimPunchDefaultTypeInternal _CCSPredictionEvent_AddAimPunch_default_instance_;
+static ::_pb::Metadata file_level_metadata_cs_5fprediction_5fevents_2eproto[2];
+static const ::_pb::EnumDescriptor* file_level_enum_descriptors_cs_5fprediction_5fevents_2eproto[1];
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_cs_5fprediction_5fevents_2eproto = nullptr;
+
+const uint32_t TableStruct_cs_5fprediction_5fevents_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_DamageTag, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_DamageTag, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_DamageTag, _impl_.flinch_mod_small_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_DamageTag, _impl_.flinch_mod_large_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_DamageTag, _impl_.friendly_fire_damage_reduction_ratio_),
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_AddAimPunch, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_AddAimPunch, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_AddAimPunch, _impl_.punch_angle_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_AddAimPunch, _impl_.when_tick_),
+  PROTOBUF_FIELD_OFFSET(::CCSPredictionEvent_AddAimPunch, _impl_.when_tick_frac_),
+  0,
+  1,
+  2,
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 9, -1, sizeof(::CCSPredictionEvent_DamageTag)},
+  { 12, 21, -1, sizeof(::CCSPredictionEvent_AddAimPunch)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_CCSPredictionEvent_DamageTag_default_instance_._instance,
+  &::_CCSPredictionEvent_AddAimPunch_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_cs_5fprediction_5fevents_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\032cs_prediction_events.proto\032\026networkbas"
+  "etypes.proto\032\027prediction_events.proto\"\200\001"
+  "\n\034CCSPredictionEvent_DamageTag\022\030\n\020flinch"
+  "_mod_small\030\001 \001(\002\022\030\n\020flinch_mod_large\030\002 \001"
+  "(\002\022,\n$friendly_fire_damage_reduction_rat"
+  "io\030\003 \001(\002\"m\n\036CCSPredictionEvent_AddAimPun"
+  "ch\022 \n\013punch_angle\030\001 \001(\0132\013.CMsgQAngle\022\021\n\t"
+  "when_tick\030\002 \001(\r\022\026\n\016when_tick_frac\030\003 \001(\002*"
+  "\?\n\023ECSPredictionEvents\022\022\n\016CSPE_DamageTag"
+  "\020\001\022\024\n\020CSPE_AddAimPunch\020\003"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_cs_5fprediction_5fevents_2eproto_deps[2] = {
+  &::descriptor_table_networkbasetypes_2eproto,
+  &::descriptor_table_prediction_5fevents_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_cs_5fprediction_5fevents_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_cs_5fprediction_5fevents_2eproto = {
+    false, false, 384, descriptor_table_protodef_cs_5fprediction_5fevents_2eproto,
+    "cs_prediction_events.proto",
+    &descriptor_table_cs_5fprediction_5fevents_2eproto_once, descriptor_table_cs_5fprediction_5fevents_2eproto_deps, 2, 2,
+    schemas, file_default_instances, TableStruct_cs_5fprediction_5fevents_2eproto::offsets,
+    file_level_metadata_cs_5fprediction_5fevents_2eproto, file_level_enum_descriptors_cs_5fprediction_5fevents_2eproto,
+    file_level_service_descriptors_cs_5fprediction_5fevents_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_cs_5fprediction_5fevents_2eproto_getter() {
+  return &descriptor_table_cs_5fprediction_5fevents_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_cs_5fprediction_5fevents_2eproto(&descriptor_table_cs_5fprediction_5fevents_2eproto);
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ECSPredictionEvents_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_cs_5fprediction_5fevents_2eproto);
+  return file_level_enum_descriptors_cs_5fprediction_5fevents_2eproto[0];
+}
+bool ECSPredictionEvents_IsValid(int value) {
+  switch (value) {
+    case 1:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+class CCSPredictionEvent_DamageTag::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CCSPredictionEvent_DamageTag>()._impl_._has_bits_);
+  static void set_has_flinch_mod_small(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_flinch_mod_large(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_friendly_fire_damage_reduction_ratio(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+CCSPredictionEvent_DamageTag::CCSPredictionEvent_DamageTag(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CCSPredictionEvent_DamageTag)
+}
+CCSPredictionEvent_DamageTag::CCSPredictionEvent_DamageTag(const CCSPredictionEvent_DamageTag& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CCSPredictionEvent_DamageTag* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.flinch_mod_small_){}
+    , decltype(_impl_.flinch_mod_large_){}
+    , decltype(_impl_.friendly_fire_damage_reduction_ratio_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.flinch_mod_small_, &from._impl_.flinch_mod_small_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.friendly_fire_damage_reduction_ratio_) -
+    reinterpret_cast<char*>(&_impl_.flinch_mod_small_)) + sizeof(_impl_.friendly_fire_damage_reduction_ratio_));
+  // @@protoc_insertion_point(copy_constructor:CCSPredictionEvent_DamageTag)
+}
+
+inline void CCSPredictionEvent_DamageTag::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.flinch_mod_small_){0}
+    , decltype(_impl_.flinch_mod_large_){0}
+    , decltype(_impl_.friendly_fire_damage_reduction_ratio_){0}
+  };
+}
+
+CCSPredictionEvent_DamageTag::~CCSPredictionEvent_DamageTag() {
+  // @@protoc_insertion_point(destructor:CCSPredictionEvent_DamageTag)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CCSPredictionEvent_DamageTag::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void CCSPredictionEvent_DamageTag::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CCSPredictionEvent_DamageTag::Clear() {
+// @@protoc_insertion_point(message_clear_start:CCSPredictionEvent_DamageTag)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.flinch_mod_small_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.friendly_fire_damage_reduction_ratio_) -
+        reinterpret_cast<char*>(&_impl_.flinch_mod_small_)) + sizeof(_impl_.friendly_fire_damage_reduction_ratio_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CCSPredictionEvent_DamageTag::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional float flinch_mod_small = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
+          _Internal::set_has_flinch_mod_small(&has_bits);
+          _impl_.flinch_mod_small_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float flinch_mod_large = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+          _Internal::set_has_flinch_mod_large(&has_bits);
+          _impl_.flinch_mod_large_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float friendly_fire_damage_reduction_ratio = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+          _Internal::set_has_friendly_fire_damage_reduction_ratio(&has_bits);
+          _impl_.friendly_fire_damage_reduction_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CCSPredictionEvent_DamageTag::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CCSPredictionEvent_DamageTag)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional float flinch_mod_small = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(1, this->_internal_flinch_mod_small(), target);
+  }
+
+  // optional float flinch_mod_large = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_flinch_mod_large(), target);
+  }
+
+  // optional float friendly_fire_damage_reduction_ratio = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(3, this->_internal_friendly_fire_damage_reduction_ratio(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CCSPredictionEvent_DamageTag)
+  return target;
+}
+
+size_t CCSPredictionEvent_DamageTag::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CCSPredictionEvent_DamageTag)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional float flinch_mod_small = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 + 4;
+    }
+
+    // optional float flinch_mod_large = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 4;
+    }
+
+    // optional float friendly_fire_damage_reduction_ratio = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CCSPredictionEvent_DamageTag::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CCSPredictionEvent_DamageTag::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CCSPredictionEvent_DamageTag::GetClassData() const { return &_class_data_; }
+
+
+void CCSPredictionEvent_DamageTag::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CCSPredictionEvent_DamageTag*>(&to_msg);
+  auto& from = static_cast<const CCSPredictionEvent_DamageTag&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CCSPredictionEvent_DamageTag)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.flinch_mod_small_ = from._impl_.flinch_mod_small_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.flinch_mod_large_ = from._impl_.flinch_mod_large_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.friendly_fire_damage_reduction_ratio_ = from._impl_.friendly_fire_damage_reduction_ratio_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CCSPredictionEvent_DamageTag::CopyFrom(const CCSPredictionEvent_DamageTag& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CCSPredictionEvent_DamageTag)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CCSPredictionEvent_DamageTag::IsInitialized() const {
+  return true;
+}
+
+void CCSPredictionEvent_DamageTag::InternalSwap(CCSPredictionEvent_DamageTag* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CCSPredictionEvent_DamageTag, _impl_.friendly_fire_damage_reduction_ratio_)
+      + sizeof(CCSPredictionEvent_DamageTag::_impl_.friendly_fire_damage_reduction_ratio_)
+      - PROTOBUF_FIELD_OFFSET(CCSPredictionEvent_DamageTag, _impl_.flinch_mod_small_)>(
+          reinterpret_cast<char*>(&_impl_.flinch_mod_small_),
+          reinterpret_cast<char*>(&other->_impl_.flinch_mod_small_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CCSPredictionEvent_DamageTag::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_cs_5fprediction_5fevents_2eproto_getter, &descriptor_table_cs_5fprediction_5fevents_2eproto_once,
+      file_level_metadata_cs_5fprediction_5fevents_2eproto[0]);
+}
+
+// ===================================================================
+
+class CCSPredictionEvent_AddAimPunch::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CCSPredictionEvent_AddAimPunch>()._impl_._has_bits_);
+  static const ::CMsgQAngle& punch_angle(const CCSPredictionEvent_AddAimPunch* msg);
+  static void set_has_punch_angle(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_when_tick(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_when_tick_frac(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::CMsgQAngle&
+CCSPredictionEvent_AddAimPunch::_Internal::punch_angle(const CCSPredictionEvent_AddAimPunch* msg) {
+  return *msg->_impl_.punch_angle_;
+}
+void CCSPredictionEvent_AddAimPunch::clear_punch_angle() {
+  if (_impl_.punch_angle_ != nullptr) _impl_.punch_angle_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+CCSPredictionEvent_AddAimPunch::CCSPredictionEvent_AddAimPunch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CCSPredictionEvent_AddAimPunch)
+}
+CCSPredictionEvent_AddAimPunch::CCSPredictionEvent_AddAimPunch(const CCSPredictionEvent_AddAimPunch& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CCSPredictionEvent_AddAimPunch* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.punch_angle_){nullptr}
+    , decltype(_impl_.when_tick_){}
+    , decltype(_impl_.when_tick_frac_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_punch_angle()) {
+    _this->_impl_.punch_angle_ = new ::CMsgQAngle(*from._impl_.punch_angle_);
+  }
+  ::memcpy(&_impl_.when_tick_, &from._impl_.when_tick_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.when_tick_frac_) -
+    reinterpret_cast<char*>(&_impl_.when_tick_)) + sizeof(_impl_.when_tick_frac_));
+  // @@protoc_insertion_point(copy_constructor:CCSPredictionEvent_AddAimPunch)
+}
+
+inline void CCSPredictionEvent_AddAimPunch::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.punch_angle_){nullptr}
+    , decltype(_impl_.when_tick_){0u}
+    , decltype(_impl_.when_tick_frac_){0}
+  };
+}
+
+CCSPredictionEvent_AddAimPunch::~CCSPredictionEvent_AddAimPunch() {
+  // @@protoc_insertion_point(destructor:CCSPredictionEvent_AddAimPunch)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CCSPredictionEvent_AddAimPunch::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.punch_angle_;
+}
+
+void CCSPredictionEvent_AddAimPunch::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CCSPredictionEvent_AddAimPunch::Clear() {
+// @@protoc_insertion_point(message_clear_start:CCSPredictionEvent_AddAimPunch)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.punch_angle_ != nullptr);
+    _impl_.punch_angle_->Clear();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.when_tick_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.when_tick_frac_) -
+        reinterpret_cast<char*>(&_impl_.when_tick_)) + sizeof(_impl_.when_tick_frac_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CCSPredictionEvent_AddAimPunch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .CMsgQAngle punch_angle = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_punch_angle(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 when_tick = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_when_tick(&has_bits);
+          _impl_.when_tick_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float when_tick_frac = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+          _Internal::set_has_when_tick_frac(&has_bits);
+          _impl_.when_tick_frac_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CCSPredictionEvent_AddAimPunch::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CCSPredictionEvent_AddAimPunch)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .CMsgQAngle punch_angle = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::punch_angle(this),
+        _Internal::punch_angle(this).GetCachedSize(), target, stream);
+  }
+
+  // optional uint32 when_tick = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_when_tick(), target);
+  }
+
+  // optional float when_tick_frac = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(3, this->_internal_when_tick_frac(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CCSPredictionEvent_AddAimPunch)
+  return target;
+}
+
+size_t CCSPredictionEvent_AddAimPunch::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CCSPredictionEvent_AddAimPunch)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .CMsgQAngle punch_angle = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.punch_angle_);
+    }
+
+    // optional uint32 when_tick = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_when_tick());
+    }
+
+    // optional float when_tick_frac = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CCSPredictionEvent_AddAimPunch::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CCSPredictionEvent_AddAimPunch::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CCSPredictionEvent_AddAimPunch::GetClassData() const { return &_class_data_; }
+
+
+void CCSPredictionEvent_AddAimPunch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CCSPredictionEvent_AddAimPunch*>(&to_msg);
+  auto& from = static_cast<const CCSPredictionEvent_AddAimPunch&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CCSPredictionEvent_AddAimPunch)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_punch_angle()->::CMsgQAngle::MergeFrom(
+          from._internal_punch_angle());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.when_tick_ = from._impl_.when_tick_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.when_tick_frac_ = from._impl_.when_tick_frac_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CCSPredictionEvent_AddAimPunch::CopyFrom(const CCSPredictionEvent_AddAimPunch& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CCSPredictionEvent_AddAimPunch)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CCSPredictionEvent_AddAimPunch::IsInitialized() const {
+  return true;
+}
+
+void CCSPredictionEvent_AddAimPunch::InternalSwap(CCSPredictionEvent_AddAimPunch* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CCSPredictionEvent_AddAimPunch, _impl_.when_tick_frac_)
+      + sizeof(CCSPredictionEvent_AddAimPunch::_impl_.when_tick_frac_)
+      - PROTOBUF_FIELD_OFFSET(CCSPredictionEvent_AddAimPunch, _impl_.punch_angle_)>(
+          reinterpret_cast<char*>(&_impl_.punch_angle_),
+          reinterpret_cast<char*>(&other->_impl_.punch_angle_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CCSPredictionEvent_AddAimPunch::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_cs_5fprediction_5fevents_2eproto_getter, &descriptor_table_cs_5fprediction_5fevents_2eproto_once,
+      file_level_metadata_cs_5fprediction_5fevents_2eproto[1]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::CCSPredictionEvent_DamageTag*
+Arena::CreateMaybeMessage< ::CCSPredictionEvent_DamageTag >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CCSPredictionEvent_DamageTag >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CCSPredictionEvent_AddAimPunch*
+Arena::CreateMaybeMessage< ::CCSPredictionEvent_AddAimPunch >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CCSPredictionEvent_AddAimPunch >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/cs_prediction_events.pb.h

@@ -0,0 +1,733 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: cs_prediction_events.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_cs_5fprediction_5fevents_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_cs_5fprediction_5fevents_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_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"
+#include "prediction_events.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_cs_5fprediction_5fevents_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_cs_5fprediction_5fevents_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_cs_5fprediction_5fevents_2eproto;
+class CCSPredictionEvent_AddAimPunch;
+struct CCSPredictionEvent_AddAimPunchDefaultTypeInternal;
+extern CCSPredictionEvent_AddAimPunchDefaultTypeInternal _CCSPredictionEvent_AddAimPunch_default_instance_;
+class CCSPredictionEvent_DamageTag;
+struct CCSPredictionEvent_DamageTagDefaultTypeInternal;
+extern CCSPredictionEvent_DamageTagDefaultTypeInternal _CCSPredictionEvent_DamageTag_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::CCSPredictionEvent_AddAimPunch* Arena::CreateMaybeMessage<::CCSPredictionEvent_AddAimPunch>(Arena*);
+template<> ::CCSPredictionEvent_DamageTag* Arena::CreateMaybeMessage<::CCSPredictionEvent_DamageTag>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+enum ECSPredictionEvents : int {
+  CSPE_DamageTag = 1,
+  CSPE_AddAimPunch = 3
+};
+bool ECSPredictionEvents_IsValid(int value);
+constexpr ECSPredictionEvents ECSPredictionEvents_MIN = CSPE_DamageTag;
+constexpr ECSPredictionEvents ECSPredictionEvents_MAX = CSPE_AddAimPunch;
+constexpr int ECSPredictionEvents_ARRAYSIZE = ECSPredictionEvents_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ECSPredictionEvents_descriptor();
+template<typename T>
+inline const std::string& ECSPredictionEvents_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ECSPredictionEvents>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ECSPredictionEvents_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ECSPredictionEvents_descriptor(), enum_t_value);
+}
+inline bool ECSPredictionEvents_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ECSPredictionEvents* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ECSPredictionEvents>(
+    ECSPredictionEvents_descriptor(), name, value);
+}
+// ===================================================================
+
+class CCSPredictionEvent_DamageTag final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCSPredictionEvent_DamageTag) */ {
+ public:
+  inline CCSPredictionEvent_DamageTag() : CCSPredictionEvent_DamageTag(nullptr) {}
+  ~CCSPredictionEvent_DamageTag() override;
+  explicit PROTOBUF_CONSTEXPR CCSPredictionEvent_DamageTag(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CCSPredictionEvent_DamageTag(const CCSPredictionEvent_DamageTag& from);
+  CCSPredictionEvent_DamageTag(CCSPredictionEvent_DamageTag&& from) noexcept
+    : CCSPredictionEvent_DamageTag() {
+    *this = ::std::move(from);
+  }
+
+  inline CCSPredictionEvent_DamageTag& operator=(const CCSPredictionEvent_DamageTag& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CCSPredictionEvent_DamageTag& operator=(CCSPredictionEvent_DamageTag&& 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 CCSPredictionEvent_DamageTag& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CCSPredictionEvent_DamageTag* internal_default_instance() {
+    return reinterpret_cast<const CCSPredictionEvent_DamageTag*>(
+               &_CCSPredictionEvent_DamageTag_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CCSPredictionEvent_DamageTag& a, CCSPredictionEvent_DamageTag& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CCSPredictionEvent_DamageTag* 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(CCSPredictionEvent_DamageTag* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CCSPredictionEvent_DamageTag* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CCSPredictionEvent_DamageTag>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CCSPredictionEvent_DamageTag& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CCSPredictionEvent_DamageTag& from) {
+    CCSPredictionEvent_DamageTag::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(CCSPredictionEvent_DamageTag* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CCSPredictionEvent_DamageTag";
+  }
+  protected:
+  explicit CCSPredictionEvent_DamageTag(::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 {
+    kFlinchModSmallFieldNumber = 1,
+    kFlinchModLargeFieldNumber = 2,
+    kFriendlyFireDamageReductionRatioFieldNumber = 3,
+  };
+  // optional float flinch_mod_small = 1;
+  bool has_flinch_mod_small() const;
+  private:
+  bool _internal_has_flinch_mod_small() const;
+  public:
+  void clear_flinch_mod_small();
+  float flinch_mod_small() const;
+  void set_flinch_mod_small(float value);
+  private:
+  float _internal_flinch_mod_small() const;
+  void _internal_set_flinch_mod_small(float value);
+  public:
+
+  // optional float flinch_mod_large = 2;
+  bool has_flinch_mod_large() const;
+  private:
+  bool _internal_has_flinch_mod_large() const;
+  public:
+  void clear_flinch_mod_large();
+  float flinch_mod_large() const;
+  void set_flinch_mod_large(float value);
+  private:
+  float _internal_flinch_mod_large() const;
+  void _internal_set_flinch_mod_large(float value);
+  public:
+
+  // optional float friendly_fire_damage_reduction_ratio = 3;
+  bool has_friendly_fire_damage_reduction_ratio() const;
+  private:
+  bool _internal_has_friendly_fire_damage_reduction_ratio() const;
+  public:
+  void clear_friendly_fire_damage_reduction_ratio();
+  float friendly_fire_damage_reduction_ratio() const;
+  void set_friendly_fire_damage_reduction_ratio(float value);
+  private:
+  float _internal_friendly_fire_damage_reduction_ratio() const;
+  void _internal_set_friendly_fire_damage_reduction_ratio(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CCSPredictionEvent_DamageTag)
+ 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 flinch_mod_small_;
+    float flinch_mod_large_;
+    float friendly_fire_damage_reduction_ratio_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_cs_5fprediction_5fevents_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CCSPredictionEvent_AddAimPunch final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCSPredictionEvent_AddAimPunch) */ {
+ public:
+  inline CCSPredictionEvent_AddAimPunch() : CCSPredictionEvent_AddAimPunch(nullptr) {}
+  ~CCSPredictionEvent_AddAimPunch() override;
+  explicit PROTOBUF_CONSTEXPR CCSPredictionEvent_AddAimPunch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CCSPredictionEvent_AddAimPunch(const CCSPredictionEvent_AddAimPunch& from);
+  CCSPredictionEvent_AddAimPunch(CCSPredictionEvent_AddAimPunch&& from) noexcept
+    : CCSPredictionEvent_AddAimPunch() {
+    *this = ::std::move(from);
+  }
+
+  inline CCSPredictionEvent_AddAimPunch& operator=(const CCSPredictionEvent_AddAimPunch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CCSPredictionEvent_AddAimPunch& operator=(CCSPredictionEvent_AddAimPunch&& 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 CCSPredictionEvent_AddAimPunch& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CCSPredictionEvent_AddAimPunch* internal_default_instance() {
+    return reinterpret_cast<const CCSPredictionEvent_AddAimPunch*>(
+               &_CCSPredictionEvent_AddAimPunch_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CCSPredictionEvent_AddAimPunch& a, CCSPredictionEvent_AddAimPunch& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CCSPredictionEvent_AddAimPunch* 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(CCSPredictionEvent_AddAimPunch* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CCSPredictionEvent_AddAimPunch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CCSPredictionEvent_AddAimPunch>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CCSPredictionEvent_AddAimPunch& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CCSPredictionEvent_AddAimPunch& from) {
+    CCSPredictionEvent_AddAimPunch::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(CCSPredictionEvent_AddAimPunch* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CCSPredictionEvent_AddAimPunch";
+  }
+  protected:
+  explicit CCSPredictionEvent_AddAimPunch(::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 {
+    kPunchAngleFieldNumber = 1,
+    kWhenTickFieldNumber = 2,
+    kWhenTickFracFieldNumber = 3,
+  };
+  // optional .CMsgQAngle punch_angle = 1;
+  bool has_punch_angle() const;
+  private:
+  bool _internal_has_punch_angle() const;
+  public:
+  void clear_punch_angle();
+  const ::CMsgQAngle& punch_angle() const;
+  PROTOBUF_NODISCARD ::CMsgQAngle* release_punch_angle();
+  ::CMsgQAngle* mutable_punch_angle();
+  void set_allocated_punch_angle(::CMsgQAngle* punch_angle);
+  private:
+  const ::CMsgQAngle& _internal_punch_angle() const;
+  ::CMsgQAngle* _internal_mutable_punch_angle();
+  public:
+  void unsafe_arena_set_allocated_punch_angle(
+      ::CMsgQAngle* punch_angle);
+  ::CMsgQAngle* unsafe_arena_release_punch_angle();
+
+  // optional uint32 when_tick = 2;
+  bool has_when_tick() const;
+  private:
+  bool _internal_has_when_tick() const;
+  public:
+  void clear_when_tick();
+  uint32_t when_tick() const;
+  void set_when_tick(uint32_t value);
+  private:
+  uint32_t _internal_when_tick() const;
+  void _internal_set_when_tick(uint32_t value);
+  public:
+
+  // optional float when_tick_frac = 3;
+  bool has_when_tick_frac() const;
+  private:
+  bool _internal_has_when_tick_frac() const;
+  public:
+  void clear_when_tick_frac();
+  float when_tick_frac() const;
+  void set_when_tick_frac(float value);
+  private:
+  float _internal_when_tick_frac() const;
+  void _internal_set_when_tick_frac(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CCSPredictionEvent_AddAimPunch)
+ 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* punch_angle_;
+    uint32_t when_tick_;
+    float when_tick_frac_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_cs_5fprediction_5fevents_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CCSPredictionEvent_DamageTag
+
+// optional float flinch_mod_small = 1;
+inline bool CCSPredictionEvent_DamageTag::_internal_has_flinch_mod_small() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CCSPredictionEvent_DamageTag::has_flinch_mod_small() const {
+  return _internal_has_flinch_mod_small();
+}
+inline void CCSPredictionEvent_DamageTag::clear_flinch_mod_small() {
+  _impl_.flinch_mod_small_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline float CCSPredictionEvent_DamageTag::_internal_flinch_mod_small() const {
+  return _impl_.flinch_mod_small_;
+}
+inline float CCSPredictionEvent_DamageTag::flinch_mod_small() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_DamageTag.flinch_mod_small)
+  return _internal_flinch_mod_small();
+}
+inline void CCSPredictionEvent_DamageTag::_internal_set_flinch_mod_small(float value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.flinch_mod_small_ = value;
+}
+inline void CCSPredictionEvent_DamageTag::set_flinch_mod_small(float value) {
+  _internal_set_flinch_mod_small(value);
+  // @@protoc_insertion_point(field_set:CCSPredictionEvent_DamageTag.flinch_mod_small)
+}
+
+// optional float flinch_mod_large = 2;
+inline bool CCSPredictionEvent_DamageTag::_internal_has_flinch_mod_large() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CCSPredictionEvent_DamageTag::has_flinch_mod_large() const {
+  return _internal_has_flinch_mod_large();
+}
+inline void CCSPredictionEvent_DamageTag::clear_flinch_mod_large() {
+  _impl_.flinch_mod_large_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline float CCSPredictionEvent_DamageTag::_internal_flinch_mod_large() const {
+  return _impl_.flinch_mod_large_;
+}
+inline float CCSPredictionEvent_DamageTag::flinch_mod_large() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_DamageTag.flinch_mod_large)
+  return _internal_flinch_mod_large();
+}
+inline void CCSPredictionEvent_DamageTag::_internal_set_flinch_mod_large(float value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.flinch_mod_large_ = value;
+}
+inline void CCSPredictionEvent_DamageTag::set_flinch_mod_large(float value) {
+  _internal_set_flinch_mod_large(value);
+  // @@protoc_insertion_point(field_set:CCSPredictionEvent_DamageTag.flinch_mod_large)
+}
+
+// optional float friendly_fire_damage_reduction_ratio = 3;
+inline bool CCSPredictionEvent_DamageTag::_internal_has_friendly_fire_damage_reduction_ratio() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CCSPredictionEvent_DamageTag::has_friendly_fire_damage_reduction_ratio() const {
+  return _internal_has_friendly_fire_damage_reduction_ratio();
+}
+inline void CCSPredictionEvent_DamageTag::clear_friendly_fire_damage_reduction_ratio() {
+  _impl_.friendly_fire_damage_reduction_ratio_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline float CCSPredictionEvent_DamageTag::_internal_friendly_fire_damage_reduction_ratio() const {
+  return _impl_.friendly_fire_damage_reduction_ratio_;
+}
+inline float CCSPredictionEvent_DamageTag::friendly_fire_damage_reduction_ratio() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_DamageTag.friendly_fire_damage_reduction_ratio)
+  return _internal_friendly_fire_damage_reduction_ratio();
+}
+inline void CCSPredictionEvent_DamageTag::_internal_set_friendly_fire_damage_reduction_ratio(float value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.friendly_fire_damage_reduction_ratio_ = value;
+}
+inline void CCSPredictionEvent_DamageTag::set_friendly_fire_damage_reduction_ratio(float value) {
+  _internal_set_friendly_fire_damage_reduction_ratio(value);
+  // @@protoc_insertion_point(field_set:CCSPredictionEvent_DamageTag.friendly_fire_damage_reduction_ratio)
+}
+
+// -------------------------------------------------------------------
+
+// CCSPredictionEvent_AddAimPunch
+
+// optional .CMsgQAngle punch_angle = 1;
+inline bool CCSPredictionEvent_AddAimPunch::_internal_has_punch_angle() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.punch_angle_ != nullptr);
+  return value;
+}
+inline bool CCSPredictionEvent_AddAimPunch::has_punch_angle() const {
+  return _internal_has_punch_angle();
+}
+inline const ::CMsgQAngle& CCSPredictionEvent_AddAimPunch::_internal_punch_angle() const {
+  const ::CMsgQAngle* p = _impl_.punch_angle_;
+  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
+      ::_CMsgQAngle_default_instance_);
+}
+inline const ::CMsgQAngle& CCSPredictionEvent_AddAimPunch::punch_angle() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_AddAimPunch.punch_angle)
+  return _internal_punch_angle();
+}
+inline void CCSPredictionEvent_AddAimPunch::unsafe_arena_set_allocated_punch_angle(
+    ::CMsgQAngle* punch_angle) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.punch_angle_);
+  }
+  _impl_.punch_angle_ = punch_angle;
+  if (punch_angle) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCSPredictionEvent_AddAimPunch.punch_angle)
+}
+inline ::CMsgQAngle* CCSPredictionEvent_AddAimPunch::release_punch_angle() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::CMsgQAngle* temp = _impl_.punch_angle_;
+  _impl_.punch_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* CCSPredictionEvent_AddAimPunch::unsafe_arena_release_punch_angle() {
+  // @@protoc_insertion_point(field_release:CCSPredictionEvent_AddAimPunch.punch_angle)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::CMsgQAngle* temp = _impl_.punch_angle_;
+  _impl_.punch_angle_ = nullptr;
+  return temp;
+}
+inline ::CMsgQAngle* CCSPredictionEvent_AddAimPunch::_internal_mutable_punch_angle() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.punch_angle_ == nullptr) {
+    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
+    _impl_.punch_angle_ = p;
+  }
+  return _impl_.punch_angle_;
+}
+inline ::CMsgQAngle* CCSPredictionEvent_AddAimPunch::mutable_punch_angle() {
+  ::CMsgQAngle* _msg = _internal_mutable_punch_angle();
+  // @@protoc_insertion_point(field_mutable:CCSPredictionEvent_AddAimPunch.punch_angle)
+  return _msg;
+}
+inline void CCSPredictionEvent_AddAimPunch::set_allocated_punch_angle(::CMsgQAngle* punch_angle) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.punch_angle_);
+  }
+  if (punch_angle) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(punch_angle));
+    if (message_arena != submessage_arena) {
+      punch_angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, punch_angle, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.punch_angle_ = punch_angle;
+  // @@protoc_insertion_point(field_set_allocated:CCSPredictionEvent_AddAimPunch.punch_angle)
+}
+
+// optional uint32 when_tick = 2;
+inline bool CCSPredictionEvent_AddAimPunch::_internal_has_when_tick() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CCSPredictionEvent_AddAimPunch::has_when_tick() const {
+  return _internal_has_when_tick();
+}
+inline void CCSPredictionEvent_AddAimPunch::clear_when_tick() {
+  _impl_.when_tick_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t CCSPredictionEvent_AddAimPunch::_internal_when_tick() const {
+  return _impl_.when_tick_;
+}
+inline uint32_t CCSPredictionEvent_AddAimPunch::when_tick() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_AddAimPunch.when_tick)
+  return _internal_when_tick();
+}
+inline void CCSPredictionEvent_AddAimPunch::_internal_set_when_tick(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.when_tick_ = value;
+}
+inline void CCSPredictionEvent_AddAimPunch::set_when_tick(uint32_t value) {
+  _internal_set_when_tick(value);
+  // @@protoc_insertion_point(field_set:CCSPredictionEvent_AddAimPunch.when_tick)
+}
+
+// optional float when_tick_frac = 3;
+inline bool CCSPredictionEvent_AddAimPunch::_internal_has_when_tick_frac() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CCSPredictionEvent_AddAimPunch::has_when_tick_frac() const {
+  return _internal_has_when_tick_frac();
+}
+inline void CCSPredictionEvent_AddAimPunch::clear_when_tick_frac() {
+  _impl_.when_tick_frac_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline float CCSPredictionEvent_AddAimPunch::_internal_when_tick_frac() const {
+  return _impl_.when_tick_frac_;
+}
+inline float CCSPredictionEvent_AddAimPunch::when_tick_frac() const {
+  // @@protoc_insertion_point(field_get:CCSPredictionEvent_AddAimPunch.when_tick_frac)
+  return _internal_when_tick_frac();
+}
+inline void CCSPredictionEvent_AddAimPunch::_internal_set_when_tick_frac(float value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.when_tick_frac_ = value;
+}
+inline void CCSPredictionEvent_AddAimPunch::set_when_tick_frac(float value) {
+  _internal_set_when_tick_frac(value);
+  // @@protoc_insertion_point(field_set:CCSPredictionEvent_AddAimPunch.when_tick_frac)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::ECSPredictionEvents> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::ECSPredictionEvents>() {
+  return ::ECSPredictionEvents_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_cs_5fprediction_5fevents_2eproto

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/engine_gcmessages.pb.cc

@@ -0,0 +1,595 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: engine_gcmessages.proto
+
+#include "engine_gcmessages.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR CEngineGotvSyncPacket::CEngineGotvSyncPacket(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.match_id_)*/uint64_t{0u}
+  , /*decltype(_impl_.instance_id_)*/0u
+  , /*decltype(_impl_.signupfragment_)*/0u
+  , /*decltype(_impl_.currentfragment_)*/0u
+  , /*decltype(_impl_.tickrate_)*/0
+  , /*decltype(_impl_.tick_)*/0u
+  , /*decltype(_impl_.rtdelay_)*/0
+  , /*decltype(_impl_.rcvage_)*/0
+  , /*decltype(_impl_.keyframe_interval_)*/0
+  , /*decltype(_impl_.cdndelay_)*/0u} {}
+struct CEngineGotvSyncPacketDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CEngineGotvSyncPacketDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CEngineGotvSyncPacketDefaultTypeInternal() {}
+  union {
+    CEngineGotvSyncPacket _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CEngineGotvSyncPacketDefaultTypeInternal _CEngineGotvSyncPacket_default_instance_;
+static ::_pb::Metadata file_level_metadata_engine_5fgcmessages_2eproto[1];
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_engine_5fgcmessages_2eproto = nullptr;
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_engine_5fgcmessages_2eproto = nullptr;
+
+const uint32_t TableStruct_engine_5fgcmessages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.match_id_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.instance_id_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.signupfragment_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.currentfragment_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.tickrate_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.tick_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.rtdelay_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.rcvage_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.keyframe_interval_),
+  PROTOBUF_FIELD_OFFSET(::CEngineGotvSyncPacket, _impl_.cdndelay_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 16, -1, sizeof(::CEngineGotvSyncPacket)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_CEngineGotvSyncPacket_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_engine_5fgcmessages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\027engine_gcmessages.proto\032 google/protob"
+  "uf/descriptor.proto\"\335\001\n\025CEngineGotvSyncP"
+  "acket\022\020\n\010match_id\030\001 \001(\004\022\023\n\013instance_id\030\002"
+  " \001(\r\022\026\n\016signupfragment\030\003 \001(\r\022\027\n\017currentf"
+  "ragment\030\004 \001(\r\022\020\n\010tickrate\030\005 \001(\002\022\014\n\004tick\030"
+  "\006 \001(\r\022\017\n\007rtdelay\030\010 \001(\002\022\016\n\006rcvage\030\t \001(\002\022\031"
+  "\n\021keyframe_interval\030\n \001(\002\022\020\n\010cdndelay\030\013 "
+  "\001(\r"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_engine_5fgcmessages_2eproto_deps[1] = {
+  &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_engine_5fgcmessages_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_engine_5fgcmessages_2eproto = {
+    false, false, 283, descriptor_table_protodef_engine_5fgcmessages_2eproto,
+    "engine_gcmessages.proto",
+    &descriptor_table_engine_5fgcmessages_2eproto_once, descriptor_table_engine_5fgcmessages_2eproto_deps, 1, 1,
+    schemas, file_default_instances, TableStruct_engine_5fgcmessages_2eproto::offsets,
+    file_level_metadata_engine_5fgcmessages_2eproto, file_level_enum_descriptors_engine_5fgcmessages_2eproto,
+    file_level_service_descriptors_engine_5fgcmessages_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_engine_5fgcmessages_2eproto_getter() {
+  return &descriptor_table_engine_5fgcmessages_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_engine_5fgcmessages_2eproto(&descriptor_table_engine_5fgcmessages_2eproto);
+
+// ===================================================================
+
+class CEngineGotvSyncPacket::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CEngineGotvSyncPacket>()._impl_._has_bits_);
+  static void set_has_match_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_instance_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_signupfragment(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_currentfragment(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_tickrate(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_tick(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_rtdelay(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_rcvage(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_keyframe_interval(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_cdndelay(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+};
+
+CEngineGotvSyncPacket::CEngineGotvSyncPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CEngineGotvSyncPacket)
+}
+CEngineGotvSyncPacket::CEngineGotvSyncPacket(const CEngineGotvSyncPacket& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CEngineGotvSyncPacket* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.match_id_){}
+    , decltype(_impl_.instance_id_){}
+    , decltype(_impl_.signupfragment_){}
+    , decltype(_impl_.currentfragment_){}
+    , decltype(_impl_.tickrate_){}
+    , decltype(_impl_.tick_){}
+    , decltype(_impl_.rtdelay_){}
+    , decltype(_impl_.rcvage_){}
+    , decltype(_impl_.keyframe_interval_){}
+    , decltype(_impl_.cdndelay_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.match_id_, &from._impl_.match_id_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cdndelay_) -
+    reinterpret_cast<char*>(&_impl_.match_id_)) + sizeof(_impl_.cdndelay_));
+  // @@protoc_insertion_point(copy_constructor:CEngineGotvSyncPacket)
+}
+
+inline void CEngineGotvSyncPacket::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.match_id_){uint64_t{0u}}
+    , decltype(_impl_.instance_id_){0u}
+    , decltype(_impl_.signupfragment_){0u}
+    , decltype(_impl_.currentfragment_){0u}
+    , decltype(_impl_.tickrate_){0}
+    , decltype(_impl_.tick_){0u}
+    , decltype(_impl_.rtdelay_){0}
+    , decltype(_impl_.rcvage_){0}
+    , decltype(_impl_.keyframe_interval_){0}
+    , decltype(_impl_.cdndelay_){0u}
+  };
+}
+
+CEngineGotvSyncPacket::~CEngineGotvSyncPacket() {
+  // @@protoc_insertion_point(destructor:CEngineGotvSyncPacket)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CEngineGotvSyncPacket::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void CEngineGotvSyncPacket::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CEngineGotvSyncPacket::Clear() {
+// @@protoc_insertion_point(message_clear_start:CEngineGotvSyncPacket)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    ::memset(&_impl_.match_id_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.rcvage_) -
+        reinterpret_cast<char*>(&_impl_.match_id_)) + sizeof(_impl_.rcvage_));
+  }
+  if (cached_has_bits & 0x00000300u) {
+    ::memset(&_impl_.keyframe_interval_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.cdndelay_) -
+        reinterpret_cast<char*>(&_impl_.keyframe_interval_)) + sizeof(_impl_.cdndelay_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CEngineGotvSyncPacket::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 match_id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_match_id(&has_bits);
+          _impl_.match_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 instance_id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_instance_id(&has_bits);
+          _impl_.instance_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 signupfragment = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_signupfragment(&has_bits);
+          _impl_.signupfragment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 currentfragment = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_currentfragment(&has_bits);
+          _impl_.currentfragment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float tickrate = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 45)) {
+          _Internal::set_has_tickrate(&has_bits);
+          _impl_.tickrate_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 tick = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_tick(&has_bits);
+          _impl_.tick_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float rtdelay = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
+          _Internal::set_has_rtdelay(&has_bits);
+          _impl_.rtdelay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float rcvage = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 77)) {
+          _Internal::set_has_rcvage(&has_bits);
+          _impl_.rcvage_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional float keyframe_interval = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 85)) {
+          _Internal::set_has_keyframe_interval(&has_bits);
+          _impl_.keyframe_interval_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 cdndelay = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_cdndelay(&has_bits);
+          _impl_.cdndelay_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CEngineGotvSyncPacket::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CEngineGotvSyncPacket)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 match_id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_match_id(), target);
+  }
+
+  // optional uint32 instance_id = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_instance_id(), target);
+  }
+
+  // optional uint32 signupfragment = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_signupfragment(), target);
+  }
+
+  // optional uint32 currentfragment = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_currentfragment(), target);
+  }
+
+  // optional float tickrate = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(5, this->_internal_tickrate(), target);
+  }
+
+  // optional uint32 tick = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_tick(), target);
+  }
+
+  // optional float rtdelay = 8;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(8, this->_internal_rtdelay(), target);
+  }
+
+  // optional float rcvage = 9;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(9, this->_internal_rcvage(), target);
+  }
+
+  // optional float keyframe_interval = 10;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(10, this->_internal_keyframe_interval(), target);
+  }
+
+  // optional uint32 cdndelay = 11;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_cdndelay(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CEngineGotvSyncPacket)
+  return target;
+}
+
+size_t CEngineGotvSyncPacket::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CEngineGotvSyncPacket)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional uint64 match_id = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_match_id());
+    }
+
+    // optional uint32 instance_id = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_instance_id());
+    }
+
+    // optional uint32 signupfragment = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_signupfragment());
+    }
+
+    // optional uint32 currentfragment = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentfragment());
+    }
+
+    // optional float tickrate = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 tick = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tick());
+    }
+
+    // optional float rtdelay = 8;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 4;
+    }
+
+    // optional float rcvage = 9;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (cached_has_bits & 0x00000300u) {
+    // optional float keyframe_interval = 10;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 cdndelay = 11;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cdndelay());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CEngineGotvSyncPacket::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CEngineGotvSyncPacket::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CEngineGotvSyncPacket::GetClassData() const { return &_class_data_; }
+
+
+void CEngineGotvSyncPacket::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CEngineGotvSyncPacket*>(&to_msg);
+  auto& from = static_cast<const CEngineGotvSyncPacket&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CEngineGotvSyncPacket)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.match_id_ = from._impl_.match_id_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.instance_id_ = from._impl_.instance_id_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.signupfragment_ = from._impl_.signupfragment_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.currentfragment_ = from._impl_.currentfragment_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.tickrate_ = from._impl_.tickrate_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.tick_ = from._impl_.tick_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.rtdelay_ = from._impl_.rtdelay_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.rcvage_ = from._impl_.rcvage_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000300u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.keyframe_interval_ = from._impl_.keyframe_interval_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.cdndelay_ = from._impl_.cdndelay_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CEngineGotvSyncPacket::CopyFrom(const CEngineGotvSyncPacket& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CEngineGotvSyncPacket)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CEngineGotvSyncPacket::IsInitialized() const {
+  return true;
+}
+
+void CEngineGotvSyncPacket::InternalSwap(CEngineGotvSyncPacket* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CEngineGotvSyncPacket, _impl_.cdndelay_)
+      + sizeof(CEngineGotvSyncPacket::_impl_.cdndelay_)
+      - PROTOBUF_FIELD_OFFSET(CEngineGotvSyncPacket, _impl_.match_id_)>(
+          reinterpret_cast<char*>(&_impl_.match_id_),
+          reinterpret_cast<char*>(&other->_impl_.match_id_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CEngineGotvSyncPacket::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_engine_5fgcmessages_2eproto_getter, &descriptor_table_engine_5fgcmessages_2eproto_once,
+      file_level_metadata_engine_5fgcmessages_2eproto[0]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::CEngineGotvSyncPacket*
+Arena::CreateMaybeMessage< ::CEngineGotvSyncPacket >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CEngineGotvSyncPacket >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/engine_gcmessages.pb.h

@@ -0,0 +1,651 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: engine_gcmessages.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_engine_5fgcmessages_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_engine_5fgcmessages_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021008 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_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/unknown_field_set.h>
+#include <google/protobuf/descriptor.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_engine_5fgcmessages_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_engine_5fgcmessages_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_engine_5fgcmessages_2eproto;
+class CEngineGotvSyncPacket;
+struct CEngineGotvSyncPacketDefaultTypeInternal;
+extern CEngineGotvSyncPacketDefaultTypeInternal _CEngineGotvSyncPacket_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::CEngineGotvSyncPacket* Arena::CreateMaybeMessage<::CEngineGotvSyncPacket>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+// ===================================================================
+
+class CEngineGotvSyncPacket final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CEngineGotvSyncPacket) */ {
+ public:
+  inline CEngineGotvSyncPacket() : CEngineGotvSyncPacket(nullptr) {}
+  ~CEngineGotvSyncPacket() override;
+  explicit PROTOBUF_CONSTEXPR CEngineGotvSyncPacket(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CEngineGotvSyncPacket(const CEngineGotvSyncPacket& from);
+  CEngineGotvSyncPacket(CEngineGotvSyncPacket&& from) noexcept
+    : CEngineGotvSyncPacket() {
+    *this = ::std::move(from);
+  }
+
+  inline CEngineGotvSyncPacket& operator=(const CEngineGotvSyncPacket& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CEngineGotvSyncPacket& operator=(CEngineGotvSyncPacket&& 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 CEngineGotvSyncPacket& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CEngineGotvSyncPacket* internal_default_instance() {
+    return reinterpret_cast<const CEngineGotvSyncPacket*>(
+               &_CEngineGotvSyncPacket_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CEngineGotvSyncPacket& a, CEngineGotvSyncPacket& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CEngineGotvSyncPacket* 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(CEngineGotvSyncPacket* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CEngineGotvSyncPacket* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CEngineGotvSyncPacket>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CEngineGotvSyncPacket& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CEngineGotvSyncPacket& from) {
+    CEngineGotvSyncPacket::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(CEngineGotvSyncPacket* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CEngineGotvSyncPacket";
+  }
+  protected:
+  explicit CEngineGotvSyncPacket(::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 {
+    kMatchIdFieldNumber = 1,
+    kInstanceIdFieldNumber = 2,
+    kSignupfragmentFieldNumber = 3,
+    kCurrentfragmentFieldNumber = 4,
+    kTickrateFieldNumber = 5,
+    kTickFieldNumber = 6,
+    kRtdelayFieldNumber = 8,
+    kRcvageFieldNumber = 9,
+    kKeyframeIntervalFieldNumber = 10,
+    kCdndelayFieldNumber = 11,
+  };
+  // optional uint64 match_id = 1;
+  bool has_match_id() const;
+  private:
+  bool _internal_has_match_id() const;
+  public:
+  void clear_match_id();
+  uint64_t match_id() const;
+  void set_match_id(uint64_t value);
+  private:
+  uint64_t _internal_match_id() const;
+  void _internal_set_match_id(uint64_t value);
+  public:
+
+  // optional uint32 instance_id = 2;
+  bool has_instance_id() const;
+  private:
+  bool _internal_has_instance_id() const;
+  public:
+  void clear_instance_id();
+  uint32_t instance_id() const;
+  void set_instance_id(uint32_t value);
+  private:
+  uint32_t _internal_instance_id() const;
+  void _internal_set_instance_id(uint32_t value);
+  public:
+
+  // optional uint32 signupfragment = 3;
+  bool has_signupfragment() const;
+  private:
+  bool _internal_has_signupfragment() const;
+  public:
+  void clear_signupfragment();
+  uint32_t signupfragment() const;
+  void set_signupfragment(uint32_t value);
+  private:
+  uint32_t _internal_signupfragment() const;
+  void _internal_set_signupfragment(uint32_t value);
+  public:
+
+  // optional uint32 currentfragment = 4;
+  bool has_currentfragment() const;
+  private:
+  bool _internal_has_currentfragment() const;
+  public:
+  void clear_currentfragment();
+  uint32_t currentfragment() const;
+  void set_currentfragment(uint32_t value);
+  private:
+  uint32_t _internal_currentfragment() const;
+  void _internal_set_currentfragment(uint32_t value);
+  public:
+
+  // optional float tickrate = 5;
+  bool has_tickrate() const;
+  private:
+  bool _internal_has_tickrate() const;
+  public:
+  void clear_tickrate();
+  float tickrate() const;
+  void set_tickrate(float value);
+  private:
+  float _internal_tickrate() const;
+  void _internal_set_tickrate(float value);
+  public:
+
+  // optional uint32 tick = 6;
+  bool has_tick() const;
+  private:
+  bool _internal_has_tick() const;
+  public:
+  void clear_tick();
+  uint32_t tick() const;
+  void set_tick(uint32_t value);
+  private:
+  uint32_t _internal_tick() const;
+  void _internal_set_tick(uint32_t value);
+  public:
+
+  // optional float rtdelay = 8;
+  bool has_rtdelay() const;
+  private:
+  bool _internal_has_rtdelay() const;
+  public:
+  void clear_rtdelay();
+  float rtdelay() const;
+  void set_rtdelay(float value);
+  private:
+  float _internal_rtdelay() const;
+  void _internal_set_rtdelay(float value);
+  public:
+
+  // optional float rcvage = 9;
+  bool has_rcvage() const;
+  private:
+  bool _internal_has_rcvage() const;
+  public:
+  void clear_rcvage();
+  float rcvage() const;
+  void set_rcvage(float value);
+  private:
+  float _internal_rcvage() const;
+  void _internal_set_rcvage(float value);
+  public:
+
+  // optional float keyframe_interval = 10;
+  bool has_keyframe_interval() const;
+  private:
+  bool _internal_has_keyframe_interval() const;
+  public:
+  void clear_keyframe_interval();
+  float keyframe_interval() const;
+  void set_keyframe_interval(float value);
+  private:
+  float _internal_keyframe_interval() const;
+  void _internal_set_keyframe_interval(float value);
+  public:
+
+  // optional uint32 cdndelay = 11;
+  bool has_cdndelay() const;
+  private:
+  bool _internal_has_cdndelay() const;
+  public:
+  void clear_cdndelay();
+  uint32_t cdndelay() const;
+  void set_cdndelay(uint32_t value);
+  private:
+  uint32_t _internal_cdndelay() const;
+  void _internal_set_cdndelay(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CEngineGotvSyncPacket)
+ 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 match_id_;
+    uint32_t instance_id_;
+    uint32_t signupfragment_;
+    uint32_t currentfragment_;
+    float tickrate_;
+    uint32_t tick_;
+    float rtdelay_;
+    float rcvage_;
+    float keyframe_interval_;
+    uint32_t cdndelay_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_engine_5fgcmessages_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CEngineGotvSyncPacket
+
+// optional uint64 match_id = 1;
+inline bool CEngineGotvSyncPacket::_internal_has_match_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_match_id() const {
+  return _internal_has_match_id();
+}
+inline void CEngineGotvSyncPacket::clear_match_id() {
+  _impl_.match_id_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t CEngineGotvSyncPacket::_internal_match_id() const {
+  return _impl_.match_id_;
+}
+inline uint64_t CEngineGotvSyncPacket::match_id() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.match_id)
+  return _internal_match_id();
+}
+inline void CEngineGotvSyncPacket::_internal_set_match_id(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.match_id_ = value;
+}
+inline void CEngineGotvSyncPacket::set_match_id(uint64_t value) {
+  _internal_set_match_id(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.match_id)
+}
+
+// optional uint32 instance_id = 2;
+inline bool CEngineGotvSyncPacket::_internal_has_instance_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_instance_id() const {
+  return _internal_has_instance_id();
+}
+inline void CEngineGotvSyncPacket::clear_instance_id() {
+  _impl_.instance_id_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t CEngineGotvSyncPacket::_internal_instance_id() const {
+  return _impl_.instance_id_;
+}
+inline uint32_t CEngineGotvSyncPacket::instance_id() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.instance_id)
+  return _internal_instance_id();
+}
+inline void CEngineGotvSyncPacket::_internal_set_instance_id(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.instance_id_ = value;
+}
+inline void CEngineGotvSyncPacket::set_instance_id(uint32_t value) {
+  _internal_set_instance_id(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.instance_id)
+}
+
+// optional uint32 signupfragment = 3;
+inline bool CEngineGotvSyncPacket::_internal_has_signupfragment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_signupfragment() const {
+  return _internal_has_signupfragment();
+}
+inline void CEngineGotvSyncPacket::clear_signupfragment() {
+  _impl_.signupfragment_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t CEngineGotvSyncPacket::_internal_signupfragment() const {
+  return _impl_.signupfragment_;
+}
+inline uint32_t CEngineGotvSyncPacket::signupfragment() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.signupfragment)
+  return _internal_signupfragment();
+}
+inline void CEngineGotvSyncPacket::_internal_set_signupfragment(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.signupfragment_ = value;
+}
+inline void CEngineGotvSyncPacket::set_signupfragment(uint32_t value) {
+  _internal_set_signupfragment(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.signupfragment)
+}
+
+// optional uint32 currentfragment = 4;
+inline bool CEngineGotvSyncPacket::_internal_has_currentfragment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_currentfragment() const {
+  return _internal_has_currentfragment();
+}
+inline void CEngineGotvSyncPacket::clear_currentfragment() {
+  _impl_.currentfragment_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t CEngineGotvSyncPacket::_internal_currentfragment() const {
+  return _impl_.currentfragment_;
+}
+inline uint32_t CEngineGotvSyncPacket::currentfragment() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.currentfragment)
+  return _internal_currentfragment();
+}
+inline void CEngineGotvSyncPacket::_internal_set_currentfragment(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.currentfragment_ = value;
+}
+inline void CEngineGotvSyncPacket::set_currentfragment(uint32_t value) {
+  _internal_set_currentfragment(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.currentfragment)
+}
+
+// optional float tickrate = 5;
+inline bool CEngineGotvSyncPacket::_internal_has_tickrate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_tickrate() const {
+  return _internal_has_tickrate();
+}
+inline void CEngineGotvSyncPacket::clear_tickrate() {
+  _impl_.tickrate_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline float CEngineGotvSyncPacket::_internal_tickrate() const {
+  return _impl_.tickrate_;
+}
+inline float CEngineGotvSyncPacket::tickrate() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.tickrate)
+  return _internal_tickrate();
+}
+inline void CEngineGotvSyncPacket::_internal_set_tickrate(float value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.tickrate_ = value;
+}
+inline void CEngineGotvSyncPacket::set_tickrate(float value) {
+  _internal_set_tickrate(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.tickrate)
+}
+
+// optional uint32 tick = 6;
+inline bool CEngineGotvSyncPacket::_internal_has_tick() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_tick() const {
+  return _internal_has_tick();
+}
+inline void CEngineGotvSyncPacket::clear_tick() {
+  _impl_.tick_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline uint32_t CEngineGotvSyncPacket::_internal_tick() const {
+  return _impl_.tick_;
+}
+inline uint32_t CEngineGotvSyncPacket::tick() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.tick)
+  return _internal_tick();
+}
+inline void CEngineGotvSyncPacket::_internal_set_tick(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.tick_ = value;
+}
+inline void CEngineGotvSyncPacket::set_tick(uint32_t value) {
+  _internal_set_tick(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.tick)
+}
+
+// optional float rtdelay = 8;
+inline bool CEngineGotvSyncPacket::_internal_has_rtdelay() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_rtdelay() const {
+  return _internal_has_rtdelay();
+}
+inline void CEngineGotvSyncPacket::clear_rtdelay() {
+  _impl_.rtdelay_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline float CEngineGotvSyncPacket::_internal_rtdelay() const {
+  return _impl_.rtdelay_;
+}
+inline float CEngineGotvSyncPacket::rtdelay() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.rtdelay)
+  return _internal_rtdelay();
+}
+inline void CEngineGotvSyncPacket::_internal_set_rtdelay(float value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.rtdelay_ = value;
+}
+inline void CEngineGotvSyncPacket::set_rtdelay(float value) {
+  _internal_set_rtdelay(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.rtdelay)
+}
+
+// optional float rcvage = 9;
+inline bool CEngineGotvSyncPacket::_internal_has_rcvage() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_rcvage() const {
+  return _internal_has_rcvage();
+}
+inline void CEngineGotvSyncPacket::clear_rcvage() {
+  _impl_.rcvage_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline float CEngineGotvSyncPacket::_internal_rcvage() const {
+  return _impl_.rcvage_;
+}
+inline float CEngineGotvSyncPacket::rcvage() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.rcvage)
+  return _internal_rcvage();
+}
+inline void CEngineGotvSyncPacket::_internal_set_rcvage(float value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.rcvage_ = value;
+}
+inline void CEngineGotvSyncPacket::set_rcvage(float value) {
+  _internal_set_rcvage(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.rcvage)
+}
+
+// optional float keyframe_interval = 10;
+inline bool CEngineGotvSyncPacket::_internal_has_keyframe_interval() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_keyframe_interval() const {
+  return _internal_has_keyframe_interval();
+}
+inline void CEngineGotvSyncPacket::clear_keyframe_interval() {
+  _impl_.keyframe_interval_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline float CEngineGotvSyncPacket::_internal_keyframe_interval() const {
+  return _impl_.keyframe_interval_;
+}
+inline float CEngineGotvSyncPacket::keyframe_interval() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.keyframe_interval)
+  return _internal_keyframe_interval();
+}
+inline void CEngineGotvSyncPacket::_internal_set_keyframe_interval(float value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.keyframe_interval_ = value;
+}
+inline void CEngineGotvSyncPacket::set_keyframe_interval(float value) {
+  _internal_set_keyframe_interval(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.keyframe_interval)
+}
+
+// optional uint32 cdndelay = 11;
+inline bool CEngineGotvSyncPacket::_internal_has_cdndelay() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool CEngineGotvSyncPacket::has_cdndelay() const {
+  return _internal_has_cdndelay();
+}
+inline void CEngineGotvSyncPacket::clear_cdndelay() {
+  _impl_.cdndelay_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline uint32_t CEngineGotvSyncPacket::_internal_cdndelay() const {
+  return _impl_.cdndelay_;
+}
+inline uint32_t CEngineGotvSyncPacket::cdndelay() const {
+  // @@protoc_insertion_point(field_get:CEngineGotvSyncPacket.cdndelay)
+  return _internal_cdndelay();
+}
+inline void CEngineGotvSyncPacket::_internal_set_cdndelay(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.cdndelay_ = value;
+}
+inline void CEngineGotvSyncPacket::set_cdndelay(uint32_t value) {
+  _internal_set_cdndelay(value);
+  // @@protoc_insertion_point(field_set:CEngineGotvSyncPacket.cdndelay)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_engine_5fgcmessages_2eproto

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/network_connection.pb.cc

@@ -0,0 +1,454 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: network_connection.proto
+
+#include "network_connection.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+static const ::_pb::EnumDescriptor* file_level_enum_descriptors_network_5fconnection_2eproto[1];
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_network_5fconnection_2eproto = nullptr;
+const uint32_t TableStruct_network_5fconnection_2eproto::offsets[1] = {};
+static constexpr ::_pbi::MigrationSchema* schemas = nullptr;
+static constexpr ::_pb::Message* const* file_default_instances = nullptr;
+
+const char descriptor_table_protodef_network_5fconnection_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\030network_connection.proto\032 google/proto"
+  "buf/descriptor.proto*\260M\n\033ENetworkDisconn"
+  "ectionReason\022\036\n\032NETWORK_DISCONNECT_INVAL"
+  "ID\020\000\022\037\n\033NETWORK_DISCONNECT_SHUTDOWN\020\001\022F\n"
+  "%NETWORK_DISCONNECT_DISCONNECT_BY_USER\020\002"
+  "\032\033\242\324\030\027#GameUI_Disconnect_User\022J\n\'NETWORK"
+  "_DISCONNECT_DISCONNECT_BY_SERVER\020\003\032\035\242\324\030\031"
+  "#GameUI_Disconnect_Server\022B\n\027NETWORK_DIS"
+  "CONNECT_LOST\020\004\032%\242\324\030!#GameUI_Disconnect_C"
+  "onnectionLost\022J\n\033NETWORK_DISCONNECT_OVER"
+  "FLOW\020\005\032)\242\324\030%#GameUI_Disconnect_Connectio"
+  "nOverflow\022I\n\037NETWORK_DISCONNECT_STEAM_BA"
+  "NNED\020\006\032$\242\324\030 #GameUI_Disconnect_SteamIDBa"
+  "nned\022G\n\036NETWORK_DISCONNECT_STEAM_INUSE\020\007"
+  "\032#\242\324\030\037#GameUI_Disconnect_SteamIDInUse\022G\n"
+  "\037NETWORK_DISCONNECT_STEAM_TICKET\020\010\032\"\242\324\030\036"
+  "#GameUI_Disconnect_SteamTicket\022E\n\036NETWOR"
+  "K_DISCONNECT_STEAM_LOGON\020\t\032!\242\324\030\035#GameUI_"
+  "Disconnect_SteamLogon\022M\n&NETWORK_DISCONN"
+  "ECT_STEAM_AUTHCANCELLED\020\n\032!\242\324\030\035#GameUI_D"
+  "isconnect_SteamLogon\022O\n(NETWORK_DISCONNE"
+  "CT_STEAM_AUTHALREADYUSED\020\013\032!\242\324\030\035#GameUI_"
+  "Disconnect_SteamLogon\022K\n$NETWORK_DISCONN"
+  "ECT_STEAM_AUTHINVALID\020\014\032!\242\324\030\035#GameUI_Dis"
+  "connect_SteamLogon\022M\n$NETWORK_DISCONNECT"
+  "_STEAM_VACBANSTATE\020\r\032#\242\324\030\033#GameUI_Discon"
+  "nect_SteamVAC\260\324\030\000\022S\n,NETWORK_DISCONNECT_"
+  "STEAM_LOGGED_IN_ELSEWHERE\020\016\032!\242\324\030\035#GameUI"
+  "_Disconnect_SteamInUse\022T\n+NETWORK_DISCON"
+  "NECT_STEAM_VAC_CHECK_TIMEDOUT\020\017\032#\242\324\030\037#Ga"
+  "meUI_Disconnect_SteamTimeOut\022I\n NETWORK_"
+  "DISCONNECT_STEAM_DROPPED\020\020\032#\242\324\030\037#GameUI_"
+  "Disconnect_SteamDropped\022M\n\"NETWORK_DISCO"
+  "NNECT_STEAM_OWNERSHIP\020\021\032%\242\324\030!#GameUI_Dis"
+  "connect_SteamOwnership\022U\n&NETWORK_DISCON"
+  "NECT_SERVERINFO_OVERFLOW\020\022\032)\242\324\030%#GameUI_"
+  "Disconnect_ServerInfoOverflow\022K\n#NETWORK"
+  "_DISCONNECT_TICKMSG_OVERFLOW\020\023\032\"\242\324\030\036#Gam"
+  "eUI_Disconnect_TickMessage\022Y\n*NETWORK_DI"
+  "SCONNECT_STRINGTABLEMSG_OVERFLOW\020\024\032)\242\324\030%"
+  "#GameUI_Disconnect_StringTableMessage\022S\n"
+  "\'NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW"
+  "\020\025\032&\242\324\030\"#GameUI_Disconnect_DeltaEntMessa"
+  "ge\022Q\n&NETWORK_DISCONNECT_TEMPENTMSG_OVER"
+  "FLOW\020\026\032%\242\324\030!#GameUI_Disconnect_TempEntMe"
+  "ssage\022O\n%NETWORK_DISCONNECT_SOUNDSMSG_OV"
+  "ERFLOW\020\027\032$\242\324\030 #GameUI_Disconnect_SoundsM"
+  "essage\022P\n#NETWORK_DISCONNECT_SNAPSHOTOVE"
+  "RFLOW\020\030\032\'\242\324\030##GameUI_Disconnect_Snapshot"
+  "Overflow\022J\n NETWORK_DISCONNECT_SNAPSHOTE"
+  "RROR\020\031\032$\242\324\030 #GameUI_Disconnect_SnapshotE"
+  "rror\022P\n#NETWORK_DISCONNECT_RELIABLEOVERF"
+  "LOW\020\032\032\'\242\324\030##GameUI_Disconnect_ReliableOv"
+  "erflow\022N\n\037NETWORK_DISCONNECT_BADDELTATIC"
+  "K\020\033\032)\242\324\030%#GameUI_Disconnect_BadClientDel"
+  "taTick\022H\n\037NETWORK_DISCONNECT_NOMORESPLIT"
+  "S\020\034\032#\242\324\030\037#GameUI_Disconnect_NoMoreSplits"
+  "\022@\n\033NETWORK_DISCONNECT_TIMEDOUT\020\035\032\037\242\324\030\033#"
+  "GameUI_Disconnect_TimedOut\022H\n\037NETWORK_DI"
+  "SCONNECT_DISCONNECTED\020\036\032#\242\324\030\037#GameUI_Dis"
+  "connect_Disconnected\022H\n\037NETWORK_DISCONNE"
+  "CT_LEAVINGSPLIT\020\037\032#\242\324\030\037#GameUI_Disconnec"
+  "t_LeavingSplit\022X\n\'NETWORK_DISCONNECT_DIF"
+  "FERENTCLASSTABLES\020 \032+\242\324\030\'#GameUI_Disconn"
+  "ect_DifferentClassTables\022P\n#NETWORK_DISC"
+  "ONNECT_BADRELAYPASSWORD\020!\032\'\242\324\030##GameUI_D"
+  "isconnect_BadRelayPassword\022X\n\'NETWORK_DI"
+  "SCONNECT_BADSPECTATORPASSWORD\020\"\032+\242\324\030\'#Ga"
+  "meUI_Disconnect_BadSpectatorPassword\022L\n!"
+  "NETWORK_DISCONNECT_HLTVRESTRICTED\020#\032%\242\324\030"
+  "!#GameUI_Disconnect_HLTVRestricted\022H\n\037NE"
+  "TWORK_DISCONNECT_NOSPECTATORS\020$\032#\242\324\030\037#Ga"
+  "meUI_Disconnect_NoSpectators\022N\n\"NETWORK_"
+  "DISCONNECT_HLTVUNAVAILABLE\020%\032&\242\324\030\"#GameU"
+  "I_Disconnect_HLTVUnavailable\022@\n\033NETWORK_"
+  "DISCONNECT_HLTVSTOP\020&\032\037\242\324\030\033#GameUI_Disco"
+  "nnect_HLTVStop\022<\n\031NETWORK_DISCONNECT_KIC"
+  "KED\020\'\032\035\242\324\030\031#GameUI_Disconnect_Kicked\022@\n\033"
+  "NETWORK_DISCONNECT_BANADDED\020(\032\037\242\324\030\033#Game"
+  "UI_Disconnect_BanAdded\022H\n\037NETWORK_DISCON"
+  "NECT_KICKBANADDED\020)\032#\242\324\030\037#GameUI_Disconn"
+  "ect_KickBanAdded\022D\n\035NETWORK_DISCONNECT_H"
+  "LTVDIRECT\020*\032!\242\324\030\035#GameUI_Disconnect_HLTV"
+  "Direct\022\\\n)NETWORK_DISCONNECT_PURESERVER_"
+  "CLIENTEXTRA\020+\032-\242\324\030)#GameUI_Disconnect_Pu"
+  "reServer_ClientExtra\022V\n&NETWORK_DISCONNE"
+  "CT_PURESERVER_MISMATCH\020,\032*\242\324\030&#GameUI_Di"
+  "sconnect_PureServer_Mismatch\022>\n\032NETWORK_"
+  "DISCONNECT_USERCMD\020-\032\036\242\324\030\032#GameUI_Discon"
+  "nect_UserCmd\022N\n#NETWORK_DISCONNECT_REJEC"
+  "TED_BY_GAME\020.\032%\242\324\030!#GameUI_Disconnect_Re"
+  "jectedByGame\022T\n&NETWORK_DISCONNECT_MESSA"
+  "GE_PARSE_ERROR\020/\032(\242\324\030$#GameUI_Disconnect"
+  "_MessageParseError\022X\n(NETWORK_DISCONNECT"
+  "_INVALID_MESSAGE_ERROR\0200\032*\242\324\030&#GameUI_Di"
+  "sconnect_InvalidMessageError\022T\n&NETWORK_"
+  "DISCONNECT_BAD_SERVER_PASSWORD\0201\032(\242\324\030$#G"
+  "ameUI_Disconnect_BadServerPassword\0221\n-NE"
+  "TWORK_DISCONNECT_DIRECT_CONNECT_RESERVAT"
+  "ION\0202\022S\n%NETWORK_DISCONNECT_CONNECTION_F"
+  "AILURE\0203\032(\242\324\030$#GameUI_Disconnect_Connect"
+  "ionFailure\022Y\n)NETWORK_DISCONNECT_NO_PEER"
+  "_GROUP_HANDLERS\0204\032*\242\324\030&#GameUI_Disconnec"
+  "t_NoPeerGroupHandlers\022#\n\037NETWORK_DISCONN"
+  "ECT_RECONNECTION\0205\022H\n\037NETWORK_DISCONNECT"
+  "_LOOPSHUTDOWN\0206\032#\242\324\030\037#GameUI_Disconnect_"
+  "LoopShutdown\022L\n!NETWORK_DISCONNECT_LOOPD"
+  "EACTIVATE\0207\032%\242\324\030!#GameUI_Disconnect_Loop"
+  "Deactivate\022H\n\037NETWORK_DISCONNECT_HOST_EN"
+  "DGAME\0208\032#\242\324\030\037#GameUI_Disconnect_Host_End"
+  "Game\022\\\n*NETWORK_DISCONNECT_LOOP_LEVELLOA"
+  "D_ACTIVATE\0209\032,\242\324\030(#GameUI_Disconnect_Loo"
+  "pLevelLoadActivate\022V\n\'NETWORK_DISCONNECT"
+  "_CREATE_SERVER_FAILED\020:\032)\242\324\030%#GameUI_Dis"
+  "connect_CreateServerFailed\022D\n\032NETWORK_DI"
+  "SCONNECT_EXITING\020;\032$\242\324\030 #GameUI_Disconne"
+  "ct_ExitingEngine\022T\n)NETWORK_DISCONNECT_R"
+  "EQUEST_HOSTSTATE_IDLE\020<\032%\242\324\030!#GameUI_Dis"
+  "connect_Request_HSIdle\022\\\n.NETWORK_DISCON"
+  "NECT_REQUEST_HOSTSTATE_HLTVRELAY\020=\032(\242\324\030$"
+  "#GameUI_Disconnect_Request_HLTVRelay\022Q\n*"
+  "NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FA"
+  "IL\020>\032!\242\324\030\035#GameUI_ClientConsistencyFail\022"
+  "Q\n+NETWORK_DISCONNECT_CLIENT_UNABLE_TO_C"
+  "RC_MAP\020\?\032 \242\324\030\034#GameUI_ClientUnableToCRCM"
+  "ap\022=\n NETWORK_DISCONNECT_CLIENT_NO_MAP\020@"
+  "\032\027\242\324\030\023#GameUI_ClientNoMap\022K\n\'NETWORK_DIS"
+  "CONNECT_CLIENT_DIFFERENT_MAP\020A\032\036\242\324\030\032#Gam"
+  "eUI_ClientDifferentMap\022M\n(NETWORK_DISCON"
+  "NECT_SERVER_REQUIRES_STEAM\020B\032\037\242\324\030\033#GameU"
+  "I_ServerRequireSteams\022M\n\"NETWORK_DISCONN"
+  "ECT_STEAM_DENY_MISC\020C\032%\242\324\030!#GameUI_Disco"
+  "nnect_SteamDeny_Misc\022_\n,NETWORK_DISCONNE"
+  "CT_STEAM_DENY_BAD_ANTI_CHEAT\020D\032-\242\324\030)#Gam"
+  "eUI_Disconnect_SteamDeny_BadAntiCheat\022M\n"
+  "\"NETWORK_DISCONNECT_SERVER_SHUTDOWN\020E\032%\242"
+  "\324\030!#GameUI_Disconnect_ServerShutdown\022U\n&"
+  "NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE\020G"
+  "\032)\242\324\030%#GameUI_Disconnect_ReplayIncompati"
+  "ble\022Z\n+NETWORK_DISCONNECT_CONNECT_REQUES"
+  "T_TIMEDOUT\020H\032)\242\324\030%#GameUI_Disconnect_Con"
+  "nectionTimedout\022U\n&NETWORK_DISCONNECT_SE"
+  "RVER_INCOMPATIBLE\020I\032)\242\324\030%#GameUI_Disconn"
+  "ect_ServerIncompatible\022^\n*NETWORK_DISCON"
+  "NECT_LOCALPROBLEM_MANYRELAYS\020J\032.\242\324\030*#Gam"
+  "eUI_Disconnect_LocalProblem_ManyRelays\022z"
+  "\n8NETWORK_DISCONNECT_LOCALPROBLEM_HOSTED"
+  "SERVERPRIMARYRELAY\020K\032<\242\324\0308#GameUI_Discon"
+  "nect_LocalProblem_HostedServerPrimaryRel"
+  "ay\022d\n-NETWORK_DISCONNECT_LOCALPROBLEM_NE"
+  "TWORKCONFIG\020L\0321\242\324\030-#GameUI_Disconnect_Lo"
+  "calProblem_NetworkConfig\022T\n%NETWORK_DISC"
+  "ONNECT_LOCALPROBLEM_OTHER\020M\032)\242\324\030%#GameUI"
+  "_Disconnect_LocalProblem_Other\022S\n!NETWOR"
+  "K_DISCONNECT_REMOTE_TIMEOUT\020O\032,\242\324\030(#Game"
+  "UI_Disconnect_RemoteProblem_Timeout\022h\n,N"
+  "ETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECT"
+  "ING\020P\0326\242\324\0302#GameUI_Disconnect_RemoteProb"
+  "lem_TimeoutConnecting\022O\n\037NETWORK_DISCONN"
+  "ECT_REMOTE_OTHER\020Q\032*\242\324\030&#GameUI_Disconne"
+  "ct_RemoteProblem_Other\022U\n\"NETWORK_DISCON"
+  "NECT_REMOTE_BADCRYPT\020R\032-\242\324\030)#GameUI_Disc"
+  "onnect_RemoteProblem_BadCrypt\022Z\n(NETWORK"
+  "_DISCONNECT_REMOTE_CERTNOTTRUSTED\020S\032,\242\324\030"
+  "(#GameUI_Disconnect_RemoteProblem_BadCer"
+  "t\022>\n\032NETWORK_DISCONNECT_UNUSUAL\020T\032\036\242\324\030\032#"
+  "GameUI_Disconnect_Unusual\022K\n!NETWORK_DIS"
+  "CONNECT_INTERNAL_ERROR\020U\032$\242\324\030 #GameUI_Di"
+  "sconnect_InternalError\022Q\n&NETWORK_DISCON"
+  "NECT_REJECT_BADCHALLENGE\020\200\001\032$\242\324\030 #GameUI"
+  "_ServerRejectBadChallenge\022A\n!NETWORK_DIS"
+  "CONNECT_REJECT_NOLOBBY\020\201\001\032\031\242\324\030\025#GameUI_S"
+  "erverNoLobby\022O\n(NETWORK_DISCONNECT_REJEC"
+  "T_BACKGROUND_MAP\020\202\001\032 \242\324\030\034#Valve_Reject_B"
+  "ackground_Map\022M\n\'NETWORK_DISCONNECT_REJE"
+  "CT_SINGLE_PLAYER\020\203\001\032\037\242\324\030\033#Valve_Reject_S"
+  "ingle_Player\022I\n%NETWORK_DISCONNECT_REJEC"
+  "T_HIDDEN_GAME\020\204\001\032\035\242\324\030\031#Valve_Reject_Hidd"
+  "en_Game\022O\n%NETWORK_DISCONNECT_REJECT_LAN"
+  "RESTRICT\020\205\001\032#\242\324\030\037#GameUI_ServerRejectLAN"
+  "Restrict\022O\n%NETWORK_DISCONNECT_REJECT_BA"
+  "DPASSWORD\020\206\001\032#\242\324\030\037#GameUI_ServerRejectBa"
+  "dPassword\022M\n$NETWORK_DISCONNECT_REJECT_S"
+  "ERVERFULL\020\207\001\032\"\242\324\030\036#GameUI_ServerRejectSe"
+  "rverFull\022]\n,NETWORK_DISCONNECT_REJECT_IN"
+  "VALIDRESERVATION\020\210\001\032*\242\324\030&#GameUI_ServerR"
+  "ejectInvalidReservation\022S\n\'NETWORK_DISCO"
+  "NNECT_REJECT_FAILEDCHANNEL\020\211\001\032%\242\324\030!#Game"
+  "UI_ServerRejectFailedChannel\022W\n,NETWORK_"
+  "DISCONNECT_REJECT_CONNECT_FROM_LOBBY\020\212\001\032"
+  "$\242\324\030 #Valve_Reject_Connect_From_Lobby\022W\n"
+  ",NETWORK_DISCONNECT_REJECT_RESERVED_FOR_"
+  "LOBBY\020\213\001\032$\242\324\030 #Valve_Reject_Reserved_For"
+  "_Lobby\022Z\n*NETWORK_DISCONNECT_REJECT_INVA"
+  "LIDKEYLENGTH\020\214\001\032)\242\324\030%#GameUI_ServerRejec"
+  "t_InvalidKeyLength\022O\n%NETWORK_DISCONNECT"
+  "_REJECT_OLDPROTOCOL\020\215\001\032#\242\324\030\037#GameUI_Serv"
+  "erRejectOldProtocol\022O\n%NETWORK_DISCONNEC"
+  "T_REJECT_NEWPROTOCOL\020\216\001\032#\242\324\030\037#GameUI_Ser"
+  "verRejectNewProtocol\022[\n+NETWORK_DISCONNE"
+  "CT_REJECT_INVALIDCONNECTION\020\217\001\032)\242\324\030%#Gam"
+  "eUI_ServerRejectInvalidConnection\022U\n(NET"
+  "WORK_DISCONNECT_REJECT_INVALIDCERTLEN\020\220\001"
+  "\032&\242\324\030\"#GameUI_ServerRejectInvalidCertLen"
+  "\022_\n-NETWORK_DISCONNECT_REJECT_INVALIDSTE"
+  "AMCERTLEN\020\221\001\032+\242\324\030\'#GameUI_ServerRejectIn"
+  "validSteamCertLen\022C\n\037NETWORK_DISCONNECT_"
+  "REJECT_STEAM\020\222\001\032\035\242\324\030\031#GameUI_ServerRejec"
+  "tSteam\022Q\n,NETWORK_DISCONNECT_REJECT_SERV"
+  "ERAUTHDISABLED\020\223\001\032\036\242\324\030\032#GameUI_ServerAut"
+  "hDisabled\022Y\n0NETWORK_DISCONNECT_REJECT_S"
+  "ERVERCDKEYAUTHINVALID\020\224\001\032\"\242\324\030\036#GameUI_Se"
+  "rverCDKeyAuthInvalid\022E\n NETWORK_DISCONNE"
+  "CT_REJECT_BANNED\020\225\001\032\036\242\324\030\032#GameUI_ServerR"
+  "ejectBanned\022T\n%NETWORK_DISCONNECT_KICKED"
+  "_TEAMKILLING\020\226\001\032(\242\324\030$#Player_DisconnectR"
+  "eason_TeamKilling\022N\n\"NETWORK_DISCONNECT_"
+  "KICKED_TK_START\020\227\001\032%\242\324\030!#Player_Disconne"
+  "ctReason_TK_Start\022^\n*NETWORK_DISCONNECT_"
+  "KICKED_UNTRUSTEDACCOUNT\020\230\001\032-\242\324\030)#Player_"
+  "DisconnectReason_UntrustedAccount\022^\n*NET"
+  "WORK_DISCONNECT_KICKED_CONVICTEDACCOUNT\020"
+  "\231\001\032-\242\324\030)#Player_DisconnectReason_Convict"
+  "edAccount\022d\n-NETWORK_DISCONNECT_KICKED_C"
+  "OMPETITIVECOOLDOWN\020\232\001\0320\242\324\030,#Player_Disco"
+  "nnectReason_CompetitiveCooldown\022T\n%NETWO"
+  "RK_DISCONNECT_KICKED_TEAMHURTING\020\233\001\032(\242\324\030"
+  "$#Player_DisconnectReason_TeamHurting\022Z\n"
+  "(NETWORK_DISCONNECT_KICKED_HOSTAGEKILLIN"
+  "G\020\234\001\032+\242\324\030\'#Player_DisconnectReason_Hosta"
+  "geKilling\022N\n\"NETWORK_DISCONNECT_KICKED_V"
+  "OTEDOFF\020\235\001\032%\242\324\030!#Player_DisconnectReason"
+  "_VotedOff\022F\n\036NETWORK_DISCONNECT_KICKED_I"
+  "DLE\020\236\001\032!\242\324\030\035#Player_DisconnectReason_Idl"
+  "e\022L\n!NETWORK_DISCONNECT_KICKED_SUICIDE\020\237"
+  "\001\032$\242\324\030 #Player_DisconnectReason_Suicide\022"
+  "V\n&NETWORK_DISCONNECT_KICKED_NOSTEAMLOGI"
+  "N\020\240\001\032)\242\324\030%#Player_DisconnectReason_NoSte"
+  "amLogin\022X\n\'NETWORK_DISCONNECT_KICKED_NOS"
+  "TEAMTICKET\020\241\001\032*\242\324\030&#Player_DisconnectRea"
+  "son_NoSteamTicket\022\217\001\n)NETWORK_DISCONNECT"
+  "_KICKED_INPUTAUTOMATION\020\242\001\032_\242\324\030(#Player_"
+  "DisconnectReason_InputAutomation\252\324\030/#Pla"
+  "yer_DisconnectReason_InputAutomation_Det"
+  "ail\022n\n0NETWORK_DISCONNECT_KICKED_VACNETA"
+  "BNORMALBEHAVIOR\020\243\001\0327\242\324\030/#Player_Disconne"
+  "ctReason_VacNetAbnormalBehavior\260\324\030\000\022Z\n(N"
+  "ETWORK_DISCONNECT_KICKED_INSECURECLIENT\020"
+  "\244\001\032+\242\324\030\'#Player_DisconnectReason_Insecur"
+  "eClient:E\n\030network_connection_token\022!.go"
+  "ogle.protobuf.EnumValueOptions\030\304\212\003 \001(\t:L"
+  "\n\037network_connection_detail_token\022!.goog"
+  "le.protobuf.EnumValueOptions\030\305\212\003 \001(\t:F\n\023"
+  "allowed_from_client\022!.google.protobuf.En"
+  "umValueOptions\030\306\212\003 \001(\010:\004true"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_network_5fconnection_2eproto_deps[1] = {
+  &::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_network_5fconnection_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_network_5fconnection_2eproto = {
+    false, false, 10188, descriptor_table_protodef_network_5fconnection_2eproto,
+    "network_connection.proto",
+    &descriptor_table_network_5fconnection_2eproto_once, descriptor_table_network_5fconnection_2eproto_deps, 1, 0,
+    schemas, file_default_instances, TableStruct_network_5fconnection_2eproto::offsets,
+    nullptr, file_level_enum_descriptors_network_5fconnection_2eproto,
+    file_level_service_descriptors_network_5fconnection_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_network_5fconnection_2eproto_getter() {
+  return &descriptor_table_network_5fconnection_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_network_5fconnection_2eproto(&descriptor_table_network_5fconnection_2eproto);
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ENetworkDisconnectionReason_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_network_5fconnection_2eproto);
+  return file_level_enum_descriptors_network_5fconnection_2eproto[0];
+}
+bool ENetworkDisconnectionReason_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+    case 25:
+    case 26:
+    case 27:
+    case 28:
+    case 29:
+    case 30:
+    case 31:
+    case 32:
+    case 33:
+    case 34:
+    case 35:
+    case 36:
+    case 37:
+    case 38:
+    case 39:
+    case 40:
+    case 41:
+    case 42:
+    case 43:
+    case 44:
+    case 45:
+    case 46:
+    case 47:
+    case 48:
+    case 49:
+    case 50:
+    case 51:
+    case 52:
+    case 53:
+    case 54:
+    case 55:
+    case 56:
+    case 57:
+    case 58:
+    case 59:
+    case 60:
+    case 61:
+    case 62:
+    case 63:
+    case 64:
+    case 65:
+    case 66:
+    case 67:
+    case 68:
+    case 69:
+    case 71:
+    case 72:
+    case 73:
+    case 74:
+    case 75:
+    case 76:
+    case 77:
+    case 79:
+    case 80:
+    case 81:
+    case 82:
+    case 83:
+    case 84:
+    case 85:
+    case 128:
+    case 129:
+    case 130:
+    case 131:
+    case 132:
+    case 133:
+    case 134:
+    case 135:
+    case 136:
+    case 137:
+    case 138:
+    case 139:
+    case 140:
+    case 141:
+    case 142:
+    case 143:
+    case 144:
+    case 145:
+    case 146:
+    case 147:
+    case 148:
+    case 149:
+    case 150:
+    case 151:
+    case 152:
+    case 153:
+    case 154:
+    case 155:
+    case 156:
+    case 157:
+    case 158:
+    case 159:
+    case 160:
+    case 161:
+    case 162:
+    case 163:
+    case 164:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const std::string network_connection_token_default("");
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::StringTypeTraits, 9, false>
+  network_connection_token(kNetworkConnectionTokenFieldNumber, network_connection_token_default, nullptr);
+const std::string network_connection_detail_token_default("");
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::StringTypeTraits, 9, false>
+  network_connection_detail_token(kNetworkConnectionDetailTokenFieldNumber, network_connection_detail_token_default, nullptr);
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::PrimitiveTypeTraits< bool >, 8, false>
+  allowed_from_client(kAllowedFromClientFieldNumber, true, nullptr);
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/network_connection.pb.h

@@ -0,0 +1,236 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: network_connection.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_network_5fconnection_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_network_5fconnection_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_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.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/descriptor.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_network_5fconnection_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_network_5fconnection_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_network_5fconnection_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+
+enum ENetworkDisconnectionReason : int {
+  NETWORK_DISCONNECT_INVALID = 0,
+  NETWORK_DISCONNECT_SHUTDOWN = 1,
+  NETWORK_DISCONNECT_DISCONNECT_BY_USER = 2,
+  NETWORK_DISCONNECT_DISCONNECT_BY_SERVER = 3,
+  NETWORK_DISCONNECT_LOST = 4,
+  NETWORK_DISCONNECT_OVERFLOW = 5,
+  NETWORK_DISCONNECT_STEAM_BANNED = 6,
+  NETWORK_DISCONNECT_STEAM_INUSE = 7,
+  NETWORK_DISCONNECT_STEAM_TICKET = 8,
+  NETWORK_DISCONNECT_STEAM_LOGON = 9,
+  NETWORK_DISCONNECT_STEAM_AUTHCANCELLED = 10,
+  NETWORK_DISCONNECT_STEAM_AUTHALREADYUSED = 11,
+  NETWORK_DISCONNECT_STEAM_AUTHINVALID = 12,
+  NETWORK_DISCONNECT_STEAM_VACBANSTATE = 13,
+  NETWORK_DISCONNECT_STEAM_LOGGED_IN_ELSEWHERE = 14,
+  NETWORK_DISCONNECT_STEAM_VAC_CHECK_TIMEDOUT = 15,
+  NETWORK_DISCONNECT_STEAM_DROPPED = 16,
+  NETWORK_DISCONNECT_STEAM_OWNERSHIP = 17,
+  NETWORK_DISCONNECT_SERVERINFO_OVERFLOW = 18,
+  NETWORK_DISCONNECT_TICKMSG_OVERFLOW = 19,
+  NETWORK_DISCONNECT_STRINGTABLEMSG_OVERFLOW = 20,
+  NETWORK_DISCONNECT_DELTAENTMSG_OVERFLOW = 21,
+  NETWORK_DISCONNECT_TEMPENTMSG_OVERFLOW = 22,
+  NETWORK_DISCONNECT_SOUNDSMSG_OVERFLOW = 23,
+  NETWORK_DISCONNECT_SNAPSHOTOVERFLOW = 24,
+  NETWORK_DISCONNECT_SNAPSHOTERROR = 25,
+  NETWORK_DISCONNECT_RELIABLEOVERFLOW = 26,
+  NETWORK_DISCONNECT_BADDELTATICK = 27,
+  NETWORK_DISCONNECT_NOMORESPLITS = 28,
+  NETWORK_DISCONNECT_TIMEDOUT = 29,
+  NETWORK_DISCONNECT_DISCONNECTED = 30,
+  NETWORK_DISCONNECT_LEAVINGSPLIT = 31,
+  NETWORK_DISCONNECT_DIFFERENTCLASSTABLES = 32,
+  NETWORK_DISCONNECT_BADRELAYPASSWORD = 33,
+  NETWORK_DISCONNECT_BADSPECTATORPASSWORD = 34,
+  NETWORK_DISCONNECT_HLTVRESTRICTED = 35,
+  NETWORK_DISCONNECT_NOSPECTATORS = 36,
+  NETWORK_DISCONNECT_HLTVUNAVAILABLE = 37,
+  NETWORK_DISCONNECT_HLTVSTOP = 38,
+  NETWORK_DISCONNECT_KICKED = 39,
+  NETWORK_DISCONNECT_BANADDED = 40,
+  NETWORK_DISCONNECT_KICKBANADDED = 41,
+  NETWORK_DISCONNECT_HLTVDIRECT = 42,
+  NETWORK_DISCONNECT_PURESERVER_CLIENTEXTRA = 43,
+  NETWORK_DISCONNECT_PURESERVER_MISMATCH = 44,
+  NETWORK_DISCONNECT_USERCMD = 45,
+  NETWORK_DISCONNECT_REJECTED_BY_GAME = 46,
+  NETWORK_DISCONNECT_MESSAGE_PARSE_ERROR = 47,
+  NETWORK_DISCONNECT_INVALID_MESSAGE_ERROR = 48,
+  NETWORK_DISCONNECT_BAD_SERVER_PASSWORD = 49,
+  NETWORK_DISCONNECT_DIRECT_CONNECT_RESERVATION = 50,
+  NETWORK_DISCONNECT_CONNECTION_FAILURE = 51,
+  NETWORK_DISCONNECT_NO_PEER_GROUP_HANDLERS = 52,
+  NETWORK_DISCONNECT_RECONNECTION = 53,
+  NETWORK_DISCONNECT_LOOPSHUTDOWN = 54,
+  NETWORK_DISCONNECT_LOOPDEACTIVATE = 55,
+  NETWORK_DISCONNECT_HOST_ENDGAME = 56,
+  NETWORK_DISCONNECT_LOOP_LEVELLOAD_ACTIVATE = 57,
+  NETWORK_DISCONNECT_CREATE_SERVER_FAILED = 58,
+  NETWORK_DISCONNECT_EXITING = 59,
+  NETWORK_DISCONNECT_REQUEST_HOSTSTATE_IDLE = 60,
+  NETWORK_DISCONNECT_REQUEST_HOSTSTATE_HLTVRELAY = 61,
+  NETWORK_DISCONNECT_CLIENT_CONSISTENCY_FAIL = 62,
+  NETWORK_DISCONNECT_CLIENT_UNABLE_TO_CRC_MAP = 63,
+  NETWORK_DISCONNECT_CLIENT_NO_MAP = 64,
+  NETWORK_DISCONNECT_CLIENT_DIFFERENT_MAP = 65,
+  NETWORK_DISCONNECT_SERVER_REQUIRES_STEAM = 66,
+  NETWORK_DISCONNECT_STEAM_DENY_MISC = 67,
+  NETWORK_DISCONNECT_STEAM_DENY_BAD_ANTI_CHEAT = 68,
+  NETWORK_DISCONNECT_SERVER_SHUTDOWN = 69,
+  NETWORK_DISCONNECT_REPLAY_INCOMPATIBLE = 71,
+  NETWORK_DISCONNECT_CONNECT_REQUEST_TIMEDOUT = 72,
+  NETWORK_DISCONNECT_SERVER_INCOMPATIBLE = 73,
+  NETWORK_DISCONNECT_LOCALPROBLEM_MANYRELAYS = 74,
+  NETWORK_DISCONNECT_LOCALPROBLEM_HOSTEDSERVERPRIMARYRELAY = 75,
+  NETWORK_DISCONNECT_LOCALPROBLEM_NETWORKCONFIG = 76,
+  NETWORK_DISCONNECT_LOCALPROBLEM_OTHER = 77,
+  NETWORK_DISCONNECT_REMOTE_TIMEOUT = 79,
+  NETWORK_DISCONNECT_REMOTE_TIMEOUT_CONNECTING = 80,
+  NETWORK_DISCONNECT_REMOTE_OTHER = 81,
+  NETWORK_DISCONNECT_REMOTE_BADCRYPT = 82,
+  NETWORK_DISCONNECT_REMOTE_CERTNOTTRUSTED = 83,
+  NETWORK_DISCONNECT_UNUSUAL = 84,
+  NETWORK_DISCONNECT_INTERNAL_ERROR = 85,
+  NETWORK_DISCONNECT_REJECT_BADCHALLENGE = 128,
+  NETWORK_DISCONNECT_REJECT_NOLOBBY = 129,
+  NETWORK_DISCONNECT_REJECT_BACKGROUND_MAP = 130,
+  NETWORK_DISCONNECT_REJECT_SINGLE_PLAYER = 131,
+  NETWORK_DISCONNECT_REJECT_HIDDEN_GAME = 132,
+  NETWORK_DISCONNECT_REJECT_LANRESTRICT = 133,
+  NETWORK_DISCONNECT_REJECT_BADPASSWORD = 134,
+  NETWORK_DISCONNECT_REJECT_SERVERFULL = 135,
+  NETWORK_DISCONNECT_REJECT_INVALIDRESERVATION = 136,
+  NETWORK_DISCONNECT_REJECT_FAILEDCHANNEL = 137,
+  NETWORK_DISCONNECT_REJECT_CONNECT_FROM_LOBBY = 138,
+  NETWORK_DISCONNECT_REJECT_RESERVED_FOR_LOBBY = 139,
+  NETWORK_DISCONNECT_REJECT_INVALIDKEYLENGTH = 140,
+  NETWORK_DISCONNECT_REJECT_OLDPROTOCOL = 141,
+  NETWORK_DISCONNECT_REJECT_NEWPROTOCOL = 142,
+  NETWORK_DISCONNECT_REJECT_INVALIDCONNECTION = 143,
+  NETWORK_DISCONNECT_REJECT_INVALIDCERTLEN = 144,
+  NETWORK_DISCONNECT_REJECT_INVALIDSTEAMCERTLEN = 145,
+  NETWORK_DISCONNECT_REJECT_STEAM = 146,
+  NETWORK_DISCONNECT_REJECT_SERVERAUTHDISABLED = 147,
+  NETWORK_DISCONNECT_REJECT_SERVERCDKEYAUTHINVALID = 148,
+  NETWORK_DISCONNECT_REJECT_BANNED = 149,
+  NETWORK_DISCONNECT_KICKED_TEAMKILLING = 150,
+  NETWORK_DISCONNECT_KICKED_TK_START = 151,
+  NETWORK_DISCONNECT_KICKED_UNTRUSTEDACCOUNT = 152,
+  NETWORK_DISCONNECT_KICKED_CONVICTEDACCOUNT = 153,
+  NETWORK_DISCONNECT_KICKED_COMPETITIVECOOLDOWN = 154,
+  NETWORK_DISCONNECT_KICKED_TEAMHURTING = 155,
+  NETWORK_DISCONNECT_KICKED_HOSTAGEKILLING = 156,
+  NETWORK_DISCONNECT_KICKED_VOTEDOFF = 157,
+  NETWORK_DISCONNECT_KICKED_IDLE = 158,
+  NETWORK_DISCONNECT_KICKED_SUICIDE = 159,
+  NETWORK_DISCONNECT_KICKED_NOSTEAMLOGIN = 160,
+  NETWORK_DISCONNECT_KICKED_NOSTEAMTICKET = 161,
+  NETWORK_DISCONNECT_KICKED_INPUTAUTOMATION = 162,
+  NETWORK_DISCONNECT_KICKED_VACNETABNORMALBEHAVIOR = 163,
+  NETWORK_DISCONNECT_KICKED_INSECURECLIENT = 164
+};
+bool ENetworkDisconnectionReason_IsValid(int value);
+constexpr ENetworkDisconnectionReason ENetworkDisconnectionReason_MIN = NETWORK_DISCONNECT_INVALID;
+constexpr ENetworkDisconnectionReason ENetworkDisconnectionReason_MAX = NETWORK_DISCONNECT_KICKED_INSECURECLIENT;
+constexpr int ENetworkDisconnectionReason_ARRAYSIZE = ENetworkDisconnectionReason_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ENetworkDisconnectionReason_descriptor();
+template<typename T>
+inline const std::string& ENetworkDisconnectionReason_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ENetworkDisconnectionReason>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ENetworkDisconnectionReason_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ENetworkDisconnectionReason_descriptor(), enum_t_value);
+}
+inline bool ENetworkDisconnectionReason_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ENetworkDisconnectionReason* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ENetworkDisconnectionReason>(
+    ENetworkDisconnectionReason_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kNetworkConnectionTokenFieldNumber = 50500;
+extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::StringTypeTraits, 9, false >
+  network_connection_token;
+static const int kNetworkConnectionDetailTokenFieldNumber = 50501;
+extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::StringTypeTraits, 9, false >
+  network_connection_detail_token;
+static const int kAllowedFromClientFieldNumber = 50502;
+extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumValueOptions,
+    ::PROTOBUF_NAMESPACE_ID::internal::PrimitiveTypeTraits< bool >, 8, false >
+  allowed_from_client;
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::ENetworkDisconnectionReason> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::ENetworkDisconnectionReason>() {
+  return ::ENetworkDisconnectionReason_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_network_5fconnection_2eproto

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/networksystem_protomessages.pb.cc

@@ -0,0 +1,986 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: networksystem_protomessages.proto
+
+#include "networksystem_protomessages.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR NetMessageSplitscreenUserChanged::NetMessageSplitscreenUserChanged(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.slot_)*/0u} {}
+struct NetMessageSplitscreenUserChangedDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NetMessageSplitscreenUserChangedDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NetMessageSplitscreenUserChangedDefaultTypeInternal() {}
+  union {
+    NetMessageSplitscreenUserChanged _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetMessageSplitscreenUserChangedDefaultTypeInternal _NetMessageSplitscreenUserChanged_default_instance_;
+PROTOBUF_CONSTEXPR NetMessageConnectionClosed::NetMessageConnectionClosed(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.reason_)*/0u} {}
+struct NetMessageConnectionClosedDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NetMessageConnectionClosedDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NetMessageConnectionClosedDefaultTypeInternal() {}
+  union {
+    NetMessageConnectionClosed _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetMessageConnectionClosedDefaultTypeInternal _NetMessageConnectionClosed_default_instance_;
+PROTOBUF_CONSTEXPR NetMessageConnectionCrashed::NetMessageConnectionCrashed(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.reason_)*/0u} {}
+struct NetMessageConnectionCrashedDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NetMessageConnectionCrashedDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NetMessageConnectionCrashedDefaultTypeInternal() {}
+  union {
+    NetMessageConnectionCrashed _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetMessageConnectionCrashedDefaultTypeInternal _NetMessageConnectionCrashed_default_instance_;
+PROTOBUF_CONSTEXPR NetMessagePacketStart::NetMessagePacketStart(
+    ::_pbi::ConstantInitialized) {}
+struct NetMessagePacketStartDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NetMessagePacketStartDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NetMessagePacketStartDefaultTypeInternal() {}
+  union {
+    NetMessagePacketStart _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetMessagePacketStartDefaultTypeInternal _NetMessagePacketStart_default_instance_;
+PROTOBUF_CONSTEXPR NetMessagePacketEnd::NetMessagePacketEnd(
+    ::_pbi::ConstantInitialized) {}
+struct NetMessagePacketEndDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NetMessagePacketEndDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NetMessagePacketEndDefaultTypeInternal() {}
+  union {
+    NetMessagePacketEnd _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetMessagePacketEndDefaultTypeInternal _NetMessagePacketEnd_default_instance_;
+static ::_pb::Metadata file_level_metadata_networksystem_5fprotomessages_2eproto[5];
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_networksystem_5fprotomessages_2eproto = nullptr;
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_networksystem_5fprotomessages_2eproto = nullptr;
+
+const uint32_t TableStruct_networksystem_5fprotomessages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::NetMessageSplitscreenUserChanged, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::NetMessageSplitscreenUserChanged, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::NetMessageSplitscreenUserChanged, _impl_.slot_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionClosed, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionClosed, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionClosed, _impl_.reason_),
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionClosed, _impl_.message_),
+  1,
+  0,
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionCrashed, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionCrashed, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionCrashed, _impl_.reason_),
+  PROTOBUF_FIELD_OFFSET(::NetMessageConnectionCrashed, _impl_.message_),
+  1,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::NetMessagePacketStart, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::NetMessagePacketEnd, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 7, -1, sizeof(::NetMessageSplitscreenUserChanged)},
+  { 8, 16, -1, sizeof(::NetMessageConnectionClosed)},
+  { 18, 26, -1, sizeof(::NetMessageConnectionCrashed)},
+  { 28, -1, -1, sizeof(::NetMessagePacketStart)},
+  { 34, -1, -1, sizeof(::NetMessagePacketEnd)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_NetMessageSplitscreenUserChanged_default_instance_._instance,
+  &::_NetMessageConnectionClosed_default_instance_._instance,
+  &::_NetMessageConnectionCrashed_default_instance_._instance,
+  &::_NetMessagePacketStart_default_instance_._instance,
+  &::_NetMessagePacketEnd_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_networksystem_5fprotomessages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n!networksystem_protomessages.proto\"0\n N"
+  "etMessageSplitscreenUserChanged\022\014\n\004slot\030"
+  "\001 \001(\r\"=\n\032NetMessageConnectionClosed\022\016\n\006r"
+  "eason\030\001 \001(\r\022\017\n\007message\030\002 \001(\t\">\n\033NetMessa"
+  "geConnectionCrashed\022\016\n\006reason\030\001 \001(\r\022\017\n\007m"
+  "essage\030\002 \001(\t\"\027\n\025NetMessagePacketStart\"\025\n"
+  "\023NetMessagePacketEnd"
+  ;
+static ::_pbi::once_flag descriptor_table_networksystem_5fprotomessages_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_networksystem_5fprotomessages_2eproto = {
+    false, false, 260, descriptor_table_protodef_networksystem_5fprotomessages_2eproto,
+    "networksystem_protomessages.proto",
+    &descriptor_table_networksystem_5fprotomessages_2eproto_once, nullptr, 0, 5,
+    schemas, file_default_instances, TableStruct_networksystem_5fprotomessages_2eproto::offsets,
+    file_level_metadata_networksystem_5fprotomessages_2eproto, file_level_enum_descriptors_networksystem_5fprotomessages_2eproto,
+    file_level_service_descriptors_networksystem_5fprotomessages_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_networksystem_5fprotomessages_2eproto_getter() {
+  return &descriptor_table_networksystem_5fprotomessages_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_networksystem_5fprotomessages_2eproto(&descriptor_table_networksystem_5fprotomessages_2eproto);
+
+// ===================================================================
+
+class NetMessageSplitscreenUserChanged::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NetMessageSplitscreenUserChanged>()._impl_._has_bits_);
+  static void set_has_slot(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+NetMessageSplitscreenUserChanged::NetMessageSplitscreenUserChanged(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:NetMessageSplitscreenUserChanged)
+}
+NetMessageSplitscreenUserChanged::NetMessageSplitscreenUserChanged(const NetMessageSplitscreenUserChanged& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NetMessageSplitscreenUserChanged* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.slot_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.slot_ = from._impl_.slot_;
+  // @@protoc_insertion_point(copy_constructor:NetMessageSplitscreenUserChanged)
+}
+
+inline void NetMessageSplitscreenUserChanged::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.slot_){0u}
+  };
+}
+
+NetMessageSplitscreenUserChanged::~NetMessageSplitscreenUserChanged() {
+  // @@protoc_insertion_point(destructor:NetMessageSplitscreenUserChanged)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NetMessageSplitscreenUserChanged::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void NetMessageSplitscreenUserChanged::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NetMessageSplitscreenUserChanged::Clear() {
+// @@protoc_insertion_point(message_clear_start:NetMessageSplitscreenUserChanged)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.slot_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NetMessageSplitscreenUserChanged::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 slot = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_slot(&has_bits);
+          _impl_.slot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NetMessageSplitscreenUserChanged::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:NetMessageSplitscreenUserChanged)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 slot = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_slot(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:NetMessageSplitscreenUserChanged)
+  return target;
+}
+
+size_t NetMessageSplitscreenUserChanged::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:NetMessageSplitscreenUserChanged)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint32 slot = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_slot());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetMessageSplitscreenUserChanged::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NetMessageSplitscreenUserChanged::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetMessageSplitscreenUserChanged::GetClassData() const { return &_class_data_; }
+
+
+void NetMessageSplitscreenUserChanged::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NetMessageSplitscreenUserChanged*>(&to_msg);
+  auto& from = static_cast<const NetMessageSplitscreenUserChanged&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:NetMessageSplitscreenUserChanged)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_slot()) {
+    _this->_internal_set_slot(from._internal_slot());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NetMessageSplitscreenUserChanged::CopyFrom(const NetMessageSplitscreenUserChanged& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:NetMessageSplitscreenUserChanged)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NetMessageSplitscreenUserChanged::IsInitialized() const {
+  return true;
+}
+
+void NetMessageSplitscreenUserChanged::InternalSwap(NetMessageSplitscreenUserChanged* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.slot_, other->_impl_.slot_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NetMessageSplitscreenUserChanged::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_networksystem_5fprotomessages_2eproto_getter, &descriptor_table_networksystem_5fprotomessages_2eproto_once,
+      file_level_metadata_networksystem_5fprotomessages_2eproto[0]);
+}
+
+// ===================================================================
+
+class NetMessageConnectionClosed::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NetMessageConnectionClosed>()._impl_._has_bits_);
+  static void set_has_reason(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+NetMessageConnectionClosed::NetMessageConnectionClosed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:NetMessageConnectionClosed)
+}
+NetMessageConnectionClosed::NetMessageConnectionClosed(const NetMessageConnectionClosed& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NetMessageConnectionClosed* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.reason_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_message()) {
+    _this->_impl_.message_.Set(from._internal_message(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.reason_ = from._impl_.reason_;
+  // @@protoc_insertion_point(copy_constructor:NetMessageConnectionClosed)
+}
+
+inline void NetMessageConnectionClosed::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.reason_){0u}
+  };
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NetMessageConnectionClosed::~NetMessageConnectionClosed() {
+  // @@protoc_insertion_point(destructor:NetMessageConnectionClosed)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NetMessageConnectionClosed::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.message_.Destroy();
+}
+
+void NetMessageConnectionClosed::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NetMessageConnectionClosed::Clear() {
+// @@protoc_insertion_point(message_clear_start:NetMessageConnectionClosed)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.message_.ClearNonDefaultToEmpty();
+  }
+  _impl_.reason_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NetMessageConnectionClosed::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 reason = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_reason(&has_bits);
+          _impl_.reason_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_message();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "NetMessageConnectionClosed.message");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NetMessageConnectionClosed::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:NetMessageConnectionClosed)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 reason = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_reason(), target);
+  }
+
+  // optional string message = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "NetMessageConnectionClosed.message");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_message(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:NetMessageConnectionClosed)
+  return target;
+}
+
+size_t NetMessageConnectionClosed::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:NetMessageConnectionClosed)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string message = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_message());
+    }
+
+    // optional uint32 reason = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_reason());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetMessageConnectionClosed::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NetMessageConnectionClosed::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetMessageConnectionClosed::GetClassData() const { return &_class_data_; }
+
+
+void NetMessageConnectionClosed::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NetMessageConnectionClosed*>(&to_msg);
+  auto& from = static_cast<const NetMessageConnectionClosed&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:NetMessageConnectionClosed)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_message(from._internal_message());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.reason_ = from._impl_.reason_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NetMessageConnectionClosed::CopyFrom(const NetMessageConnectionClosed& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:NetMessageConnectionClosed)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NetMessageConnectionClosed::IsInitialized() const {
+  return true;
+}
+
+void NetMessageConnectionClosed::InternalSwap(NetMessageConnectionClosed* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.message_, lhs_arena,
+      &other->_impl_.message_, rhs_arena
+  );
+  swap(_impl_.reason_, other->_impl_.reason_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NetMessageConnectionClosed::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_networksystem_5fprotomessages_2eproto_getter, &descriptor_table_networksystem_5fprotomessages_2eproto_once,
+      file_level_metadata_networksystem_5fprotomessages_2eproto[1]);
+}
+
+// ===================================================================
+
+class NetMessageConnectionCrashed::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NetMessageConnectionCrashed>()._impl_._has_bits_);
+  static void set_has_reason(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+NetMessageConnectionCrashed::NetMessageConnectionCrashed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:NetMessageConnectionCrashed)
+}
+NetMessageConnectionCrashed::NetMessageConnectionCrashed(const NetMessageConnectionCrashed& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  NetMessageConnectionCrashed* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.reason_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_message()) {
+    _this->_impl_.message_.Set(from._internal_message(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.reason_ = from._impl_.reason_;
+  // @@protoc_insertion_point(copy_constructor:NetMessageConnectionCrashed)
+}
+
+inline void NetMessageConnectionCrashed::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.reason_){0u}
+  };
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NetMessageConnectionCrashed::~NetMessageConnectionCrashed() {
+  // @@protoc_insertion_point(destructor:NetMessageConnectionCrashed)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NetMessageConnectionCrashed::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.message_.Destroy();
+}
+
+void NetMessageConnectionCrashed::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NetMessageConnectionCrashed::Clear() {
+// @@protoc_insertion_point(message_clear_start:NetMessageConnectionCrashed)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.message_.ClearNonDefaultToEmpty();
+  }
+  _impl_.reason_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NetMessageConnectionCrashed::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 reason = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_reason(&has_bits);
+          _impl_.reason_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_message();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "NetMessageConnectionCrashed.message");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NetMessageConnectionCrashed::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:NetMessageConnectionCrashed)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 reason = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_reason(), target);
+  }
+
+  // optional string message = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "NetMessageConnectionCrashed.message");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_message(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:NetMessageConnectionCrashed)
+  return target;
+}
+
+size_t NetMessageConnectionCrashed::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:NetMessageConnectionCrashed)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string message = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_message());
+    }
+
+    // optional uint32 reason = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_reason());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetMessageConnectionCrashed::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    NetMessageConnectionCrashed::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetMessageConnectionCrashed::GetClassData() const { return &_class_data_; }
+
+
+void NetMessageConnectionCrashed::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<NetMessageConnectionCrashed*>(&to_msg);
+  auto& from = static_cast<const NetMessageConnectionCrashed&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:NetMessageConnectionCrashed)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_message(from._internal_message());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.reason_ = from._impl_.reason_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NetMessageConnectionCrashed::CopyFrom(const NetMessageConnectionCrashed& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:NetMessageConnectionCrashed)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NetMessageConnectionCrashed::IsInitialized() const {
+  return true;
+}
+
+void NetMessageConnectionCrashed::InternalSwap(NetMessageConnectionCrashed* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.message_, lhs_arena,
+      &other->_impl_.message_, rhs_arena
+  );
+  swap(_impl_.reason_, other->_impl_.reason_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NetMessageConnectionCrashed::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_networksystem_5fprotomessages_2eproto_getter, &descriptor_table_networksystem_5fprotomessages_2eproto_once,
+      file_level_metadata_networksystem_5fprotomessages_2eproto[2]);
+}
+
+// ===================================================================
+
+class NetMessagePacketStart::_Internal {
+ public:
+};
+
+NetMessagePacketStart::NetMessagePacketStart(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:NetMessagePacketStart)
+}
+NetMessagePacketStart::NetMessagePacketStart(const NetMessagePacketStart& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  NetMessagePacketStart* const _this = this; (void)_this;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:NetMessagePacketStart)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetMessagePacketStart::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetMessagePacketStart::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata NetMessagePacketStart::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_networksystem_5fprotomessages_2eproto_getter, &descriptor_table_networksystem_5fprotomessages_2eproto_once,
+      file_level_metadata_networksystem_5fprotomessages_2eproto[3]);
+}
+
+// ===================================================================
+
+class NetMessagePacketEnd::_Internal {
+ public:
+};
+
+NetMessagePacketEnd::NetMessagePacketEnd(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:NetMessagePacketEnd)
+}
+NetMessagePacketEnd::NetMessagePacketEnd(const NetMessagePacketEnd& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  NetMessagePacketEnd* const _this = this; (void)_this;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:NetMessagePacketEnd)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NetMessagePacketEnd::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NetMessagePacketEnd::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata NetMessagePacketEnd::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_networksystem_5fprotomessages_2eproto_getter, &descriptor_table_networksystem_5fprotomessages_2eproto_once,
+      file_level_metadata_networksystem_5fprotomessages_2eproto[4]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::NetMessageSplitscreenUserChanged*
+Arena::CreateMaybeMessage< ::NetMessageSplitscreenUserChanged >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::NetMessageSplitscreenUserChanged >(arena);
+}
+template<> PROTOBUF_NOINLINE ::NetMessageConnectionClosed*
+Arena::CreateMaybeMessage< ::NetMessageConnectionClosed >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::NetMessageConnectionClosed >(arena);
+}
+template<> PROTOBUF_NOINLINE ::NetMessageConnectionCrashed*
+Arena::CreateMaybeMessage< ::NetMessageConnectionCrashed >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::NetMessageConnectionCrashed >(arena);
+}
+template<> PROTOBUF_NOINLINE ::NetMessagePacketStart*
+Arena::CreateMaybeMessage< ::NetMessagePacketStart >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::NetMessagePacketStart >(arena);
+}
+template<> PROTOBUF_NOINLINE ::NetMessagePacketEnd*
+Arena::CreateMaybeMessage< ::NetMessagePacketEnd >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::NetMessagePacketEnd >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/steammessages_helprequest.steamworkssdk.pb.cc

@@ -0,0 +1,791 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: steammessages_helprequest.steamworkssdk.proto
+
+#include "steammessages_helprequest.steamworkssdk.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_Request::CHelpRequestLogs_UploadUserApplicationLog_Request(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.log_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_string_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.log_contents_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.appid_)*/0u} {}
+struct CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal() {}
+  union {
+    CHelpRequestLogs_UploadUserApplicationLog_Request _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal _CHelpRequestLogs_UploadUserApplicationLog_Request_default_instance_;
+PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_Response::CHelpRequestLogs_UploadUserApplicationLog_Response(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/uint64_t{0u}} {}
+struct CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal() {}
+  union {
+    CHelpRequestLogs_UploadUserApplicationLog_Response _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal _CHelpRequestLogs_UploadUserApplicationLog_Response_default_instance_;
+static ::_pb::Metadata file_level_metadata_steammessages_5fhelprequest_2esteamworkssdk_2eproto[2];
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto = nullptr;
+static const ::_pb::ServiceDescriptor* file_level_service_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto[1];
+
+const uint32_t TableStruct_steammessages_5fhelprequest_2esteamworkssdk_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _impl_.appid_),
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _impl_.log_type_),
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _impl_.version_string_),
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Request, _impl_.log_contents_),
+  3,
+  0,
+  1,
+  2,
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Response, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Response, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CHelpRequestLogs_UploadUserApplicationLog_Response, _impl_.id_),
+  0,
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 10, -1, sizeof(::CHelpRequestLogs_UploadUserApplicationLog_Request)},
+  { 14, 21, -1, sizeof(::CHelpRequestLogs_UploadUserApplicationLog_Response)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_CHelpRequestLogs_UploadUserApplicationLog_Request_default_instance_._instance,
+  &::_CHelpRequestLogs_UploadUserApplicationLog_Response_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_steammessages_5fhelprequest_2esteamworkssdk_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n-steammessages_helprequest.steamworkssd"
+  "k.proto\032.steammessages_unified_base.stea"
+  "mworkssdk.proto\"\202\001\n1CHelpRequestLogs_Upl"
+  "oadUserApplicationLog_Request\022\r\n\005appid\030\001"
+  " \001(\r\022\020\n\010log_type\030\002 \001(\t\022\026\n\016version_string"
+  "\030\003 \001(\t\022\024\n\014log_contents\030\004 \001(\t\"@\n2CHelpReq"
+  "uestLogs_UploadUserApplicationLog_Respon"
+  "se\022\n\n\002id\030\001 \001(\0042\356\001\n\017HelpRequestLogs\022\250\001\n\030U"
+  "ploadUserApplicationLog\0222.CHelpRequestLo"
+  "gs_UploadUserApplicationLog_Request\0323.CH"
+  "elpRequestLogs_UploadUserApplicationLog_"
+  "Response\"#\202\265\030\037User uploading application"
+  " logs\0320\202\265\030,Service for dealing with user"
+  "-submitted logsB\003\200\001\001"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_deps[1] = {
+  &::descriptor_table_steammessages_5funified_5fbase_2esteamworkssdk_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto = {
+    false, false, 540, descriptor_table_protodef_steammessages_5fhelprequest_2esteamworkssdk_2eproto,
+    "steammessages_helprequest.steamworkssdk.proto",
+    &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_once, descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_deps, 1, 2,
+    schemas, file_default_instances, TableStruct_steammessages_5fhelprequest_2esteamworkssdk_2eproto::offsets,
+    file_level_metadata_steammessages_5fhelprequest_2esteamworkssdk_2eproto, file_level_enum_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto,
+    file_level_service_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_getter() {
+  return &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_steammessages_5fhelprequest_2esteamworkssdk_2eproto(&descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto);
+
+// ===================================================================
+
+class CHelpRequestLogs_UploadUserApplicationLog_Request::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CHelpRequestLogs_UploadUserApplicationLog_Request>()._impl_._has_bits_);
+  static void set_has_appid(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_log_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_version_string(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_log_contents(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+CHelpRequestLogs_UploadUserApplicationLog_Request::CHelpRequestLogs_UploadUserApplicationLog_Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CHelpRequestLogs_UploadUserApplicationLog_Request)
+}
+CHelpRequestLogs_UploadUserApplicationLog_Request::CHelpRequestLogs_UploadUserApplicationLog_Request(const CHelpRequestLogs_UploadUserApplicationLog_Request& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CHelpRequestLogs_UploadUserApplicationLog_Request* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.log_type_){}
+    , decltype(_impl_.version_string_){}
+    , decltype(_impl_.log_contents_){}
+    , decltype(_impl_.appid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.log_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.log_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_log_type()) {
+    _this->_impl_.log_type_.Set(from._internal_log_type(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.version_string_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_string_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version_string()) {
+    _this->_impl_.version_string_.Set(from._internal_version_string(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.log_contents_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.log_contents_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_log_contents()) {
+    _this->_impl_.log_contents_.Set(from._internal_log_contents(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.appid_ = from._impl_.appid_;
+  // @@protoc_insertion_point(copy_constructor:CHelpRequestLogs_UploadUserApplicationLog_Request)
+}
+
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.log_type_){}
+    , decltype(_impl_.version_string_){}
+    , decltype(_impl_.log_contents_){}
+    , decltype(_impl_.appid_){0u}
+  };
+  _impl_.log_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.log_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.version_string_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_string_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.log_contents_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.log_contents_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+CHelpRequestLogs_UploadUserApplicationLog_Request::~CHelpRequestLogs_UploadUserApplicationLog_Request() {
+  // @@protoc_insertion_point(destructor:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.log_type_.Destroy();
+  _impl_.version_string_.Destroy();
+  _impl_.log_contents_.Destroy();
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Request::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Request::Clear() {
+// @@protoc_insertion_point(message_clear_start:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.log_type_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.version_string_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.log_contents_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.appid_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CHelpRequestLogs_UploadUserApplicationLog_Request::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 appid = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_appid(&has_bits);
+          _impl_.appid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string log_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_log_type();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "CHelpRequestLogs_UploadUserApplicationLog_Request.log_type");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string version_string = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_version_string();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "CHelpRequestLogs_UploadUserApplicationLog_Request.version_string");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string log_contents = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_log_contents();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CHelpRequestLogs_UploadUserApplicationLog_Request::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 appid = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_appid(), target);
+  }
+
+  // optional string log_type = 2;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_log_type().data(), static_cast<int>(this->_internal_log_type().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "CHelpRequestLogs_UploadUserApplicationLog_Request.log_type");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_log_type(), target);
+  }
+
+  // optional string version_string = 3;
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_version_string().data(), static_cast<int>(this->_internal_version_string().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "CHelpRequestLogs_UploadUserApplicationLog_Request.version_string");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_version_string(), target);
+  }
+
+  // optional string log_contents = 4;
+  if (cached_has_bits & 0x00000004u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_log_contents().data(), static_cast<int>(this->_internal_log_contents().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_log_contents(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  return target;
+}
+
+size_t CHelpRequestLogs_UploadUserApplicationLog_Request::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string log_type = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_log_type());
+    }
+
+    // optional string version_string = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_version_string());
+    }
+
+    // optional string log_contents = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_log_contents());
+    }
+
+    // optional uint32 appid = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_appid());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CHelpRequestLogs_UploadUserApplicationLog_Request::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CHelpRequestLogs_UploadUserApplicationLog_Request::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CHelpRequestLogs_UploadUserApplicationLog_Request::GetClassData() const { return &_class_data_; }
+
+
+void CHelpRequestLogs_UploadUserApplicationLog_Request::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CHelpRequestLogs_UploadUserApplicationLog_Request*>(&to_msg);
+  auto& from = static_cast<const CHelpRequestLogs_UploadUserApplicationLog_Request&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_log_type(from._internal_log_type());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_version_string(from._internal_version_string());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_log_contents(from._internal_log_contents());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.appid_ = from._impl_.appid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Request::CopyFrom(const CHelpRequestLogs_UploadUserApplicationLog_Request& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CHelpRequestLogs_UploadUserApplicationLog_Request)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CHelpRequestLogs_UploadUserApplicationLog_Request::IsInitialized() const {
+  return true;
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Request::InternalSwap(CHelpRequestLogs_UploadUserApplicationLog_Request* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.log_type_, lhs_arena,
+      &other->_impl_.log_type_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_string_, lhs_arena,
+      &other->_impl_.version_string_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.log_contents_, lhs_arena,
+      &other->_impl_.log_contents_, rhs_arena
+  );
+  swap(_impl_.appid_, other->_impl_.appid_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CHelpRequestLogs_UploadUserApplicationLog_Request::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_getter, &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_once,
+      file_level_metadata_steammessages_5fhelprequest_2esteamworkssdk_2eproto[0]);
+}
+
+// ===================================================================
+
+class CHelpRequestLogs_UploadUserApplicationLog_Response::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CHelpRequestLogs_UploadUserApplicationLog_Response>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+CHelpRequestLogs_UploadUserApplicationLog_Response::CHelpRequestLogs_UploadUserApplicationLog_Response(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CHelpRequestLogs_UploadUserApplicationLog_Response)
+}
+CHelpRequestLogs_UploadUserApplicationLog_Response::CHelpRequestLogs_UploadUserApplicationLog_Response(const CHelpRequestLogs_UploadUserApplicationLog_Response& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CHelpRequestLogs_UploadUserApplicationLog_Response* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.id_ = from._impl_.id_;
+  // @@protoc_insertion_point(copy_constructor:CHelpRequestLogs_UploadUserApplicationLog_Response)
+}
+
+inline void CHelpRequestLogs_UploadUserApplicationLog_Response::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){uint64_t{0u}}
+  };
+}
+
+CHelpRequestLogs_UploadUserApplicationLog_Response::~CHelpRequestLogs_UploadUserApplicationLog_Response() {
+  // @@protoc_insertion_point(destructor:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CHelpRequestLogs_UploadUserApplicationLog_Response::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Response::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Response::Clear() {
+// @@protoc_insertion_point(message_clear_start:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.id_ = uint64_t{0u};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CHelpRequestLogs_UploadUserApplicationLog_Response::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint64 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_id(&has_bits);
+          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CHelpRequestLogs_UploadUserApplicationLog_Response::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint64 id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  return target;
+}
+
+size_t CHelpRequestLogs_UploadUserApplicationLog_Response::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional uint64 id = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CHelpRequestLogs_UploadUserApplicationLog_Response::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CHelpRequestLogs_UploadUserApplicationLog_Response::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CHelpRequestLogs_UploadUserApplicationLog_Response::GetClassData() const { return &_class_data_; }
+
+
+void CHelpRequestLogs_UploadUserApplicationLog_Response::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CHelpRequestLogs_UploadUserApplicationLog_Response*>(&to_msg);
+  auto& from = static_cast<const CHelpRequestLogs_UploadUserApplicationLog_Response&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_id()) {
+    _this->_internal_set_id(from._internal_id());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Response::CopyFrom(const CHelpRequestLogs_UploadUserApplicationLog_Response& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CHelpRequestLogs_UploadUserApplicationLog_Response)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CHelpRequestLogs_UploadUserApplicationLog_Response::IsInitialized() const {
+  return true;
+}
+
+void CHelpRequestLogs_UploadUserApplicationLog_Response::InternalSwap(CHelpRequestLogs_UploadUserApplicationLog_Response* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.id_, other->_impl_.id_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CHelpRequestLogs_UploadUserApplicationLog_Response::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_getter, &descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto_once,
+      file_level_metadata_steammessages_5fhelprequest_2esteamworkssdk_2eproto[1]);
+}
+
+// ===================================================================
+
+HelpRequestLogs::~HelpRequestLogs() {}
+
+const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor* HelpRequestLogs::descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto);
+  return file_level_service_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto[0];
+}
+
+const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor* HelpRequestLogs::GetDescriptor() {
+  return descriptor();
+}
+
+void HelpRequestLogs::UploadUserApplicationLog(::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                         const ::CHelpRequestLogs_UploadUserApplicationLog_Request*,
+                         ::CHelpRequestLogs_UploadUserApplicationLog_Response*,
+                         ::google::protobuf::Closure* done) {
+  controller->SetFailed("Method UploadUserApplicationLog() not implemented.");
+  done->Run();
+}
+
+void HelpRequestLogs::CallMethod(const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method,
+                             ::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                             const ::PROTOBUF_NAMESPACE_ID::Message* request,
+                             ::PROTOBUF_NAMESPACE_ID::Message* response,
+                             ::google::protobuf::Closure* done) {
+  GOOGLE_DCHECK_EQ(method->service(), file_level_service_descriptors_steammessages_5fhelprequest_2esteamworkssdk_2eproto[0]);
+  switch(method->index()) {
+    case 0:
+      UploadUserApplicationLog(controller,
+             ::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ::CHelpRequestLogs_UploadUserApplicationLog_Request*>(
+                 request),
+             ::PROTOBUF_NAMESPACE_ID::internal::DownCast<::CHelpRequestLogs_UploadUserApplicationLog_Response*>(
+                 response),
+             done);
+      break;
+    default:
+      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+      break;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message& HelpRequestLogs::GetRequestPrototype(
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method) const {
+  GOOGLE_DCHECK_EQ(method->service(), descriptor());
+  switch(method->index()) {
+    case 0:
+      return ::CHelpRequestLogs_UploadUserApplicationLog_Request::default_instance();
+    default:
+      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+      return *::PROTOBUF_NAMESPACE_ID::MessageFactory::generated_factory()
+          ->GetPrototype(method->input_type());
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message& HelpRequestLogs::GetResponsePrototype(
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method) const {
+  GOOGLE_DCHECK_EQ(method->service(), descriptor());
+  switch(method->index()) {
+    case 0:
+      return ::CHelpRequestLogs_UploadUserApplicationLog_Response::default_instance();
+    default:
+      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
+      return *::PROTOBUF_NAMESPACE_ID::MessageFactory::generated_factory()
+          ->GetPrototype(method->output_type());
+  }
+}
+
+HelpRequestLogs_Stub::HelpRequestLogs_Stub(::PROTOBUF_NAMESPACE_ID::RpcChannel* channel)
+  : channel_(channel), owns_channel_(false) {}
+HelpRequestLogs_Stub::HelpRequestLogs_Stub(
+    ::PROTOBUF_NAMESPACE_ID::RpcChannel* channel,
+    ::PROTOBUF_NAMESPACE_ID::Service::ChannelOwnership ownership)
+  : channel_(channel),
+    owns_channel_(ownership == ::PROTOBUF_NAMESPACE_ID::Service::STUB_OWNS_CHANNEL) {}
+HelpRequestLogs_Stub::~HelpRequestLogs_Stub() {
+  if (owns_channel_) delete channel_;
+}
+
+void HelpRequestLogs_Stub::UploadUserApplicationLog(::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                              const ::CHelpRequestLogs_UploadUserApplicationLog_Request* request,
+                              ::CHelpRequestLogs_UploadUserApplicationLog_Response* response,
+                              ::google::protobuf::Closure* done) {
+  channel_->CallMethod(descriptor()->method(0),
+                       controller, request, response, done);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::CHelpRequestLogs_UploadUserApplicationLog_Request*
+Arena::CreateMaybeMessage< ::CHelpRequestLogs_UploadUserApplicationLog_Request >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CHelpRequestLogs_UploadUserApplicationLog_Request >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CHelpRequestLogs_UploadUserApplicationLog_Response*
+Arena::CreateMaybeMessage< ::CHelpRequestLogs_UploadUserApplicationLog_Response >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CHelpRequestLogs_UploadUserApplicationLog_Response >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/steammessages_helprequest.steamworkssdk.pb.h

@@ -0,0 +1,786 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: steammessages_helprequest.steamworkssdk.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_steammessages_5fhelprequest_2esteamworkssdk_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_steammessages_5fhelprequest_2esteamworkssdk_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_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/service.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "steammessages_unified_base.steamworkssdk.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_steammessages_5fhelprequest_2esteamworkssdk_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_steammessages_5fhelprequest_2esteamworkssdk_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_steammessages_5fhelprequest_2esteamworkssdk_2eproto;
+class CHelpRequestLogs_UploadUserApplicationLog_Request;
+struct CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal;
+extern CHelpRequestLogs_UploadUserApplicationLog_RequestDefaultTypeInternal _CHelpRequestLogs_UploadUserApplicationLog_Request_default_instance_;
+class CHelpRequestLogs_UploadUserApplicationLog_Response;
+struct CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal;
+extern CHelpRequestLogs_UploadUserApplicationLog_ResponseDefaultTypeInternal _CHelpRequestLogs_UploadUserApplicationLog_Response_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::CHelpRequestLogs_UploadUserApplicationLog_Request* Arena::CreateMaybeMessage<::CHelpRequestLogs_UploadUserApplicationLog_Request>(Arena*);
+template<> ::CHelpRequestLogs_UploadUserApplicationLog_Response* Arena::CreateMaybeMessage<::CHelpRequestLogs_UploadUserApplicationLog_Response>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+// ===================================================================
+
+class CHelpRequestLogs_UploadUserApplicationLog_Request final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CHelpRequestLogs_UploadUserApplicationLog_Request) */ {
+ public:
+  inline CHelpRequestLogs_UploadUserApplicationLog_Request() : CHelpRequestLogs_UploadUserApplicationLog_Request(nullptr) {}
+  ~CHelpRequestLogs_UploadUserApplicationLog_Request() override;
+  explicit PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_Request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CHelpRequestLogs_UploadUserApplicationLog_Request(const CHelpRequestLogs_UploadUserApplicationLog_Request& from);
+  CHelpRequestLogs_UploadUserApplicationLog_Request(CHelpRequestLogs_UploadUserApplicationLog_Request&& from) noexcept
+    : CHelpRequestLogs_UploadUserApplicationLog_Request() {
+    *this = ::std::move(from);
+  }
+
+  inline CHelpRequestLogs_UploadUserApplicationLog_Request& operator=(const CHelpRequestLogs_UploadUserApplicationLog_Request& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CHelpRequestLogs_UploadUserApplicationLog_Request& operator=(CHelpRequestLogs_UploadUserApplicationLog_Request&& 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 CHelpRequestLogs_UploadUserApplicationLog_Request& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CHelpRequestLogs_UploadUserApplicationLog_Request* internal_default_instance() {
+    return reinterpret_cast<const CHelpRequestLogs_UploadUserApplicationLog_Request*>(
+               &_CHelpRequestLogs_UploadUserApplicationLog_Request_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CHelpRequestLogs_UploadUserApplicationLog_Request& a, CHelpRequestLogs_UploadUserApplicationLog_Request& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CHelpRequestLogs_UploadUserApplicationLog_Request* 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(CHelpRequestLogs_UploadUserApplicationLog_Request* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CHelpRequestLogs_UploadUserApplicationLog_Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CHelpRequestLogs_UploadUserApplicationLog_Request>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CHelpRequestLogs_UploadUserApplicationLog_Request& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CHelpRequestLogs_UploadUserApplicationLog_Request& from) {
+    CHelpRequestLogs_UploadUserApplicationLog_Request::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(CHelpRequestLogs_UploadUserApplicationLog_Request* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CHelpRequestLogs_UploadUserApplicationLog_Request";
+  }
+  protected:
+  explicit CHelpRequestLogs_UploadUserApplicationLog_Request(::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 {
+    kLogTypeFieldNumber = 2,
+    kVersionStringFieldNumber = 3,
+    kLogContentsFieldNumber = 4,
+    kAppidFieldNumber = 1,
+  };
+  // optional string log_type = 2;
+  bool has_log_type() const;
+  private:
+  bool _internal_has_log_type() const;
+  public:
+  void clear_log_type();
+  const std::string& log_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_log_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_log_type();
+  PROTOBUF_NODISCARD std::string* release_log_type();
+  void set_allocated_log_type(std::string* log_type);
+  private:
+  const std::string& _internal_log_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_type(const std::string& value);
+  std::string* _internal_mutable_log_type();
+  public:
+
+  // optional string version_string = 3;
+  bool has_version_string() const;
+  private:
+  bool _internal_has_version_string() const;
+  public:
+  void clear_version_string();
+  const std::string& version_string() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version_string(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version_string();
+  PROTOBUF_NODISCARD std::string* release_version_string();
+  void set_allocated_version_string(std::string* version_string);
+  private:
+  const std::string& _internal_version_string() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version_string(const std::string& value);
+  std::string* _internal_mutable_version_string();
+  public:
+
+  // optional string log_contents = 4;
+  bool has_log_contents() const;
+  private:
+  bool _internal_has_log_contents() const;
+  public:
+  void clear_log_contents();
+  const std::string& log_contents() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_log_contents(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_log_contents();
+  PROTOBUF_NODISCARD std::string* release_log_contents();
+  void set_allocated_log_contents(std::string* log_contents);
+  private:
+  const std::string& _internal_log_contents() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_contents(const std::string& value);
+  std::string* _internal_mutable_log_contents();
+  public:
+
+  // optional uint32 appid = 1;
+  bool has_appid() const;
+  private:
+  bool _internal_has_appid() const;
+  public:
+  void clear_appid();
+  uint32_t appid() const;
+  void set_appid(uint32_t value);
+  private:
+  uint32_t _internal_appid() const;
+  void _internal_set_appid(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CHelpRequestLogs_UploadUserApplicationLog_Request)
+ 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 log_type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_string_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_contents_;
+    uint32_t appid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_steammessages_5fhelprequest_2esteamworkssdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CHelpRequestLogs_UploadUserApplicationLog_Response final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CHelpRequestLogs_UploadUserApplicationLog_Response) */ {
+ public:
+  inline CHelpRequestLogs_UploadUserApplicationLog_Response() : CHelpRequestLogs_UploadUserApplicationLog_Response(nullptr) {}
+  ~CHelpRequestLogs_UploadUserApplicationLog_Response() override;
+  explicit PROTOBUF_CONSTEXPR CHelpRequestLogs_UploadUserApplicationLog_Response(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CHelpRequestLogs_UploadUserApplicationLog_Response(const CHelpRequestLogs_UploadUserApplicationLog_Response& from);
+  CHelpRequestLogs_UploadUserApplicationLog_Response(CHelpRequestLogs_UploadUserApplicationLog_Response&& from) noexcept
+    : CHelpRequestLogs_UploadUserApplicationLog_Response() {
+    *this = ::std::move(from);
+  }
+
+  inline CHelpRequestLogs_UploadUserApplicationLog_Response& operator=(const CHelpRequestLogs_UploadUserApplicationLog_Response& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CHelpRequestLogs_UploadUserApplicationLog_Response& operator=(CHelpRequestLogs_UploadUserApplicationLog_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 CHelpRequestLogs_UploadUserApplicationLog_Response& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CHelpRequestLogs_UploadUserApplicationLog_Response* internal_default_instance() {
+    return reinterpret_cast<const CHelpRequestLogs_UploadUserApplicationLog_Response*>(
+               &_CHelpRequestLogs_UploadUserApplicationLog_Response_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CHelpRequestLogs_UploadUserApplicationLog_Response& a, CHelpRequestLogs_UploadUserApplicationLog_Response& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CHelpRequestLogs_UploadUserApplicationLog_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(CHelpRequestLogs_UploadUserApplicationLog_Response* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CHelpRequestLogs_UploadUserApplicationLog_Response* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CHelpRequestLogs_UploadUserApplicationLog_Response>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CHelpRequestLogs_UploadUserApplicationLog_Response& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CHelpRequestLogs_UploadUserApplicationLog_Response& from) {
+    CHelpRequestLogs_UploadUserApplicationLog_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(CHelpRequestLogs_UploadUserApplicationLog_Response* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CHelpRequestLogs_UploadUserApplicationLog_Response";
+  }
+  protected:
+  explicit CHelpRequestLogs_UploadUserApplicationLog_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 ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+  };
+  // optional uint64 id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  uint64_t id() const;
+  void set_id(uint64_t value);
+  private:
+  uint64_t _internal_id() const;
+  void _internal_set_id(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CHelpRequestLogs_UploadUserApplicationLog_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_;
+    uint64_t id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_steammessages_5fhelprequest_2esteamworkssdk_2eproto;
+};
+// ===================================================================
+
+class HelpRequestLogs_Stub;
+
+class HelpRequestLogs : public ::PROTOBUF_NAMESPACE_ID::Service {
+ protected:
+  // This class should be treated as an abstract interface.
+  inline HelpRequestLogs() {};
+ public:
+  virtual ~HelpRequestLogs();
+
+  typedef HelpRequestLogs_Stub Stub;
+
+  static const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor* descriptor();
+
+  virtual void UploadUserApplicationLog(::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                       const ::CHelpRequestLogs_UploadUserApplicationLog_Request* request,
+                       ::CHelpRequestLogs_UploadUserApplicationLog_Response* response,
+                       ::google::protobuf::Closure* done);
+
+  // implements Service ----------------------------------------------
+
+  const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor* GetDescriptor();
+  void CallMethod(const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method,
+                  ::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                  const ::PROTOBUF_NAMESPACE_ID::Message* request,
+                  ::PROTOBUF_NAMESPACE_ID::Message* response,
+                  ::google::protobuf::Closure* done);
+  const ::PROTOBUF_NAMESPACE_ID::Message& GetRequestPrototype(
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method) const;
+  const ::PROTOBUF_NAMESPACE_ID::Message& GetResponsePrototype(
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptor* method) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(HelpRequestLogs);
+};
+
+class HelpRequestLogs_Stub : public HelpRequestLogs {
+ public:
+  HelpRequestLogs_Stub(::PROTOBUF_NAMESPACE_ID::RpcChannel* channel);
+  HelpRequestLogs_Stub(::PROTOBUF_NAMESPACE_ID::RpcChannel* channel,
+                   ::PROTOBUF_NAMESPACE_ID::Service::ChannelOwnership ownership);
+  ~HelpRequestLogs_Stub();
+
+  inline ::PROTOBUF_NAMESPACE_ID::RpcChannel* channel() { return channel_; }
+
+  // implements HelpRequestLogs ------------------------------------------
+
+  void UploadUserApplicationLog(::PROTOBUF_NAMESPACE_ID::RpcController* controller,
+                       const ::CHelpRequestLogs_UploadUserApplicationLog_Request* request,
+                       ::CHelpRequestLogs_UploadUserApplicationLog_Response* response,
+                       ::google::protobuf::Closure* done);
+ private:
+  ::PROTOBUF_NAMESPACE_ID::RpcChannel* channel_;
+  bool owns_channel_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(HelpRequestLogs_Stub);
+};
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CHelpRequestLogs_UploadUserApplicationLog_Request
+
+// optional uint32 appid = 1;
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_has_appid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::has_appid() const {
+  return _internal_has_appid();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::clear_appid() {
+  _impl_.appid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_appid() const {
+  return _impl_.appid_;
+}
+inline uint32_t CHelpRequestLogs_UploadUserApplicationLog_Request::appid() const {
+  // @@protoc_insertion_point(field_get:CHelpRequestLogs_UploadUserApplicationLog_Request.appid)
+  return _internal_appid();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_set_appid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.appid_ = value;
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::set_appid(uint32_t value) {
+  _internal_set_appid(value);
+  // @@protoc_insertion_point(field_set:CHelpRequestLogs_UploadUserApplicationLog_Request.appid)
+}
+
+// optional string log_type = 2;
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_has_log_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::has_log_type() const {
+  return _internal_has_log_type();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::clear_log_type() {
+  _impl_.log_type_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::log_type() const {
+  // @@protoc_insertion_point(field_get:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+  return _internal_log_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CHelpRequestLogs_UploadUserApplicationLog_Request::set_log_type(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.log_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::mutable_log_type() {
+  std::string* _s = _internal_mutable_log_type();
+  // @@protoc_insertion_point(field_mutable:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+  return _s;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_log_type() const {
+  return _impl_.log_type_.Get();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_set_log_type(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.log_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_mutable_log_type() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.log_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::release_log_type() {
+  // @@protoc_insertion_point(field_release:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+  if (!_internal_has_log_type()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.log_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.log_type_.IsDefault()) {
+    _impl_.log_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::set_allocated_log_type(std::string* log_type) {
+  if (log_type != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.log_type_.SetAllocated(log_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.log_type_.IsDefault()) {
+    _impl_.log_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CHelpRequestLogs_UploadUserApplicationLog_Request.log_type)
+}
+
+// optional string version_string = 3;
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_has_version_string() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::has_version_string() const {
+  return _internal_has_version_string();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::clear_version_string() {
+  _impl_.version_string_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::version_string() const {
+  // @@protoc_insertion_point(field_get:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+  return _internal_version_string();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CHelpRequestLogs_UploadUserApplicationLog_Request::set_version_string(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.version_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::mutable_version_string() {
+  std::string* _s = _internal_mutable_version_string();
+  // @@protoc_insertion_point(field_mutable:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+  return _s;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_version_string() const {
+  return _impl_.version_string_.Get();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_set_version_string(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.version_string_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_mutable_version_string() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.version_string_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::release_version_string() {
+  // @@protoc_insertion_point(field_release:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+  if (!_internal_has_version_string()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.version_string_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_string_.IsDefault()) {
+    _impl_.version_string_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::set_allocated_version_string(std::string* version_string) {
+  if (version_string != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_string_.SetAllocated(version_string, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_string_.IsDefault()) {
+    _impl_.version_string_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CHelpRequestLogs_UploadUserApplicationLog_Request.version_string)
+}
+
+// optional string log_contents = 4;
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_has_log_contents() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Request::has_log_contents() const {
+  return _internal_has_log_contents();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::clear_log_contents() {
+  _impl_.log_contents_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::log_contents() const {
+  // @@protoc_insertion_point(field_get:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+  return _internal_log_contents();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CHelpRequestLogs_UploadUserApplicationLog_Request::set_log_contents(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.log_contents_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::mutable_log_contents() {
+  std::string* _s = _internal_mutable_log_contents();
+  // @@protoc_insertion_point(field_mutable:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+  return _s;
+}
+inline const std::string& CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_log_contents() const {
+  return _impl_.log_contents_.Get();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_set_log_contents(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.log_contents_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::_internal_mutable_log_contents() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.log_contents_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CHelpRequestLogs_UploadUserApplicationLog_Request::release_log_contents() {
+  // @@protoc_insertion_point(field_release:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+  if (!_internal_has_log_contents()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.log_contents_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.log_contents_.IsDefault()) {
+    _impl_.log_contents_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Request::set_allocated_log_contents(std::string* log_contents) {
+  if (log_contents != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.log_contents_.SetAllocated(log_contents, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.log_contents_.IsDefault()) {
+    _impl_.log_contents_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CHelpRequestLogs_UploadUserApplicationLog_Request.log_contents)
+}
+
+// -------------------------------------------------------------------
+
+// CHelpRequestLogs_UploadUserApplicationLog_Response
+
+// optional uint64 id = 1;
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Response::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CHelpRequestLogs_UploadUserApplicationLog_Response::has_id() const {
+  return _internal_has_id();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Response::clear_id() {
+  _impl_.id_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline uint64_t CHelpRequestLogs_UploadUserApplicationLog_Response::_internal_id() const {
+  return _impl_.id_;
+}
+inline uint64_t CHelpRequestLogs_UploadUserApplicationLog_Response::id() const {
+  // @@protoc_insertion_point(field_get:CHelpRequestLogs_UploadUserApplicationLog_Response.id)
+  return _internal_id();
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Response::_internal_set_id(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_ = value;
+}
+inline void CHelpRequestLogs_UploadUserApplicationLog_Response::set_id(uint64_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:CHelpRequestLogs_UploadUserApplicationLog_Response.id)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_steammessages_5fhelprequest_2esteamworkssdk_2eproto

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/steammessages_oauth.steamworkssdk.pb.cc

@@ -0,0 +1,642 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: steammessages_oauth.steamworkssdk.proto
+
+#include "steammessages_oauth.steamworkssdk.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_Request::COAuthToken_ImplicitGrantNoPrompt_Request(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.clientid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal() {}
+  union {
+    COAuthToken_ImplicitGrantNoPrompt_Request _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal _COAuthToken_ImplicitGrantNoPrompt_Request_default_instance_;
+PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_Response::COAuthToken_ImplicitGrantNoPrompt_Response(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.access_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.redirect_uri_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal() {}
+  union {
+    COAuthToken_ImplicitGrantNoPrompt_Response _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal _COAuthToken_ImplicitGrantNoPrompt_Response_default_instance_;
+static ::_pb::Metadata file_level_metadata_steammessages_5foauth_2esteamworkssdk_2eproto[2];
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_steammessages_5foauth_2esteamworkssdk_2eproto = nullptr;
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_steammessages_5foauth_2esteamworkssdk_2eproto = nullptr;
+
+const uint32_t TableStruct_steammessages_5foauth_2esteamworkssdk_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Request, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Request, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Request, _impl_.clientid_),
+  0,
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Response, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Response, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Response, _impl_.access_token_),
+  PROTOBUF_FIELD_OFFSET(::COAuthToken_ImplicitGrantNoPrompt_Response, _impl_.redirect_uri_),
+  0,
+  1,
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, 7, -1, sizeof(::COAuthToken_ImplicitGrantNoPrompt_Request)},
+  { 8, 16, -1, sizeof(::COAuthToken_ImplicitGrantNoPrompt_Response)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_COAuthToken_ImplicitGrantNoPrompt_Request_default_instance_._instance,
+  &::_COAuthToken_ImplicitGrantNoPrompt_Response_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_steammessages_5foauth_2esteamworkssdk_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\'steammessages_oauth.steamworkssdk.prot"
+  "o\032.steammessages_unified_base.steamworks"
+  "sdk.proto\"{\n)COAuthToken_ImplicitGrantNo"
+  "Prompt_Request\022N\n\010clientid\030\001 \001(\tB<\202\265\0308Cl"
+  "ient ID for which to count the number of"
+  " issued tokens\"\267\001\n*COAuthToken_ImplicitG"
+  "rantNoPrompt_Response\0229\n\014access_token\030\001 "
+  "\001(\tB#\202\265\030\037OAuth Token, granted on success"
+  "\022N\n\014redirect_uri\030\002 \001(\tB8\202\265\0304Redirection "
+  "URI provided during client registration."
+  "2\261\002\n\nOAuthToken\022\353\001\n\025ImplicitGrantNoPromp"
+  "t\022*.COAuthToken_ImplicitGrantNoPrompt_Re"
+  "quest\032+.COAuthToken_ImplicitGrantNoPromp"
+  "t_Response\"y\202\265\030uGrants an implicit OAuth"
+  " token (grant type \'token\') for the spec"
+  "ified client ID on behalf of a user with"
+  "out prompting\0325\202\265\0301Service containing me"
+  "thods to manage OAuth tokens"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_deps[1] = {
+  &::descriptor_table_steammessages_5funified_5fbase_2esteamworkssdk_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto = {
+    false, false, 708, descriptor_table_protodef_steammessages_5foauth_2esteamworkssdk_2eproto,
+    "steammessages_oauth.steamworkssdk.proto",
+    &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_once, descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_deps, 1, 2,
+    schemas, file_default_instances, TableStruct_steammessages_5foauth_2esteamworkssdk_2eproto::offsets,
+    file_level_metadata_steammessages_5foauth_2esteamworkssdk_2eproto, file_level_enum_descriptors_steammessages_5foauth_2esteamworkssdk_2eproto,
+    file_level_service_descriptors_steammessages_5foauth_2esteamworkssdk_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_getter() {
+  return &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_steammessages_5foauth_2esteamworkssdk_2eproto(&descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto);
+
+// ===================================================================
+
+class COAuthToken_ImplicitGrantNoPrompt_Request::_Internal {
+ public:
+  using HasBits = decltype(std::declval<COAuthToken_ImplicitGrantNoPrompt_Request>()._impl_._has_bits_);
+  static void set_has_clientid(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+COAuthToken_ImplicitGrantNoPrompt_Request::COAuthToken_ImplicitGrantNoPrompt_Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:COAuthToken_ImplicitGrantNoPrompt_Request)
+}
+COAuthToken_ImplicitGrantNoPrompt_Request::COAuthToken_ImplicitGrantNoPrompt_Request(const COAuthToken_ImplicitGrantNoPrompt_Request& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  COAuthToken_ImplicitGrantNoPrompt_Request* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.clientid_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.clientid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.clientid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_clientid()) {
+    _this->_impl_.clientid_.Set(from._internal_clientid(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:COAuthToken_ImplicitGrantNoPrompt_Request)
+}
+
+inline void COAuthToken_ImplicitGrantNoPrompt_Request::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.clientid_){}
+  };
+  _impl_.clientid_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.clientid_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+COAuthToken_ImplicitGrantNoPrompt_Request::~COAuthToken_ImplicitGrantNoPrompt_Request() {
+  // @@protoc_insertion_point(destructor:COAuthToken_ImplicitGrantNoPrompt_Request)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void COAuthToken_ImplicitGrantNoPrompt_Request::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.clientid_.Destroy();
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Request::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Request::Clear() {
+// @@protoc_insertion_point(message_clear_start:COAuthToken_ImplicitGrantNoPrompt_Request)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.clientid_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* COAuthToken_ImplicitGrantNoPrompt_Request::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string clientid = 1 [(.description) = "Client ID for which to count the number of issued tokens"];
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_clientid();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "COAuthToken_ImplicitGrantNoPrompt_Request.clientid");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* COAuthToken_ImplicitGrantNoPrompt_Request::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:COAuthToken_ImplicitGrantNoPrompt_Request)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string clientid = 1 [(.description) = "Client ID for which to count the number of issued tokens"];
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_clientid().data(), static_cast<int>(this->_internal_clientid().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "COAuthToken_ImplicitGrantNoPrompt_Request.clientid");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_clientid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:COAuthToken_ImplicitGrantNoPrompt_Request)
+  return target;
+}
+
+size_t COAuthToken_ImplicitGrantNoPrompt_Request::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:COAuthToken_ImplicitGrantNoPrompt_Request)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string clientid = 1 [(.description) = "Client ID for which to count the number of issued tokens"];
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_clientid());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData COAuthToken_ImplicitGrantNoPrompt_Request::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    COAuthToken_ImplicitGrantNoPrompt_Request::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*COAuthToken_ImplicitGrantNoPrompt_Request::GetClassData() const { return &_class_data_; }
+
+
+void COAuthToken_ImplicitGrantNoPrompt_Request::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<COAuthToken_ImplicitGrantNoPrompt_Request*>(&to_msg);
+  auto& from = static_cast<const COAuthToken_ImplicitGrantNoPrompt_Request&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:COAuthToken_ImplicitGrantNoPrompt_Request)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_clientid()) {
+    _this->_internal_set_clientid(from._internal_clientid());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Request::CopyFrom(const COAuthToken_ImplicitGrantNoPrompt_Request& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:COAuthToken_ImplicitGrantNoPrompt_Request)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool COAuthToken_ImplicitGrantNoPrompt_Request::IsInitialized() const {
+  return true;
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Request::InternalSwap(COAuthToken_ImplicitGrantNoPrompt_Request* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.clientid_, lhs_arena,
+      &other->_impl_.clientid_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata COAuthToken_ImplicitGrantNoPrompt_Request::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_getter, &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_once,
+      file_level_metadata_steammessages_5foauth_2esteamworkssdk_2eproto[0]);
+}
+
+// ===================================================================
+
+class COAuthToken_ImplicitGrantNoPrompt_Response::_Internal {
+ public:
+  using HasBits = decltype(std::declval<COAuthToken_ImplicitGrantNoPrompt_Response>()._impl_._has_bits_);
+  static void set_has_access_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_redirect_uri(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+COAuthToken_ImplicitGrantNoPrompt_Response::COAuthToken_ImplicitGrantNoPrompt_Response(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:COAuthToken_ImplicitGrantNoPrompt_Response)
+}
+COAuthToken_ImplicitGrantNoPrompt_Response::COAuthToken_ImplicitGrantNoPrompt_Response(const COAuthToken_ImplicitGrantNoPrompt_Response& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  COAuthToken_ImplicitGrantNoPrompt_Response* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.access_token_){}
+    , decltype(_impl_.redirect_uri_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.access_token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.access_token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_access_token()) {
+    _this->_impl_.access_token_.Set(from._internal_access_token(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.redirect_uri_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.redirect_uri_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_redirect_uri()) {
+    _this->_impl_.redirect_uri_.Set(from._internal_redirect_uri(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:COAuthToken_ImplicitGrantNoPrompt_Response)
+}
+
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.access_token_){}
+    , decltype(_impl_.redirect_uri_){}
+  };
+  _impl_.access_token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.access_token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.redirect_uri_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.redirect_uri_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+COAuthToken_ImplicitGrantNoPrompt_Response::~COAuthToken_ImplicitGrantNoPrompt_Response() {
+  // @@protoc_insertion_point(destructor:COAuthToken_ImplicitGrantNoPrompt_Response)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.access_token_.Destroy();
+  _impl_.redirect_uri_.Destroy();
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Response::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Response::Clear() {
+// @@protoc_insertion_point(message_clear_start:COAuthToken_ImplicitGrantNoPrompt_Response)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.access_token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.redirect_uri_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* COAuthToken_ImplicitGrantNoPrompt_Response::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string access_token = 1 [(.description) = "OAuth Token, granted on success"];
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_access_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "COAuthToken_ImplicitGrantNoPrompt_Response.access_token");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string redirect_uri = 2 [(.description) = "Redirection URI provided during client registration."];
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_redirect_uri();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          #ifndef NDEBUG
+          ::_pbi::VerifyUTF8(str, "COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri");
+          #endif  // !NDEBUG
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* COAuthToken_ImplicitGrantNoPrompt_Response::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:COAuthToken_ImplicitGrantNoPrompt_Response)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string access_token = 1 [(.description) = "OAuth Token, granted on success"];
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_access_token().data(), static_cast<int>(this->_internal_access_token().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "COAuthToken_ImplicitGrantNoPrompt_Response.access_token");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_access_token(), target);
+  }
+
+  // optional string redirect_uri = 2 [(.description) = "Redirection URI provided during client registration."];
+  if (cached_has_bits & 0x00000002u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_redirect_uri().data(), static_cast<int>(this->_internal_redirect_uri().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_redirect_uri(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:COAuthToken_ImplicitGrantNoPrompt_Response)
+  return target;
+}
+
+size_t COAuthToken_ImplicitGrantNoPrompt_Response::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:COAuthToken_ImplicitGrantNoPrompt_Response)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string access_token = 1 [(.description) = "OAuth Token, granted on success"];
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_access_token());
+    }
+
+    // optional string redirect_uri = 2 [(.description) = "Redirection URI provided during client registration."];
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_redirect_uri());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData COAuthToken_ImplicitGrantNoPrompt_Response::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    COAuthToken_ImplicitGrantNoPrompt_Response::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*COAuthToken_ImplicitGrantNoPrompt_Response::GetClassData() const { return &_class_data_; }
+
+
+void COAuthToken_ImplicitGrantNoPrompt_Response::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<COAuthToken_ImplicitGrantNoPrompt_Response*>(&to_msg);
+  auto& from = static_cast<const COAuthToken_ImplicitGrantNoPrompt_Response&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:COAuthToken_ImplicitGrantNoPrompt_Response)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_access_token(from._internal_access_token());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_redirect_uri(from._internal_redirect_uri());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Response::CopyFrom(const COAuthToken_ImplicitGrantNoPrompt_Response& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:COAuthToken_ImplicitGrantNoPrompt_Response)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool COAuthToken_ImplicitGrantNoPrompt_Response::IsInitialized() const {
+  return true;
+}
+
+void COAuthToken_ImplicitGrantNoPrompt_Response::InternalSwap(COAuthToken_ImplicitGrantNoPrompt_Response* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.access_token_, lhs_arena,
+      &other->_impl_.access_token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.redirect_uri_, lhs_arena,
+      &other->_impl_.redirect_uri_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata COAuthToken_ImplicitGrantNoPrompt_Response::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_getter, &descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto_once,
+      file_level_metadata_steammessages_5foauth_2esteamworkssdk_2eproto[1]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::COAuthToken_ImplicitGrantNoPrompt_Request*
+Arena::CreateMaybeMessage< ::COAuthToken_ImplicitGrantNoPrompt_Request >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::COAuthToken_ImplicitGrantNoPrompt_Request >(arena);
+}
+template<> PROTOBUF_NOINLINE ::COAuthToken_ImplicitGrantNoPrompt_Response*
+Arena::CreateMaybeMessage< ::COAuthToken_ImplicitGrantNoPrompt_Response >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::COAuthToken_ImplicitGrantNoPrompt_Response >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

Andromeda-CS2-Base/Andromeda-CS2-Base/CS2/Protobuf/steammessages_oauth.steamworkssdk.pb.h

@@ -0,0 +1,640 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: steammessages_oauth.steamworkssdk.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_steammessages_5foauth_2esteamworkssdk_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_steammessages_5foauth_2esteamworkssdk_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_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/unknown_field_set.h>
+#include "steammessages_unified_base.steamworkssdk.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_steammessages_5foauth_2esteamworkssdk_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_steammessages_5foauth_2esteamworkssdk_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_steammessages_5foauth_2esteamworkssdk_2eproto;
+class COAuthToken_ImplicitGrantNoPrompt_Request;
+struct COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal;
+extern COAuthToken_ImplicitGrantNoPrompt_RequestDefaultTypeInternal _COAuthToken_ImplicitGrantNoPrompt_Request_default_instance_;
+class COAuthToken_ImplicitGrantNoPrompt_Response;
+struct COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal;
+extern COAuthToken_ImplicitGrantNoPrompt_ResponseDefaultTypeInternal _COAuthToken_ImplicitGrantNoPrompt_Response_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::COAuthToken_ImplicitGrantNoPrompt_Request* Arena::CreateMaybeMessage<::COAuthToken_ImplicitGrantNoPrompt_Request>(Arena*);
+template<> ::COAuthToken_ImplicitGrantNoPrompt_Response* Arena::CreateMaybeMessage<::COAuthToken_ImplicitGrantNoPrompt_Response>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+// ===================================================================
+
+class COAuthToken_ImplicitGrantNoPrompt_Request final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:COAuthToken_ImplicitGrantNoPrompt_Request) */ {
+ public:
+  inline COAuthToken_ImplicitGrantNoPrompt_Request() : COAuthToken_ImplicitGrantNoPrompt_Request(nullptr) {}
+  ~COAuthToken_ImplicitGrantNoPrompt_Request() override;
+  explicit PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_Request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  COAuthToken_ImplicitGrantNoPrompt_Request(const COAuthToken_ImplicitGrantNoPrompt_Request& from);
+  COAuthToken_ImplicitGrantNoPrompt_Request(COAuthToken_ImplicitGrantNoPrompt_Request&& from) noexcept
+    : COAuthToken_ImplicitGrantNoPrompt_Request() {
+    *this = ::std::move(from);
+  }
+
+  inline COAuthToken_ImplicitGrantNoPrompt_Request& operator=(const COAuthToken_ImplicitGrantNoPrompt_Request& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline COAuthToken_ImplicitGrantNoPrompt_Request& operator=(COAuthToken_ImplicitGrantNoPrompt_Request&& 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 COAuthToken_ImplicitGrantNoPrompt_Request& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const COAuthToken_ImplicitGrantNoPrompt_Request* internal_default_instance() {
+    return reinterpret_cast<const COAuthToken_ImplicitGrantNoPrompt_Request*>(
+               &_COAuthToken_ImplicitGrantNoPrompt_Request_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(COAuthToken_ImplicitGrantNoPrompt_Request& a, COAuthToken_ImplicitGrantNoPrompt_Request& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(COAuthToken_ImplicitGrantNoPrompt_Request* 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(COAuthToken_ImplicitGrantNoPrompt_Request* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  COAuthToken_ImplicitGrantNoPrompt_Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<COAuthToken_ImplicitGrantNoPrompt_Request>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const COAuthToken_ImplicitGrantNoPrompt_Request& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const COAuthToken_ImplicitGrantNoPrompt_Request& from) {
+    COAuthToken_ImplicitGrantNoPrompt_Request::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(COAuthToken_ImplicitGrantNoPrompt_Request* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "COAuthToken_ImplicitGrantNoPrompt_Request";
+  }
+  protected:
+  explicit COAuthToken_ImplicitGrantNoPrompt_Request(::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 {
+    kClientidFieldNumber = 1,
+  };
+  // optional string clientid = 1 [(.description) = "Client ID for which to count the number of issued tokens"];
+  bool has_clientid() const;
+  private:
+  bool _internal_has_clientid() const;
+  public:
+  void clear_clientid();
+  const std::string& clientid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_clientid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_clientid();
+  PROTOBUF_NODISCARD std::string* release_clientid();
+  void set_allocated_clientid(std::string* clientid);
+  private:
+  const std::string& _internal_clientid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_clientid(const std::string& value);
+  std::string* _internal_mutable_clientid();
+  public:
+
+  // @@protoc_insertion_point(class_scope:COAuthToken_ImplicitGrantNoPrompt_Request)
+ 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 clientid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_steammessages_5foauth_2esteamworkssdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class COAuthToken_ImplicitGrantNoPrompt_Response final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:COAuthToken_ImplicitGrantNoPrompt_Response) */ {
+ public:
+  inline COAuthToken_ImplicitGrantNoPrompt_Response() : COAuthToken_ImplicitGrantNoPrompt_Response(nullptr) {}
+  ~COAuthToken_ImplicitGrantNoPrompt_Response() override;
+  explicit PROTOBUF_CONSTEXPR COAuthToken_ImplicitGrantNoPrompt_Response(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  COAuthToken_ImplicitGrantNoPrompt_Response(const COAuthToken_ImplicitGrantNoPrompt_Response& from);
+  COAuthToken_ImplicitGrantNoPrompt_Response(COAuthToken_ImplicitGrantNoPrompt_Response&& from) noexcept
+    : COAuthToken_ImplicitGrantNoPrompt_Response() {
+    *this = ::std::move(from);
+  }
+
+  inline COAuthToken_ImplicitGrantNoPrompt_Response& operator=(const COAuthToken_ImplicitGrantNoPrompt_Response& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline COAuthToken_ImplicitGrantNoPrompt_Response& operator=(COAuthToken_ImplicitGrantNoPrompt_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 COAuthToken_ImplicitGrantNoPrompt_Response& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const COAuthToken_ImplicitGrantNoPrompt_Response* internal_default_instance() {
+    return reinterpret_cast<const COAuthToken_ImplicitGrantNoPrompt_Response*>(
+               &_COAuthToken_ImplicitGrantNoPrompt_Response_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(COAuthToken_ImplicitGrantNoPrompt_Response& a, COAuthToken_ImplicitGrantNoPrompt_Response& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(COAuthToken_ImplicitGrantNoPrompt_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(COAuthToken_ImplicitGrantNoPrompt_Response* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  COAuthToken_ImplicitGrantNoPrompt_Response* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<COAuthToken_ImplicitGrantNoPrompt_Response>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const COAuthToken_ImplicitGrantNoPrompt_Response& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const COAuthToken_ImplicitGrantNoPrompt_Response& from) {
+    COAuthToken_ImplicitGrantNoPrompt_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(COAuthToken_ImplicitGrantNoPrompt_Response* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "COAuthToken_ImplicitGrantNoPrompt_Response";
+  }
+  protected:
+  explicit COAuthToken_ImplicitGrantNoPrompt_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 ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAccessTokenFieldNumber = 1,
+    kRedirectUriFieldNumber = 2,
+  };
+  // optional string access_token = 1 [(.description) = "OAuth Token, granted on success"];
+  bool has_access_token() const;
+  private:
+  bool _internal_has_access_token() const;
+  public:
+  void clear_access_token();
+  const std::string& access_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_access_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_access_token();
+  PROTOBUF_NODISCARD std::string* release_access_token();
+  void set_allocated_access_token(std::string* access_token);
+  private:
+  const std::string& _internal_access_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_access_token(const std::string& value);
+  std::string* _internal_mutable_access_token();
+  public:
+
+  // optional string redirect_uri = 2 [(.description) = "Redirection URI provided during client registration."];
+  bool has_redirect_uri() const;
+  private:
+  bool _internal_has_redirect_uri() const;
+  public:
+  void clear_redirect_uri();
+  const std::string& redirect_uri() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_redirect_uri(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_redirect_uri();
+  PROTOBUF_NODISCARD std::string* release_redirect_uri();
+  void set_allocated_redirect_uri(std::string* redirect_uri);
+  private:
+  const std::string& _internal_redirect_uri() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_redirect_uri(const std::string& value);
+  std::string* _internal_mutable_redirect_uri();
+  public:
+
+  // @@protoc_insertion_point(class_scope:COAuthToken_ImplicitGrantNoPrompt_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::internal::ArenaStringPtr access_token_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr redirect_uri_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_steammessages_5foauth_2esteamworkssdk_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// COAuthToken_ImplicitGrantNoPrompt_Request
+
+// optional string clientid = 1 [(.description) = "Client ID for which to count the number of issued tokens"];
+inline bool COAuthToken_ImplicitGrantNoPrompt_Request::_internal_has_clientid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool COAuthToken_ImplicitGrantNoPrompt_Request::has_clientid() const {
+  return _internal_has_clientid();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Request::clear_clientid() {
+  _impl_.clientid_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Request::clientid() const {
+  // @@protoc_insertion_point(field_get:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+  return _internal_clientid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void COAuthToken_ImplicitGrantNoPrompt_Request::set_clientid(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.clientid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Request::mutable_clientid() {
+  std::string* _s = _internal_mutable_clientid();
+  // @@protoc_insertion_point(field_mutable:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+  return _s;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Request::_internal_clientid() const {
+  return _impl_.clientid_.Get();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Request::_internal_set_clientid(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.clientid_.Set(value, GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Request::_internal_mutable_clientid() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.clientid_.Mutable(GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Request::release_clientid() {
+  // @@protoc_insertion_point(field_release:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+  if (!_internal_has_clientid()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.clientid_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.clientid_.IsDefault()) {
+    _impl_.clientid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Request::set_allocated_clientid(std::string* clientid) {
+  if (clientid != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.clientid_.SetAllocated(clientid, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.clientid_.IsDefault()) {
+    _impl_.clientid_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:COAuthToken_ImplicitGrantNoPrompt_Request.clientid)
+}
+
+// -------------------------------------------------------------------
+
+// COAuthToken_ImplicitGrantNoPrompt_Response
+
+// optional string access_token = 1 [(.description) = "OAuth Token, granted on success"];
+inline bool COAuthToken_ImplicitGrantNoPrompt_Response::_internal_has_access_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool COAuthToken_ImplicitGrantNoPrompt_Response::has_access_token() const {
+  return _internal_has_access_token();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::clear_access_token() {
+  _impl_.access_token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Response::access_token() const {
+  // @@protoc_insertion_point(field_get:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+  return _internal_access_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void COAuthToken_ImplicitGrantNoPrompt_Response::set_access_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.access_token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::mutable_access_token() {
+  std::string* _s = _internal_mutable_access_token();
+  // @@protoc_insertion_point(field_mutable:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+  return _s;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Response::_internal_access_token() const {
+  return _impl_.access_token_.Get();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::_internal_set_access_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.access_token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::_internal_mutable_access_token() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.access_token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::release_access_token() {
+  // @@protoc_insertion_point(field_release:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+  if (!_internal_has_access_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.access_token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.access_token_.IsDefault()) {
+    _impl_.access_token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::set_allocated_access_token(std::string* access_token) {
+  if (access_token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.access_token_.SetAllocated(access_token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.access_token_.IsDefault()) {
+    _impl_.access_token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:COAuthToken_ImplicitGrantNoPrompt_Response.access_token)
+}
+
+// optional string redirect_uri = 2 [(.description) = "Redirection URI provided during client registration."];
+inline bool COAuthToken_ImplicitGrantNoPrompt_Response::_internal_has_redirect_uri() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool COAuthToken_ImplicitGrantNoPrompt_Response::has_redirect_uri() const {
+  return _internal_has_redirect_uri();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::clear_redirect_uri() {
+  _impl_.redirect_uri_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Response::redirect_uri() const {
+  // @@protoc_insertion_point(field_get:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+  return _internal_redirect_uri();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void COAuthToken_ImplicitGrantNoPrompt_Response::set_redirect_uri(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.redirect_uri_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::mutable_redirect_uri() {
+  std::string* _s = _internal_mutable_redirect_uri();
+  // @@protoc_insertion_point(field_mutable:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+  return _s;
+}
+inline const std::string& COAuthToken_ImplicitGrantNoPrompt_Response::_internal_redirect_uri() const {
+  return _impl_.redirect_uri_.Get();
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::_internal_set_redirect_uri(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.redirect_uri_.Set(value, GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::_internal_mutable_redirect_uri() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.redirect_uri_.Mutable(GetArenaForAllocation());
+}
+inline std::string* COAuthToken_ImplicitGrantNoPrompt_Response::release_redirect_uri() {
+  // @@protoc_insertion_point(field_release:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+  if (!_internal_has_redirect_uri()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.redirect_uri_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.redirect_uri_.IsDefault()) {
+    _impl_.redirect_uri_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void COAuthToken_ImplicitGrantNoPrompt_Response::set_allocated_redirect_uri(std::string* redirect_uri) {
+  if (redirect_uri != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.redirect_uri_.SetAllocated(redirect_uri, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.redirect_uri_.IsDefault()) {
+    _impl_.redirect_uri_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:COAuthToken_ImplicitGrantNoPrompt_Response.redirect_uri)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_steammessages_5foauth_2esteamworkssdk_2eproto