diff options
Diffstat (limited to 'internal_rewrite')
177 files changed, 37746 insertions, 0 deletions
diff --git a/internal_rewrite/CHLClient.hpp b/internal_rewrite/CHLClient.hpp new file mode 100644 index 0000000..94d209f --- /dev/null +++ b/internal_rewrite/CHLClient.hpp @@ -0,0 +1,83 @@ +#pragma once +#include "util.hpp" +#include "IClientEntityList.hpp" +#include "ClientClass.hpp" +#include "color.hpp" + +enum ClientFrameStage_t { + FRAME_UNDEFINED = -1, + FRAME_START, + FRAME_NET_UPDATE_START, + FRAME_NET_UPDATE_POSTDATAUPDATE_START, + FRAME_NET_UPDATE_POSTDATAUPDATE_END, + FRAME_NET_UPDATE_END, + FRAME_RENDER_START, + FRAME_RENDER_END +}; + +struct GlowObject_t { + IClientEntity* m_pEntity; + fclr_t color; + char junk0[ 8 ]; + float m_flBloomAmount; + char junk1[ 4 ]; + bool m_bRenderWhenOccluded; + bool m_bRenderWhenUnoccluded; + bool m_bFullBloom; + char junk2[ 14 ]; +}; + +struct GlowObjectManager_t { + GlowObject_t* DataPtr; //0000 + unsigned int Max; //0004 + unsigned int unk02; //0008 + unsigned int Count; //000C + unsigned int DataPtrBack; //0010 + int m_nFirstFreeSlot; //0014 + unsigned int unk1; //0018 + unsigned int unk2; //001C + unsigned int unk3; //0020 + unsigned int unk4; //0024 + unsigned int unk5; //0028 +}; + +class IBaseClientDLL +{ +public: + ClientClass* GetAllClasses( ) { + using fn = ClientClass*( __thiscall* )( void* ); + return util::get_vfunc< fn >( this, 8 )( this ); + } + + /* + DONTCARE + void SetCrosshairAngle( Vector& angle ) + { + typedef void( __thiscall* SetCrosshairAngleFn )( void*, Vector& ); + CallVFunction<SetCrosshairAngleFn>( this, 29 )( this, angle ); + } + + void HudProcessInput( bool enable ) + { + using fn = void( __thiscall* )( void*, bool ); + CallVFunction<fn>( this, 10 )( this, enable ); + } + + void HudUpdate( bool enable ) + { + using fn = void( __thiscall* )( void*, bool ); + CallVFunction<fn>( this, 11 )( this, enable ); + } + + void IN_ActivateMouse( ) + { + using fn = void( __thiscall* )( void* ); + CallVFunction<fn>( this, 15 )( this ); + } + + void IN_DeactivateMouse( ) + { + using fn = void( __thiscall* )( void* ); + CallVFunction<fn>( this, 16 )( this ); + }*/ +};
\ No newline at end of file diff --git a/internal_rewrite/CInput.hpp b/internal_rewrite/CInput.hpp new file mode 100644 index 0000000..84802d3 --- /dev/null +++ b/internal_rewrite/CInput.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include "vector.hpp" +#include "IClientMode.hpp" + +#define MULTIPLAYER_BACKUP 150 + +struct verified_cmd_t { + user_cmd_t m_cmd; + CRC32_t m_crc; +}; + +class CInput { + void* pvftable; //0x00 +public: + bool m_fTrackIRAvailable; //0x04 + bool m_fMouseInitialized; //0x05 + bool m_fMouseActive; //0x06 + bool m_fJoystickAdvancedInit; //0x07 +private: + char pad_0x08[ 0x2C ]; //0x08 +public: + void* m_pKeys; //0x34 +private: + char pad_0x38[ 0x64 ]; //0x38 + int pad_0x41; + int pad_0x42; +public: + bool m_fCameraInterceptingMouse; //0x9C + bool m_fCameraInThirdPerson; //0x9D + bool m_fCameraMovingWithMouse; //0x9E + vec3_t m_vecCameraOffset; //0xA0 + bool m_fCameraDistanceMove; //0xAC + int m_nCameraOldX; //0xB0 + int m_nCameraOldY; //0xB4 + int m_nCameraX; //0xB8 + int m_nCameraY; //0xBC + bool m_CameraIsOrthographic; //0xC0 + vec3_t m_angPreviousViewAngles; //0xC4 + vec3_t m_angPreviousViewAnglesTilt; //0xD0 + float m_flLastForwardMove; //0xDC + int m_nClearInputState; //0xE0 +public: + user_cmd_t* m_pCommands; //0xEC + verified_cmd_t* m_pVerifiedCommands; //0xF0 + int m_hSelectedWeapon; + + user_cmd_t* GetUserCmd( int slot, int seq_num ) { + return util::get_vfunc< 8, user_cmd_t* >( this, slot, seq_num ); + } + + void CreateMove( int sequence_number, float input_sample_time, bool active ) { + return util::get_vfunc< 3, void >( this, sequence_number, input_sample_time, active ); + } +}; diff --git a/internal_rewrite/CUtlVector.hpp b/internal_rewrite/CUtlVector.hpp new file mode 100644 index 0000000..6e43505 --- /dev/null +++ b/internal_rewrite/CUtlVector.hpp @@ -0,0 +1,47 @@ +#pragma once + +template <typename T, typename I = int> +class CUtlMemory { +public: + T* GetBuffer( void ) { + return m_pMemory; + } + + int GetAllocationCount( void ) { + return m_nAllocationCount; + } + + int GetGrowSize( void ) { + return m_nGrowSize; + } + + T* OffsetBufferByIndex( size_t index ) { + return m_pMemory + index; + } + +private: + T* m_pMemory; + int m_nAllocationCount; + int m_nGrowSize; +}; + +template <typename T, typename Allocator = CUtlMemory<T>> +class CUtlVector { +public: + Allocator GetMemory( void ) { + return m_Memory; + } + + int GetSize( void ) { + return m_Size; + } + + T* GetElements( void ) { + return m_pElements; + } + +private: + Allocator m_Memory; + int m_Size; + T* m_pElements; +};
\ No newline at end of file diff --git a/internal_rewrite/ClientClass.hpp b/internal_rewrite/ClientClass.hpp new file mode 100644 index 0000000..fc1f140 --- /dev/null +++ b/internal_rewrite/ClientClass.hpp @@ -0,0 +1,272 @@ +#pragma once +#include "Valve/dt_common.h" +#include "Valve/dt_recv.h" + +enum ClassId_t { + CAI_BaseNPC, + CAK47, + CBaseAnimating, + CBaseAnimatingOverlay, + CBaseAttributableItem, + CBaseButton, + CBaseCombatCharacter, + CBaseCombatWeapon, + CBaseCSGrenade, + CBaseCSGrenadeProjectile, + CBaseDoor, + CBaseEntity_, + CBaseFlex, + CBaseGrenade, + CBaseParticleEntity, + CBasePlayer, + CBasePropDoor, + CBaseTeamObjectiveResource, + CBaseTempEntity, + CBaseToggle, + CBaseTrigger, + CBaseViewModel, + CBaseVPhysicsTrigger, + CBaseWeaponWorldModel, + CBeam, + CBeamSpotlight, + CBoneFollower, + CBreakableProp, + CBreakableSurface, + CC4, + CCascadeLight, + CChicken, + CColorCorrection, + CColorCorrectionVolume, + CCSGameRulesProxy, + CCSPlayer, + CCSPlayerResource, + CCSRagdoll, + CCSTeam, + CDEagle, + CDecoyGrenade, + CDecoyProjectile, + CDynamicLight, + CDynamicProp, + CEconEntity, + CEconWearable, + CEmbers, + CEntityDissolve, + CEntityFlame, + CEntityFreezing, + CEntityParticleTrail, + CEnvAmbientLight, + CEnvDetailController, + CEnvDOFController, + CEnvParticleScript, + CEnvProjectedTexture, + CEnvQuadraticBeam, + CEnvScreenEffect, + CEnvScreenOverlay, + CEnvTonemapController, + CEnvWind, + CFEPlayerDecal, + CFireCrackerBlast, + CFireSmoke, + CFireTrail, + CFish, + CFlashbang, + CFogController, + CFootstepControl, + CFunc_Dust, + CFunc_LOD, + CFuncAreaPortalWindow, + CFuncBrush, + CFuncConveyor, + CFuncLadder, + CFuncMonitor, + CFuncMoveLinear, + CFuncOccluder, + CFuncReflectiveGlass, + CFuncRotating, + CFuncSmokeVolume, + CFuncTrackTrain, + CGameRulesProxy, + CHandleTest, + CHEGrenade, + CHostage, + CHostageCarriableProp, + CIncendiaryGrenade, + CInferno, + CInfoLadderDismount, + CInfoOverlayAccessor, + CItem_Healthshot, + CItemDogtags, + CKnife, + CKnifeGG, + CLightGlow, + CMaterialModifyControl, + CMolotovGrenade, + CMolotovProjectile, + CMovieDisplay, + CParticleFire, + CParticlePerformanceMonitor, + CParticleSystem, + CPhysBox, + CPhysBoxMultiplayer, + CPhysicsProp, + CPhysicsPropMultiplayer, + CPhysMagnet, + CPlantedC4, + CPlasma, + CPlayerResource, + CPointCamera, + CPointCommentaryNode, + CPointWorldText, + CPoseController, + CPostProcessController, + CPrecipitation, + CPrecipitationBlocker, + CPredictedViewModel, + CProp_Hallucination, + CPropDoorRotating, + CPropJeep, + CPropVehicleDriveable, + CRagdollManager, + CRagdollProp, + CRagdollPropAttached, + CRopeKeyframe, + CSCAR17, + CSceneEntity, + CSensorGrenade, + CSensorGrenadeProjectile, + CShadowControl, + CSlideshowDisplay, + CSmokeGrenade, + CSmokeGrenadeProjectile, + CSmokeStack, + CSpatialEntity, + CSpotlightEnd, + CSprite, + CSpriteOriented, + CSpriteTrail, + CStatueProp, + CSteamJet, + CSun, + CSunlightShadowControl, + CTeam, + CTeamplayRoundBasedRulesProxy, + CTEArmorRicochet, + CTEBaseBeam, + CTEBeamEntPoint, + CTEBeamEnts, + CTEBeamFollow, + CTEBeamLaser, + CTEBeamPoints, + CTEBeamRing, + CTEBeamRingPoint, + CTEBeamSpline, + CTEBloodSprite, + CTEBloodStream, + CTEBreakModel, + CTEBSPDecal, + CTEBubbles, + CTEBubbleTrail, + CTEClientProjectile, + CTEDecal, + CTEDust, + CTEDynamicLight, + CTEEffectDispatch, + CTEEnergySplash, + CTEExplosion, + CTEFireBullets, + CTEFizz, + CTEFootprintDecal, + CTEFoundryHelpers, + CTEGaussExplosion, + CTEGlowSprite, + CTEImpact, + CTEKillPlayerAttachments, + CTELargeFunnel, + CTEMetalSparks, + CTEMuzzleFlash, + CTEParticleSystem, + CTEPhysicsProp, + CTEPlantBomb, + CTEPlayerAnimEvent, + CTEPlayerDecal, + CTEProjectedDecal, + CTERadioIcon, + CTEShatterSurface, + CTEShowLine, + CTesla, + CTESmoke, + CTESparks, + CTESprite, + CTESpriteSpray, + CTest_ProxyToggle_Networkable, + CTestTraceline, + CTEWorldDecal, + CTriggerPlayerMovement, + CTriggerSoundOperator, + CVGuiScreen, + CVoteController, + CWaterBullet, + CWaterLODControl, + CWeaponAug, + CWeaponAWP, + CWeaponBaseItem, + CWeaponBizon, + CWeaponCSBase, + CWeaponCSBaseGun, + CWeaponCycler, + CWeaponElite, + CWeaponFamas, + CWeaponFiveSeven, + CWeaponG3SG1, + CWeaponGalil, + CWeaponGalilAR, + CWeaponGlock, + CWeaponHKP2000, + CWeaponM249, + CWeaponM3, + CWeaponM4A1, + CWeaponMAC10, + CWeaponMag7, + CWeaponMP5Navy, + CWeaponMP7, + CWeaponMP9, + CWeaponNegev, + CWeaponNOVA, + CWeaponP228, + CWeaponP250, + CWeaponP90, + CWeaponSawedoff, + CWeaponSCAR20, + CWeaponScout, + CWeaponSG550, + CWeaponSG552, + CWeaponSG556, + CWeaponSSG08, + CWeaponTaser, + CWeaponTec9, + CWeaponTMP, + CWeaponUMP45, + CWeaponUSP, + CWeaponXM1014, + CWorld, + DustTrail, + MovieExplosion, + ParticleSmokeGrenade, + RocketTrail, + SmokeTrail, + SporeExplosion, + SporeTrail, +}; + +class ClientClass { +public: + using create_fn = void*( *)( int, int ); + using event_fn = void*( *); + + create_fn m_create_fn; + event_fn m_createevent_fn; + char* m_name; + RecvTable* m_rt_table; + ClientClass* m_next; + int m_class_id; +};
\ No newline at end of file diff --git a/internal_rewrite/GlobalVars_t.hpp b/internal_rewrite/GlobalVars_t.hpp new file mode 100644 index 0000000..4cfcfb4 --- /dev/null +++ b/internal_rewrite/GlobalVars_t.hpp @@ -0,0 +1,21 @@ +#pragma once + +class global_vars_t { +public: + float m_realtime; + int m_framecount; + float m_absframetime; +private: + float m_absoluteframestarttimestddev; +public: + float m_curtime; + float m_frametime; + int m_maxclients; + int m_tickcount; + float m_interval_per_tick; + float m_interpolation_amount; + int m_sim_ticks; + int m_network_protocol; +private: + char pad00[ 14 ]; +};
\ No newline at end of file diff --git a/internal_rewrite/IAppSystem.hpp b/internal_rewrite/IAppSystem.hpp new file mode 100644 index 0000000..61a6c8e --- /dev/null +++ b/internal_rewrite/IAppSystem.hpp @@ -0,0 +1,28 @@ +#pragma once + +class AppSystemInfo_t; + +enum InitReturnVal_t; + +enum AppSystemTier_t { + APP_SYSTEM_TIER0 = 0, + APP_SYSTEM_TIER1, + APP_SYSTEM_TIER2, + APP_SYSTEM_TIER3, + + APP_SYSTEM_TIER_OTHER, +}; + + +class IAppSystem { +public: + virtual bool Connect( void* factory ) = 0; + virtual void Disconnect( ) = 0; + virtual void* QueryInterface( const char* pInterfaceName ) = 0; + virtual InitReturnVal_t Init( ) = 0; + virtual void Shutdown( ) = 0; + virtual const AppSystemInfo_t* GetDependencies( ) = 0; + virtual AppSystemTier_t GetTier( ) = 0; + virtual void Reconnect( void* factory, const char* pInterfaceName ) = 0; + virtual bool IsSingleton( ) = 0; +};
\ No newline at end of file diff --git a/internal_rewrite/IClientEntityList.hpp b/internal_rewrite/IClientEntityList.hpp new file mode 100644 index 0000000..ff33417 --- /dev/null +++ b/internal_rewrite/IClientEntityList.hpp @@ -0,0 +1,140 @@ +#pragma once
+#include "util.hpp"
+#include "vector.hpp"
+#include "ClientClass.hpp"
+#include "IVEngineClient.hpp"
+
+class ICollideable;
+class IClientNetworkable;
+class IClientRenderable;
+class IClientThinkable;
+class IClientEntity;
+class IClientAlphaProperty;
+class bf_read;
+using model_t = uintptr_t;
+
+
+class c_base_player;
+
+class IClientUnknown {
+public:
+ virtual ICollideable* GetCollideable( ) = 0;
+ virtual IClientNetworkable* GetClientNetworkable( ) = 0;
+ virtual IClientRenderable* GetClientRenderable( ) = 0;
+ virtual IClientEntity* GetIClientEntity( ) = 0;
+ virtual IClientEntity* GetBaseEntity( ) = 0;
+ virtual IClientThinkable* GetClientThinkable( ) = 0;
+ //virtual IClientModelRenderable* GetClientModelRenderable() = 0;
+ virtual IClientAlphaProperty* GetClientAlphaProperty( ) = 0;
+};
+
+class IClientNetworkable {
+public:
+ virtual IClientUnknown* GetIClientUnknown( ) = 0;
+ virtual void Release( ) = 0;
+ virtual ClientClass* GetClientClass( ) = 0;
+ virtual void NotifyShouldTransmit( int state ) = 0;
+ virtual void OnPreDataChanged( int updateType ) = 0;
+ virtual void OnDataChanged( int updateType ) = 0;
+ virtual void PreDataUpdate( int updateType ) = 0;
+ virtual void PostDataUpdate( int updateType ) = 0;
+ virtual void OnDataUnchangedInPVS( void ) = 0;
+ virtual bool IsDormant( void ) = 0;
+ virtual int EntIndex( void ) const = 0;
+ virtual void ReceiveMessage( int classID, bf_read& msg ) = 0;
+ virtual void* GetDataTableBasePtr( ) = 0;
+ virtual void SetDestroyedOnRecreateEntities( void ) = 0;
+};
+
+class IClientEntity {
+public:
+ void* GetClientRenderable( ) {
+ return reinterpret_cast< void* >( this + 0x4 );
+ }
+
+ IClientNetworkable* GetClientNetworkable( ) {
+ return reinterpret_cast< IClientNetworkable* >( this + 0x8 );
+ }
+
+ ICollideable* GetCollideable( ) {
+ using fn = ICollideable* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 2 )( this );
+ }
+
+ vec3_t& GetRenderOrigin( ) {
+ using fn = vec3_t& ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 10 )( this );
+ }
+
+ vec3_t& GetRenderAngles( ) {
+ using fn = vec3_t& ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 11 )( this );
+ }
+
+ ClientClass* GetClientClass( ) {
+ if( !*( void** )( this ) )
+ return nullptr;
+
+ if( !*( void** )( GetClientNetworkable( ) ) )
+ return nullptr;
+
+ return GetClientNetworkable( )->GetClientClass( );
+ }
+
+ bool IsDormant( ) {
+ return GetClientNetworkable( )->IsDormant( );
+ }
+
+ int GetIndex( ) {
+ if( !this ) return 0;
+
+ return GetClientNetworkable( )->EntIndex( );
+ }
+
+ model_t* GetModel( ) {
+ using fn = model_t* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this->GetClientRenderable( ), 8 )( this->GetClientRenderable( ) );
+ }
+
+ int DrawModel( int flags, uint8_t alpha ) {
+ using fn = int( __thiscall* )( void*, int, uint8_t );
+ return util::get_vfunc< fn >( this->GetClientRenderable( ), 9 )( this->GetClientRenderable( ), flags, alpha );
+ }
+
+ bool SetupBones( matrix3x4* bone_to_world, int max_bones, int mask, float time ) {
+ using fn = bool( __thiscall* )( void*, matrix3x4*, int, int, float );
+ return util::get_vfunc< fn >( GetClientRenderable( ), 13 )
+ ( GetClientRenderable( ), bone_to_world, max_bones, mask, time );
+ }
+
+ template < typename t >
+ t* as( ) {
+ return reinterpret_cast< t* >( this );
+ }
+};
+
+class IClientEntityList
+{
+public:
+ IClientNetworkable* GetClientNetworkable( int index ) {
+ using fn = IClientNetworkable* ( __thiscall* )( void*, int );
+ return util::get_vfunc< fn >( this, 1 )( this, index );
+ }
+
+ template < typename t = c_base_player >
+ t* GetClientEntity( int index ) {
+ using fn = t* ( __thiscall* )( void*, int );
+ return util::get_vfunc< fn >( this, 3 )( this, index );
+ }
+
+ template < typename t = c_base_player >
+ t* GetClientEntityFromHandle( uint32_t handle ) {
+ using fn = t* ( __thiscall* )( void*, int );
+ return util::get_vfunc< fn >( this, 4 )( this, handle );
+ }
+
+ int GetHighestEntityIndex( ) {
+ using fn = int( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 6 )( this );
+ }
+};
\ No newline at end of file diff --git a/internal_rewrite/IClientMode.hpp b/internal_rewrite/IClientMode.hpp new file mode 100644 index 0000000..8f2142a --- /dev/null +++ b/internal_rewrite/IClientMode.hpp @@ -0,0 +1,175 @@ +#pragma once +#include "valve/checksum_crc.h" + +#include "util.hpp" +#include "vector.hpp" + +enum player_controls_t { + IN_ATTACK = 1 << 0, + IN_JUMP = 1 << 1, + IN_DUCK = 1 << 2, + IN_FORWARD = 1 << 3, + IN_BACK = 1 << 4, + IN_USE = 1 << 5, + IN_CANCEL = 1 << 6, + IN_LEFT = 1 << 7, + IN_RIGHT = 1 << 8, + IN_MOVELEFT = 1 << 9, + IN_MOVERIGHT = 1 << 10, + IN_ATTACK2 = 1 << 11, + IN_RUN = 1 << 12, + IN_RELOAD = 1 << 13, + IN_ALT1 = 1 << 14, + IN_ALT2 = 1 << 15, + IN_SCORE = 1 << 16, + IN_SPEED = 1 << 17, + IN_WALK = 1 << 18, + IN_ZOOM = 1 << 19, + IN_WEAPON1 = 1 << 20, + IN_WEAPON2 = 1 << 21, + IN_BULLRUSH = 1 << 22, + IN_GRENADE1 = 1 << 23, + IN_GRENADE2 = 1 << 24, + IN_ATTACK3 = 1 << 25, +}; + +class user_cmd_t { +public: + virtual ~user_cmd_t( ) { }; + + int m_cmd_nr; // 0x04 For matching server and client commands for debugging + int m_tick_count; // 0x08 the tick the client created this command + vec3_t m_viewangles; // 0x0C Player instantaneous view angles. + vec3_t m_aimdirection; // 0x18 + float m_forwardmove; // 0x24 + float m_sidemove; // 0x28 + float m_upmove; // 0x2C + int m_buttons; // 0x30 Attack button states + uint8_t m_impulse; // 0x34 + int m_weaponselect; // 0x38 Current weapon id + int m_weaponsubtype; // 0x3C + int m_random_seed; // 0x40 For shared random functions + short m_mousedx; // 0x44 mouse accum in x from create move + short m_mousedy; // 0x46 mouse accum in y from create move + bool m_predicted; // 0x48 Client only, tracks whether we've predicted this command at least once + vec3_t headangles; // 0x49 + vec3_t headoffset; // 0x55 + + __forceinline user_cmd_t clamp( bool angles = true ) { + if( angles ) + m_viewangles.clamp( ); + + m_forwardmove = std::clamp( m_forwardmove, -450.f, 450.f ); + m_sidemove = std::clamp( m_sidemove, -450.f, 450.f ); + m_upmove = std::clamp( m_upmove, -450.f, 450.f ); + + return *this; + } + + CRC32_t get_check_sum( ) { + CRC32_t crc; + CRC32_Init( &crc ); + + CRC32_ProcessBuffer( &crc, &m_cmd_nr, sizeof( m_cmd_nr ) ); + CRC32_ProcessBuffer( &crc, &m_tick_count, sizeof( m_tick_count ) ); + CRC32_ProcessBuffer( &crc, &m_viewangles, sizeof( m_viewangles ) ); + CRC32_ProcessBuffer( &crc, &m_aimdirection, sizeof( m_aimdirection ) ); + CRC32_ProcessBuffer( &crc, &m_forwardmove, sizeof( m_forwardmove ) ); + CRC32_ProcessBuffer( &crc, &m_sidemove, sizeof( m_sidemove ) ); + CRC32_ProcessBuffer( &crc, &m_upmove, sizeof( m_upmove ) ); + CRC32_ProcessBuffer( &crc, &m_buttons, sizeof( m_buttons ) ); + CRC32_ProcessBuffer( &crc, &m_impulse, sizeof( m_impulse ) ); + CRC32_ProcessBuffer( &crc, &m_weaponselect, sizeof( m_weaponselect ) ); + CRC32_ProcessBuffer( &crc, &m_weaponsubtype, sizeof( m_weaponsubtype ) ); + CRC32_ProcessBuffer( &crc, &m_random_seed, sizeof( m_random_seed ) ); + CRC32_ProcessBuffer( &crc, &m_mousedx, sizeof( m_mousedx ) ); + CRC32_ProcessBuffer( &crc, &m_mousedy, sizeof( m_mousedy ) ); + + CRC32_Final( &crc ); + return crc; + } + +private: + + //char pad_0x4C[ 0x18 ]; // 0x4C Current sizeof( usercmd ) = 100 = 0x64 +}; + +class CHudChat { +public: + void ChatPrintf( int iPlayerIndex, int iFilter, const char* fmt ) { + using fn = void( __cdecl* )( void*, int, int, const char* ); + util::get_vfunc< fn >( this, 27 )( this, iPlayerIndex, iFilter, fmt ); + } +}; + +class CViewSetup { +public: + int m_x; + int m_oldX; + int m_y; + int m_oldY; + int m_width; + int m_oldWidth; + int m_height; + int m_oldHeight; + + bool m_bOrtho; + float m_OrthoLeft; + float m_OrthoTop; + float m_OrthoRight; + float m_OrthoBottom; + +private: + char pad1[ 0x7C ]; + +public: + float m_flFov; + float m_flFovViewmodel; + vec3_t m_vecOrigin; + vec3_t m_vecAngles; + + float zNear; + float zFar; + float zNearViewmodel; + float zFarViewmodel; + + float m_flAspectRatio; + float m_flNearBlurDepth; + float m_flNearFocusDepth; + float m_flFarFocusDepth; + float m_flFarBlurDepth; + float m_flNearBlurRadius; + float m_flFarBlurRadius; + int m_nDoFQuality; + int m_nMotionBlurMode; + + float m_flShutterTime; + vec3_t m_vShutterOpenPosition; + vec3_t m_shutterOpenAngles; + vec3_t m_vShutterClosePosition; + vec3_t m_shutterCloseAngles; + + float m_flOffCenterTop; + float m_flOffCenterBottom; + float m_flOffCenterLeft; + float m_flOffCenterRight; + + bool m_bOffCenter : 1; + bool m_bRenderToSubrectOfLargerScreen : 1; + bool m_bDoBloomAndToneMapping : 1; + bool m_bDoDepthOfField : 1; + bool m_bHDRTarget : 1; + bool m_bDrawWorldNormal : 1; + bool m_bCullFrontFaces : 1; + bool m_bCacheFullSceneState : 1; + bool m_bRenderFlashlightDepthTranslucents : 1; +private: + char pad2[ 0x40 ]; +}; + +class IClientMode { +public: + char _pad[ 28 ]; + + CHudChat* m_pChatElement; //0x2A +};
\ No newline at end of file diff --git a/internal_rewrite/ICvar.hpp b/internal_rewrite/ICvar.hpp new file mode 100644 index 0000000..9e8040f --- /dev/null +++ b/internal_rewrite/ICvar.hpp @@ -0,0 +1,206 @@ +#pragma once +#include "IAppSystem.hpp" +#include "util.hpp" +#include "color.hpp" + +using CVarDLLIdentifier_t = int; +class IConVar; +using FnChangeCallback_t = void( *)( IConVar *var, const char *pOldValue, float flOldValue ); +class ConCommandBase; +class ConCommand; +class ICvarQuery; + +class IConsoleDisplayFunc { +public: + virtual void ColorPrint( const uint8_t* clr, const char *pMessage ) = 0; + virtual void Print( const char *pMessage ) = 0; + virtual void DPrint( const char *pMessage ) = 0; +}; + +#define FCVAR_NONE 0 + +// Command to ConVars and ConCommands +// ConVar Systems +#define FCVAR_UNREGISTERED (1<<0) // If this is set, don't add to linked list, etc. +#define FCVAR_DEVELOPMENTONLY (1<<1) // Hidden in released products. Flag is removed automatically if ALLOW_DEVELOPMENT_CVARS is defined. +#define FCVAR_GAMEDLL (1<<2) // defined by the game DLL +#define FCVAR_CLIENTDLL (1<<3) // defined by the client DLL +#define FCVAR_HIDDEN (1<<4) // Hidden. Doesn't appear in find or autocomplete. Like DEVELOPMENTONLY, but can't be compiled out. + +// ConVar only +#define FCVAR_PROTECTED (1<<5) // It's a server cvar, but we don't send the data since it's a password, etc. Sends 1 if it's not bland/zero, 0 otherwise as value +#define FCVAR_SPONLY (1<<6) // This cvar cannot be changed by clients connected to a multiplayer server. +#define FCVAR_ARCHIVE (1<<7) // set to cause it to be saved to vars.rc +#define FCVAR_NOTIFY (1<<8) // notifies players when changed +#define FCVAR_USERINFO (1<<9) // changes the client's info string +#define FCVAR_CHEAT (1<<14) // Only useable in singleplayer / debug / multiplayer & sv_cheats + +#define FCVAR_PRINTABLEONLY (1<<10) // This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ). +#define FCVAR_UNLOGGED (1<<11) // If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log +#define FCVAR_NEVER_AS_STRING (1<<12) // never try to print that cvar + +// It's a ConVar that's shared between the client and the server. +// At signon, the values of all such ConVars are sent from the server to the client (skipped for local +// client, of course ) +// If a change is requested it must come from the console (i.e., no remote client changes) +// If a value is changed while a server is active, it's replicated to all connected clients +#define FCVAR_REPLICATED (1<<13) // server setting enforced on clients, TODO rename to FCAR_SERVER at some time +#define FCVAR_DEMO (1<<16) // record this cvar when starting a demo file +#define FCVAR_DONTRECORD (1<<17) // don't record these command in demofiles +#define FCVAR_RELOAD_MATERIALS (1<<20) // If this cvar changes, it forces a material reload +#define FCVAR_RELOAD_TEXTURES (1<<21) // If this cvar changes, if forces a texture reload + +#define FCVAR_NOT_CONNECTED (1<<22) // cvar cannot be changed by a client that is connected to a server +#define FCVAR_MATERIAL_SYSTEM_THREAD (1<<23) // Indicates this cvar is read from the material system thread +#define FCVAR_ARCHIVE_XBOX (1<<24) // cvar written to config.cfg on the Xbox + +#define FCVAR_ACCESSIBLE_FROM_THREADS (1<<25) // used as a debugging tool necessary to check material system thread convars + +#define FCVAR_SERVER_CAN_EXECUTE (1<<28)// the server is allowed to execute this command on clients via ClientCommand/NET_StringCmd/CBaseClientState::ProcessStringCmd. +#define FCVAR_SERVER_CANNOT_QUERY (1<<29)// If this is set, then the server is not allowed to query this cvar's value (via IServerPluginHelpers::StartQueryCvarValue). +#define FCVAR_CLIENTCMD_CAN_EXECUTE (1<<30) // IVEngineClient::ClientCmd is allowed to execute this command. + + +class cvar_t { +public: + void set_value( const char* value ) { + using fn = void( __thiscall* )( void*, const char* ); + return util::get_vfunc< fn >( this, 14 )( this, value ); + } + + void set_value( float value ) { + using fn = void( __thiscall* )( void*, float ); + return util::get_vfunc< fn >( this, 15 )( this, value ); + } + + void set_value( int value ) { + using fn = void( __thiscall* )( void*, int ); + return util::get_vfunc< fn >( this, 16 )( this, value ); + } + + void set_value( clr_t value ) { + using fn = void( __thiscall* )( void*, clr_t ); + return util::get_vfunc< fn >( this, 17 )( this, value ); + } + + char* get_name( ) { + using fn = char*( __thiscall* )( void* ); + return util::get_vfunc< fn >( this, 5 )( this ); + } + + char* get_default( ) { + return m_default; + } + + const char* get_string( ) { + return m_string; + } + + float get_float( ) { + using fn = float( __thiscall* )( void* ); + return util::get_vfunc< fn >( this, 12 )( this ); + } + + int get_int( ) { + using fn = int( __thiscall* )( void* ); + return util::get_vfunc< fn >( this, 13 )( this ); + } + +private: + void* m_vft; +public: + cvar_t* m_next; //0x0004 + __int32 m_registered; //0x0008 + char* m_name; //0x000C + char* m_help_str; //0x0010 + __int32 m_flags; //0x0014 +private: + char pad_0x0018[ 0x4 ]; //0x0018 +public: + cvar_t* m_parent; //0x001C + char* m_default; //0x0020 + char* m_string; //0x0024 + __int32 m_str_len; //0x0028 + float m_flvalue; //0x002C + __int32 m_nvalue; //0x0030 + __int32 m_has_min; //0x0034 + float m_min; //0x0038 + __int32 m_hax_max; //0x003C + float m_max; //0x0040 + void* m_change_callback; //0x0044 +};//Size=0x0048 + +class ICVar : public IAppSystem +{ +public: + // Allocate a unique DLL identifier + virtual CVarDLLIdentifier_t AllocateDLLIdentifier( ) = 0; + + // Register, unregister commands + virtual void RegisterConCommand( ConCommandBase *pCommandBase ) = 0; + virtual void UnregisterConCommand( ConCommandBase *pCommandBase ) = 0; + virtual void UnregisterConCommands( CVarDLLIdentifier_t id ) = 0; + + // If there is a +<varname> <value> on the command line, this returns the value. + // Otherwise, it returns NULL. + virtual const char* GetCommandLineValue( const char *pVariableName ) = 0; + + // Try to find the cvar pointer by name + virtual ConCommandBase* FindCommandBase( const char *name ) = 0; + virtual const ConCommandBase* FindCommandBase( const char *name ) const = 0; + virtual cvar_t *FindVar( const char *var_name ) = 0; + virtual const cvar_t *FindVar( const char *var_name ) const = 0; + virtual ConCommand *FindCommand( const char *name ) = 0; + virtual const ConCommand *FindCommand( const char *name ) const = 0; + + + + // Install a global change callback (to be called when any convar changes) + virtual void InstallGlobalChangeCallback( FnChangeCallback_t callback ) = 0; + virtual void RemoveGlobalChangeCallback( FnChangeCallback_t callback ) = 0; + virtual void CallGlobalChangeCallbacks( cvar_t *var, const char *pOldString, float flOldValue ) = 0; + + // Install a console printer + virtual void InstallConsoleDisplayFunc( IConsoleDisplayFunc* pDisplayFunc ) = 0; + virtual void RemoveConsoleDisplayFunc( IConsoleDisplayFunc* pDisplayFunc ) = 0; + virtual void ConsoleColorPrintf( const clr_t& clr, const char *pFormat, ... ) const = 0; + virtual void ConsolePrintf( const char *pFormat, ... ) const = 0; + virtual void ConsoleDPrintf( const char *pFormat, ... ) const = 0; + + // Reverts cvars which contain a specific flag + virtual void RevertFlaggedConVars( int nFlag ) = 0; + + // Method allowing the engine ICvarQuery interface to take over + // A little hacky, owing to the fact the engine is loaded + // well after ICVar, so we can't use the standard connect pattern + virtual void InstallCVarQuery( ICvarQuery *pQuery ) = 0; + + + virtual void SetMaxSplitScreenSlots( int nSlots ) = 0; + virtual int GetMaxSplitScreenSlots( ) const = 0; + + virtual void AddSplitScreenConVars( ) = 0; + virtual void RemoveSplitScreenConVars( CVarDLLIdentifier_t id ) = 0; + + virtual int GetConsoleDisplayFuncCount( ) const = 0; + virtual void GetConsoleText( int nDisplayFuncIndex, char *pchText, size_t bufSize ) const = 0; + + // Utilities for convars accessed by the material system thread + virtual bool IsMaterialThreadSetAllowed( ) const = 0; + virtual void QueueMaterialThreadSetValue( cvar_t *pConVar, const char *pValue ) = 0; + virtual void QueueMaterialThreadSetValue( cvar_t *pConVar, int nValue ) = 0; + virtual void QueueMaterialThreadSetValue( cvar_t *pConVar, float flValue ) = 0; + virtual bool HasQueuedMaterialThreadConVarSets( ) const = 0; + virtual int ProcessQueuedMaterialThreadConVarSets( ) = 0; + + class ICVarIteratorInternal + { + public: + virtual void SetFirst( ) = 0; + virtual void Next( ) = 0; + virtual bool IsValid( ) = 0; + virtual ConCommandBase *Get( ) = 0; + }; + + virtual ICVarIteratorInternal* FactoryInternalIterator( ) = 0; +};
\ No newline at end of file diff --git a/internal_rewrite/IEngineTrace.hpp b/internal_rewrite/IEngineTrace.hpp new file mode 100644 index 0000000..681d64b --- /dev/null +++ b/internal_rewrite/IEngineTrace.hpp @@ -0,0 +1,384 @@ +#pragma once
+#include "vector.hpp"
+#include "IClientEntityList.hpp"
+
+enum TraceType_t {
+ TRACE_EVERYTHING = 0,
+ TRACE_WORLD_ONLY, // NOTE: This does *not* test static props!!!
+ TRACE_ENTITIES_ONLY, // NOTE: This version will *not* test static props
+ TRACE_EVERYTHING_FILTER_PROPS, // NOTE: This version will pass the IHandleEntity for props through the filter, unlike all other filters
+};
+
+enum SurfaceFlags_t {
+ DISPSURF_FLAG_SURFACE = 1 << 0,
+ DISPSURF_FLAG_WALKABLE = 1 << 1,
+ DISPSURF_FLAG_BUILDABLE = 1 << 2,
+ DISPSURF_FLAG_SURFPROP1 = 1 << 3,
+ DISPSURF_FLAG_SURFPROP2 = 1 << 4,
+};
+
+enum Hitgroup_t {
+ HITGROUP_GENERIC,
+ HITGROUP_HEAD,
+ HITGROUP_CHEST,
+ HITGROUP_STOMACH,
+ HITGROUP_LEFTARM,
+ HITGROUP_RIGHTARM,
+ HITGROUP_LEFTLEG,
+ HITGROUP_RIGHTLEG,
+ HITGROUP_GEAR
+};
+
+struct csurface_t {
+ const char* name;
+ short surfaceProps;
+ unsigned short flags;
+};
+
+struct cplane_t {
+ vec3_t normal;
+ float dist;
+ uint8_t type;
+ uint8_t signbits;
+ uint8_t pad[ 2 ];
+};
+
+class ITraceFilter {
+public:
+ virtual bool ShouldHitEntity( void* pEntity, int contentsMask ) = 0;
+ virtual int GetTraceType( ) const = 0;
+};
+
+class CTraceFilter : public ITraceFilter {
+public:
+ CTraceFilter( ) {}
+
+ CTraceFilter( void *ent )
+ : pSkip( ent ) {}
+
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ return !( pEntityHandle == pSkip );
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_EVERYTHING;
+ }
+
+ void* pSkip;
+};
+
+class CTraceFilterOneEntity : public ITraceFilter {
+public:
+ bool ShouldHitEntity( void* entity_handle, int contents ) override {
+ return entity_handle == ent;
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_ENTITIES_ONLY;
+ }
+
+ void* ent;
+};
+
+class CTraceFilterWorldAndPropsOnly : public ITraceFilter {
+public:
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ return false;
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_EVERYTHING;
+ }
+};
+
+class CTraceFilterEntitiesOnly : public ITraceFilter {
+public:
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ return !( pEntityHandle == pSkip );
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_ENTITIES_ONLY;
+ }
+
+ void* pSkip;
+};
+
+class CTraceFilterPlayersOnly : public ITraceFilter {
+public:
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ IClientEntity* hit_entity = ( IClientEntity* )pEntityHandle;
+ int index = hit_entity->GetIndex( );
+ return !( pEntityHandle == pSkip || index < 1 || index > 64 );
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_ENTITIES_ONLY;
+ }
+
+ void* pSkip;
+};
+
+class CTraceFilterWorldOnly : public ITraceFilter {
+public:
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ return false;
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_WORLD_ONLY;
+ }
+
+ void* pSkip;
+};
+
+class CTraceFilterSkipTwoEntities : public ITraceFilter {
+public:
+ CTraceFilterSkipTwoEntities( ) {
+
+ }
+
+ CTraceFilterSkipTwoEntities( void* pPassEnt1, void* pPassEnt2 ) {
+ passentity1 = pPassEnt1;
+ passentity2 = pPassEnt2;
+ }
+
+ bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+ return !( pEntityHandle == passentity1 || pEntityHandle == passentity2 );
+ }
+
+ int GetTraceType( ) const override {
+ return TRACE_EVERYTHING;
+ }
+
+ void* passentity1;
+ void* passentity2;
+};
+
+class __declspec( align( 16 ) )VectorAligned : public vec3_t {
+public:
+ VectorAligned( float _x, float _y, float _z ) {
+ x = _x;
+ y = _y;
+ z = _z;
+ w = 0;
+ }
+
+ VectorAligned( ) { }
+
+ void operator=( const vec3_t& vOther ) {
+ x = vOther.x;
+ y = vOther.y;
+ z = vOther.z;
+ }
+
+ float w;
+};
+
+struct Ray_t
+{
+ VectorAligned m_Start;
+ VectorAligned m_Delta;
+ VectorAligned m_StartOffset;
+ VectorAligned m_Extents;
+
+ const matrix3x4* m_pWorldAxisTransform;
+
+ bool m_IsRay;
+ bool m_IsSwept;
+
+ Ray_t( ) : m_pWorldAxisTransform( nullptr ) { }
+
+ void Init( const vec3_t& start, const vec3_t& end ) {
+ m_Delta = end - start;
+
+ m_IsSwept = m_Delta.lengthsqr( ) != 0;
+
+ m_Extents = vec3_t( 0.f, 0.f, 0.f );
+ m_pWorldAxisTransform = nullptr;
+ m_IsRay = true;
+
+ m_StartOffset = vec3_t( 0.f, 0.f, 0.f );
+ m_Start = start;
+ }
+
+ void Init( const vec3_t& start, const vec3_t& end, const vec3_t& mins, const vec3_t& maxs ) {
+ m_Delta = end - start;
+
+ m_pWorldAxisTransform = nullptr;
+ m_IsSwept = m_Delta.lengthsqr( ) != 0;
+
+ m_Extents = maxs - mins;
+ m_Extents *= 0.5f;
+ m_IsRay = m_Extents.lengthsqr( ) < 1e-6;
+
+ m_StartOffset = mins + maxs;
+ m_StartOffset *= 0.5f;
+ m_Start = start + m_StartOffset;
+ m_StartOffset *= -1.0f;
+ }
+};
+
+class CBaseTrace
+{
+public:
+ bool IsDispSurface( ) const { return ( dispFlags & DISPSURF_FLAG_SURFACE ) != 0; }
+ bool IsDispSurfaceWalkable( ) const { return ( dispFlags & DISPSURF_FLAG_WALKABLE ) != 0; }
+ bool IsDispSurfaceBuildable( ) const { return ( dispFlags & DISPSURF_FLAG_BUILDABLE ) != 0; }
+ bool IsDispSurfaceProp1( ) const { return ( dispFlags & DISPSURF_FLAG_SURFPROP1 ) != 0; }
+ bool IsDispSurfaceProp2( ) const { return ( dispFlags & DISPSURF_FLAG_SURFPROP2 ) != 0; }
+
+public:
+ vec3_t startpos;
+ vec3_t endpos;
+ cplane_t plane;
+
+ float fraction;
+
+ int contents;
+ unsigned short dispFlags;
+
+ bool allsolid;
+ bool startsolid;
+
+ CBaseTrace( ) {}
+
+private:
+ CBaseTrace( const CBaseTrace& vOther );
+};
+
+class CGameTrace : public CBaseTrace
+{
+public:
+ bool DidHitWorld( ) const;
+
+ bool DidHitNonWorldEntity( ) const;
+
+ int GetEntityIndex( ) const;
+
+ bool DidHit( ) const
+ {
+ return fraction < 1 || allsolid || startsolid;
+ }
+
+public:
+ float fractionleftsolid;
+ csurface_t surface;
+
+ int hitgroup;
+
+ short physicsbone;
+ unsigned short worldSurfaceIndex;
+
+ IClientEntity* m_pEnt;
+ int hitbox;
+
+ CGameTrace( ) {}
+ CGameTrace( const CGameTrace& vOther );
+};
+
+class IEngineTrace {
+public:
+ int GetPointContents( const vec3_t& vecAbsPosition, int contentsMask = 0xffffffff ) {
+ using fn = int( __thiscall* )( void*, const vec3_t&, int, void* );
+ return util::get_vfunc< fn >( this, 0 )( this, vecAbsPosition, contentsMask, nullptr );
+ }
+
+ void TraceRay( const Ray_t& ray, unsigned int fMask, ITraceFilter* pTraceFilter, CBaseTrace* pTrace ) {
+ return util::get_vfunc< 5, void >( this, ray, fMask, pTraceFilter, pTrace );
+ }
+
+ void ClipRayToEntity( const Ray_t& ray, unsigned int fMask, IClientEntity* pEnt, CBaseTrace* pTrace ) {
+ return util::get_vfunc< 3, void >( this, ray, fMask, pEnt, pTrace );
+ }
+};
+
+#define CONTENTS_EMPTY 0
+
+#define CONTENTS_SOLID 0x1
+#define CONTENTS_WINDOW 0x2
+#define CONTENTS_SOLID_SURF 0x3
+#define CONTENTS_AUX 0x4
+#define CONTENTS_LIGHT_SURF 0x7
+#define CONTENTS_GRATE 0x8
+#define CONTENTS_SLIME 0x10
+#define CONTENTS_WATER 0x20
+#define CONTENTS_BLOCKLOS 0x40
+#define CONTENTS_OPAQUE 0x80
+#define LAST_VISIBLE_CONTENTS CONTENTS_OPAQUE
+
+#define ALL_VISIBLE_CONTENTS (LAST_VISIBLE_CONTENTS | (LAST_VISIBLE_CONTENTS-1))
+
+#define CONTENTS_TESTFOGVOLUME 0x100
+#define CONTENTS_UNUSED 0x200
+#define CONTENTS_BLOCKLIGHT 0x400
+#define CONTENTS_TEAM1 0x800
+#define CONTENTS_TEAM2 0x1000
+#define CONTENTS_IGNORE_NODRAW_OPAQUE 0x2000
+#define CONTENTS_MOVEABLE 0x4000
+#define CONTENTS_AREAPORTAL 0x8000
+#define CONTENTS_PLAYERCLIP 0x10000
+#define CONTENTS_MONSTERCLIP 0x20000
+#define CONTENTS_CURRENT_0 0x40000
+#define CONTENTS_CURRENT_90 0x80000
+#define CONTENTS_CURRENT_180 0x100000
+#define CONTENTS_CURRENT_270 0x200000
+#define CONTENTS_CURRENT_UP 0x400000
+#define CONTENTS_CURRENT_DOWN 0x800000
+
+#define CONTENTS_ORIGIN 0x1000000
+
+#define CONTENTS_MONSTER 0x2000000
+#define CONTENTS_DEBRIS 0x4000000
+#define CONTENTS_DETAIL 0x8000000
+#define CONTENTS_TRANSLUCENT 0x10000000
+#define CONTENTS_LADDER 0x20000000
+#define CONTENTS_HITBOX 0x40000000
+
+#define SURF_LIGHT 0x0001
+#define SURF_SKY2D 0x0002
+#define SURF_SKY 0x0004
+#define SURF_WARP 0x0008
+#define SURF_TRANS 0x0010
+#define SURF_NOPORTAL 0x0020
+#define SURF_TRIGGER 0x0040
+#define SURF_NODRAW 0x0080
+
+#define SURF_HINT 0x0100
+
+#define SURF_SKIP 0x0200
+#define SURF_NOLIGHT 0x0400
+#define SURF_BUMPLIGHT 0x0800
+#define SURF_NOSHADOWS 0x1000
+#define SURF_NODECALS 0x2000
+#define SURF_NOPAINT SURF_NODECALS
+#define SURF_NOCHOP 0x4000
+#define SURF_HITBOX 0x8000
+
+// -----------------------------------------------------
+// spatial content masks - used for spatial queries (traceline,etc.)
+// -----------------------------------------------------
+#define MASK_ALL (0xFFFFFFFF)
+#define MASK_SOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE)
+#define MASK_PLAYERSOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE)
+#define MASK_NPCSOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE)
+#define MASK_NPCFLUID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER)
+#define MASK_WATER (CONTENTS_WATER|CONTENTS_MOVEABLE|CONTENTS_SLIME)
+#define MASK_OPAQUE (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_OPAQUE)
+#define MASK_OPAQUE_AND_NPCS (MASK_OPAQUE|CONTENTS_MONSTER)
+#define MASK_BLOCKLOS (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_BLOCKLOS)
+#define MASK_BLOCKLOS_AND_NPCS (MASK_BLOCKLOS|CONTENTS_MONSTER)
+#define MASK_VISIBLE (MASK_OPAQUE|CONTENTS_IGNORE_NODRAW_OPAQUE)
+#define MASK_VISIBLE_AND_NPCS (MASK_OPAQUE_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE)
+#define MASK_SHOT (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_HITBOX)
+#define MASK_SHOT_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_DEBRIS)
+#define MASK_SHOT_HULL (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_GRATE)
+#define MASK_SHOT_PORTAL (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTER)
+#define MASK_SOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_GRATE)
+#define MASK_PLAYERSOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_PLAYERCLIP|CONTENTS_GRATE)
+#define MASK_NPCSOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE)
+#define MASK_NPCWORLDSTATIC (CONTENTS_SOLID|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE)
+#define MASK_NPCWORLDSTATIC_FLUID (CONTENTS_SOLID|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP)
+#define MASK_SPLITAREAPORTAL (CONTENTS_WATER|CONTENTS_SLIME)
+#define MASK_CURRENT (CONTENTS_CURRENT_0|CONTENTS_CURRENT_90|CONTENTS_CURRENT_180|CONTENTS_CURRENT_270|CONTENTS_CURRENT_UP|CONTENTS_CURRENT_DOWN)
+#define MASK_DEADSOLID (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_GRATE)
\ No newline at end of file diff --git a/internal_rewrite/IGameEventManager.hpp b/internal_rewrite/IGameEventManager.hpp new file mode 100644 index 0000000..ec37320 --- /dev/null +++ b/internal_rewrite/IGameEventManager.hpp @@ -0,0 +1,77 @@ +#pragma once +#include "util.hpp" + +class IGameEvent +{ +public: + const char* GetName( ) { + return util::get_vfunc< 1, const char* >( this ); + } + + int GetInt( const char* szKeyName, int nDefault = 0 ) { + return util::get_vfunc< 6, int >( this, szKeyName, nDefault ); + } + + float GetFloat( const char* name, float default_ = 0 ) { + return util::get_vfunc< 8, float >( this, name, default_ ); + } + + const char* GetString( const char* szKeyName ) { + return util::get_vfunc< 9, const char* >( this, szKeyName, 0 ); + } + + void SetString( const char* szKeyName, const char* szValue ) { + return util::get_vfunc< 16, void >( this, szKeyName, szValue ); + } +}; + +class IGameEventListener2 { +public: + virtual ~IGameEventListener2( void ) {}; + + // FireEvent is called by EventManager if event just occured + // KeyValue memory will be freed by manager if not needed anymore + virtual void FireGameEvent( IGameEvent* event ) = 0; + + virtual int GetEventDebugID( void ) = 0; +}; + +class IGameEventManager2 { +public: + virtual ~IGameEventManager2( void ) {}; + + // load game event descriptions from a file eg "resource\gameevents.res" + virtual int LoadEventsFromFile( const char* filename ) = 0; + + // removes all and anything + virtual void Reset( ) = 0; + + // adds a listener for a particular event + virtual bool AddListener( IGameEventListener2* listener, const char* name, bool bServerSide ) = 0; + + // returns true if this listener is listens to given event + virtual bool FindListener( IGameEventListener2* listener, const char* name ) = 0; + + // removes a listener + virtual void RemoveListener( IGameEventListener2* listener ) = 0; + + // create an event by name, but doesn't fire it. returns NULL is event is not + // known or no listener is registered for it. bForce forces the creation even if no listener is active + virtual IGameEvent* CreateEvent( const char* name, bool bForce = false, int* pCookie = nullptr ) = 0; + + // fires a server event created earlier, if bDontBroadcast is set, event is not send to clients + virtual bool FireEvent( IGameEvent* event, bool bDontBroadcast = false ) = 0; + + // fires an event for the local client only, should be used only by client code + virtual bool FireEventClientSide( IGameEvent* event ) = 0; + + // create a new copy of this event, must be free later + virtual IGameEvent* DuplicateEvent( IGameEvent* event ) = 0; + + // if an event was created but not fired for some reason, it has to bee freed, same UnserializeEvent + virtual void FreeEvent( IGameEvent* event ) = 0; + + // write/read event to/from bitbuffer + virtual bool SerializeEvent( IGameEvent* event, int* buf ) = 0; + virtual IGameEvent* UnserializeEvent( void* buf ) = 0; // create new KeyValues, must be deleted +};
\ No newline at end of file diff --git a/internal_rewrite/IMaterialSystem.hpp b/internal_rewrite/IMaterialSystem.hpp new file mode 100644 index 0000000..c27bf24 --- /dev/null +++ b/internal_rewrite/IMaterialSystem.hpp @@ -0,0 +1,222 @@ +#pragma once
+#include "util.hpp"
+#include "ISurface.hpp"
+
+using MaterialHandle_t = unsigned short;
+
+enum MaterialVarFlags_t {
+ MATERIAL_VAR_DEBUG = 1 << 0,
+ MATERIAL_VAR_NO_DEBUG_OVERRIDE = 1 << 1,
+ MATERIAL_VAR_NO_DRAW = 1 << 2,
+ MATERIAL_VAR_USE_IN_FILLRATE_MODE = 1 << 3,
+ MATERIAL_VAR_VERTEXCOLOR = 1 << 4,
+ MATERIAL_VAR_VERTEXALPHA = 1 << 5,
+ MATERIAL_VAR_SELFILLUM = 1 << 6,
+ MATERIAL_VAR_ADDITIVE = 1 << 7,
+ MATERIAL_VAR_ALPHATEST = 1 << 8,
+ MATERIAL_VAR_MULTIPASS = 1 << 9,
+ MATERIAL_VAR_ZNEARER = 1 << 10,
+ MATERIAL_VAR_MODEL = 1 << 11,
+ MATERIAL_VAR_FLAT = 1 << 12,
+ MATERIAL_VAR_NOCULL = 1 << 13,
+ MATERIAL_VAR_NOFOG = 1 << 14,
+ MATERIAL_VAR_IGNOREZ = 1 << 15,
+ MATERIAL_VAR_DECAL = 1 << 16,
+ MATERIAL_VAR_ENVMAPSPHERE = 1 << 17,
+ MATERIAL_VAR_NOALPHAMOD = 1 << 18,
+ MATERIAL_VAR_ENVMAPCAMERASPACE = 1 << 19,
+ MATERIAL_VAR_BASEALPHAENVMAPMASK = 1 << 20,
+ MATERIAL_VAR_TRANSLUCENT = 1 << 21,
+ MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK = 1 << 22,
+ MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING = 1 << 23,
+ MATERIAL_VAR_OPAQUETEXTURE = 1 << 24,
+ MATERIAL_VAR_ENVMAPMODE = 1 << 25,
+ MATERIAL_VAR_SUPPRESS_DECALS = 1 << 26,
+ MATERIAL_VAR_HALFLAMBERT = 1 << 27,
+ MATERIAL_VAR_WIREFRAME = 1 << 28,
+};
+
+class ITexture {
+public:
+ int GetActualWidth( ) {
+ return util::get_vfunc< 3, int >( this );
+ }
+
+ int GetActualHeight( ) {
+ return util::get_vfunc< 4, int >( this );
+ }
+};
+
+struct MaterialVideoMode_t {
+ int m_width;
+ int m_height;
+ int m_format;
+ int m_hz;
+};
+
+struct IMaterialSystem_Config_t {
+ MaterialVideoMode_t m_vid_mode;
+ float m_monitor_gamma;
+ float m_monitor_max;
+ float m_monitor_min;
+ float m_monitor_exp;
+ bool m_gamma_enabled;
+ bool m_triple_buffer;
+ int m_aa_samples;
+ int m_force_anisotropic_level;
+ int m_skip_mip_levels;
+ int m_dx_level;
+ int m_flags;
+ bool m_edit_mode;
+ char m_proxy_test_mode;
+ bool m_compressed_textures;
+ bool m_filter_lightmaps;
+ bool m_filter_textures;
+ bool m_reverse_depth;
+ bool m_buffer_primitives;
+ bool m_draw_flat;
+ bool m_measure_fillrate;
+ bool m_visualize_fillrate;
+ bool m_no_transperacy;
+ bool m_software_lighting;
+ bool m_allow_cheats;
+ char m_show_mipmap;
+ bool m_low_res;
+ bool m_normal_mapping;
+ bool m_mipmap_textures;
+ char m_fullbright;
+ bool m_fast_nobumd;
+ bool m_supress_rendering;
+ bool m_drawgray;
+ bool m_show_specular;
+ bool m_show_diffuse;
+ int m_winsize_widthlimit;
+ int m_winsize_heightlimit;
+ int m_aa_quality;
+ bool m_shadow_depth_texture;
+ bool m_motion_blur;
+ bool m_flashlight;
+ bool m_paint_enabled;
+ char pad[ 0xC ];
+};
+
+class IMaterial {
+ char pad[ 0x1C ];
+public:
+ int m_ref_count;
+
+ auto GetName( ) {
+ return util::get_vfunc< 0, const char* >( this );
+ }
+
+ auto GetTextureGroupName( ) {
+ return util::get_vfunc< 1, const char* >( this );
+ }
+
+ void IncrementReferenceCount( ) {
+ return util::get_vfunc< 12, void >( this );
+ }
+
+ void DecrementReferenceCount( ) {
+ return util::get_vfunc< 13, void >( this );
+ }
+
+ void AlphaModulate( float alpha ) {
+ return util::get_vfunc< 27, void >( this, alpha );
+ }
+
+ void ColorModulate( float r, float g, float b ) {
+ return util::get_vfunc< 28, void >( this, r, g, b );
+ }
+
+ void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on ) {
+ return util::get_vfunc< 29, void >( this, flag, on );
+ }
+
+ bool GetMaterialVarFlag( MaterialVarFlags_t flag ) {
+ return util::get_vfunc< 30, bool >( this, flag );
+ }
+
+ auto GetAlphaModulation( ) {
+ return util::get_vfunc< 44, float >( this );
+ }
+
+ void GetColorModulate( float* r, float* g, float* b ) {
+ return util::get_vfunc< 45, void >( this, r, g, b );
+ }
+
+ void Refresh( ) {
+ return util::get_vfunc< 37, void >( this );
+ }
+};
+
+class IMaterialSystem
+{
+public:
+ enum RenderTargetSizeMode_t {
+ RT_SIZE_NO_CHANGE = 0, // Only allowed for render targets that don't want a depth buffer
+ // (because if they have a depth buffer, the render target must be less than or equal to the size of the framebuffer).
+ RT_SIZE_DEFAULT = 1, // Don't play with the specified width and height other than making sure it fits in the framebuffer.
+ RT_SIZE_PICMIP = 2, // Apply picmip to the render target's width and height.
+ RT_SIZE_HDR = 3, // frame_buffer_width / 4
+ RT_SIZE_FULL_FRAME_BUFFER = 4, // Same size as frame buffer, or next lower power of 2 if we can't do that.
+ RT_SIZE_OFFSCREEN = 5, // Target of specified size, don't mess with dimensions
+ RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP = 6 // Same size as the frame buffer, rounded up if necessary for systems that can't do non-power of two textures.
+ };
+
+ enum MaterialRenderTargetDepth_t {
+ MATERIAL_RT_DEPTH_SHARED = 0x0,
+ MATERIAL_RT_DEPTH_SEPARATE = 0x1,
+ MATERIAL_RT_DEPTH_NONE = 0x2,
+ MATERIAL_RT_DEPTH_ONLY = 0x3,
+ };
+
+ ImageFormat GetBackBufferFormat( ) {
+ return util::get_vfunc< 36, ImageFormat >( this );
+ }
+
+ IMaterial* CreateMaterial( const char* pMaterialName, void* pVMTKeyValues ) {
+ return util::get_vfunc< 83, IMaterial* >( this, pMaterialName, pVMTKeyValues );
+ }
+
+ IMaterial* FindMaterial( const char* pMaterialName, const char* pTextureGroupName = "Model textures", bool complain = true, const char* pComplainPrefix = nullptr ) {
+ return util::get_vfunc< 84, IMaterial* >( this, pMaterialName, pTextureGroupName, complain, pComplainPrefix );
+ }
+
+ MaterialHandle_t FirstMaterial( ) {
+ return util::get_vfunc< 86, MaterialHandle_t >( this );
+ }
+
+ MaterialHandle_t NextMaterial( MaterialHandle_t h ) {
+ return util::get_vfunc< 87, MaterialHandle_t >( this, h );
+ }
+
+ MaterialHandle_t InvalidMaterial( ) {
+ return util::get_vfunc< 88, MaterialHandle_t >( this );
+ }
+
+ IMaterial* GetMaterial( MaterialHandle_t h ) {
+ return util::get_vfunc< 89, IMaterial* >( this, h );
+ }
+
+ void BeginRenderTargetAllocation( ) {
+ return util::get_vfunc< 94, void >( this );
+ }
+
+ void EndRenderTargetAllocation( ) {
+ return util::get_vfunc< 95, void >( this );
+ }
+
+ ITexture* CreateNamedRenderTargetTextureEx( const char* name, int w, int h, RenderTargetSizeMode_t sizeMode,
+ ImageFormat format, MaterialRenderTargetDepth_t depth )
+ {
+ const int textureFlags = 0x4 | 0x8; //TEXTUREFLAGS_CLAMPS, TEXTUREFLAGS_CLAMPT
+ const int renderTargetFlags = 0x1; //CREATERENDERTARGETFLAGS_HDR
+ return util::get_vfunc< 97, ITexture* >( this, name, w, h, sizeMode, format, depth, textureFlags, renderTargetFlags );
+ }
+
+ /*void* GetRenderContext( ) {
+ typedef IMatRenderContext*( __thiscall* GetRenderContextFn )( void* );
+ return CallVFunction<GetRenderContextFn>( this, 115 )( this );
+ }*/
+};
\ No newline at end of file diff --git a/internal_rewrite/IMemAlloc.hpp b/internal_rewrite/IMemAlloc.hpp new file mode 100644 index 0000000..580104c --- /dev/null +++ b/internal_rewrite/IMemAlloc.hpp @@ -0,0 +1,79 @@ +#pragma once + +typedef size_t( *MemAllocFailHandler_t )( size_t ); + +class IMemAlloc { +public: + // Release versions + virtual void *Alloc( size_t nSize ) = 0; + virtual void *Realloc( void *pMem, size_t nSize ) = 0; + virtual void Free( void *pMem ) = 0; + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize ) = 0; + + // Debug versions + virtual void *Alloc( size_t nSize, const char *pFileName, int nLine ) = 0; + virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ) = 0; + virtual void Free( void *pMem, const char *pFileName, int nLine ) = 0; + virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ) = 0; + + // Returns size of a particular allocation + virtual size_t GetSize( void *pMem ) = 0; + + // Force file + line information for an allocation + virtual void PushAllocDbgInfo( const char *pFileName, int nLine ) = 0; + virtual void PopAllocDbgInfo( ) = 0; + + // FIXME: Remove when we have our own allocator + // these methods of the Crt debug code is used in our codebase currently + virtual long CrtSetBreakAlloc( long lNewBreakAlloc ) = 0; + virtual int CrtSetReportMode( int nReportType, int nReportMode ) = 0; + virtual int CrtIsValidHeapPointer( const void *pMem ) = 0; + virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access ) = 0; + virtual int CrtCheckMemory( void ) = 0; + virtual int CrtSetDbgFlag( int nNewFlag ) = 0; + virtual void CrtMemCheckpoint( void *pState ) = 0; + + // FIXME: Make a better stats interface + virtual void DumpStats( ) = 0; + virtual void DumpStatsFileBase( char const *pchFileBase ) = 0; + + // FIXME: Remove when we have our own allocator + virtual void* CrtSetReportFile( int nRptType, void* hFile ) = 0; + virtual void* CrtSetReportHook( void* pfnNewHook ) = 0; + virtual int CrtDbgReport( int nRptType, const char * szFile, + int nLine, const char * szModule, const char * pMsg ) = 0; + + virtual int heapchk( ) = 0; + + virtual bool IsDebugHeap( ) = 0; + + virtual void GetActualDbgInfo( const char *&pFileName, int &nLine ) = 0; + virtual void RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ) = 0; + virtual void RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime ) = 0; + + virtual int GetVersion( ) = 0; + + virtual void CompactHeap( ) = 0; + + // Function called when malloc fails or memory limits hit to attempt to free up memory (can come in any thread) + virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler ) = 0; + + virtual void DumpBlockStats( void * ) = 0; + +#if defined( _MEMTEST ) + virtual void SetStatsExtraInfo( const char *pMapName, const char *pComment ) = 0; +#endif + + // Returns 0 if no failure, otherwise the size_t of the last requested chunk + // "I'm sure this is completely thread safe!" Brian Deen 7/19/2012. + virtual size_t MemoryAllocFailed( ) = 0; + + // handles storing allocation info for coroutines + virtual unsigned GetDebugInfoSize( ) = 0; + virtual void SaveDebugInfo( void *pvDebugInfo ) = 0; + virtual void RestoreDebugInfo( const void *pvDebugInfo ) = 0; + virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ) = 0; + + // Replacement for ::GlobalMemoryStatus which accounts for unused memory in our system + virtual void GlobalMemoryStatus( size_t *pUsedMemory, size_t *pFreeMemory ) = 0; +};
\ No newline at end of file diff --git a/internal_rewrite/IPanel.hpp b/internal_rewrite/IPanel.hpp new file mode 100644 index 0000000..bbae705 --- /dev/null +++ b/internal_rewrite/IPanel.hpp @@ -0,0 +1,10 @@ +#pragma once +#include "util.hpp" + +class IPanel { +public: + const char* GetName( int panel ) { + using fn = const char* ( __thiscall* )( void*, int ); + return util::get_vfunc< fn >( this, 36 )( this, panel ); + } +};
\ No newline at end of file diff --git a/internal_rewrite/IPhysicsSurfaceProps.hpp b/internal_rewrite/IPhysicsSurfaceProps.hpp new file mode 100644 index 0000000..8e4f10f --- /dev/null +++ b/internal_rewrite/IPhysicsSurfaceProps.hpp @@ -0,0 +1,79 @@ +#pragma once + +struct surfacephysicsparams_t { + // vphysics physical properties + float friction; + float elasticity; // collision elasticity - used to compute coefficient of restitution + float density; // physical density (in kg / m^3) + float thickness; // material thickness if not solid (sheet materials) in inches + float dampening; +}; + +struct surfaceaudioparams_t { + float reflectivity; // like elasticity, but how much sound should be reflected by this surface + float hardnessFactor; // like elasticity, but only affects impact sound choices + float roughnessFactor; // like friction, but only affects scrape sound choices + float roughThreshold; // surface roughness > this causes "rough" scrapes, < this causes "smooth" scrapes + float hardThreshold; // surface hardness > this causes "hard" impacts, < this causes "soft" impacts + float hardVelocityThreshold; // collision velocity > this causes "hard" impacts, < this causes "soft" impacts + float highPitchOcclusion; //a value betweeen 0 and 100 where 0 is not occluded at all and 100 is silent (except for any additional reflected sound) + float midPitchOcclusion; + float lowPitchOcclusion; +}; + +struct surfacesoundnames_t { + unsigned short walkStepLeft; + unsigned short walkStepRight; + unsigned short runStepLeft; + unsigned short runStepRight; + unsigned short impactSoft; + unsigned short impactHard; + unsigned short scrapeSmooth; + unsigned short scrapeRough; + unsigned short bulletImpact; + unsigned short rolling; + unsigned short breakSound; + unsigned short strainSound; +}; + +struct surfacegameprops_t { + float maxspeedfactor; + float jumpfactor; + float penetrationmodifier; + float damagemodifier; + uint16_t material; + uint8_t climbable; +}; + +struct surfacedata_t { + surfacephysicsparams_t physics; // physics parameters + surfaceaudioparams_t audio; // audio parameters + surfacesoundnames_t sounds; // names of linked sounds + surfacegameprops_t game; // Game data / properties +}; + +class IPhysicsSurfaceProps +{ +public: + virtual ~IPhysicsSurfaceProps( void ) {} + + // parses a text file containing surface prop keys + virtual int ParseSurfaceData( const char* pFilename, const char* pTextfile ) = 0; + // current number of entries in the database + virtual int SurfacePropCount( void ) const = 0; + + virtual int GetSurfaceIndex( const char* pSurfacePropName ) const = 0; + virtual void GetPhysicsProperties( int surfaceDataIndex, float* density, float* thickness, float* friction, float* elasticity ) const = 0; + + virtual surfacedata_t* GetSurfaceData( int surfaceDataIndex ) = 0; + virtual const char* GetString( unsigned short stringTableIndex ) const = 0; + + virtual const char* GetPropName( int surfaceDataIndex ) const = 0; + + // sets the global index table for world materials + // UNDONE: Make this per-CPhysCollide + virtual void SetWorldMaterialIndexTable( int* pMapArray, int mapSize ) = 0; + + // NOTE: Same as GetPhysicsProperties, but maybe more convenient + //virtual void GetPhysicsParameters(int surfaceDataIndex, surfacephysicsparams_t* pParamsOut) const = 0; +};
\ No newline at end of file diff --git a/internal_rewrite/IPrediction.hpp b/internal_rewrite/IPrediction.hpp new file mode 100644 index 0000000..35fb6b2 --- /dev/null +++ b/internal_rewrite/IPrediction.hpp @@ -0,0 +1,153 @@ +#pragma once +#include "vector.hpp" + +//forward declarations +class user_cmd_t; +class IClientEntity; + +class IMoveHelper { +private: + virtual void unk00( ) = 0; +public: + virtual void SetHost( IClientEntity* host ) = 0; +private: + virtual void unk01( ) = 0; + virtual void unk02( ) = 0; +public: + virtual void ProcessImpacts( ) = 0; +}; + +class CMoveData { +public: + bool m_bFirstRunOfFunctions : 1; + bool m_bGameCodeMovedPlayer : 1; + bool m_bNoAirControl : 1; + + unsigned long m_nPlayerHandle; + int m_nImpulseCommand; + vec3_t m_vecViewAngles; + vec3_t m_vecAbsViewAngles; + int m_nButtons; + int m_nOldButtons; + float m_flForwardMove; + float m_flSideMove; + float m_flUpMove; + + float m_flMaxSpeed; + float m_flClientMaxSpeed; + + vec3_t m_vecVelocity; + vec3_t m_vecOldVelocity; + float somefloat; + vec3_t m_vecAngles; + vec3_t m_vecOldAngles; + + float m_outStepHeight; + vec3_t m_outWishVel; + vec3_t m_outJumpVel; + + vec3_t m_vecConstraintCenter; + float m_flConstraintRadius; + float m_flConstraintWidth; + float m_flConstraintSpeedFactor; + bool m_bConstraintPastRadius; + + void SetAbsOrigin( const vec3_t& vec ); + const vec3_t& GetAbsOrigin( ) const; + +private: + vec3_t m_vecAbsOrigin; // edict::origin + uint8_t pad_ending_001[0x160]; +}; + +class ICSGameMovement { +public: + void ProcessMovement( IClientEntity* ent, void* data ) { + using fn = void( __thiscall* )( void*, IClientEntity*, void* ); + return util::get_vfunc< fn >( this, 1 )( this, ent, data ); + } + + void Reset( ) { + using fn = void( __thiscall* )( void* ); + return util::get_vfunc< fn >( this, 2 )( this ); + } + + void StartTrackPredictionErrors( IClientEntity* ent ) { + using fn = void( __thiscall* )( void*, IClientEntity* ); + return util::get_vfunc< fn >( this, 3 )( this, ent ); + } + + void FinishTrackPredictionErrors( IClientEntity* ent ) { + using fn = void( __thiscall* )( void*, IClientEntity* ); + return util::get_vfunc< fn >( this, 4 )( this, ent ); + } +}; + +class IPrediction { +public: + + // You will need these members to avoid double footsteps and other + // prediction mistakes from happening. + + char pad00 [ 8 ]; // 0x0000
+ bool m_bInPrediction; // 0x0008
+ char pad01 [ 1 ]; // 0x0009
+ bool m_bEnginePaused; // 0x000A
+ char pad02 [ 13 ]; // 0x000B
+ bool m_bIsFirstTimePredicted; // 0x0018 + + virtual ~IPrediction( ) { }; + + virtual void Init( ) = 0; + virtual void Shutdown( ) = 0; + + // Run prediction + virtual void Update + ( + int startframe, // World update ( un-modded ) most recently received + bool validframe, // Is frame data valid + int incoming_acknowledged, // Last command acknowledged to have been run by server (un-modded) + int outgoing_command // Last command (most recent) sent to server (un-modded) + ) = 0; + + // We are about to get a network update from the server. We know the update #, so we can pull any + // data purely predicted on the client side and transfer it to the new from data state. + virtual void PreEntityPacketReceived( int commands_acknowledged, int current_world_update_packet ) = 0; + virtual void PostEntityPacketReceived( ) = 0; + virtual void PostNetworkDataReceived( int commands_acknowledged ) = 0; + + virtual void OnReceivedUncompressedPacket( ) = 0; + + // The engine needs to be able to access a few predicted values + virtual void GetViewOrigin( vec3_t& org ) = 0; + virtual void SetViewOrigin( vec3_t& org ) = 0; + virtual void GetViewAngles( vec3_t& ang ) = 0; + virtual void SetViewAngles( vec3_t& ang ) = 0; + virtual void GetLocalViewAngles( vec3_t& ang ) = 0; + virtual void SetLocalViewAngles( vec3_t& ang ) = 0; + + virtual bool InPrediction( ) const = 0; + virtual bool IsFirstTimePredicted( ) const = 0; + + virtual int GetLastAcknowledgedCommandNumber( ) const = 0; + + virtual int GetIncomingPacketNumber( ) const = 0; + + virtual void CheckMovingGround( IClientEntity* player, double frametime ) = 0; + virtual void RunCommand( IClientEntity *player, user_cmd_t *ucmd, IMoveHelper *moveHelper ) = 0; + + virtual void SetupMove( IClientEntity *player, user_cmd_t *ucmd, IMoveHelper *pHelper, CMoveData *move ) = 0; + virtual void FinishMove( IClientEntity *player, user_cmd_t *ucmd, CMoveData *move ) = 0; + virtual void SetIdealPitch( int nSlot, IClientEntity *player, const vec3_t& origin, const vec3_t& angles, const vec3_t& viewheight ) = 0; + + virtual void CheckError( int nSlot, IClientEntity *player, int commands_acknowledged ) = 0; + + virtual void _Update + ( + int nSlot, + bool received_new_world_update, + bool validframe, // Is frame data valid + int incoming_acknowledged, // Last command acknowledged to have been run by server (un-modded) + int outgoing_command // Last command (most recent) sent to server (un-modded) + ) = 0; +}; diff --git a/internal_rewrite/ISteamClient.hpp b/internal_rewrite/ISteamClient.hpp new file mode 100644 index 0000000..190607f --- /dev/null +++ b/internal_rewrite/ISteamClient.hpp @@ -0,0 +1,43 @@ +#include "util.hpp"
+using SteamPipeHandle = uint32_t;
+using SteamUserHandle = uint32_t;
+
+enum game_coordinator_result_t {
+ result_ok,
+ result_no_message,
+ result_small_buffer,
+ result_not_logged_on,
+ result_invalid,
+
+};
+
+class ISteamFriends {
+public:
+ bool set_rich_presence( const char* key, const char* value ) {
+ return util::get_vfunc< 43, bool >( this, key, value );
+ }
+
+ void clear_rich_presence( ) {
+ util::get_vfunc< 44, void >( this );
+ }
+};
+
+class ISteamClient {
+public:
+
+ void* GetISteamFriends( SteamUserHandle user, SteamPipeHandle pipe, const char* name ) {
+ return util::get_vfunc< 8, void* >( this, user, pipe, name );
+ }
+
+ void* GetISteamGenericInterface( SteamUserHandle user, SteamPipeHandle pipe, const char* name ) {
+ return util::get_vfunc< 12, void* >( this, user, pipe, name );
+ }
+
+};
+
+class ISteamGameCoordinator {
+public:
+ virtual game_coordinator_result_t send_message( uint32_t msg_type, const void* pub_data, uint32_t data ) = 0;
+ virtual bool IsMessageAvailable( uint32_t* msg_size ) = 0;
+ virtual game_coordinator_result_t RetrieveMessage( uint32_t* msg_type, void* pub_dest, uint32_t dest, uint32_t* msg_size ) = 0;
+};
diff --git a/internal_rewrite/ISurface.hpp b/internal_rewrite/ISurface.hpp new file mode 100644 index 0000000..2845eaa --- /dev/null +++ b/internal_rewrite/ISurface.hpp @@ -0,0 +1,421 @@ +#pragma once +#include "IAppSystem.hpp" +#include "vector.hpp" +#include "color.hpp" + +enum FontDrawType_t { + FONT_DRAW_DEFAULT = 0, + FONT_DRAW_NONADDITIVE, + FONT_DRAW_ADDITIVE, + FONT_DRAW_TYPE_COUNT = 2, +}; + +enum FontFlags_t { + FONTFLAG_NONE, + FONTFLAG_ITALIC = 0x001, + FONTFLAG_UNDERLINE = 0x002, + FONTFLAG_STRIKEOUT = 0x004, + FONTFLAG_SYMBOL = 0x008, + FONTFLAG_ANTIALIAS = 0x010, + FONTFLAG_GAUSSIANBLUR = 0x020, + FONTFLAG_ROTARY = 0x040, + FONTFLAG_DROPSHADOW = 0x080, + FONTFLAG_ADDITIVE = 0x100, + FONTFLAG_OUTLINE = 0x200, + FONTFLAG_CUSTOM = 0x400, + FONTFLAG_BITMAP = 0x800, +}; + +enum ImageFormat { + IMAGE_FORMAT_UNKNOWN = -1, + IMAGE_FORMAT_RGBA8888 = 0, + IMAGE_FORMAT_ABGR8888, + IMAGE_FORMAT_RGB888, + IMAGE_FORMAT_BGR888, + IMAGE_FORMAT_RGB565, + IMAGE_FORMAT_I8, + IMAGE_FORMAT_IA88, + IMAGE_FORMAT_P8, + IMAGE_FORMAT_A8, + IMAGE_FORMAT_RGB888_BLUESCREEN, + IMAGE_FORMAT_BGR888_BLUESCREEN, + IMAGE_FORMAT_ARGB8888, + IMAGE_FORMAT_BGRA8888, + IMAGE_FORMAT_DXT1, + IMAGE_FORMAT_DXT3, + IMAGE_FORMAT_DXT5, + IMAGE_FORMAT_BGRX8888, + IMAGE_FORMAT_BGR565, + IMAGE_FORMAT_BGRX5551, + IMAGE_FORMAT_BGRA4444, + IMAGE_FORMAT_DXT1_ONEBITALPHA, + IMAGE_FORMAT_BGRA5551, + IMAGE_FORMAT_UV88, + IMAGE_FORMAT_UVWQ8888, + IMAGE_FORMAT_RGBA16161616F, + IMAGE_FORMAT_RGBA16161616, + IMAGE_FORMAT_UVLX8888, + IMAGE_FORMAT_R32F, // Single-channel 32-bit floating point + IMAGE_FORMAT_RGB323232F, + IMAGE_FORMAT_RGBA32323232F, + + // Depth-stencil texture formats for shadow depth mapping + IMAGE_FORMAT_NV_DST16, // + IMAGE_FORMAT_NV_DST24, // + IMAGE_FORMAT_NV_INTZ, // Vendor-specific depth-stencil texture + IMAGE_FORMAT_NV_RAWZ, // formats for shadow depth mapping + IMAGE_FORMAT_ATI_DST16, // + IMAGE_FORMAT_ATI_DST24, // + IMAGE_FORMAT_NV_NULL, // Dummy format which takes no video memory + + // Compressed normal map formats + IMAGE_FORMAT_ATI2N, // One-surface ATI2N / DXN format + IMAGE_FORMAT_ATI1N, // Two-surface ATI1N format + + NUM_IMAGE_FORMATS +}; + +struct vertex_t { + vertex_t( ) {} + + vertex_t( const vec2_t& pos, const vec2_t& coord = vec2_t( 0, 0 ) ) { + m_position = pos; + m_tex_coord = coord; + } + + void init( float x, float y, const vec2_t& coord = vec2_t( 0, 0 ) ) { + m_position = vec2_t( x, y ); + m_tex_coord = coord; + } + + vec2_t m_position; + vec2_t m_tex_coord; +}; + +using HFont = unsigned long; +using VPANEL = unsigned long; +class IntRect; +class IHTMLEvents; +class IHTML; +using HCursor = unsigned long; +using HTexture = unsigned long; +class CharRenderInfo; +class IVguiMatInfo; +class IImage; +class DrawTexturedRectParms_t; +class IHTMLChromeController; + +class ISurface : public IAppSystem { +public: + // frame + virtual void RunFrame( ) = 0; + + // hierarchy root + virtual VPANEL GetEmbeddedPanel( ) = 0; + virtual void SetEmbeddedPanel( VPANEL pPanel ) = 0; + + // drawing context + virtual void PushMakeCurrent( VPANEL panel, bool useInsets ) = 0; + virtual void PopMakeCurrent( VPANEL panel ) = 0; //13 + + // rendering functions + virtual void DrawSetColor( ) = 0; //15 + virtual void DrawSetColor( clr_t col ) = 0; //14 + + virtual void DrawFilledRect( int x0, int y0, int x1, int y1 ) = 0; //16 + virtual void DrawFilledRectArray( IntRect *pRects, int numRects ) = 0; + virtual void DrawOutlinedRect( int x0, int y0, int x1, int y1 ) = 0; + + virtual void DrawLine( int x0, int y0, int x1, int y1 ) = 0; + virtual void DrawPolyLine( int *px, int *py, int numPoints ) = 0; + + virtual void DrawSetApparentDepth( float flDepth ) = 0; + virtual void DrawClearApparentDepth( ) = 0; + + virtual void DrawSetTextFont( HFont font ) = 0; + virtual void DrawSetTextColor( ) = 0; //25 + virtual void DrawSetTextColor( clr_t col ) = 0; //24 + virtual void DrawSetTextPos( int x, int y ) = 0; //26 + virtual void DrawGetTextPos( int& x, int& y ) = 0; + virtual void DrawPrintText( const wchar_t *text, int textLen, FontDrawType_t drawType = FONT_DRAW_DEFAULT ) = 0; + virtual void DrawUnicodeChar( wchar_t wch, FontDrawType_t drawType = FONT_DRAW_DEFAULT ) = 0; + + virtual void DrawFlushText( ) = 0; // flushes any buffered text (for rendering optimizations) + virtual IHTML *CreateHTMLWindow( IHTMLEvents *events, VPANEL context ) = 0; + virtual void PaintHTMLWindow( IHTML *htmlwin ) = 0; + virtual void DeleteHTMLWindow( IHTML *htmlwin ) = 0; + + enum ETextureFormat + { + eTextureFormat_RGBA, + eTextureFormat_BGRA, + eTextureFormat_BGRA_Opaque, // bgra format but alpha is always 255, CEF does this, we can use this fact for better perf on win32 gdi + }; + + virtual int DrawGetTextureId( char const *filename ) = 0; + virtual bool DrawGetTextureFile( int id, char *filename, int maxlen ) = 0; + virtual void DrawSetTextureFile( int id, const char *filename, int hardwareFilter, bool forceReload ) = 0; + virtual void DrawSetTextureRGBA( int id, const unsigned char *rgba, int wide, int tall ) = 0; + virtual void DrawSetTexture( int id ) = 0; //38 + virtual void DrawGetTextureSize( int id, int &wide, int &tall ) = 0; + virtual void DrawTexturedRect( int x0, int y0, int x1, int y1 ) = 0; + virtual bool IsTextureIDValid( int id ) = 0; + virtual bool DeleteTextureByID( int id ) = 0; + + virtual int CreateNewTextureID( bool procedural = false ) = 0; //43 + + virtual void GetScreenSize( int &wide, int &tall ) = 0; + virtual void SetAsTopMost( VPANEL panel, bool state ) = 0; + virtual void BringToFront( VPANEL panel ) = 0; + virtual void SetForegroundWindow( VPANEL panel ) = 0; + virtual void SetPanelVisible( VPANEL panel, bool state ) = 0; + virtual void SetMinimized( VPANEL panel, bool state ) = 0; + virtual bool IsMinimized( VPANEL panel ) = 0; + virtual void FlashWindow( VPANEL panel, bool state ) = 0; + virtual void SetTitle( VPANEL panel, const wchar_t *title ) = 0; + virtual void SetAsToolBar( VPANEL panel, bool state ) = 0; // removes the window's task bar entry (for context menu's, etc.) + + // windows stuff + virtual void CreatePopup( VPANEL panel, bool minimised, bool showTaskbarIcon = true, bool disabled = false, bool mouseInput = true, bool kbInput = true ) = 0; + virtual void SwapBuffers( VPANEL panel ) = 0; + virtual void Invalidate( VPANEL panel ) = 0; + virtual void SetCursor( HCursor cursor ) = 0; + virtual bool IsCursorVisible( ) = 0; + virtual void ApplyChanges( ) = 0; + virtual bool IsWithin( int x, int y ) = 0; + virtual bool HasFocus( ) = 0; + + // returns true if the surface supports minimize & maximize capabilities + enum SurfaceFeature_e + { + ANTIALIASED_FONTS = 1, + DROPSHADOW_FONTS = 2, + ESCAPE_KEY = 3, + OPENING_NEW_HTML_WINDOWS = 4, + FRAME_MINIMIZE_MAXIMIZE = 5, + OUTLINE_FONTS = 6, + DIRECT_HWND_RENDER = 7, + }; + virtual bool SupportsFeature( SurfaceFeature_e feature ) = 0; + + // restricts what gets drawn to one panel and it's children + // currently only works in the game + virtual void RestrictPaintToSinglePanel( VPANEL panel ) = 0; + + // these two functions obselete, use IInput::SetAppModalSurface() instead + virtual void SetModalPanel( VPANEL ) = 0; + virtual VPANEL GetModalPanel( ) = 0; + + virtual void UnlockCursor( ) = 0; + virtual void LockCursor( ) = 0; + virtual void SetTranslateExtendedKeys( bool state ) = 0; + virtual VPANEL GetTopmostPopup( ) = 0; + + // engine-only focus handling (replacing WM_FOCUS windows handling) + virtual void SetTopLevelFocus( VPANEL panel ) = 0; + + // fonts + // creates an empty handle to a vgui font. windows fonts can be add to this via SetFontGlyphSet(). + virtual HFont CreateFont( ) = 0; //71 + + // adds to the font + enum EFontFlags + { + FONTFLAG_NONE, + FONTFLAG_ITALIC = 0x001, + FONTFLAG_UNDERLINE = 0x002, + FONTFLAG_STRIKEOUT = 0x004, + FONTFLAG_SYMBOL = 0x008, + FONTFLAG_ANTIALIAS = 0x010, + FONTFLAG_GAUSSIANBLUR = 0x020, + FONTFLAG_ROTARY = 0x040, + FONTFLAG_DROPSHADOW = 0x080, + FONTFLAG_ADDITIVE = 0x100, + FONTFLAG_OUTLINE = 0x200, + FONTFLAG_CUSTOM = 0x400, // custom generated font - never fall back to asian compatibility mode + FONTFLAG_BITMAP = 0x800, // compiled bitmap font - no fallbacks + }; + + virtual bool SetFontGlyphSet( HFont font, const char *windowsFontName, int tall, int weight, int blur, int scanlines, int flags, int nRangeMin = 0, int nRangeMax = 0 ) = 0; + + // adds a custom font file (only supports true type font files (.ttf) for now) + virtual bool AddCustomFontFile( const char *fontName, const char *fontFileName ) = 0; + + // returns the details about the font + virtual int GetFontTall( HFont font ) = 0; + virtual int GetFontAscent( HFont font, wchar_t wch ) = 0; + virtual bool IsFontAdditive( HFont font ) = 0; + virtual void GetCharABCwide( HFont font, int ch, int &a, int &b, int &c ) = 0; + virtual int GetCharacterWidth( HFont font, int ch ) = 0; + virtual void GetTextSize( HFont font, const wchar_t *text, int &wide, int &tall ) = 0; + + // notify icons?!? + virtual VPANEL GetNotifyPanel( ) = 0; + virtual void SetNotifyIcon( VPANEL context, HTexture icon, VPANEL panelToReceiveMessages, const char *text ) = 0; + + // plays a sound + virtual void PlaySound( const char *fileName ) = 0; //82 + + //!! these functions should not be accessed directly, but only through other vgui items + //!! need to move these to seperate interface + virtual int GetPopupCount( ) = 0; + virtual VPANEL GetPopup( int index ) = 0; + virtual bool ShouldPaintChildPanel( VPANEL childPanel ) = 0; + virtual bool RecreateContext( VPANEL panel ) = 0; + virtual void AddPanel( VPANEL panel ) = 0; + virtual void ReleasePanel( VPANEL panel ) = 0; + virtual void MovePopupToFront( VPANEL panel ) = 0; + virtual void MovePopupToBack( VPANEL panel ) = 0; + + virtual void SolveTraverse( VPANEL panel, bool forceApplySchemeSettings = false ) = 0; + virtual void PaintTraverse( VPANEL panel ) = 0; + + virtual void EnableMouseCapture( VPANEL panel, bool state ) = 0; + + // returns the size of the workspace + virtual void GetWorkspaceBounds( int &x, int &y, int &wide, int &tall ) = 0; + + // gets the absolute coordinates of the screen (in windows space) + virtual void GetAbsoluteWindowBounds( int &x, int &y, int &wide, int &tall ) = 0; + + // gets the base resolution used in proportional mode + virtual void GetProportionalBase( int &width, int &height ) = 0; + + virtual void CalculateMouseVisible( ) = 0; + virtual bool NeedKBInput( ) = 0; + + virtual bool HasCursorPosFunctions( ) = 0; + virtual void SurfaceGetCursorPos( int &x, int &y ) = 0; + virtual void SurfaceSetCursorPos( int x, int y ) = 0; + + // SRC only functions!!! + virtual void DrawTexturedLine( const vertex_t &a, const vertex_t &b ) = 0; + virtual void DrawOutlinedCircle( int x, int y, int radius, int segments ) = 0; + virtual void DrawTexturedPolyLine( const vertex_t *p, int n ) = 0; // (Note: this connects the first and last points). + virtual void DrawTexturedSubRect( int x0, int y0, int x1, int y1, float texs0, float text0, float texs1, float text1 ) = 0; + virtual void DrawTexturedPolygon( int n, vertex_t *pVertice, bool bClipVertices = true ) = 0; //106 + virtual const wchar_t* GetTitle( VPANEL panel ) = 0; + virtual bool IsCursorLocked( ) const = 0; + virtual void SetWorkspaceInsets( int left, int top, int right, int bottom ) = 0; + + // squarish comic book word bubble with pointer, rect params specify the space inside the bubble + virtual void DrawWordBubble( int x0, int y0, int x1, int y1, int nBorderThickness, clr_t rgbaBackground, clr_t rgbaBorder, + bool bPointer = false, int nPointerX = 0, int nPointerY = 0, int nPointerBaseThickness = 16 ) = 0; + + + // Lower level char drawing code, call DrawGet then pass in info to DrawRender + virtual bool DrawGetUnicodeCharRenderInfo( wchar_t ch, CharRenderInfo& info ) = 0; + virtual void DrawRenderCharFromInfo( const CharRenderInfo& info ) = 0; + + // global alpha setting functions + // affect all subsequent draw calls - shouldn't normally be used directly, only in Panel::PaintTraverse() + virtual void DrawSetAlphaMultiplier( float alpha /* [0..1] */ ) = 0; + virtual float DrawGetAlphaMultiplier( ) = 0; + + // web browser + virtual void SetAllowHTMLJavaScript( bool state ) = 0; + + // video mode changing + virtual void OnScreenSizeChanged( int nOldWidth, int nOldHeight ) = 0; + + virtual HCursor CreateCursorFromFile( char const *curOrAniFile, char const *pPathID = nullptr ) = 0; + + // create IVguiMatInfo object ( IMaterial wrapper in VguiMatSurface, NULL in CWin32Surface ) + virtual IVguiMatInfo* DrawGetTextureMatInfoFactory( int id ) = 0; + + virtual void PaintTraverseEx( VPANEL panel, bool paintPopups = false ) = 0; + + virtual float GetZPos( ) const = 0; + + // From the Xbox + virtual void SetPanelForInput( VPANEL vpanel ) = 0; + virtual void DrawFilledRectFastFade( int x0, int y0, int x1, int y1, int fadeStartPt, int fadeEndPt, unsigned int alpha0, unsigned int alpha1, bool bHorizontal ) = 0; + virtual void DrawFilledRectFade( int x0, int y0, int x1, int y1, unsigned int alpha0, unsigned int alpha1, bool bHorizontal ) = 0; //123 + + virtual void DrawSetTextureRGBAEx( int id, const unsigned char *rgba, int wide, int tall, ImageFormat imageFormat ) = 0; + virtual void DrawSetTextScale( float sx, float sy ) = 0; + virtual bool SetBitmapFontGlyphSet( HFont font, const char *windowsFontName, float scalex, float scaley, int flags ) = 0; + // adds a bitmap font file + virtual bool AddBitmapFontFile( const char *fontFileName ) = 0; + // sets a symbol for the bitmap font + virtual void SetBitmapFontName( const char *pName, const char *pFontFilename ) = 0; + // gets the bitmap font filename + virtual const char* GetBitmapFontName( const char *pName ) = 0; + virtual void ClearTemporaryFontCache( ) = 0; + + virtual IImage* GetIconImageForFullPath( char const *pFullPath ) = 0; + virtual void DrawUnicodeString( const wchar_t *pwString, FontDrawType_t drawType = FONT_DRAW_DEFAULT ) = 0; + virtual void PrecacheFontCharacters( HFont font, const wchar_t *pCharacters ) = 0; + // Console-only. Get the string to use for the current video mode for layout files. + //virtual const char *GetResolutionKey( void ) const = 0; + + virtual const char *GetFontName( HFont font ) = 0; + //virtual const char *GetFontFamilyName( HFont font ) = 0; + + virtual bool ForceScreenSizeOverride( bool bState, int wide, int tall ) = 0; + // LocalToScreen, ParentLocalToScreen fixups for explicit PaintTraverse calls on Panels not at 0, 0 position + virtual bool ForceScreenPosOffset( bool bState, int x, int y ) = 0; + virtual void OffsetAbsPos( int &x, int &y ) = 0; + + virtual void SetAbsPosForContext( int, int, int ) = 0; + virtual void GetAbsPosForContext( int, int &, int & ) = 0; + + // Causes fonts to get reloaded, etc. + virtual void ResetFontCaches( ) = 0; + + virtual bool IsScreenSizeOverrideActive( ) = 0; + virtual bool IsScreenPosOverrideActive( ) = 0; + + virtual void DestroyTextureID( int id ) = 0; + + virtual int GetTextureNumFrames( int id ) = 0; + virtual void DrawSetTextureFrame( int id, int nFrame, unsigned int *pFrameCache ) = 0; + + virtual void GetClipRect( int &x0, int &y0, int &x1, int &y1 ) = 0; + virtual void SetClipRect( int x0, int y0, int x1, int y1 ) = 0; + + virtual void DrawTexturedRectEx( DrawTexturedRectParms_t *pDrawParms ) = 0; + + virtual void GetKernedCharWidth( HFont font, wchar_t ch, wchar_t chBefore, wchar_t chAfter, float &wide, float &abcA ) = 0; + + virtual void DrawUpdateRegionTextureRGBA( int nTextureID, int x, int y, const unsigned char *pchData, int wide, int tall, ImageFormat imageFormat ) = 0; + virtual bool BHTMLWindowNeedsPaint( IHTML *htmlwin ) = 0; + + virtual void DrawSetTextureRGBALinear( int, unsigned char const*, int, int ) = 0; + + virtual const char *GetWebkitHTMLUserAgentString( ) = 0; + + virtual IHTMLChromeController *Deprecated_AccessChromeHTMLController( ) = 0; + + /* + 154 CMatSystemSurface::SetAppDrivesInput(bool) + 155 CMatSystemSurface::EnableWindowsMessages(bool) + 156 CMatSystemSurface::Begin3DPaint(int,int,int,int,bool) + 157 CMatSystemSurface::End3DPaint(bool) + 158 CMatSystemSurface::DisableClipping(bool) + 159 CMatSystemSurface::SetMouseCallbacks(void (*)(int &,int &),void (*)(int,int)) + 160 CMatSystemSurface::InstallPlaySoundFunc(void (*)(char const*)) + 161 CMatSystemSurface::DrawColoredCircle(int,int,float,int,int,int,int) + 162 CMatSystemSurface::DrawColoredText(unsigned long,int,int,int,int,int,int,char const*,...) + 163 CMatSystemSurface::DrawColoredTextRect(unsigned long,int,int,int,int,int,int,int,int,char const*,...) + 164 CMatSystemSurface::DrawTextHeight(unsigned long,int,int &,char *,...) + 165 CMatSystemSurface::DrawTextLen(unsigned long,char const*,...) + 166 CMatSystemSurface::DrawPanelIn3DSpace(unsigned long long,VMatrix const&,int,int,float,float) + 167 CMatSystemSurface::DrawSetTextureMaterial(int,IMaterial *) + 168 CMatSystemSurface::HandleInputEvent(InputEvent_t const&) + 169 CMatSystemSurface::Set3DPaintTempRenderTarget(char const*) + 170 CMatSystemSurface::Reset3DPaintTempRenderTarget(void) + 171 CMatSystemSurface::DrawGetTextureMaterial(int) + 172 CMatSystemSurface::SetInputContext(InputContextHandle_t__ *) + 173 CMatSystemSurface::DrawSetSubTextureRGBA(int,int,int,unsigned char const*,int,int) + 174 CMatSystemSurface::DrawTexturedSubRectGradient(int,int,int,int,float,float,float,float,Color,Color,bool) + 175 CMatSystemSurface::~CMatSystemSurface() + 176 CMatSystemSurface::~CMatSystemSurface() + 177 CMatSystemSurface::SupportsFontFeature(FontFeature_t) + 178 CMatSystemSurface::InEngine(void) + 179 CMatSystemSurface::IsInThink(unsigned long long) + 180 CMatSystemSurface::SetLanguage(char const*) + 181 CMatSystemSurface::GetLanguage(void) + 182 CMatSystemSurface::ComputeTextWidth(wchar_t const*) + */ +};
\ No newline at end of file diff --git a/internal_rewrite/IVEngineClient.hpp b/internal_rewrite/IVEngineClient.hpp new file mode 100644 index 0000000..d3a4d8f --- /dev/null +++ b/internal_rewrite/IVEngineClient.hpp @@ -0,0 +1,258 @@ +#pragma once
+#include <string>
+#include <algorithm>
+
+#include "util.hpp"
+#include "vector.hpp"
+
+using matrix3x4 = float[ 3 ][ 4 ];
+
+typedef struct player_info_s {
+private:
+ uint32_t __pad0[ 2 ];
+public:
+ unsigned int m_xuidlow;
+ unsigned int m_xuidhigh;
+ char name[ 128 ];//32
+ int m_userid;
+ char m_steamid[ 33 ];//32
+ unsigned m_steam3id;
+ char m_friendsname[ 128 ];
+ bool m_isfakeplayer;
+ bool m_ishltv;
+ uint32_t m_customfiles[ 4 ];
+ uint8_t m_filesdownloaded;
+private:
+ int __pad1;
+} player_info_t;
+
+class INetChannelInfo {
+public:
+ enum
+ {
+ GENERIC = 0, // must be first and is default group
+ LOCALPLAYER, // bytes for local player entity update
+ OTHERPLAYERS, // bytes for other players update
+ ENTITIES, // all other entity bytes
+ SOUNDS, // game sounds
+ EVENTS, // event messages
+ TEMPENTS, // temp entities
+ USERMESSAGES, // user messages
+ ENTMESSAGES, // entity messages
+ VOICE, // voice data
+ STRINGTABLE, // a stringtable update
+ MOVE, // client move cmds
+ STRINGCMD, // string command
+ SIGNON, // various signondata
+ TOTAL, // must be last and is not a real group
+ };
+
+ virtual const char* GetName( ) const = 0; // get channel name
+ virtual const char* GetAddress( ) const = 0; // get channel IP address as string
+ virtual float GetTime( ) const = 0; // current net time
+ virtual float GetTimeConnected( ) const = 0; // get connection time in seconds
+ virtual int GetBufferSize( ) const = 0; // netchannel packet history size
+ virtual int GetDataRate( ) const = 0; // send data rate in byte/sec
+
+ virtual bool IsLoopback( ) const = 0; // true if loopback channel
+ virtual bool IsTimingOut( ) const = 0; // true if timing out
+ virtual bool IsPlayback( ) const = 0; // true if demo playback
+
+ virtual float GetLatency( int flow ) const = 0; // current latency (RTT), more accurate but jittering
+ virtual float GetAvgLatency( int flow ) const = 0; // average packet latency in seconds
+ virtual float GetAvgLoss( int flow ) const = 0; // avg packet loss[0..1]
+ virtual float GetAvgChoke( int flow ) const = 0; // avg packet choke[0..1]
+ virtual float GetAvgData( int flow ) const = 0; // data flow in bytes/sec
+ virtual float GetAvgPackets( int flow ) const = 0; // avg packets/sec
+ virtual int GetTotalData( int flow ) const = 0; // total flow in/out in bytes
+ virtual int GetTotalPackets( int flow ) const = 0;
+ virtual int GetSequenceNr( int flow ) const = 0; // last send seq number
+ virtual bool IsValidPacket( int flow, int frame_number ) const = 0; // true if packet was not lost/dropped/chocked/flushed
+ virtual float GetPacketTime( int flow, int frame_number ) const = 0; // time when packet was send
+ virtual int GetPacketBytes( int flow, int frame_number, int group ) const = 0; // group size of this packet
+ virtual bool GetStreamProgress( int flow, int* received, int* total ) const = 0; // TCP progress if transmitting
+ virtual float GetTimeSinceLastReceived( ) const = 0; // get time since last recieved packet in seconds
+ virtual float GetCommandInterpolationAmount( int flow, int frame_number ) const = 0;
+ virtual void GetPacketResponseLatency( int flow, int frame_number, int* pnLatencyMsecs, int* pnChoke ) const = 0;
+ virtual void GetRemoteFramerate( float* pflFrameTime, float* pflFrameTimeStdDeviation ) const = 0;
+
+ virtual float GetTimeoutSeconds( ) const = 0;
+};
+
+class INetChannel {
+public:
+ char pad_0000[ 20 ]; //0x0000
+ bool m_bProcessingMessages; //0x0014
+ bool m_bShouldDelete; //0x0015
+ char pad_0016[ 2 ]; //0x0016
+ int32_t m_nOutSequenceNr; //0x0018 last send outgoing sequence number
+ int32_t m_nInSequenceNr; //0x001C last received incoming sequnec number
+ int32_t m_nOutSequenceNrAck; //0x0020 last received acknowledge outgoing sequnce number
+ int32_t m_nOutReliableState; //0x0024 state of outgoing reliable data (0/1) flip flop used for loss detection
+ int32_t m_nInReliableState; //0x0028 state of incoming reliable data
+ int32_t m_nChokedPackets; //0x002C number of choked packets
+ float m_fClearTime;
+ float m_TimeOut;
+ char m_Name[ 32 ];
+
+
+ char pad_0030[ 1044 ]; //0x0030
+
+ bool transmit( bool only_reliable ) {
+ return util::get_vfunc< 49, bool >( this, only_reliable );
+ }
+}; //Size: 0x0444
+
+struct INetMessage {
+ virtual ~INetMessage( );
+};
+
+template<typename T>
+class CNetMessagePB : public INetMessage, public T {};
+
+class CCLCMsg_Move_ {
+private:
+ char __PAD0[ 0x8 ];
+public:
+ int numBackupCommands;
+ int numNewCommands;
+};
+
+using CCLCMsg_Move_t = CNetMessagePB<CCLCMsg_Move_>;
+
+class CClientState {
+public:
+ char pad_0000[ 0x9c ]; //0x0000
+ class INetChannel* m_netchannel; //0x0094
+ char pad_0098[ 16 ]; //0x0098
+ unsigned int m_retrynum; //0x00A8
+ char pad_00AC[ 84 ]; //0x00AC
+ int m_signon_state; //0x0100
+ char pad_0104[ 8 ]; //0x0104
+ float m_next_cmd_time; //0x010C
+ int m_servercount; //0x0110
+ int m_current_sequence; //0x0114
+ char pad_0118[ 75 ]; //0x0118
+ int m_server_tick; //0x0163
+ int m_client_tick; //0x0167
+ int m_delta_tick; //0x016B
+ char pad_016F[ 4 ]; //0x016F
+ int m_view_entity; //0x0173
+ char pad_0177[ 8 ]; //0x0177
+ char m_level_name[ 260 ]; //0x017F
+ char m_level_name_short[ 40 ]; //0x0283
+ char pad_02AB[ 18932 ]; //0x02AB
+ char pad_0x2DA0; //0x4CA7
+ int m_lastoutgoingcommand; //0x4CA8
+ int m_chokedcommands; //0x4CAC
+ int m_last_acknowledged_cmd; //0x4CB0
+ int m_command_ack; //0x4CB4
+ int m_sound_seq; //0x4CB8
+ char pad_4CBC[ 8 ]; //0x4CBC
+ bool m_ishltv; //0x4CC4
+};
+
+class CGlobalState {
+public:
+ uintptr_t* m_manager;
+ CClientState *m_def_clientstate;
+
+ __forceinline CClientState* get_client_state( ) {
+ return m_def_clientstate;
+ }
+};
+
+class IVEngineClient
+{
+public:
+ void GetScreenSize( int& width, int& height ) {
+ using fn = void( __thiscall* )( void*, int&, int& );
+ return util::get_vfunc< fn >( this, 5 )( this, width, height );
+ }
+
+ void ClientCmd( const char* szCommandString ) {
+ std::string command( szCommandString );
+ std::replace( command.begin( ), command.end( ), ';', ':' );
+ std::replace( command.begin( ), command.end( ), '"', '*' );
+ using fn = void( __thiscall* )( void*, const char* );
+ return util::get_vfunc< fn >( this, 7 )( this, command.c_str( ) );
+ }
+
+ void ClientCmd_Unrestricted( const char* szCommandString ) {
+ std::string command( szCommandString );
+ std::replace( command.begin( ), command.end( ), ';', ':' );
+ std::replace( command.begin( ), command.end( ), '"', '*' );
+ using fn = void( __thiscall* )( void*, const char*, const char* );
+ return util::get_vfunc< fn >( this, 114 )( this, command.c_str( ), nullptr );
+ }
+
+ bool GetPlayerInfo( int index, player_info_t* pInfo ) {
+ using fn = bool( __thiscall* )( void*, int, player_info_t* );
+ return util::get_vfunc< fn >( this, 8 )( this, index, pInfo );
+ }
+
+ int GetPlayerForUserID( int UserID ) {
+ using fn = int( __thiscall* )( void*, int );
+ return util::get_vfunc< fn >( this, 9 )( this, UserID );
+ }
+
+ int GetLocalPlayer( ) {
+ using fn = int( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 12 )( this );
+ }
+
+ float Time( ) {
+ using fn = float( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 14 )( this );
+ }
+
+ void GetViewAngles( vec3_t& ang ) {
+ using fn = void( __thiscall* )( void*, vec3_t& );
+ return util::get_vfunc< fn >( this, 18 )( this, ang );
+ }
+
+ vec3_t GetViewAngles( ) {
+ vec3_t ret;
+ GetViewAngles( ret );
+ return ret;
+ }
+
+ void SetViewAngles( vec3_t& ang ) {
+ using fn = void( __thiscall* )( void*, vec3_t& );
+ return util::get_vfunc< fn >( this, 19 )( this, ang );
+ }
+
+ int GetMaxClients( ) {
+ using fn = int( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 20 )( this );
+ }
+
+ bool IsInGame( ) {
+ using fn = bool( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 26 )( this );
+ }
+
+ bool IsConnected( ) {
+ using fn = bool( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 27 )( this );
+ }
+
+ bool IsPaused( ) {
+ return util::get_vfunc< 91, bool >( this );
+ }
+
+ const matrix3x4& WorldToScreenMatrix( ) {
+ using fn = const matrix3x4& ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 37 )( this );
+ }
+
+ const char* GetLevelName( ) {
+ using fn = const char* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 52 )( this );
+ }
+
+ INetChannelInfo* GetNetChannelInfo( ) {
+ using fn = INetChannelInfo* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 78 )( this );
+ }
+};
\ No newline at end of file diff --git a/internal_rewrite/IVModelInfoClient.hpp b/internal_rewrite/IVModelInfoClient.hpp new file mode 100644 index 0000000..3cc418b --- /dev/null +++ b/internal_rewrite/IVModelInfoClient.hpp @@ -0,0 +1,268 @@ +#pragma once
+#include "IVEngineClient.hpp"
+#include "IClientEntityList.hpp"
+
+enum BoneMask_t {
+ BONE_USED_MASK = 0x0007FF00,
+ BONE_USED_BY_ANYTHING = 0x0007FF00,
+ BONE_USED_BY_HITBOX = 0x00000100, // bone (or child) is used by a hit box
+ BONE_USED_BY_ATTACHMENT = 0x00000200, // bone (or child) is used by an attachment point
+ BONE_USED_BY_VERTEX_MASK = 0x0003FC00,
+ BONE_USED_BY_VERTEX_LOD0 = 0x00000400, // bone (or child) is used by the toplevel model via skinned vertex
+ BONE_USED_BY_VERTEX_LOD1 = 0x00000800,
+ BONE_USED_BY_VERTEX_LOD2 = 0x00001000,
+ BONE_USED_BY_VERTEX_LOD3 = 0x00002000,
+ BONE_USED_BY_VERTEX_LOD4 = 0x00004000,
+ BONE_USED_BY_VERTEX_LOD5 = 0x00008000,
+ BONE_USED_BY_VERTEX_LOD6 = 0x00010000,
+ BONE_USED_BY_VERTEX_LOD7 = 0x00020000,
+ BONE_USED_BY_BONE_MERGE = 0x00040000 // bone is available for bone merge to occur against it
+};
+
+struct DrawModelState_t;
+
+class INetworkStringTable;
+
+struct mstudiobbox_t {
+ int bone;
+ int group;
+ vec3_t bbmin;
+ vec3_t bbmax;
+ int szhitboxnameindex;
+ int m_iPad01[ 3 ];
+ float m_flRadius;
+ int m_iPad02[ 4 ];
+};
+
+struct mstudiohitboxset_t {
+ int sznameindex;
+ const char* pszName( ) const { return reinterpret_cast< const char* >( uintptr_t( this ) + sznameindex ); }
+ int numhitboxes;
+ int hitboxindex;
+ mstudiobbox_t* pHitbox( int i ) const { return reinterpret_cast< mstudiobbox_t* >( uintptr_t( this ) + hitboxindex ) + i; };
+};
+
+struct mstudiobone_t {
+ int sznameindex;
+ char* GetName( ) const { return reinterpret_cast< char* >( reinterpret_cast< uintptr_t >( this ) ) + sznameindex; }
+ int parent;
+ int bonecontroller[ 6 ];
+ vec3_t pos;
+ float quat[ 4 ];
+ vec3_t rot;
+ vec3_t posscale;
+ vec3_t rotscale;
+ matrix3x4 poseToBone;
+ float qAlignment[ 4 ];
+ int flags;
+ int proctype;
+ int procindex;
+ mutable int physicsbone;
+ void* GetProcedure( ) const { return procindex == 0 ? nullptr : reinterpret_cast<void*>( reinterpret_cast<uintptr_t>( this ) + procindex ); };
+ int surfacepropidx;
+ char* GetSurfaceProps( ) const { return reinterpret_cast<char*>( reinterpret_cast<uintptr_t>( this ) ) + surfacepropidx; }
+ int contents;
+ unsigned char pad[ 32 ];
+};
+
+struct mstudioseqdesc_t {
+ int baseptr;
+ int szlabelindex;
+ int szactivitynameindex;
+ int flags; // looping/non-looping flags
+ int activity; // initialized at loadtime to game DLL values
+ int actweight;
+ int numevents;
+ int eventindex;
+ vec3_t bbmin; // per sequence bounding box
+ vec3_t bbmax;
+ int numblends;
+ int animindexindex;
+ int movementindex; // [blend] float array for blended movement
+ int groupsize[ 2 ];
+ int paramindex[ 2 ]; // X, Y, Z, XR, YR, ZR
+ float paramstart[ 2 ]; // local (0..1) starting value
+ float paramend[ 2 ]; // local (0..1) ending value
+ int paramparent;
+ float fadeintime; // ideal cross fate in time (0.2 default)
+ float fadeouttime; // ideal cross fade out time (0.2 default)
+ int localentrynode; // transition node at entry
+ int localexitnode; // transition node at exit
+ int nodeflags; // transition rules
+ float entryphase; // used to match entry gait
+ float exitphase; // used to match exit gait
+ float lastframe; // frame that should generation EndOfSequence
+ int nextseq; // auto advancing sequences
+ int pose; // index of delta animation between end and nextseq
+ int numikrules;
+ int numautolayers; //
+ int autolayerindex;
+ int weightlistindex;
+ int posekeyindex;
+ int numiklocks;
+ int iklockindex;
+ int keyvalueindex;
+ int keyvaluesize;
+ int cycleposeindex; // index of pose parameter to use as cycle index
+ int activitymodifierindex;
+ int numactivitymodifiers;
+ int unused[ 5 ]; // remove/add as appropriate (grow back to 8 ints on version change!)
+};
+
+struct studiohdr_t {
+ unsigned char pad00[ 12 ];
+ char name[ 64 ];
+ unsigned char pad01[ 80 ];
+ int numbones;
+ int boneindex;
+ unsigned char pad02[ 12 ];
+ int hitboxsetindex;
+ unsigned char pad03[ 8 ];
+ int numlocalseq;
+ int localseqindex;
+ mutable int activitylistversion;
+ mutable int eventsindexed;
+
+ int numtextures;
+ int textureindex;
+
+ int numcdtextures;
+ int cdtextureindex;
+ unsigned char pad04[ 188 ];
+
+ mstudiobone_t *GetBone( int i ) const {
+ return reinterpret_cast<mstudiobone_t*>( uintptr_t( this ) + boneindex ) + i;
+ };
+
+ mstudiohitboxset_t* pHitboxSet( int i ) const {
+ return reinterpret_cast<mstudiohitboxset_t*>( uintptr_t( this ) + hitboxsetindex ) + i;
+ };
+
+ mstudiobbox_t* pHitbox( int i, int set ) const {
+ const mstudiohitboxset_t* s = pHitboxSet( set );
+ if ( !s )
+ return nullptr;
+
+ return s->pHitbox( i );
+ };
+
+ int iHitboxCount( int set ) const {
+ const mstudiohitboxset_t* s = pHitboxSet( set );
+ if ( !s )
+ return 0;
+
+ return s->numhitboxes;
+ };
+};
+
+struct ModelRenderInfo_t {
+ vec3_t m_origin;
+ vec3_t m_angles;
+ char pad[ 0x4 ];
+ void* m_renderable;
+ const model_t* m_model;
+ const matrix3x4* m_model2world;
+ const matrix3x4* m_light_offset;
+ const vec3_t* m_light_origin;
+ int m_flags;
+ int m_entity_index;
+ int m_skin;
+ int m_body;
+ int m_hitboxset;
+ uint16_t* m_instance;
+
+ ModelRenderInfo_t( ) {
+ m_model2world = nullptr;
+ m_light_offset = nullptr;
+ m_light_origin = nullptr;
+ }
+};
+
+class IVModelInfoClient {
+public:
+ model_t* GetModel( int index ) {
+ using fn = model_t*( __thiscall* )( void*, int );
+ return util::get_vfunc< fn >( this, 1 )( this, index );
+ }
+
+ int GetModelIndex( const char* name ) {
+ using fn = int( __thiscall* )( void*, const char* );
+ return util::get_vfunc< fn >( this, 2 )( this, name );
+ }
+
+ const char* GetModelName( const model_t* model ) {
+ using fn = const char* ( __thiscall* )( void*, const model_t* );
+ return util::get_vfunc< fn >( this, 3 )( this, model );
+ }
+
+ studiohdr_t* GetStudiomodel( const model_t* mod ) {
+ using fn = studiohdr_t* ( __thiscall* )( void*, const model_t* );
+ return util::get_vfunc< fn >( this, 32 )( this, mod );
+ }
+
+ model_t* FindOrLoadModel( const char* name ) {
+ using fn = model_t* ( __thiscall* )( void*, const char* );
+ return util::get_vfunc< fn >( this, 43 )( this, name );
+ }
+
+ void GetModelMaterials( const model_t *model, int count, class IMaterial** ppMaterial ) {
+ using fn = const void( __thiscall* )( void*, const model_t*, int, IMaterial** );
+ util::get_vfunc< fn >( this, 19 )( this, model, count, ppMaterial );
+ }
+};
+
+enum OverrideType_t {
+ OVERRIDE_NORMAL = 0,
+ OVERRIDE_BUILD_SHADOWS,
+ OVERRIDE_DEPTH_WRITE,
+ OVERRIDE_SSAO_DEPTH_WRITE,
+};
+
+class IVModelRender {
+public:
+ void ForcedMaterialOverride( IMaterial* newMaterial, OverrideType_t nOverrideType = OVERRIDE_NORMAL, int unk = 0 ) {
+ using fn = void( __thiscall* )( void*, IMaterial*, OverrideType_t, int );
+ return util::get_vfunc< fn >( this, 1 )( this, newMaterial, nOverrideType, unk );
+ }
+
+ void DrawModelExecute( void* matctx, const DrawModelState_t& state, const ModelRenderInfo_t& pInfo, matrix3x4* pCustomBoneToWorld ) {
+ using fn = void( __thiscall* )( void*, void*, const DrawModelState_t&, const ModelRenderInfo_t&, matrix3x4* );
+ util::get_vfunc< fn >( this, 21 )( this, matctx, state, pInfo, pCustomBoneToWorld );
+ }
+};
+
+class CStringTable {
+public:
+ INetworkStringTable* FindTable( const char* table ) {
+ using fn = INetworkStringTable * ( __thiscall* )( void*, const char* );
+ return util::get_vfunc< fn >( this, 3 )( this, table );
+ }
+};
+
+class INetworkStringTable {
+public:
+
+ virtual ~INetworkStringTable( void ) {};
+
+ // Table Info
+ virtual const char *GetTableName( void ) const = 0;
+ virtual int GetTableId( void ) const = 0;
+ virtual int GetNumStrings( void ) const = 0;
+ virtual int GetMaxStrings( void ) const = 0;
+ virtual int GetEntryBits( void ) const = 0;
+
+ // Networking
+ virtual void SetTick( int tick ) = 0;
+ virtual bool ChangedSinceTick( int tick ) const = 0;
+
+ // Accessors (length -1 means don't change user data if string already exits)
+ virtual int AddString( bool bIsServer, const char *value, int length = -1, const void *userdata = 0 ) = 0;
+
+ virtual const char *GetString( int stringNumber ) = 0;
+ virtual void SetStringUserData( int stringNumber, int length, const void *userdata ) = 0;
+ virtual const void *GetStringUserData( int stringNumber, int *length ) = 0;
+ virtual int FindStringIndex( char const *string ) = 0; // returns INVALID_STRING_INDEX if not found
+
+ // Callbacks
+ virtual void SetStringChangedCallback( void *object, void* changeFunc ) = 0;
+};
\ No newline at end of file diff --git a/internal_rewrite/IVRenderView.hpp b/internal_rewrite/IVRenderView.hpp new file mode 100644 index 0000000..a8396f5 --- /dev/null +++ b/internal_rewrite/IVRenderView.hpp @@ -0,0 +1,185 @@ +#pragma once
+#include "util.hpp"
+
+class Beam_t;
+class C_Beam;
+class c_base_player;
+class ITraceFilter;
+
+
+class IVRenderView {
+public:
+ void SetBlend( float blend ) {
+ return util::get_vfunc< 4, void >( this, blend );
+ }
+
+ float GetBlend( ) {
+ return util::get_vfunc< 5, float >( this );
+ }
+
+ void SetColorModulation( float const* blend ) {
+ return util::get_vfunc< 6, void >( this, blend );
+ }
+
+ void GetColorModulation( float* blend ) {
+ return util::get_vfunc< 7, void >( this, blend );
+ }
+};
+
+enum beam_types {
+ beam_normal = 0,
+ beam_disk = 2,
+ beam_cylinder,
+ beam_follow,
+ beam_ring,
+ beam_spline,
+ beam_ring_point,
+ beam_laser,
+ beam_tesla,
+};
+
+enum beam_flags {
+ FBEAM_STARTENTITY = 0x00000001,
+ FBEAM_ENDENTITY = 0x00000002,
+ FBEAM_FADEIN = 0x00000004,
+ FBEAM_FADEOUT = 0x00000008,
+ FBEAM_SINENOISE = 0x00000010,
+ FBEAM_SOLID = 0x00000020,
+ FBEAM_SHADEIN = 0x00000040,
+ FBEAM_SHADEOUT = 0x00000080,
+ FBEAM_ONLYNOISEONCE = 0x00000100, // Only calculate our noise once
+ FBEAM_NOTILE = 0x00000200,
+ FBEAM_USE_HITBOXES = 0x00000400, // Attachment indices represent hitbox indices instead when this is set.
+ FBEAM_STARTVISIBLE = 0x00000800, // Has this client actually seen this beam's start entity yet?
+ FBEAM_ENDVISIBLE = 0x00001000, // Has this client actually seen this beam's end entity yet?
+ FBEAM_ISACTIVE = 0x00002000,
+ FBEAM_FOREVER = 0x00004000,
+ FBEAM_HALOBEAM = 0x00008000, // When drawing a beam with a halo, don't ignore the segments and endwidth
+ FBEAM_REVERSED = 0x00010000,
+ NUM_BEAM_FLAGS = 17 // KEEP THIS UPDATED!
+};
+
+struct BeamInfo_t {
+ beam_types m_nType;
+
+ // Entities
+ c_base_player* m_pStartEnt;
+ int m_nStartAttachment;
+ c_base_player* m_pEndEnt;
+ int m_nEndAttachment;
+
+ // Points
+ vec3_t m_vecStart;
+ vec3_t m_vecEnd;
+
+ int m_nModelIndex;
+ const char *m_pszModelName;
+
+ int m_nHaloIndex;
+ const char *m_pszHaloName;
+ float m_flHaloScale;
+
+ float m_flLife;
+ float m_flWidth;
+ float m_flEndWidth;
+ float m_flFadeLength;
+ float m_flAmplitude;
+
+ float m_flBrightness;
+ float m_flSpeed;
+
+ int m_nStartFrame;
+ float m_flFrameRate;
+
+ float m_flRed;
+ float m_flGreen;
+ float m_flBlue;
+
+ bool m_bRenderable;
+
+ int m_nSegments;
+
+ int m_nFlags;
+
+ // Rings
+ vec3_t m_vecCenter;
+ float m_flStartRadius;
+ float m_flEndRadius;
+
+ BeamInfo_t( )
+ {
+ m_nType = beam_normal;
+ m_nSegments = -1;
+ m_pszModelName = NULL;
+ m_pszHaloName = NULL;
+ m_nModelIndex = -1;
+ m_nHaloIndex = -1;
+ m_bRenderable = true;
+ m_nFlags = 0;
+ }
+};
+
+class IViewRenderBeams
+{
+public:
+ // Construction
+public:
+ IViewRenderBeams( void );
+ virtual ~IViewRenderBeams( void );
+
+ // Implement IViewRenderBeams
+public:
+ virtual void InitBeams( void );
+ virtual void ShutdownBeams( void );
+ virtual void ClearBeams( void );
+
+ // Updates the state of the temp ent beams
+ virtual void UpdateTempEntBeams( );
+
+ virtual void DrawBeam( Beam_t *pbeam );
+ virtual void DrawBeam( C_Beam* pbeam, ITraceFilter*pEntityBeamTraceFilter = NULL );
+
+ virtual void KillDeadBeams( IClientEntity *pDeadEntity );
+
+ virtual void CreateBeamEnts( int startEnt, int endEnt, int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float endWidth, float fadeLength, float amplitude,
+ float brightness, float speed, int startFrame,
+ float framerate, float r, float g, float b, int type = -1 );
+ virtual Beam_t *CreateBeamEnts( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamEntPoint( int nStartEntity, const vec3_t *pStart, int nEndEntity, const vec3_t* pEnd,
+ int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float endWidth, float fadeLength, float amplitude,
+ float brightness, float speed, int startFrame,
+ float framerate, float r, float g, float b );
+ virtual Beam_t *CreateBeamEntPoint( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamPoints( vec3_t& start, vec3_t& end, int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float endWidth, float fadeLength, float amplitude,
+ float brightness, float speed, int startFrame,
+ float framerate, float r, float g, float b );
+ virtual Beam_t *CreateBeamPoints( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamRing( int startEnt, int endEnt, int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float endWidth, float fadeLength, float amplitude,
+ float brightness, float speed, int startFrame,
+ float framerate, float r, float g, float b, int flags );
+ virtual Beam_t *CreateBeamRing( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamRingPoint( const vec3_t& center, float start_radius, float end_radius, int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float m_nEndWidth, float m_nFadeLength, float amplitude,
+ float brightness, float speed, int startFrame,
+ float framerate, float r, float g, float b, int flags );
+ virtual Beam_t *CreateBeamRingPoint( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamCirclePoints( int type, vec3_t& start, vec3_t& end,
+ int modelIndex, int haloIndex, float haloScale, float life, float width,
+ float endWidth, float fadeLength, float amplitude, float brightness, float speed,
+ int startFrame, float framerate, float r, float g, float b );
+ virtual Beam_t *CreateBeamCirclePoints( BeamInfo_t &beamInfo );
+
+ virtual void CreateBeamFollow( int startEnt, int modelIndex, int haloIndex, float haloScale,
+ float life, float width, float endWidth, float fadeLength, float r, float g, float b,
+ float brightness );
+ virtual Beam_t *CreateBeamFollow( BeamInfo_t &beamInfo );
+};
\ No newline at end of file diff --git a/internal_rewrite/KeyValues.cpp b/internal_rewrite/KeyValues.cpp new file mode 100644 index 0000000..300b6f1 --- /dev/null +++ b/internal_rewrite/KeyValues.cpp @@ -0,0 +1,83 @@ +#include "KeyValues.hpp" +#include "pattern.hpp" +#include "interface.hpp" + +void IKeyValuesSystem::FreeKeyValuesMemory( void* memory ) { + return util::get_vfunc< 2, void >( this, memory ); +} + +int IKeyValuesSystem::GetSymbolForString( const char* str, bool create ) { + static auto offset = pattern::first_code_match( GetModuleHandleA( xors( "vstdlib.dll" ) ), xors( "55 8B EC 83 EC 0C 53 8B 5D 08 57" ) ); + using fn = int( __thiscall* )( void*, const char*, bool ); + + int symbol = ( ( fn )( offset ) )( this, str, create ); + return symbol; +} + +const char* IKeyValuesSystem::GetStringForSymbol( int symbol ) { + static auto offset = pattern::first_code_match( GetModuleHandleA( xors( "vstdlib.dll" ) ), xors( "55 8B EC 8B 55 08 83 FA FF" ) ); + using fn = const char*( __thiscall* )( void*, int ); + + auto result = ( ( fn )( offset ) )( this, symbol ); + printf( "%d: %d\n", symbol, *( int* )( &result ) ); + + return result; +} + +KeyValues::KeyValues( const char* setName ) { + static void( __thiscall* keyvalues_constructor )( KeyValues*, const char* ) = 0; + + if( !keyvalues_constructor ) { + auto address = pattern::first_code_match( g_csgo.m_chl.dll( ), + xors( "68 ? ? ? ? 8B C8 E8 ? ? ? ? 89 45 FC EB 07 C7 45 ? ? ? ? ? 8B 03 56" ), + 0x8 ); + + keyvalues_constructor = decltype( keyvalues_constructor )( address + *( uintptr_t* )( address ) + 4 ); + } + + keyvalues_constructor( this, setName ); +} + +KeyValues::~KeyValues( ) { + static bool( __thiscall* keyvalues_remove_everything )( KeyValues* ) = 0; + + if( !keyvalues_remove_everything ) { + auto address = pattern::first_code_match( g_csgo.m_chl.dll( ), + xors( "E8 ? ? ? ? 81 23 ? ? ? ?" ), + 0x1 ); + + keyvalues_remove_everything = decltype( keyvalues_remove_everything )( address + *( uintptr_t* )( address ) + 4 ); + } + + keyvalues_remove_everything( this ); + g_csgo.m_keyvalues->FreeKeyValuesMemory( this ); + +} + + +bool KeyValues::LoadFromBuffer( char const *resourceName, const char *pBuffer, void* pFileSystem, const char *pPathID, bool( *unknown )( const char* ) ) { + static auto load_from_buffer = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 34 53 8B 5D 0C 89 4C 24 04" ) ); + return reinterpret_cast< bool( __thiscall* )( KeyValues*, const char*, const char*, void*, const char*, bool( *)( const char* ) ) >( load_from_buffer ) + ( this, resourceName, pBuffer, pFileSystem, pPathID, unknown ); +} + +const char* KeyValues::get_string( const char* name, const char* value ) { + static auto offset = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 C0 81 EC ?? ?? ?? ?? 53 8B 5D 08" ) ); + using fn = const char*( __thiscall* )( void*, const char*, const char* ); + + auto result = ( ( fn )( offset ) )( this, name, value ); + + return result; + +} + +KeyValues* KeyValues::FindKey( const char* name ) { + auto key = g_csgo.m_keyvalues->GetSymbolForString( name, false ); + for( auto dat = m_pSub; !!dat; dat = dat->m_pPeer ) { + if( dat->m_iKeyName == key ) { + return dat; + } + } + + return nullptr; +}
\ No newline at end of file diff --git a/internal_rewrite/KeyValues.hpp b/internal_rewrite/KeyValues.hpp new file mode 100644 index 0000000..94eb6ca --- /dev/null +++ b/internal_rewrite/KeyValues.hpp @@ -0,0 +1,43 @@ +#pragma once +#include "util.hpp" + +class IKeyValuesSystem { +public: + void FreeKeyValuesMemory( void* memory ); + int GetSymbolForString( const char* string, bool create ); + const char* GetStringForSymbol( int symbol ); +}; + +class KeyValues +{ +public: + KeyValues( const char *setName ); + ~KeyValues( ); + + bool LoadFromBuffer( char const *resourceName, const char *pBuffer, void* pFileSystem = nullptr, const char *pPathID = nullptr, bool( *unknown )( const char* ) = nullptr ); + + const char* get_string( const char* name, const char* value ); + + int m_iKeyName; + + char *m_sValue; + wchar_t *m_wsValue; + + // we don't delete these + union { + int m_iValue; + float m_flValue; + void *m_pValue; + unsigned char m_Color[ 4 ]; + }; + + char m_iDataType; + char m_bHasEscapeSequences; + char m_bEvaluateConditionals; + + KeyValues* FindKey( const char* key_name ); + + KeyValues *m_pPeer; // pointer to next key in list + KeyValues *m_pSub; // pointer to Start of a new sub key list + KeyValues *m_pChain;// Search here if it's not in our list +};
\ No newline at end of file diff --git a/internal_rewrite/Source.cpp b/internal_rewrite/Source.cpp new file mode 100644 index 0000000..2acc896 --- /dev/null +++ b/internal_rewrite/Source.cpp @@ -0,0 +1,118 @@ +//this cheat was a mistake
+
+#include <thread>
+#include <iostream>
+
+#include "hooks.hpp"
+#include "console.hpp"
+#include "input_system.hpp"
+#include "mem.hpp"
+
+HMODULE g_dll;
+
+/*
+im so so fucking sorry for everything
+i cant do this anymore, im so fed up with everything and everyone
+anything i do feels like a chore and anyone i speak to feels like my worst enemy
+i wish i could still love the people i loved and appreciate the things i enjoyed doing but no matter what i cant
+life seems so blend, greyed out and boring, its like every single fucking day will be the same till the end
+yet i keep getting worse and things are not improving at any rate whatsover
+
+it feels like a monster is trying to rip you apart from the inside, theres so much pain involved i cant even describe it
+and the worst part is that you break down every day, every hour and then pick yourself up but it doesnt help, you just start over whenever the next time comes
+im tired of taking 1 step forwards and 2 steps backwards whenever i try to improve anything, i cant keep going like this
+
+seeing how others are able to put their lives together because the cards they were given allthough terrible werent as bad as mine is too much for me to sustain
+i envy every single one of you for the fact you can still exist and you can still live your life and hopefully move on in the future
+the only thing i desire and the only thing ive ever wanted is to move on
+it hurts me so much to see myself waste away in spite of the massive potential and genius that i am
+its too much
+
+i love you, i love all of you, i love you chiddy for being that positive guy that used to always bring a smile to my face
+i love chawndi for always being here
+i love you dylan for showing me what it really means to love someone for who they really are
+i love you grassii for doing everything you could in spite of not understanding
+i love you sim for understanding me like noone else before
+i love you h0pde for being the greatest and most honest friend i ever met
+i love you hayden for being so light-hearted and cheerful
+i love you carol for showing me whats it like to care for someone with your life
+
+i hope all of you find a way in your life and dont suffer trying like i do forever
+ive been doing my best to survive for the past months but it got progressively harder and harder, every night gets worse and every day kills the remainings of my hope
+i cant do it anymore
+
+i will keep myself in this numb state of vegetation until i snap and end myself
+i hope to come back one day but i dont think i could
+
+im sorry
+
+- nave
+*/
+
+void main_thread( HINSTANCE uh ) {
+#ifdef IFACE_DLLMAIN
+ util::memset( ( uint8_t* )uh, 0x90, 0x1000 );
+#endif
+ g_csgo.initialize( );
+
+ while ( !g_csgo.m_panic ) {
+ std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) );
+ }
+
+ g_csgo.uninitialize( );
+ ExitThread( 0 );
+}
+
+long __stdcall exception_handler( EXCEPTION_POINTERS* e ) {
+ return EXCEPTION_CONTINUE_EXECUTION;
+}
+
+int __stdcall DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved ) {
+ HANDLE thread;
+
+ uintptr_t wanted_reason;
+#ifdef _DEBUG
+ wanted_reason = DLL_PROCESS_ATTACH;
+#else
+ wanted_reason = DLL_PROCESS_ATTACH;
+#endif
+
+ if ( reason == wanted_reason
+#ifdef IFACE_DLLMAIN
+ && !!reserved
+#endif
+ ) {
+#ifdef IFACE_DLLMAIN
+ g_factory.init( ( uintptr_t )( reserved ) );
+#endif
+ g_dll = inst;
+ //yayo
+ //SetUnhandledExceptionFilter( exception_handler );
+ DisableThreadLibraryCalls( inst );
+
+
+ thread = CreateThread( nullptr, 0,
+ ( LPTHREAD_START_ROUTINE )( main_thread ),
+ inst, 0, nullptr );
+
+ if( !thread )
+ return 0;
+
+ CloseHandle( thread );
+
+ return 1;
+ }
+#ifdef IFACE_DLLMAIN
+ else if( !reserved ) {
+ MessageBoxA( nullptr, "interface data nullptr (loader error?)", "error", MB_OK );
+ return 1;
+ }
+#endif
+
+ if( reason == DLL_PROCESS_DETACH ) {
+ g_csgo.m_panic = true;
+ //SetUnhandledExceptionFilter( nullptr );
+ }
+
+ return 0;
+}
\ No newline at end of file diff --git a/internal_rewrite/Valve/checksum_crc.cpp b/internal_rewrite/Valve/checksum_crc.cpp new file mode 100644 index 0000000..bc7b433 --- /dev/null +++ b/internal_rewrite/Valve/checksum_crc.cpp @@ -0,0 +1,169 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Generic CRC functions +// +//=============================================================================// + + +#include "checksum_crc.h" + +#define CRC32_INIT_VALUE 0xFFFFFFFFUL +#define CRC32_XOR_VALUE 0xFFFFFFFFUL + +#define NUM_BYTES 256 +static const CRC32_t pulCRCTable[ NUM_BYTES ] = +{ + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, + 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, + 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, + 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, + 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, + 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, + 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, + 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, + 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, + 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, + 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, + 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, + 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, + 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, + 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, + 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, + 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, + 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, + 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, + 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, + 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, + 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, + 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, + 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, + 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, + 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, + 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, + 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, + 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, + 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, + 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, + 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, + 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, + 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, + 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, + 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d +}; + +void CRC32_Init( CRC32_t *pulCRC ) { + *pulCRC = CRC32_INIT_VALUE; +} + +void CRC32_Final( CRC32_t *pulCRC ) { + *pulCRC ^= CRC32_XOR_VALUE; +} + +CRC32_t CRC32_GetTableEntry( unsigned int slot ) { + return pulCRCTable[ ( unsigned char )slot ]; +} + +void CRC32_ProcessBuffer( CRC32_t *pulCRC, const void *pBuffer, int nBuffer ) { + CRC32_t ulCrc = *pulCRC; + unsigned char *pb = ( unsigned char * )pBuffer; + unsigned int nFront; + int nMain; + +JustAfew: + + switch( nBuffer ) { + case 7: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 6: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 5: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 4: + ulCrc ^= *( CRC32_t * )pb; + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + *pulCRC = ulCrc; + return; + + case 3: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 2: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 1: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + + case 0: + *pulCRC = ulCrc; + return; + } + + // We may need to do some alignment work up front, and at the end, so that + // the main loop is aligned and only has to worry about 8 byte at a time. + // + // The low-order two bits of pb and nBuffer in total control the + // upfront work. + // + nFront = ( ( unsigned int )pb ) & 3; + nBuffer -= nFront; + switch( nFront ) { + case 3: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + case 2: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + case 1: + ulCrc = pulCRCTable[ *pb++ ^ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + } + + nMain = nBuffer >> 3; + while( nMain-- ) { + ulCrc ^= *( CRC32_t * )pb ; + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc ^= *( CRC32_t * )( pb + 4 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + ulCrc = pulCRCTable[ ( unsigned char )ulCrc ] ^ ( ulCrc >> 8 ); + pb += 8; + } + + nBuffer &= 7; + goto JustAfew; +} diff --git a/internal_rewrite/Valve/checksum_crc.h b/internal_rewrite/Valve/checksum_crc.h new file mode 100644 index 0000000..356de67 --- /dev/null +++ b/internal_rewrite/Valve/checksum_crc.h @@ -0,0 +1,30 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Generic CRC functions +// +// $NoKeywords: $ +//=============================================================================// +#ifndef CHECKSUM_CRC_H +#define CHECKSUM_CRC_H +#ifdef _WIN32 +#pragma once +#endif + +typedef unsigned int CRC32_t; + +void CRC32_Init( CRC32_t *pulCRC ); +void CRC32_ProcessBuffer( CRC32_t *pulCRC, const void *p, int len ); +void CRC32_Final( CRC32_t *pulCRC ); +CRC32_t CRC32_GetTableEntry( unsigned int slot ); + +inline CRC32_t CRC32_ProcessSingleBuffer( const void *p, int len ) { + CRC32_t crc; + + CRC32_Init( &crc ); + CRC32_ProcessBuffer( &crc, p, len ); + CRC32_Final( &crc ); + + return crc; +} + +#endif // CHECKSUM_CRC_H diff --git a/internal_rewrite/Valve/dt_common.h b/internal_rewrite/Valve/dt_common.h new file mode 100644 index 0000000..9555056 --- /dev/null +++ b/internal_rewrite/Valve/dt_common.h @@ -0,0 +1,226 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#ifndef DATATABLE_COMMON_H +#define DATATABLE_COMMON_H + +#ifdef _WIN32 +#pragma once +#endif + +#include <stdio.h> + +#ifdef LINUX +#undef offsetof +#define offsetof(s,m) (size_t)&(((s *)0)->m) +#endif + +// Max number of properties in a datatable and its children. +#define MAX_DATATABLES 1024 // must be a power of 2. +#define MAX_DATATABLE_PROPS 4096 + +#define MAX_ARRAY_ELEMENTS 2048 // a network array should have more that 1024 elements + +#define HIGH_DEFAULT -121121.121121f + +#define BITS_FULLRES -1 // Use the full resolution of the type being encoded. +#define BITS_WORLDCOORD -2 // Encode as a world coordinate. + +#define DT_MAX_STRING_BITS 9 +#define DT_MAX_STRING_BUFFERSIZE (1<<DT_MAX_STRING_BITS) // Maximum length of a string that can be sent. + +#define STRINGBUFSIZE(className, varName) sizeof( ((className*)0)->varName ) + +// Gets the size of a variable in a class. +#define PROPSIZEOF(className, varName) sizeof(((className*)0)->varName) + + +// SendProp::m_Flags. +#define SPROP_UNSIGNED (1<<0) // Unsigned integer data. + +#define SPROP_COORD (1<<1) // If this is set, the float/vector is treated like a world coordinate. +// Note that the bit count is ignored in this case. + +#define SPROP_NOSCALE (1<<2) // For floating point, don't scale into range, just take value as is. + +#define SPROP_ROUNDDOWN (1<<3) // For floating point, limit high value to range minus one bit unit + +#define SPROP_ROUNDUP (1<<4) // For floating point, limit low value to range minus one bit unit + +#define SPROP_NORMAL (1<<5) // If this is set, the vector is treated like a normal (only valid for vectors) + +#define SPROP_EXCLUDE (1<<6) // This is an exclude prop (not excludED, but it points at another prop to be excluded). + +#define SPROP_XYZE (1<<7) // Use XYZ/Exponent encoding for vectors. + +#define SPROP_INSIDEARRAY (1<<8) // This tells us that the property is inside an array, so it shouldn't be put into the +// flattened property list. Its array will point at it when it needs to. + +#define SPROP_PROXY_ALWAYS_YES (1<<9) // Set for datatable props using one of the default datatable proxies like +// SendProxy_DataTableToDataTable that always send the data to all clients. + +#define SPROP_CHANGES_OFTEN (1<<10) // this is an often changed field, moved to head of sendtable so it gets a small index + +#define SPROP_IS_A_VECTOR_ELEM (1<<11) // Set automatically if SPROP_VECTORELEM is used. + +#define SPROP_COLLAPSIBLE (1<<12) // Set automatically if it's a datatable with an offset of 0 that doesn't change the pointer +// (ie: for all automatically-chained base classes). +// In this case, it can get rid of this SendPropDataTable altogether and spare the +// trouble of walking the hierarchy more than necessary. + +#define SPROP_COORD_MP (1<<13) // Like SPROP_COORD, but special handling for multiplayer games +#define SPROP_COORD_MP_LOWPRECISION (1<<14) // Like SPROP_COORD, but special handling for multiplayer games where the fractional component only gets a 3 bits instead of 5 +#define SPROP_COORD_MP_INTEGRAL (1<<15) // SPROP_COORD_MP, but coordinates are rounded to integral boundaries + +#define SPROP_VARINT SPROP_NORMAL // reuse existing flag so we don't break demo. note you want to include SPROP_UNSIGNED if needed, its more efficient + +#define SPROP_NUMFLAGBITS_NETWORKED 16 + +// This is server side only, it's used to mark properties whose SendProxy_* functions encode against gpGlobals->tickcount (the only ones that currently do this are +// m_flAnimTime and m_flSimulationTime. MODs shouldn't need to mess with this probably +#define SPROP_ENCODED_AGAINST_TICKCOUNT (1<<16) + +// See SPROP_NUMFLAGBITS_NETWORKED for the ones which are networked +#define SPROP_NUMFLAGBITS 17 + +// Used by the SendProp and RecvProp functions to disable debug checks on type sizes. +#define SIZEOF_IGNORE -1 + + +// Use this to extern send and receive datatables, and reference them. +#define EXTERN_SEND_TABLE(tableName) namespace tableName {extern SendTable g_SendTable;} +#define EXTERN_RECV_TABLE(tableName) namespace tableName {extern RecvTable g_RecvTable;} + +#define REFERENCE_SEND_TABLE(tableName) tableName::g_SendTable +#define REFERENCE_RECV_TABLE(tableName) tableName::g_RecvTable + + +class SendProp; + +// The day we do this, we break all mods until they recompile. +//#define SUPPORTS_INT64 + +typedef enum +{ + DPT_Int = 0, + DPT_Float, + DPT_Vector, + DPT_VectorXY, // Only encodes the XY of a vector, ignores Z + DPT_String, + DPT_Array, // An array of the base types (can't be of datatables). + DPT_DataTable, +#if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!! + DPT_Quaternion, +#endif + +#ifdef SUPPORTS_INT64 + DPT_Int64, +#endif + + DPT_NUMSendPropTypes + +} SendPropType; + + +class DVariant +{ +public: + DVariant() + { + m_Type = DPT_Float; + } + DVariant( float val ) + { + m_Type = DPT_Float; m_Float = val; + } + + const char *ToString() + { + static char text[ 128 ]; + + switch( m_Type ) + { + case DPT_Int: + sprintf( text, "%i", m_Int ); + break; + case DPT_Float: + sprintf( text, "%.3f", m_Float ); + break; + case DPT_Vector: + sprintf( text, "(%.3f,%.3f,%.3f)", + m_Vector[ 0 ], m_Vector[ 1 ], m_Vector[ 2 ] ); + break; + case DPT_VectorXY: + sprintf( text, "(%.3f,%.3f)", + m_Vector[ 0 ], m_Vector[ 1 ] ); + break; +#if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!! + case DPT_Quaternion: + snprintf( text, sizeof( text ), "(%.3f,%.3f,%.3f %.3f)", + m_Vector[ 0 ], m_Vector[ 1 ], m_Vector[ 2 ], m_Vector[ 3 ] ); + break; +#endif + case DPT_String: + if( m_pString ) + return m_pString; + else + return "NULL"; + break; + case DPT_Array: + sprintf( text, "Array" ); + break; + case DPT_DataTable: + sprintf( text, "DataTable" ); + break; +#ifdef SUPPORTS_INT64 + case DPT_Int64: + snprintf( text, sizeof( text ), "%I64d", m_Int64 ); + break; +#endif + default: + sprintf( text, "DVariant type %i unknown", m_Type ); + break; + } + + return text; + } + + union + { + float m_Float; + int m_Int; + const char *m_pString; + void *m_pData; // For DataTables. +#if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!! + float m_Vector[ 4 ]; +#else + float m_Vector[ 3 ]; +#endif + +#ifdef SUPPORTS_INT64 + int64 m_Int64; +#endif + }; + SendPropType m_Type; +}; + + +// This can be used to set the # of bits used to transmit a number between 0 and nMaxElements-1. +inline int NumBitsForCount( int nMaxElements ) +{ + int nBits = 0; + while( nMaxElements > 0 ) + { + ++nBits; + nMaxElements >>= 1; + } + return nBits; +} + + +#endif // DATATABLE_COMMON_H
\ No newline at end of file diff --git a/internal_rewrite/Valve/dt_recv.h b/internal_rewrite/Valve/dt_recv.h new file mode 100644 index 0000000..b47922c --- /dev/null +++ b/internal_rewrite/Valve/dt_recv.h @@ -0,0 +1,586 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#ifndef DATATABLE_RECV_H +#define DATATABLE_RECV_H + +#ifdef _WIN32 +#pragma once +#endif + +#include "dt_common.h" + +#define ADDRESSPROXY_NONE -1 + + +class RecvTable; +class RecvProp; + + +// This is passed into RecvProxy functions. +class CRecvProxyData +{ +public: + const RecvProp *m_pRecvProp; // The property it's receiving. + + DVariant m_Value; // The value given to you to store. + + int m_iElement; // Which array element you're getting. + + int m_ObjectID; // The object being referred to. +}; + + +//----------------------------------------------------------------------------- +// pStruct = the base structure of the datatable this variable is in (like C_BaseEntity) +// pOut = the variable that this this proxy represents (like C_BaseEntity::m_SomeValue). +// +// Convert the network-standard-type value in m_Value into your own format in pStruct/pOut. +//----------------------------------------------------------------------------- +typedef void( *RecvVarProxyFn )( const CRecvProxyData *pData, void *pStruct, void *pOut ); + +// ------------------------------------------------------------------------ // +// ArrayLengthRecvProxies are optionally used to get the length of the +// incoming array when it changes. +// ------------------------------------------------------------------------ // +typedef void( *ArrayLengthRecvProxyFn )( void *pStruct, int objectID, int currentArrayLength ); + + +// NOTE: DataTable receive proxies work differently than the other proxies. +// pData points at the object + the recv table's offset. +// pOut should be set to the location of the object to unpack the data table into. +// If the parent object just contains the child object, the default proxy just does *pOut = pData. +// If the parent object points at the child object, you need to dereference the pointer here. +// NOTE: don't ever return null from a DataTable receive proxy function. Bad things will happen. +typedef void( *DataTableRecvVarProxyFn )( const RecvProp *pProp, void **pOut, void *pData, int objectID ); + + +// This is used to fork over the standard proxy functions to the engine so it can +// make some optimizations. +class CStandardRecvProxies +{ +public: + CStandardRecvProxies(); + + RecvVarProxyFn m_Int32ToInt8; + RecvVarProxyFn m_Int32ToInt16; + RecvVarProxyFn m_Int32ToInt32; + RecvVarProxyFn m_FloatToFloat; + RecvVarProxyFn m_VectorToVector; +#ifdef SUPPORTS_INT64 + RecvVarProxyFn m_Int64ToInt64; +#endif +}; +extern CStandardRecvProxies g_StandardRecvProxies; + + +class CRecvDecoder; + + +class RecvProp +{ + // This info comes from the receive data table. +public: + RecvProp(); + + void InitArray( int nElements, int elementStride ); + + int GetNumElements() const; + void SetNumElements( int nElements ); + + int GetElementStride() const; + void SetElementStride( int stride ); + + int GetFlags() const; + + const char* GetName() const; + SendPropType GetType() const; + + RecvTable* GetDataTable() const; + void SetDataTable( RecvTable *pTable ); + + RecvVarProxyFn GetProxyFn() const; + void SetProxyFn( RecvVarProxyFn fn ); + + DataTableRecvVarProxyFn GetDataTableProxyFn() const; + void SetDataTableProxyFn( DataTableRecvVarProxyFn fn ); + + int GetOffset() const; + void SetOffset( int o ); + + // Arrays only. + RecvProp* GetArrayProp() const; + void SetArrayProp( RecvProp *pProp ); + + // Arrays only. + void SetArrayLengthProxy( ArrayLengthRecvProxyFn proxy ); + ArrayLengthRecvProxyFn GetArrayLengthProxy() const; + + bool IsInsideArray() const; + void SetInsideArray(); + + // Some property types bind more data to the prop in here. + const void* GetExtraData() const; + void SetExtraData( const void *pData ); + + // If it's one of the numbered "000", "001", etc properties in an array, then + // these can be used to get its array property name for debugging. + const char* GetParentArrayPropName(); + void SetParentArrayPropName( const char *pArrayPropName ); + +public: + + const char *m_pVarName; + SendPropType m_RecvType; + int m_Flags; + int m_StringBufferSize; + + +public: + + bool m_bInsideArray; // Set to true by the engine if this property sits inside an array. + + // Extra data that certain special property types bind to the property here. + const void *m_pExtraData; + + // If this is an array (DPT_Array). + RecvProp *m_pArrayProp; + ArrayLengthRecvProxyFn m_ArrayLengthProxy; + + RecvVarProxyFn m_ProxyFn; + DataTableRecvVarProxyFn m_DataTableProxyFn; // For RDT_DataTable. + + RecvTable *m_pDataTable; // For RDT_DataTable. + int m_Offset; + + int m_ElementStride; + int m_nElements; + + // If it's one of the numbered "000", "001", etc properties in an array, then + // these can be used to get its array property name for debugging. + const char *m_pParentArrayPropName; +}; + + +class RecvTable +{ +public: + + typedef RecvProp PropType; + + RecvTable(); + RecvTable( RecvProp *pProps, int nProps, const char *pNetTableName ); + ~RecvTable(); + + void Construct( RecvProp *pProps, int nProps, const char *pNetTableName ); + + int GetNumProps(); + RecvProp* GetProp( int i ); + + const char* GetName(); + + // Used by the engine while initializing array props. + void SetInitialized( bool bInitialized ); + bool IsInitialized() const; + + // Used by the engine. + void SetInMainList( bool bInList ); + bool IsInMainList() const; + + +public: + + // Properties described in a table. + RecvProp *m_pProps; + int m_nProps; + + // The decoder. NOTE: this covers each RecvTable AND all its children (ie: its children + // will have their own decoders that include props for all their children). + CRecvDecoder *m_pDecoder; + + const char *m_pNetTableName; // The name matched between client and server. + + +private: + + bool m_bInitialized; + bool m_bInMainList; +}; + + +inline int RecvTable::GetNumProps() +{ + return m_nProps; +} + +inline RecvProp* RecvTable::GetProp( int i ) +{ + return &m_pProps[ i ]; +} + +inline const char* RecvTable::GetName() +{ + return m_pNetTableName; +} + +inline void RecvTable::SetInitialized( bool bInitialized ) +{ + m_bInitialized = bInitialized; +} + +inline bool RecvTable::IsInitialized() const +{ + return m_bInitialized; +} + +inline void RecvTable::SetInMainList( bool bInList ) +{ + m_bInMainList = bInList; +} + +inline bool RecvTable::IsInMainList() const +{ + return m_bInMainList; +} + + +// ------------------------------------------------------------------------------------------------------ // +// See notes on BEGIN_SEND_TABLE for a description. These macros work similarly. +// ------------------------------------------------------------------------------------------------------ // +#define BEGIN_RECV_TABLE(className, tableName) \ + BEGIN_RECV_TABLE_NOBASE(className, tableName) \ + RecvPropDataTable("baseclass", 0, 0, className::BaseClass::m_pClassRecvTable, DataTableRecvProxy_StaticDataTable), + +#define BEGIN_RECV_TABLE_NOBASE(className, tableName) \ + template <typename T> int ClientClassInit(T *); \ + namespace tableName { \ + struct ignored; \ + } \ + template <> int ClientClassInit<tableName::ignored>(tableName::ignored *); \ + namespace tableName { \ + RecvTable g_RecvTable; \ + int g_RecvTableInit = ClientClassInit((tableName::ignored *)NULL); \ + } \ + template <> int ClientClassInit<tableName::ignored>(tableName::ignored *) \ + { \ + typedef className currentRecvDTClass; \ + const char *pRecvTableName = #tableName; \ + RecvTable &RecvTable = tableName::g_RecvTable; \ + static RecvProp RecvProps[] = { \ + RecvPropInt("should_never_see_this", 0, sizeof(int)), // It adds a dummy property at the start so you can define "empty" SendTables. + +#define END_RECV_TABLE() \ + }; \ + RecvTable.Construct(RecvProps+1, sizeof(RecvProps) / sizeof(RecvProp) - 1, pRecvTableName); \ + return 1; \ + } + + +#define RECVINFO(varName) #varName, offsetof(currentRecvDTClass, varName), sizeof(((currentRecvDTClass*)0)->varName) +#define RECVINFO_NAME(varName, remoteVarName) #remoteVarName, offsetof(currentRecvDTClass, varName), sizeof(((currentRecvDTClass*)0)->varName) +#define RECVINFO_STRING(varName) #varName, offsetof(currentRecvDTClass, varName), STRINGBUFSIZE(currentRecvDTClass, varName) +#define RECVINFO_BASECLASS(tableName) RecvPropDataTable("this", 0, 0, &REFERENCE_RECV_TABLE(tableName)) +#define RECVINFO_ARRAY(varName) #varName, offsetof(currentRecvDTClass, varName), sizeof(((currentRecvDTClass*)0)->varName[0]), sizeof(((currentRecvDTClass*)0)->varName)/sizeof(((currentRecvDTClass*)0)->varName[0]) + +// Just specify the name and offset. Used for strings and data tables. +#define RECVINFO_NOSIZE(varName) #varName, offsetof(currentRecvDTClass, varName) +#define RECVINFO_DT(varName) RECVINFO_NOSIZE(varName) +#define RECVINFO_DTNAME(varName,remoteVarName) #remoteVarName, offsetof(currentRecvDTClass, varName) + + +void RecvProxy_FloatToFloat( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_VectorToVector( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_VectorXYToVectorXY( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_QuaternionToQuaternion( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_Int32ToInt8( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_Int32ToInt16( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_StringToString( const CRecvProxyData *pData, void *pStruct, void *pOut ); +void RecvProxy_Int32ToInt32( const CRecvProxyData *pData, void *pStruct, void *pOut ); +#ifdef SUPPORTS_INT64 +void RecvProxy_Int64ToInt64( const CRecvProxyData *pData, void *pStruct, void *pOut ); +#endif + +// StaticDataTable does *pOut = pData. +void DataTableRecvProxy_StaticDataTable( const RecvProp *pProp, void **pOut, void *pData, int objectID ); + +// PointerDataTable does *pOut = *((void**)pData) (ie: pData is a pointer to the object to decode into). +void DataTableRecvProxy_PointerDataTable( const RecvProp *pProp, void **pOut, void *pData, int objectID ); + + +RecvProp RecvPropFloat( + const char *pVarName, + int offset, + int sizeofVar = SIZEOF_IGNORE, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother. + int flags = 0, + RecvVarProxyFn varProxy = RecvProxy_FloatToFloat + ); + +RecvProp RecvPropVector( + const char *pVarName, + int offset, + int sizeofVar = SIZEOF_IGNORE, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother. + int flags = 0, + RecvVarProxyFn varProxy = RecvProxy_VectorToVector + ); + +RecvProp RecvPropVectorXY( + const char *pVarName, + int offset, + int sizeofVar = SIZEOF_IGNORE, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother. + int flags = 0, + RecvVarProxyFn varProxy = RecvProxy_VectorXYToVectorXY + ); + +// This is here so the RecvTable can look more like the SendTable. +#define RecvPropQAngles RecvPropVector + +#if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!! + +RecvProp RecvPropQuaternion( + const char *pVarName, + int offset, + int sizeofVar = SIZEOF_IGNORE, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother. + int flags = 0, + RecvVarProxyFn varProxy = RecvProxy_QuaternionToQuaternion + ); +#endif + +RecvProp RecvPropInt( + const char *pVarName, + int offset, + int sizeofVar = SIZEOF_IGNORE, // Handled by RECVINFO macro, but set to SIZEOF_IGNORE if you don't want to bother. + int flags = 0, + RecvVarProxyFn varProxy = 0 + ); + +RecvProp RecvPropString( + const char *pVarName, + int offset, + int bufferSize, + int flags = 0, + RecvVarProxyFn varProxy = RecvProxy_StringToString + ); + +RecvProp RecvPropDataTable( + const char *pVarName, + int offset, + int flags, + RecvTable *pTable, + DataTableRecvVarProxyFn varProxy = DataTableRecvProxy_StaticDataTable + ); + +RecvProp RecvPropArray3( + const char *pVarName, + int offset, + int sizeofVar, + int elements, + RecvProp pArrayProp, + DataTableRecvVarProxyFn varProxy = DataTableRecvProxy_StaticDataTable + ); + +// Use the macro to let it automatically generate a table name. You shouldn't +// ever need to reference the table name. If you want to exclude this array, then +// reference the name of the variable in varTemplate. +RecvProp InternalRecvPropArray( + const int elementCount, + const int elementStride, + const char *pName, + ArrayLengthRecvProxyFn proxy + ); + + +// +// Use this if you want to completely manage the way the array data is stored. +// You'll need to provide a proxy inside varTemplate that looks for 'iElement' +// to figure out where to store the specified element. +// +#define RecvPropVirtualArray( arrayLengthProxy, maxArrayLength, varTemplate, propertyName ) \ + varTemplate, \ + InternalRecvPropArray( \ + maxArrayLength, \ + 0, \ + #propertyName, \ + arrayLengthProxy \ + ) + + +// Use this and pass the array name and it will figure out the count and stride automatically. +#define RecvPropVariableLengthArray( arrayLengthProxy, varTemplate, arrayName ) \ + varTemplate, \ + InternalRecvPropArray( \ + sizeof(((currentRecvDTClass*)0)->arrayName) / PROPSIZEOF(currentRecvDTClass, arrayName[0]), \ + PROPSIZEOF(currentRecvDTClass, arrayName[0]), \ + #arrayName, \ + arrayLengthProxy \ + ) + + +// Use this and pass the array name and it will figure out the count and stride automatically. +#define RecvPropArray( varTemplate, arrayName ) \ + RecvPropVariableLengthArray( 0, varTemplate, arrayName ) + + +// Use this one to specify the element count and stride manually. +#define RecvPropArray2( arrayLengthProxy, varTemplate, elementCount, elementStride, arrayName ) \ + varTemplate, \ + InternalRecvPropArray( elementCount, elementStride, #arrayName, arrayLengthProxy ) + + +// ---------------------------------------------------------------------------------------- // +// Inlines. +// ---------------------------------------------------------------------------------------- // + +inline void RecvProp::InitArray( int nElements, int elementStride ) +{ + m_RecvType = DPT_Array; + m_nElements = nElements; + m_ElementStride = elementStride; +} + +inline int RecvProp::GetNumElements() const +{ + return m_nElements; +} + +inline void RecvProp::SetNumElements( int nElements ) +{ + m_nElements = nElements; +} + +inline int RecvProp::GetElementStride() const +{ + return m_ElementStride; +} + +inline void RecvProp::SetElementStride( int stride ) +{ + m_ElementStride = stride; +} + +inline int RecvProp::GetFlags() const +{ + return m_Flags; +} + +inline const char* RecvProp::GetName() const +{ + return m_pVarName; +} + +inline SendPropType RecvProp::GetType() const +{ + return m_RecvType; +} + +inline RecvTable* RecvProp::GetDataTable() const +{ + return m_pDataTable; +} + +inline void RecvProp::SetDataTable( RecvTable *pTable ) +{ + m_pDataTable = pTable; +} + +inline RecvVarProxyFn RecvProp::GetProxyFn() const +{ + return m_ProxyFn; +} + +inline void RecvProp::SetProxyFn( RecvVarProxyFn fn ) +{ + m_ProxyFn = fn; +} + +inline DataTableRecvVarProxyFn RecvProp::GetDataTableProxyFn() const +{ + return m_DataTableProxyFn; +} + +inline void RecvProp::SetDataTableProxyFn( DataTableRecvVarProxyFn fn ) +{ + m_DataTableProxyFn = fn; +} + +inline int RecvProp::GetOffset() const +{ + return m_Offset; +} + +inline void RecvProp::SetOffset( int o ) +{ + m_Offset = o; +} + +inline RecvProp* RecvProp::GetArrayProp() const +{ + return m_pArrayProp; +} + +inline void RecvProp::SetArrayProp( RecvProp *pProp ) +{ + m_pArrayProp = pProp; +} + +inline void RecvProp::SetArrayLengthProxy( ArrayLengthRecvProxyFn proxy ) +{ + m_ArrayLengthProxy = proxy; +} + +inline ArrayLengthRecvProxyFn RecvProp::GetArrayLengthProxy() const +{ + return m_ArrayLengthProxy; +} + +inline bool RecvProp::IsInsideArray() const +{ + return m_bInsideArray; +} + +inline void RecvProp::SetInsideArray() +{ + m_bInsideArray = true; +} + +inline const void* RecvProp::GetExtraData() const +{ + return m_pExtraData; +} + +inline void RecvProp::SetExtraData( const void *pData ) +{ + m_pExtraData = pData; +} + +inline const char* RecvProp::GetParentArrayPropName() +{ + return m_pParentArrayPropName; +} + +inline void RecvProp::SetParentArrayPropName( const char *pArrayPropName ) +{ + m_pParentArrayPropName = pArrayPropName; +} + +inline void**& GetVTable( void* instance ) +{ + return *reinterpret_cast<void***>( ( size_t )instance ); +} + +inline const void** GetVTable( const void* instance ) +{ + return *reinterpret_cast<const void***>( ( size_t )instance ); +} + +template<typename T> +inline T GetMethod( const void* instance, size_t index ) +{ + return reinterpret_cast<T>( GetVTable( instance )[ index ] ); +} + +#endif // DATATABLE_RECV_H
\ No newline at end of file diff --git a/internal_rewrite/autowall.cpp b/internal_rewrite/autowall.cpp new file mode 100644 index 0000000..d402ee1 --- /dev/null +++ b/internal_rewrite/autowall.cpp @@ -0,0 +1,313 @@ +#include <algorithm> + +#include "autowall.hpp" +#include "settings.hpp" +#include "context.hpp" +#include "math.hpp" + +namespace features +{ + bool c_autowall::is_armored( c_base_player* ent, int armor_value, int hitgroup ) { + if ( armor_value <= 0 ) return false; + + switch( hitgroup ) { + case HITGROUP_GENERIC: + case HITGROUP_CHEST: + case HITGROUP_STOMACH: + case HITGROUP_LEFTARM: + case HITGROUP_RIGHTARM: + return true; + case HITGROUP_HEAD: + return ent->m_bHasHelmet( ); + } + + return false; + } + + void c_autowall::trace_line( const vec3_t& start, const vec3_t& end, unsigned mask, void* ignore, CGameTrace* tr ) { + CTraceFilter filter; + Ray_t ray; + + filter.pSkip = ignore; + ray.Init( start, end ); + + g_csgo.m_trace( )->TraceRay( ray, mask, &filter, tr ); + } + + void c_autowall::scale_damage( c_base_player* ent, int hitgroup, float weapon_armor_ratio, float& damage ) { + float multiplier; + float armor_ratio; + float new_damage; + int armor; + + auto get_hitgroup_mul = []( int hitgroup ) { + switch ( hitgroup ) { + case HITGROUP_HEAD: + return 4.f; + case HITGROUP_STOMACH: + return 1.25f; + case HITGROUP_LEFTLEG: + case HITGROUP_RIGHTLEG: + return 0.75f; + } + + return 1.0f; + }; + + multiplier = get_hitgroup_mul( hitgroup ); + damage *= multiplier; + armor = ent->m_ArmorValue( ); + + if( is_armored( ent, armor, hitgroup ) ) { + armor_ratio = weapon_armor_ratio * 0.5f; + new_damage = damage * armor_ratio; + if( hitgroup != HITGROUP_HEAD && damage - damage * armor_ratio * 0.5f > armor ) { + new_damage = damage - armor * 2.0f; + } + + damage = new_damage; + } + } + + bool c_autowall::is_breakable( IClientEntity* ent ) { + static auto is_breakable_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 51 56 8B F1 85 F6 74 68 83 BE" ) ); + + auto& v2 = *reinterpret_cast< uint8_t* >( uintptr_t( ent ) + 0x27c ); + uint8_t backup_value = v2; + + auto clientclass = ent->GetClientClass( ); + if( clientclass->m_class_id != CFuncBrush && clientclass->m_class_id != CBaseDoor ) + v2 = 2; + + auto is_breakable_fn = reinterpret_cast< bool( __thiscall* )( void* ) >( is_breakable_ptr ); + + bool is_breakable = is_breakable_fn( ent ); + v2 = backup_value; + + return is_breakable; + } + + bool c_autowall::trace_to_exit( vec3_t start, vec3_t& dir, vec3_t& out_end, CGameTrace& tr, CGameTrace* exit_trace ) { + float dist = 0.f; + CTraceFilter filter; + Ray_t ray, ray_2; + + while( dist <= 90.f ) { + // This may seem retarded to you, but it will help frame-rate a lot + // and the accuracy loss is almost negligible. You can remove this if + // you want to. + if ( !util::is_low_fps( ) && g_settings.rage.autowall_fps( ) ) { + dist += 4.f; + } + else { + dist += 8.0f; + } + + out_end = start + dir * dist; + + int contents = g_csgo.m_trace( )->GetPointContents( out_end, MASK_SHOT_HULL | CONTENTS_HITBOX ); + + if( contents & MASK_SHOT_HULL && !( contents & CONTENTS_HITBOX ) ) + continue; + + ray.Init( out_end, out_end - dir * 4.f ); + g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT_HULL | CONTENTS_HITBOX, 0, exit_trace ); + + if( exit_trace->startsolid && exit_trace->surface.flags & SURF_HITBOX ) { + filter.pSkip = exit_trace->m_pEnt; + + ray_2.Init( out_end, start ); + g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT_HULL, &filter, exit_trace ); + + if( exit_trace->DidHit( ) && !exit_trace->startsolid ) { + out_end = exit_trace->endpos; + return true; + } + } + else if( !exit_trace->DidHit( ) || exit_trace->startsolid ) { + if( tr.m_pEnt && tr.m_pEnt->GetIndex( ) ) { + if( is_breakable( tr.m_pEnt ) ) + return true; + + start = tr.endpos; + } + } + else if( ( ( exit_trace->surface.flags >> 7 ) & 1 ) && !( ( tr.surface.flags >> 7 ) & 1 ) ) + continue; + else if( exit_trace->plane.normal.dot( dir ) <= 1.0f ) { + auto fraction = exit_trace->fraction * 4.0f; + out_end = out_end - dir * fraction; + + return true; + } + } + + return false; + } + + bool c_autowall::handle_bullet_penetration( weapon_info_t* wpn_data, fire_bullet_data_t& data ) { + surfacedata_t* enter_surface_data = g_csgo.m_phys_props( )->GetSurfaceData( data.enter_trace.surface.surfaceProps ); + int enter_material = enter_surface_data->game.material; + float enter_surf_penetration_mod = enter_surface_data->game.penetrationmodifier; + + data.trace_length += data.enter_trace.fraction * data.trace_length_remaining; + data.current_damage *= static_cast<float>( pow( wpn_data->range_modifier, data.trace_length * 0.002 ) ); + + if( data.trace_length > 3000.f || enter_surf_penetration_mod < 0.1f ) + data.penetrate_count = 0; + + if( data.penetrate_count <= 0 ) + return false; + + vec3_t out_end; + CGameTrace trace_exit; + if( !trace_to_exit( data.enter_trace.endpos, data.direction, out_end, data.enter_trace, &trace_exit ) ) + return false; + + surfacedata_t* exit_surface_data = g_csgo.m_phys_props( )->GetSurfaceData( trace_exit.surface.surfaceProps ); + + int exit_material = exit_surface_data->game.material; + float exit_surf_penetration_mod = exit_surface_data->game.penetrationmodifier; + + float final_damage_modifier = 0.16f; + float combined_penetration_modifier = 0.0f; + + if( ( data.enter_trace.contents & CONTENTS_GRATE ) != 0 || enter_material == 89 || enter_material == 71 ) { + combined_penetration_modifier = 3.0f; + final_damage_modifier = 0.05f; + } + else { + combined_penetration_modifier = ( enter_surf_penetration_mod + exit_surf_penetration_mod ) * 0.5f; + } + + if( enter_material == exit_material ) { + if( exit_material == 87 || exit_material == 85 ) + combined_penetration_modifier = 3.0f; + else if( exit_material == 76 ) + combined_penetration_modifier = 2.0f; + } + + float modifier = fmaxf( 0.f, 1.0f / combined_penetration_modifier ); + float taken_damage = ( data.current_damage * final_damage_modifier ) + modifier * 3.0f * fmaxf( 0.0f, + ( float )( 3.0 / ( wpn_data->penetration ) ) * 1.25f ); + float thickness = ( trace_exit.endpos - data.enter_trace.endpos ).lengthsqr( ); + + thickness *= modifier; + thickness *= 0.041666668f; + + float lost_damage = fmaxf( 0.0f, taken_damage + thickness ); + + if( lost_damage > data.current_damage ) + return false; + + if( lost_damage >= 0.0f ) + data.current_damage -= lost_damage; + + if( data.current_damage < 1.0f ) + return false; + + data.src = trace_exit.endpos; + data.penetrate_count--; + + return true; + } + + bool c_autowall::fire_bullet( c_base_player* shooter, c_base_player* target, weapon_info_t* wep_data, fire_bullet_data_t& data, bool ent_check, bool scale ) { + data.penetrate_count = 4; + data.trace_length = 0.f; + + if( !wep_data ) + return false; + + data.current_damage = ( float )( wep_data->damage ); + + while( data.penetrate_count > 0 && data.current_damage > 1.0f ) { + if ( !ent_check ) { + data.trace_length_remaining = data.length_to_end - data.trace_length; + } + else { + data.trace_length_remaining = wep_data->range - data.trace_length; + } + + vec3_t end = data.src + data.direction * data.trace_length_remaining; + trace_line( data.src, end, MASK_SHOT | CONTENTS_GRATE, shooter, &data.enter_trace ); + + util::clip_trace_to_player( target->ce( ), data.src, end + data.direction * 40.f, MASK_SHOT | CONTENTS_GRATE, &data.filter, &data.enter_trace ); + + if( data.enter_trace.fraction == 1.0f ) { + if( !ent_check ) { + data.trace_length += data.enter_trace.fraction * data.trace_length_remaining; + data.current_damage *= std::pow( wep_data->range_modifier, data.trace_length * 0.002f ); + + if( scale ) + scale_damage( target, HITGROUP_HEAD, wep_data->armor_ratio, data.current_damage ); + return true; + } + + break; + } + + + if( data.enter_trace.hitgroup <= HITGROUP_RIGHTLEG && data.enter_trace.hitgroup >= HITGROUP_HEAD + && data.enter_trace.m_pEnt == target->ce( ) ) { + data.trace_length += data.enter_trace.fraction * data.trace_length_remaining; + data.current_damage *= std::pow( wep_data->range_modifier, data.trace_length * 0.002f ); + + auto enemy = ( c_base_player* )( data.enter_trace.m_pEnt ); + auto cl = enemy->ce( )->GetClientClass( ); + if( cl->m_class_id != CCSPlayer ) { + return false; + } + + if( shooter->m_iTeamNum( ) == enemy->m_iTeamNum( ) && !g_settings.rage.friendlies ) { + return false; + } + + if( scale ) + scale_damage( enemy, data.enter_trace.hitgroup, wep_data->armor_ratio, data.current_damage ); + + return true; + } + + if( !handle_bullet_penetration( wep_data, data ) ) + break; + } + + return false; + } + + float c_autowall::run( c_base_player* shooter, c_base_player* target, const vec3_t& end, bool ent_check ) { + if( !shooter || !target ) { + return 0.f; + } + + auto wep = shooter->get_weapon( ); + if( !wep ) { + return 0.f; + } + + fire_bullet_data_t data; + data.filter.pSkip = shooter; + + if( shooter == g_ctx.m_local ) { + data.src = shooter->get_eye_pos( ); + } + else { + data.src = shooter->m_vecOrigin( ); + data.src.z += 72.f; + } + + data.length_to_end = ( end - data.src ).length( ); + + vec3_t angles = math::vector_angles( data.src, end ); + data.direction = math::angle_vectors( angles ); + + data.direction.normalize_vector( ); + + if( fire_bullet( shooter, target, wep->get_wpn_info( ), data, ent_check ) ) { + return data.current_damage; + } + + return 0.f; + } +} diff --git a/internal_rewrite/autowall.hpp b/internal_rewrite/autowall.hpp new file mode 100644 index 0000000..4d82574 --- /dev/null +++ b/internal_rewrite/autowall.hpp @@ -0,0 +1,34 @@ +#pragma once +#include "sdk.hpp" +#include "pattern.hpp" +#include "interface.hpp" + +struct fire_bullet_data_t { + vec3_t src; + CGameTrace enter_trace; + vec3_t direction; + CTraceFilter filter; + float trace_length; + float trace_length_remaining; + float length_to_end; + float current_damage; + int penetrate_count; +}; + +namespace features +{ + class c_autowall { + private: + bool is_armored( c_base_player* entity, int armor_value, int hitgroup ); + void scale_damage( c_base_player* entity, int hitgroup, float weapon_armor_ratio, float& damage ); + void trace_line( const vec3_t& abs_start, const vec3_t& abs_end, unsigned mask, void* ignore, CGameTrace* trace ); + bool is_breakable( IClientEntity* ent ); + + bool trace_to_exit( vec3_t start, vec3_t& dir, vec3_t& out_end, CGameTrace& tr, CGameTrace* exit_trace ); + + public: + bool handle_bullet_penetration( weapon_info_t* wpn_data, fire_bullet_data_t& data ); + bool fire_bullet( c_base_player* shooter, c_base_player* target, weapon_info_t* wep_data, fire_bullet_data_t& data, bool ent_check = true, bool scale_damage = true ); + float run( c_base_player* shooter, c_base_player* target, const vec3_t& end, bool ent_check = true ); + }; +}
\ No newline at end of file diff --git a/internal_rewrite/base_cheat.cpp b/internal_rewrite/base_cheat.cpp new file mode 100644 index 0000000..d21888d --- /dev/null +++ b/internal_rewrite/base_cheat.cpp @@ -0,0 +1,3 @@ +#include "base_cheat.hpp" + +features::c_base_cheat g_cheat;
\ No newline at end of file diff --git a/internal_rewrite/base_cheat.hpp b/internal_rewrite/base_cheat.hpp new file mode 100644 index 0000000..07d3588 --- /dev/null +++ b/internal_rewrite/base_cheat.hpp @@ -0,0 +1,39 @@ +#pragma once +#include "util.hpp" +#include "movement.hpp" +#include "prediction.hpp" +#include "legitbot.hpp" +#include "chams.hpp" +#include "autowall.hpp" +#include "ragebot.hpp" +#include "identity.hpp" +#include "lag_mgr.hpp" +#include "visual.hpp" +#include "extra.hpp" +#include "movement_recorder.hpp" +#include "player_manager.hpp" +#include "skins.hpp" + +NAMESPACE_REGION( features ) + +class c_base_cheat { +public: + //have your cheat classes in here + c_movement m_movement; + c_prediction m_prediction; + c_legitbot m_legitbot; + c_autowall m_autowall; + c_ragebot m_ragebot; + c_identity m_identity; + c_chams m_chams; + c_lagmgr m_lagmgr; + c_extra m_extra; + c_skins m_skins; + c_visuals m_visuals; + c_move_recorder m_move_rec; + c_player_manager m_player_mgr; +}; + +END_REGION + +extern features::c_base_cheat g_cheat;
\ No newline at end of file diff --git a/internal_rewrite/begin_lock.cpp b/internal_rewrite/begin_lock.cpp new file mode 100644 index 0000000..d441395 --- /dev/null +++ b/internal_rewrite/begin_lock.cpp @@ -0,0 +1,32 @@ +#include <intrin.h>
+
+#include "hooks.hpp"
+#include "base_cheat.hpp"
+#include "context.hpp"
+
+void __fastcall hooks::begin_lock( void* ecx, void* edx ) { // THIS IS PROLLY NOT ENDLOCK, BUT WHATEVER
+ static auto begin_lock_o = g_csgo.m_mdl_cache->get_old_function< decltype( &hooks::begin_lock ) >( 33 );
+
+
+ // signature:
+ // search "CL_CallPostDataUpdates: missing ent %d" in engine.dll.
+ // where framestagenotify gets called
+ static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_engine.dll( ), "A1 ? ? ? ? B9 ? ? ? ? 6A 00 FF 50 18 8B 15 ? ? ? ?" );
+ if( _ReturnAddress( ) == ret_addr ) {
+ g_ctx.m_stage = FRAME_NET_UPDATE_POSTDATAUPDATE_START;
+ g_cheat.m_visuals.world_modulate( );
+
+ //g_con->game_console_print( "net postdataupdate start\n" );
+
+ // FRAME_NET_UPDATE_POSTDATAUPDATE_START
+ g_cheat.m_extra.float_ragdolls( );
+
+ g_cheat.m_player_mgr.frame_stage_notify( );
+ g_cheat.m_prediction.frame_stage_notify( );
+ g_cheat.m_ragebot.m_resolver->frame_stage_notify( );
+ g_cheat.m_ragebot.m_lagcomp->fsn_render_start( );
+ g_cheat.m_skins( );
+ }
+
+ begin_lock_o( ecx, edx );
+}
\ No newline at end of file diff --git a/internal_rewrite/bf_write.hpp b/internal_rewrite/bf_write.hpp new file mode 100644 index 0000000..7d759b2 --- /dev/null +++ b/internal_rewrite/bf_write.hpp @@ -0,0 +1,34 @@ +#pragma once + +class bf_write { +public: + bf_write( void* data, int bytes, int max_bits = -1 ) { + m_data = ( unsigned char* )data; + m_bytes = bytes; + if( max_bits == -1 ) + m_bits = bytes * 8; + else + m_bits = max_bits; + } + + bf_write( const char* debug_name, void* data, int bytes, int max_bits = -1 ) { + m_debug_name = debug_name; + m_data = ( unsigned char* )data; + m_bytes = bytes; + if( max_bits == -1 ) + m_bits = bytes * 8; + else + m_bits = max_bits; + } + +public: + unsigned char* m_data{ }; + int m_bytes{ }; + int m_bits{ }; + int m_cur_bit{ }; + +private: + bool m_overflow{ }; + bool m_assert_on_overflow{ }; + const char* m_debug_name{ }; +};
\ No newline at end of file diff --git a/internal_rewrite/c_base_player.cpp b/internal_rewrite/c_base_player.cpp new file mode 100644 index 0000000..0cc95aa --- /dev/null +++ b/internal_rewrite/c_base_player.cpp @@ -0,0 +1,964 @@ +#include "c_base_player.hpp"
+#include "interface.hpp"
+#include "math.hpp"
+#include "mem.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+
+#undef max
+
+ent_animdata_t c_base_player::sm_animdata[ 65 ];
+
+void IKContext::Init( void* hdr, vec3_t& angles, vec3_t& origin, float curtime, int framecount, int bone_mask ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 EC 08 8B 45 08 56 57 8B F9 8D 8F" ) );
+
+ auto fn = ( void( __thiscall* )( void*, void*, vec3_t&, vec3_t&, float, int, int ) )( fn_ptr );
+ fn( this, hdr, angles, origin, curtime, framecount, bone_mask );
+}
+
+void IKContext::UpdateTargets( vec3_t* pos, void* q, matrix3x4* bone_array, char* computed ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F0 81 EC 00 00 00 00 33 D2" ) );
+
+ auto fn = ( void( __thiscall* )( void*, vec3_t*, void*, matrix3x4*, char* ) )( fn_ptr );
+ fn( this, pos, q, bone_array, computed );
+}
+
+void IKContext::SolveDependencies( vec3_t* pos, void* q, matrix3x4* bone_array, char* computed ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F0 81 EC 00 00 00 00 8B 81" ) );
+
+ auto fn = ( void( __thiscall* )( void*, vec3_t*, void*, matrix3x4*, char* ) )( fn_ptr );
+ fn( this, pos, q, bone_array, computed );
+}
+
+bool& c_base_player::s_bInvalidateBoneCache( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 18 56 57 8B F9 F3 0F 11 54 24" ) );
+ static auto var = *( bool** )( fn_ptr + 0xda + 2 );
+
+ return *var;
+}
+
+void CCSGOPlayerAnimState::update( float yaw, float pitch ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 18 56 57 8B F9 F3 0F 11 54 24" ) );
+
+ uintptr_t alloc = ( uintptr_t )this;
+ if( !alloc )
+ return;
+
+ //bool* b = &c_base_player::s_bInvalidateBoneCache( );
+ //char backup = *b;
+
+ //vectorcall is GAY
+ if( fn_ptr ) {
+ __asm {
+ push 0
+ mov ecx, alloc
+
+ movss xmm1, dword ptr[ yaw ]
+ movss xmm2, dword ptr[ pitch ]
+
+ call fn_ptr
+ }
+ }
+
+ //c_base_player::s_bInvalidateBoneCache( ) = backup;
+}
+
+void CCSGOPlayerAnimState::setup_velocity( float a2 ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 30 56 57 8B 3D" ) );
+ if( fn_ptr ) {
+ auto ptr_ = ( uintptr_t )this;
+
+ __asm {
+ mov ecx, ptr_
+
+ fld a2
+ call fn_ptr
+ }
+ }
+}
+
+bool CCSGOPlayerAnimState::cache_sequences( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 34 53 56 8B F1 57 8B 46 60" ) );
+ if( fn_ptr ) {
+ auto fn = ( bool( __thiscall* )( void* ) )( fn_ptr );
+ return fn( this );
+ }
+
+ return false;
+}
+
+void CCSGOPlayerAnimState::update_ex( float yaw, float pitch ) {
+/* static auto unk_func_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "8B 0D ? ? ? ? 8B 01 8B 80 ? ? ? ? FF D0 84 C0 75 14 8B 0D ? ? ? ? 8B 01" ) );
+ auto unk_fn = ( bool( *)( ) )( unk_func_ptr );
+
+ auto player = ( c_base_player* )this->pBaseEntity;
+
+ if( player && cache_sequences( ) ) {
+ float v7 = *( float* )( uintptr_t( player ) + 0x2e0d ) + pitch;
+ v7 = std::remainderf( v7, 360.f );
+
+ float last_update = m_flLastClientSideAnimationUpdateTime;
+ float cur_time = g_csgo.m_globals->m_curtime;
+
+ if( last_update != cur_time ) {
+ this->m_flLastUpdateDelta = math::max( cur_time - last_update, 0.f );
+ this->m_flEyeYaw = yaw;
+ this->m_flPitch = pitch;
+
+ this->m_vOrigin = player->m_vecOrigin( );
+ this->pActiveWeapon = player->get_weapon( );
+ if( pActiveWeapon != pLastActiveWeapon ) {
+ for( size_t i{ }; i < 13; ++i ) {
+ C_AnimationLayer* layer = &player->m_AnimOverlay( ).GetElements( )[ i ];
+
+ layer->m_unk1 = 0;
+ layer->m_unk2 = layer->m_unk3 = -1;
+ }
+ }
+
+ bool using_duck_offset = !unk_fn( );
+
+ if( using_duck_offset ) {
+ float total_duck = *( float* )( uintptr_t( player ) + 0xbe7 ) + m_fLandingDuckAdditiveSomething;
+
+ total_duck = std::clamp( total_duck, 0.f, 1.f );
+
+ float duck_amt = m_fDuckAmount;
+
+ float v28 = this->m_flLastUpdateDelta * 6.0f;
+ float v29 = 0.f;
+
+ if( total_duck - duck_amt > v28 ) {
+ if( v28 <= total_duck - duck_amt )
+ v29 = total_duck;
+ else
+ v29 = duck_amt - v28;
+ }
+ else {
+ v29 = duck_amt + v28;
+ }
+
+ m_fDuckAmount = std::clamp( v29, 0.f, 1.f );
+ }
+ else {
+ float duck_amt = m_fDuckAmount;
+
+ float v19 = player->m_fFlags( ) & FL_WATERJUMP ? 1.0 : m_fLandingDuckAdditiveSomething;
+ float v21 = 0.f;
+ if( v19 <= duck_amt )
+ v21 = 6.0f;
+ else
+ v21 = 3.1f;
+
+ float v22 = m_flLastUpdateDelta * v21;
+ float new_duck = 0.f;
+ if( v19 - duck_amt <= v22 ) {
+ if( v22 <= v19 - duck_amt )
+ new_duck = v19;
+ else
+ new_duck = duck_amt - v22;
+ }
+ else {
+ new_duck = duck_amt = v22;
+ }
+
+ m_fDuckAmount = std::clamp( new_duck, 0.f, 1.f );
+ }
+
+ *( uintptr_t* )( uintptr_t( player ) + 0x286 ) = 0;
+ player->invalidate_physics_recursive( 8 );
+ setup_velocity( v7 );
+ setup_aim_matrix( );
+ setup_weapon_action( );
+ setup_movement( );
+ setup_alive_loop( );
+
+ }
+ }*/
+}
+
+void CCSGOPlayerAnimState::reset( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "56 6A 01 68 ? ? ? ? 8B F1" ) );
+ if( fn_ptr ) {
+ auto fn = ( void( __thiscall* )( void* ) )( fn_ptr );
+ fn( this );
+ }
+}
+
+void CCSGOPlayerAnimState::setup_aim_matrix( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 81 EC ? ? ? ? 53 56 57 8B 3D" ) );
+ if( fn_ptr ) {
+ auto fn = ( void( __thiscall* )( void* ) )( fn_ptr );
+ fn( this );
+ }
+}
+
+void c_base_player::invalidate_physics_recursive( int flags ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 0C 53 8B 5D 08 8B C3" ) );
+ if( fn_ptr ) {
+ auto fn = ( void( __thiscall* )( void*, int ) )( fn_ptr );
+ fn( this, flags );
+ }
+}
+
+uintptr_t c_base_player::get_player_resource( ) {
+ for( int i{ 1 }; i < g_csgo.m_entlist( )->GetHighestEntityIndex( ); ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< IClientEntity >( i );
+ if( !ent ) continue;
+ auto class_ = ent->GetClientClass( );
+ if( class_ ) {
+ if( class_->m_class_id == CCSPlayerResource ) {
+ return uintptr_t( ent );
+ }
+ }
+ }
+
+ return 0;
+}
+
+uintptr_t c_base_player::get_game_rules( ) {
+ static uintptr_t** game_rules = pattern::first_code_match< uintptr_t** >( g_csgo.m_chl.dll( ), xors( "A1 ? ? ? ? 85 C0 0F 84 ? ? ? ? 80 B8 ? ? ? ? ? 0F 84 ? ? ? ? 0F 10 05" ), 0x1 );
+ if( !game_rules ) {
+ game_rules = pattern::first_code_match< uintptr_t** >( g_csgo.m_chl.dll( ), xors( "A1 ? ? ? ? 85 C0 0F 84 ? ? ? ? 80 B8 ? ? ? ? ? 0F 84 ? ? ? ? 0F 10 05" ), 0x1 );
+ }
+
+ return **game_rules;
+}
+
+int& c_base_player::g_iModelBoneCounter( ) {
+ static auto offset = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "A1 ? ? ? ? 48 C7 81" ), 0x1 );
+ return **( int** )( offset );
+}
+
+//use is_zero( ) on the vector to figure out if it returns a valid value
+vec3_t c_base_player::get_hitbox_pos( int hitbox ) {
+ auto ce = this->ce( );
+
+ const auto model = ce->GetModel( );
+ if( !model ) return vec3_t{ };
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !hdr ) return vec3_t{ };
+
+ matrix3x4 bone_matrix[ 128 ];
+ memcpy( bone_matrix,
+ m_CachedBoneData( ).GetElements( ),
+ m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) );
+
+ auto set = hdr->pHitboxSet( m_nHitboxSet( ) );
+ if( !set ) return vec3_t{ };
+
+ auto box = set->pHitbox( hitbox );
+ if( !box ) return vec3_t{ };
+
+ vec3_t center = ( box->bbmin + box->bbmax ) * 0.5f;
+
+ return math::vector_transform( center, bone_matrix[ box->bone ] );
+}
+
+c_base_weapon* c_base_player::get_weapon( ) {
+ auto weap_handle = m_hActiveWeapon( );
+ if( weap_handle )
+ return g_csgo.m_entlist( )->GetClientEntityFromHandle< c_base_weapon >( weap_handle );
+
+ return nullptr;
+}
+
+void c_base_player::set_needs_interpolate( bool interpolate ) {
+ auto varmap = get< VarMapping_t >( 0x24 );
+ auto elements = varmap.m_Entries.GetElements( );
+
+ for( size_t i{ }; i < varmap.m_nInterpolatedEntries; ++i ) {
+ auto& e = elements[ i ];
+ e.m_bNeedsToInterpolate = interpolate;
+ }
+}
+
+bool c_base_player::is_visible( int hitbox ) {
+ vec3_t start = g_ctx.m_local->get_eye_pos( );
+ vec3_t end = get_hitbox_pos( hitbox );
+
+ if( !end ) return false;
+ return util::trace_ray( start, end, g_ctx.m_local->ce( ), this->ce( ) );
+}
+
+float c_base_player::get_hitbox_radius( int hitbox ) {
+ auto model = ce( )->GetModel( );
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ auto set = hdr->pHitboxSet( m_nHitboxSet( ) );
+
+ if( !model || !hdr || !set )
+ return 0.f;
+
+ auto box = set->pHitbox( hitbox );
+
+ if( box ) {
+ if( box->m_flRadius == -1 ) return box->bbmin.dist_to( box->bbmax );
+ return box->m_flRadius;
+ }
+
+ return 0.f;
+}
+
+vec3_t c_base_player::get_hitbox_mins( int hitbox ) {
+ auto model = ce( )->GetModel( );
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ auto set = hdr->pHitboxSet( m_nHitboxSet( ) );
+
+ if( !model || !hdr || !set )
+ return vec3_t( );
+
+ matrix3x4 bone_matrix[ 128 ];
+ memcpy( bone_matrix,
+ m_CachedBoneData( ).GetElements( ),
+ m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) );
+
+ auto box = set->pHitbox( hitbox );
+
+ return math::vector_transform( box->bbmin, bone_matrix[ box->bone ] );
+}
+
+vec3_t c_base_player::get_hitbox_maxs( int hitbox ) {
+ auto model = ce( )->GetModel( );
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ auto set = hdr->pHitboxSet( m_nHitboxSet( ) );
+
+ if( !model || !hdr || !set )
+ return vec3_t( );
+
+ matrix3x4 bone_matrix[ 128 ];
+ memcpy( bone_matrix,
+ m_CachedBoneData( ).GetElements( ),
+ m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) );
+
+ auto box = set->pHitbox( hitbox );
+
+ vec3_t max = math::vector_transform( box->bbmax, bone_matrix[ box->bone ] );
+ return max;
+}
+
+bool c_base_player::is_fakewalking( ) {
+ auto walk_layer = m_AnimOverlay( ).GetElements( )[ 6 ];
+ auto some_layer = m_AnimOverlay( ).GetElements( )[ 4 ];
+
+ auto velocity = m_vecVelocity( ).length2d( );
+ bool on_ground = m_fFlags( ) & FL_ONGROUND;
+ if( walk_layer.m_flWeight < 0.3f
+ && some_layer.m_flWeight < 0.2f
+ && velocity > 0.1f && on_ground ) {
+ return true;
+ }
+
+ if( velocity <= 0.1f )
+ return true;
+
+ return false;
+}
+
+int c_base_player::get_choked_ticks( ) {
+ auto simtime = m_flSimulationTime( );
+
+ return TIME_TO_TICKS( g_csgo.m_globals->m_curtime - simtime ) + 1;
+}
+
+int c_base_player::get_ping( ) {
+ auto resource = get_player_resource( );
+ static auto offset = g_netvars.get_netvar( fnv( "DT_CSPlayerResource" ), fnv( "m_iPing" ) );
+ int ping = *( int* )( resource + offset + ce( )->GetIndex( ) * 4 );
+
+ return ping;
+}
+
+bool c_base_player::is_breaking_lc( ) {
+ return g_cheat.m_prediction.is_breaking_lc( this->ce( )->GetIndex( ) );
+}
+
+bool c_base_player::can_attack( bool ignore_rapid ) {
+ if( g_ctx.m_has_fired_this_frame ) return false;
+ if( !is_alive( ) ) return false;
+
+ auto weapon = get_weapon( );
+ if( !weapon ) return false;
+
+ float time = g_ctx.pred_time( );
+
+ float next_attack = m_flNextAttack( );
+ if( next_attack > time ) return false;
+
+ float next_primary_attack = weapon->m_flNextPrimaryAttack( );
+ if( next_primary_attack > time ) {
+ if( weapon->is_knife( ) ) {
+ if( weapon->m_flNextSecondaryAttack( ) > time )
+ return false;
+ }
+ else {
+ return false;
+ }
+ }
+
+ if( weapon->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER ) {
+ float ready_time = weapon->m_flPostponeFireReadyTime( );
+ if( ready_time == FLT_MAX ) return false;
+
+ float time_to_shoot = ready_time - time;
+ return TIME_TO_TICKS( time_to_shoot ) < 1;
+ }
+
+ return true;
+}
+
+int c_base_player::get_seq_activity( int sequence ) {
+ static uintptr_t fn_offset = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 7D 08 FF 56 8B F1 74 3D" ) );
+ auto fn = ( int( __thiscall* )( void*, int ) )( fn_offset );
+
+ return fn ? fn( this, sequence ) : -2;
+}
+
+void c_base_player::set_abs_angles( vec3_t angles ) {
+ static uintptr_t fn_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 64 53 56 57 8B F1 E8" ) );
+ auto fn = ( void( __thiscall* )( void*, vec3_t& ) )( fn_addr );
+
+ return fn( this, angles );
+}
+
+void c_base_player::set_abs_origin( vec3_t origin ) {
+ static uintptr_t fn_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 51 53 56 57 8B F1" ) );
+ auto fn = ( void( __thiscall* )( void*, vec3_t& ) )( fn_addr );
+
+ return fn( this, origin );
+}
+
+void c_base_player::create_animstate( CCSGOPlayerAnimState* state ) {
+ static auto fn_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 56 8B F1 B9 ? ? ? ? C7 46" ) );
+ auto fn = ( void( __thiscall* )( CCSGOPlayerAnimState*, decltype( this ) ) )( fn_addr );
+
+ fn( state, this );
+ state->pBaseEntity = this;
+}
+
+void c_base_player::set_abs_velocity( vec3_t velocity ) {
+ static auto fn_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 0C 53 56 57 8B 7D 08 8B F1" ) );
+ auto fn = ( void( __thiscall* )( void*, vec3_t& ) )( fn_addr );
+
+ fn( this, velocity );
+}
+
+void c_base_player::invalidate_bone_cache( ) {
+ m_flLastBoneSetupTime( ) = -FLT_MAX;
+ m_iMostRecentModelBoneCounter( ) = 0;
+}
+
+void c_base_player::handle_taser_animation( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 EC 08 56 8B F1 80 BE ? ? ? ? ? 0F 84 ? ? ? ? 80 BE ? ? ? ? ? 0F 84 ? ? ? ? A1" ) );
+ if( fn_ptr ) {
+ vec3_t eye_angles = m_angEyeAngles( );
+
+ __asm {
+ mov ecx, this
+ fld eye_angles.y
+ fld eye_angles.x
+
+ call fn_ptr
+ }
+ }
+}
+
+void c_base_player::calculate_duckamount( bool reset ) {
+ static float last_duckamt[ 65 ]{ };
+ static float original_duckamt[ 65 ]{ };
+ int idx = ce( )->GetIndex( );
+
+ if( reset ) {
+ original_duckamt[ idx ] = m_flDuckAmount( );
+ last_duckamt[ idx ] = m_flDuckAmount( );
+ return;
+ }
+
+ float cur_duck = m_flDuckAmount( );
+ float delta = m_flOldSimulationTime( ) - m_flSimulationTime( ) + TICK_INTERVAL( );
+
+ float old_duck = last_duckamt[ idx ];
+ float rate = ( cur_duck - old_duck ) * delta;
+
+ m_flDuckAmount( ) = old_duck + rate;
+
+ if( cur_duck != original_duckamt[ idx ] )
+ last_duckamt[ idx ] = cur_duck;
+ original_duckamt[ idx ] = cur_duck;
+}
+
+void c_base_player::cache_anim_data( ) {
+ int idx = ce( )->GetIndex( );
+ auto& animdata = sm_animdata[ idx ];
+
+ util::memcpy( animdata.m_poseparams.data( ),
+ m_flPoseParameter( ),
+ sizeof( float ) * 24 );
+
+ util::memcpy( animdata.m_animlayers.data( ),
+ m_AnimOverlay( ).GetElements( ),
+ sizeof( C_AnimationLayer ) * 13 );
+
+ util::memcpy( animdata.m_bones,
+ m_CachedBoneData( ).GetElements( ),
+ sizeof( matrix3x4 ) * m_CachedBoneData( ).GetSize( ) );
+}
+
+void c_base_player::restore_anim_data( bool layers ) {
+ int idx = ce( )->GetIndex( );
+ auto& animdata = sm_animdata[ idx ];
+
+ util::memcpy( m_flPoseParameter( ),
+ animdata.m_poseparams.data( ),
+ sizeof( float ) * 24 );
+
+ if( layers ) {
+ util::memcpy( m_AnimOverlay( ).GetElements( ),
+ animdata.m_animlayers.data( ),
+ sizeof( C_AnimationLayer ) * 13 );
+ }
+
+ util::memcpy( animdata.m_bones,
+ m_CachedBoneData( ).GetElements( ),
+ sizeof( matrix3x4 ) * m_CachedBoneData( ).GetSize( ) );
+}
+
+void c_base_player::do_ent_interpolation( bool reset ) {
+// return; //cuck
+
+
+ auto idx = ce( )->GetIndex( );
+ auto* anim_data = &sm_animdata[ idx ];
+
+ vec3_t origin = m_vecOrigin( );
+
+ if( reset ) {
+ anim_data->m_last_interp_origin = anim_data->m_interp_origin = origin;
+ anim_data->m_simtime = anim_data->m_last_simtime = g_csgo.m_globals->m_curtime;
+ return;
+ }
+
+ if( !anim_data->m_valid )
+ return;
+
+ if( origin.dist_to_sqr( anim_data->m_interp_origin ) > FLT_EPSILON ) {
+ anim_data->m_last_interp_origin = anim_data->m_interp_origin;
+ anim_data->m_interp_origin = origin;
+ anim_data->m_last_simtime = anim_data->m_simtime;
+ anim_data->m_simtime = g_csgo.m_globals->m_curtime;
+ }
+
+ float lerp = util::get_lerptime( ) * 2.f;
+ if( !lerp )
+ return;
+
+ for( size_t i{ }; i < 3; ++i ) {
+ if( !std::isfinite( anim_data->m_last_interp_origin[ i ] ) || !std::isfinite( anim_data->m_interp_origin[ i ] ) ) {
+ char error_msg[ 128 ];
+ sprintf_s< 128 >( error_msg, "player origin was NaN\nreport this bug\ndetails:\n %f %f",
+ g_csgo.m_globals->m_curtime,
+ anim_data->m_simtime );
+
+ MessageBoxA( nullptr, error_msg, "error", MB_OK );
+ exit( 0 );
+ }
+ }
+
+ float update_delta = anim_data->m_simtime - anim_data->m_last_simtime;
+ float update_lerp = std::clamp( update_delta - lerp, 0.f, 1.f );
+
+ if( !update_delta )
+ return;
+
+ if( update_delta > 0.f )
+ lerp = std::clamp( lerp, 0.f, update_delta );
+
+ vec3_t cur_vec = math::lerp( anim_data->m_last_interp_origin, origin, update_lerp / update_delta );
+ float lerp_progress = ( anim_data->m_simtime + lerp - g_csgo.m_globals->m_curtime ) / lerp;
+ if( lerp_progress < 0.f && update_delta == TICK_INTERVAL( ) )
+ lerp_progress = 1.f + lerp_progress;
+
+ vec3_t vec_lerp = math::lerp( origin, cur_vec, std::clamp( lerp_progress, 0.f, 1.f ) );
+
+ for( size_t i{ }; i < 3; ++i )
+ if( !isfinite( vec_lerp[ i ] ) )
+ return;
+
+ byte backup = *( byte* )( uintptr_t( this ) + 0x270 );
+ *( byte* )( uintptr_t( this ) + 0x270 ) = 0;
+
+ restore_anim_data( true );
+
+ //aaaaAAAAAAAA
+ //calc_abs_velocity( );
+ set_abs_origin( vec_lerp );
+ invalidate_bone_cache( );
+
+ ce( )->SetupBones( anim_data->m_bones, 128, BONE_USED_BY_ANYTHING, g_csgo.m_globals->m_curtime );
+ this->m_iMostRecentModelBoneCounter( )++;
+
+ *( byte* )( uintptr_t( this ) + 0x270 ) = backup;
+}
+
+void c_base_player::validate_animation_layers( ) {
+ for( size_t i{ }; i < m_AnimOverlay( ).GetSize( ); ++i ) {
+ auto& layer = m_AnimOverlay( ).GetElements( )[ i ];
+ layer.m_flCycle = std::clamp( layer.m_flCycle, 0.f, 1.f );
+ layer.m_flWeight = std::clamp( layer.m_flWeight, 0.f, 1.f );
+
+ layer.m_player = this;
+ }
+
+ for( size_t i{ }; i < 24; ++i ) {
+ auto& param = m_flPoseParameter( )[ i ];
+ if( !isfinite( param ) )
+ param = 0.f;
+ }
+}
+
+void c_base_player::compute_move_cycle( bool reset, bool moving ) {
+ if( !moving || reset )
+ return;
+
+ float eye_yaw = m_angEyeAngles( ).y;
+
+ float blend_ang = math::approach_angle( eye_yaw,
+ get_animstate( )->m_flCurrentFeetYaw,
+ get_animstate( )->m_flFeetYawRate * 100.f );
+
+ //get_animstate( )->m_flCurrentFeetYaw = blend_ang + 360.f;
+ m_flPoseParameter( )[ LEAN_YAW ] = ( blend_ang + 180.f ) / 360.f;
+ m_flPoseParameter( )[ BODY_YAW ] = ( blend_ang + 180.f ) / 360.f;
+}
+
+void c_base_player::calc_anim_velocity( bool reset ) {
+ int idx = ce( )->GetIndex( );
+
+ if( reset ) {
+ vec3_t velocity = m_vecVelocity( );
+ sm_animdata[ idx ].m_last_origin = m_vecOrigin( );
+ sm_animdata[ idx ].m_last_velocity = velocity;
+ sm_animdata[ idx ].m_anim_velocity = velocity;
+ }
+ else {
+ float delta = m_flSimulationTime( ) - m_flOldSimulationTime( );
+ delta = std::max( delta, TICK_INTERVAL( ) );
+
+ vec3_t origin = m_vecOrigin( );
+
+ vec3_t origin_delta = origin - sm_animdata[ idx ].m_last_origin;
+
+ vec3_t velocity = origin_delta / delta;
+ vec3_t last_velocity = sm_animdata[ idx ].m_last_velocity;
+
+ vec3_t anim_velocity = math::lerp(
+ last_velocity,
+ velocity,
+ TICK_INTERVAL( ) / delta );
+
+ if( anim_velocity.length2d( ) < 3.f ) {
+ anim_velocity.x = anim_velocity.y = 0.f;
+ velocity = anim_velocity;
+ }
+
+ sm_animdata[ idx ].m_anim_velocity = anim_velocity;
+ sm_animdata[ idx ].m_last_velocity = velocity;
+ sm_animdata[ idx ].m_last_origin = origin;
+ }
+}
+
+void c_base_player::calc_abs_velocity( ) {
+ static auto fn_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 1C 53 56 57 8B F9 F7 87" ), 0 );
+ if( fn_ptr ) {
+ auto fn = ( void( __thiscall* )( void* ) )( fn_ptr );
+ fn( this );
+ }
+}
+
+void c_base_player::fix_animations( bool reset, bool resolver_change ) {
+ //todo: legs dont match up when fakelagging <- not anymore
+ int idx = ce( )->GetIndex( );
+ sm_animdata[ idx ].m_valid = false;
+
+ if( !get_animstate( ) )
+ return;
+
+ m_angEyeAngles( ).y = std::remainder( m_angEyeAngles( ).y, 360.f );
+
+ int flags = m_fFlags( );
+ auto eye_angles = m_angEyeAngles( );
+ auto original_duck = m_flDuckAmount( );
+
+ //enable animations - time to update
+ m_bClientSideAnimation( ) = true;
+ set_needs_interpolate( false );
+
+ //we need the player data at THIS EXACT moment, somehow
+ float anim_time = m_flOldSimulationTime( ) + TICK_INTERVAL( );
+
+ auto backup_curtime = g_csgo.m_globals->m_curtime;
+ auto backup_frametime = g_csgo.m_globals->m_frametime;
+
+ g_csgo.m_globals->m_curtime = anim_time;
+ g_csgo.m_globals->m_frametime = TICK_INTERVAL( );
+
+ if( resolver_change && m_fFlags( ) & FL_ONGROUND && !reset ) {
+ float lby_delta = m_flLowerBodyYawTarget( ) - eye_angles.y;
+ lby_delta = std::remainderf( lby_delta, 360.f );
+ lby_delta = std::clamp( lby_delta, -60.f, 60.f );
+
+ float feet_yaw = std::remainderf( eye_angles.y + lby_delta, 360.f );
+ if( feet_yaw < 0.f )
+ feet_yaw += 360.f;
+
+ get_animstate( )->m_flGoalFeetYaw = get_animstate( )->m_flCurrentFeetYaw = feet_yaw;
+
+ m_flPoseParameter( )[ BODY_YAW ] = std::clamp( ( lby_delta + 180.f ) / 360.f, 0.f, 1.f );
+ m_flPoseParameter( )[ LEAN_YAW ] = std::clamp( ( lby_delta + 180.f ) / 360.f, 0.f, 1.f );
+ }
+
+ get_animstate( )->m_flFeetYawRate = 0.f;
+
+ //why?
+ //because this calls pAttachmentHelper->CalcAbsVelocity
+ //aswell as removes EFL_DIRTY_ABSVELOCITY
+ //which fixes attachments etc
+ //normally this would be called by animstate->update
+ //but we prevent that
+ calc_abs_velocity( );
+
+ //calc_anim_velocity( reset );
+
+ set_abs_origin( m_vecOrigin( ) );
+ //networked duck amount comes from the last simulation tick instead of the current one
+ calculate_duckamount( reset );
+ validate_animation_layers( );
+
+ float old_cycle = m_AnimOverlay( ).GetElements( )[ 6 ].m_flCycle;
+ get_animstate( )->m_iLastClientSideAnimationUpdateFramecount -= 1;
+
+ vec3_t velocity = m_vecVelocity( );
+ int backup_eflags = get< int >( 0xe4 );
+ int backup_byte = get< byte >( 0x35f8 );
+
+ if( !reset ) {
+ m_vecVelocity( ) = sm_animdata[ idx ].m_anim_velocity;
+ get< vec3_t >( 0x94 ) = sm_animdata[ idx ].m_anim_velocity;
+ get< byte >( 0x35f8 ) = 1;
+ get< int >( 0xe4 ) &= ~0x1000;
+
+ get_animstate( )->m_flUnknownFraction = sm_animdata[ idx ].m_fraction;
+ }
+
+ sm_animdata[ idx ].m_last_duck = m_flDuckAmount( );
+ get_animstate( )->update( eye_angles.y, eye_angles.x );
+
+ sm_animdata[ idx ].m_fraction = get_animstate( )->m_flUnknownFraction;
+
+ m_vecVelocity( ) = velocity;
+ get< vec3_t >( 0x94 ) = velocity;
+ get< int >( 0xe4 ) = backup_eflags;
+ get< byte >( 0x35f8 ) = backup_byte;
+
+ m_AnimOverlay( ).GetElements( )[ 6 ].m_flPrevCycle = old_cycle;
+
+ //estimate_layers( reset );
+
+ //check for any possible mistakes
+ validate_animation_layers( );
+
+ if( m_flSimulationTime( ) - m_flOldSimulationTime( ) > TICK_INTERVAL( ) ) {
+ auto activity = get_seq_activity( m_AnimOverlay( ).GetElements( )[ 3 ].m_nSequence );
+
+ if( activity == 979 ) {
+ float cycle = m_AnimOverlay( ).GetElements( )[ 3 ].m_flCycle;
+ m_AnimOverlay( ).GetElements( )[ 3 ].m_flCycle = cycle > 0.5f ? 1.f : 0.f;
+ }
+ }
+
+ bool moving = sm_animdata[ idx ].m_anim_velocity.length( ) > 0.1f;
+ //compute_move_cycle( reset, moving );
+
+ float backup_weight = m_AnimOverlay( ).GetElements( )[ 6 ].m_flWeight;
+
+ if( is_fakewalking( ) && !reset ) {
+ sm_animdata[ idx ].m_last_velocity = vec3_t( );
+ sm_animdata[ idx ].m_anim_velocity = vec3_t( );
+ }
+
+ ce( )->GetRenderAngles( ).y = std::remainderf( ce( )->GetRenderAngles( ).y, 360.f );
+
+ m_flDuckAmount( ) = original_duck;
+ m_fFlags( ) = flags;
+ m_angEyeAngles( ) = eye_angles;
+ m_flDuckAmount( ) = original_duck;
+
+ get_animstate( )->m_flUnknownFraction = 0.f;
+
+ //clear occlusion for setupbones (pvs fix)
+ *( int* )( uintptr_t( this ) + 0xa30 ) = 0;
+
+ byte backup = get< byte >( 0x270 );
+ get< byte >( 0x270 ) = 0;
+
+ invalidate_bone_cache( );
+ ce( )->SetupBones( nullptr, -1, BONE_USED_BY_ANYTHING, anim_time );
+ cache_anim_data( );
+ ///let the game calculate its velocity again...
+ //calc_abs_velocity( );
+
+ g_csgo.m_globals->m_curtime = backup_curtime;
+ g_csgo.m_globals->m_frametime = backup_frametime;
+
+ if( !reset ) {
+ sm_animdata[ idx ].m_valid = true;
+ }
+
+ //disable animations again
+ m_bClientSideAnimation( ) = false;
+ get< byte >( 0x270 ) = backup;
+}
+
+player_info_t c_base_player::get_info( ) {
+ player_info_t info;
+ g_csgo.m_engine( )->GetPlayerInfo( ce( )->GetIndex( ), &info );
+
+ return info;
+}
+
+bool c_base_player::is_flashed( ) {
+ return m_flFlashTime( ) - g_csgo.m_globals->m_curtime > m_flFlashDuration( ) * 0.5f;
+}
+
+bool c_base_player::is_reloading( ) {
+ auto gun_layer = m_AnimOverlay( ).GetElements( )[ 1 ];
+ float playback_rate = gun_layer.m_flPlaybackRate;
+ if( playback_rate < 0.55f ) {
+ return gun_layer.m_flCycle < 0.99f;
+ }
+
+ return false;
+}
+
+void c_base_player::get_name_safe( char* buf ) {
+ player_info_t info;
+ if( g_csgo.m_engine( )->GetPlayerInfo( this->ce( )->GetIndex( ), &info ) ) {
+ for( size_t i{ }; i < 32; ++i ) {
+ switch( info.name[ i ] ) {
+ case '"':
+ case '\\':
+ case ';':
+ case '\n':
+ buf[ i ] = ' ';
+ break;
+ default:
+ buf[ i ] = info.name[ i ];
+ break;
+ }
+ }
+
+ buf[ 31 ] = 0;
+ }
+}
+
+void c_base_player::set_local_view_angles( vec3_t *angle ) { + using fn = void( __thiscall * )( void *, vec3_t * ); + util::get_vfunc< fn >( this, 363 )( this, angle ); +} + +bool c_base_player::run_physics_think( int unk01 ) { + static auto impl = reinterpret_cast< bool( __thiscall * )( void *, int ) >(
+ pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 EC 10 53 56 57 8B F9 8B 87 ? ? ? ? C1 E8 16" ) )
+ );
+
+ return impl( this, unk01 ); +} + +void c_base_player::pre_think( ) { + using fn = void( __thiscall * )( void * ); + util::get_vfunc< fn >( this, 309 )( this ); +} + +void c_base_player::think( ) { + using fn = void( __thiscall * )( void * ); + util::get_vfunc< fn >( this, 137 )( this );
+}
+
+void c_base_player::setup_bones_ex( matrix3x4* array_out, int bone_mask, float curtime ) {
+/* auto hdr = *( studiohdr_t** )( uintptr_t( ce( )->GetClientRenderable( ) ) + 0x2938 );
+ auto bone_array = ( matrix3x4* )( m_dwBoneMatrix( ) );
+
+ auto readable_bones = *( int* )( ( uintptr_t )ce( )->GetClientRenderable( ) + 0x2694 );
+ bone_mask |= readable_bones;
+
+ //backup necessary data
+ matrix3x4 backup_bone_array[ 128 ];
+ float backup_pose_params[ 24 ];
+
+ memcpy( backup_bone_array,
+ ( void* )( m_dwBoneMatrix( ) ),
+ sizeof( backup_bone_array ) );
+
+ memcpy( backup_pose_params,
+ m_flPoseParameter( ),
+ sizeof( backup_pose_params ) );
+
+ vec3_t backup_origin = ce( )->GetRenderOrigin( );
+ vec3_t backup_angles = ce( )->GetRenderAngles( );
+
+ //setup a transform matrix
+ matrix3x4 transform{ };
+ math::angle_imatrix( backup_angles, transform );
+ math::set_matrix_position( backup_origin, transform );
+
+ //set render flags
+ *( int* )( ( uintptr_t )ce( )->GetClientRenderable( ) + 0xE0 ) |= 8;
+
+ update_ik_locks( m_flSimulationTime( ) );
+ IKContext* ik = m_IKContext( );
+
+ if( ik ) {
+ ik->ClearTargets( );
+ ik->Init( hdr, backup_angles,
+ backup_origin,
+ curtime,
+ g_csgo.m_globals->m_framecount,
+ bone_mask );
+ }
+
+ vec3_t pos[ 128 ];
+ float q[ 4 ][ 128 ];
+
+ standard_blending_rules( hdr, pos, q, curtime, bone_mask );
+
+ //idk but this is in ida
+ char computed[ 0x100 ]{ };
+
+ if( ik ) {
+ ik->UpdateTargets( pos, q, bone_array, computed );
+ calculate_ik_locks( curtime );
+ ik->SolveDependencies( pos, q, bone_array, computed );
+ }
+
+ build_transformations( hdr, pos, q, transform, bone_mask, computed );
+
+ //clear render flags
+ *( int* )( ( uintptr_t )ce( )->GetClientRenderable( ) + 0xE0 ) &= ~8;
+
+ //copy new bone array into the matrix
+ memcpy( array_out, bone_array, 128 * sizeof( matrix3x4 ) );
+
+ /*
+ //restore data
+ memcpy( bone_array,
+ backup_bone_array,
+ sizeof( matrix3x4 ) );
+
+ memcpy( m_flPoseParameter( ),
+ backup_pose_params,
+ sizeof( backup_pose_params ) );
+
+ set_abs_angles( backup_angles );
+ set_abs_origin( backup_origin );
+ */
+}
\ No newline at end of file diff --git a/internal_rewrite/c_base_player.hpp b/internal_rewrite/c_base_player.hpp new file mode 100644 index 0000000..8aef969 --- /dev/null +++ b/internal_rewrite/c_base_player.hpp @@ -0,0 +1,461 @@ +#pragma once +#include <array> + +#include "util.hpp" +#include "IClientEntityList.hpp" +#include "netvars.hpp" +#include "pattern.hpp" +#include "c_base_weapon.hpp" +#include "CUtlVector.hpp" +#include "IPhysicsSurfaceProps.hpp" +#include "settings.hpp" +#include "IPhysicsSurfaceProps.hpp" + +enum PlayerState_t { + FL_ONGROUND = 1 << 0, + FL_DUCKING = 1 << 1, + FL_WATERJUMP = 1 << 2, + FL_ONTRAIN = 1 << 3, + FL_INRAIN = 1 << 4, + FL_FROZEN = 1 << 5, + FL_ATCONTROLS = 1 << 6, + FL_CLIENT = 1 << 7, + FL_FAKECLIENT = 1 << 8, + FL_INWATER = 1 << 9, +}; + +enum PlayerHitboxes_t { + HITBOX_HEAD, + HITBOX_NECK, + HITBOX_PELVIS, + HITBOX_BODY, + HITBOX_THORAX, + HITBOX_CHEST, + HITBOX_UPPER_CHEST, + HITBOX_RIGHT_THIGH, + HITBOX_LEFT_THIGH, + HITBOX_RIGHT_CALF, + HITBOX_LEFT_CALF, + HITBOX_RIGHT_FOOT, + HITBOX_LEFT_FOOT, + HITBOX_RIGHT_HAND, + HITBOX_LEFT_HAND, + HITBOX_RIGHT_UPPER_ARM, + HITBOX_RIGHT_FOREARM, + HITBOX_LEFT_UPPER_ARM, + HITBOX_LEFT_FOREARM, + HITBOX_MAX, +}; + +enum MoveType_t { + MOVETYPE_NONE = 0, // never moves + MOVETYPE_ISOMETRIC, // For players -- in TF2 commander view, etc. + MOVETYPE_WALK, // Player only - moving on the ground + MOVETYPE_STEP, // gravity, special edge handling -- monsters use this + MOVETYPE_FLY, // No gravity, but still collides with stuff + MOVETYPE_FLYGRAVITY, // flies through the air + is affected by gravity + MOVETYPE_VPHYSICS, // uses VPHYSICS for simulation + MOVETYPE_PUSH, // no clip to world, push and crush + MOVETYPE_NOCLIP, // No gravity, no collisions, still do velocity/avelocity + MOVETYPE_LADDER, // Used by players only when going onto a ladder + MOVETYPE_OBSERVER, // Observer movement, depends on player's observer mode + MOVETYPE_CUSTOM, // Allows the entity to describe its own physics + MOVETYPE_LAST = MOVETYPE_CUSTOM, // should always be defined as the last item in the list + MOVETYPE_MAX_BITS = 4, +}; + +enum LifeState_t { + LIFE_ALIVE = 0, // alive + LIFE_DYING, // playing death animation or still falling off of a ledge waiting to hit ground + LIFE_DEAD, // dead. lying still. + LIFE_RESPAWNABLE, + LIFE_DISCARDBODY, +}; + +enum PoseParam_t { + STRAFE_YAW, + STAND, + LEAN_YAW, + SPEED, + LADDER_YAW, + LADDER_SPEED, + JUMP_FALL, + MOVE_YAW, + MOVE_BLEND_CROUCH, + MOVE_BLEND_WALK, + MOVE_BLEND_RUN, + BODY_YAW, + BODY_PITCH, + AIM_BLEND_STAND_IDLE, + AIM_BLEND_STAND_WALK, + AIM_BLEND_STAND_RUN, + AIM_BLEND_COURCH_IDLE, + AIM_BLEND_CROUCH_WALK, + DEATH_YAW +}; + +class IKContext { +public: + void Init( void* hdr, vec3_t& angles, vec3_t& origin, float curtime, int framecount, int boneMask ); + void UpdateTargets( vec3_t* pos, void* q, matrix3x4* bone_array, char* computed ); + void SolveDependencies( vec3_t* pos, void* q, matrix3x4* bone_array, char* computed ); + + //THANK YOU IDA + void ClearTargets( ) { + int max = *( int* )( ( uintptr_t )this + 4080 ); + int count = 0; + + if( max > 0 ) { + uintptr_t v60 = ( uintptr_t )( ( uintptr_t )this + 208 ); + do { + *( int* )( v60 ) = -9999; + v60 += 340; + ++count; + } while( count < max ); + } + } +}; + +class C_AnimationLayer { +private: + char pad_0x8_[ 0x8 ]; +public: + uint32_t m_unk1; + uint32_t m_unk2; + uint32_t m_unk3; + uint32_t m_nOrder; //0x0014 + uint32_t m_nSequence; //0x0018 + float m_flPrevCycle; //0x001C + float m_flWeight; //0x0020 + float m_flWeightDeltaRate; //0x0024 + float m_flPlaybackRate; //0x0028 + float m_flCycle; //0x2C + c_base_player* m_player; //0x30 + char pad_0x8[ 0x4 ]; //0x34 +}; //Size: 0x0038 + +struct clientanimating_t { + void* m_pAnimating; + unsigned int m_fFlags; + clientanimating_t( void* _pAnim, unsigned int _flags ) : m_pAnimating( _pAnim ), m_fFlags( _flags ) {} +}; + +struct CCSGOPlayerAnimState +{ + void update( float yaw, float pitch ); + void update_ex( float yaw, float pitch ); + void setup_velocity( float ); + void setup_aim_matrix( ); + void setup_weapon_action( ); + void setup_movement( ); + void setup_alive_loop( ); + void setup_whole_body_action( ); + void setup_flashed_reaction( ); + void setup_flinch( ); + bool cache_sequences( ); + + void reset( ); + + char pad[ 3 ]; + char bUnknown; //0x4 + char pad2[ 91 ]; + void* pBaseEntity; //0x60 + void* pActiveWeapon; //0x64 + void* pLastActiveWeapon; //0x68 + float m_flLastClientSideAnimationUpdateTime; //0x6C + int m_iLastClientSideAnimationUpdateFramecount; //0x70 + float m_flLastUpdateDelta; //0x74 //b8 + float m_flEyeYaw; //0x78 //c0 + float m_flPitch; //0x7C //b8 + float m_flGoalFeetYaw; //0x80 //c0 + float m_flCurrentFeetYaw; //0x84 //c8 + float m_flCurrentTorsoYaw; //0x88 //d0 + float m_flUnknownVelocityLean; //0x8C //changes when moving/jumping/hitting ground //d8 + float m_flLeanAmount; //0x90 //e0 + char pad4[ 4 ]; //NaN //e8 + float m_flFeetCycle; //0x98 0 to 1 //100 //f0 + float m_flFeetYawRate; //0x9C 0 to 1 //108 //f8 + char pad11[ 4 ]; + float m_fDuckAmount; //0xA4 //118 //108 + float m_fLandingDuckAdditiveSomething; //0xA8 //110 + float m_fUnknown3; //0xAC //118 + vec3_t m_vOrigin; //0xB0, 0xB4, 0xB8 //120 + vec3_t m_vLastOrigin; //0xBC, 0xC0, 0xC4 + vec3_t m_vecVelocity; + float m_flUnknownFloat1; //0xD4 Affected by movement and direction + char pad6[ 8 ]; + float m_flUnknownFloat2; //0xE0 //from -1 to 1 when moving and affected by direction + float m_flUnknownFloat3; //0xE4 //from -1 to 1 when moving and affected by direction + float m_unknown; //0xE8 + float m_velocity; //0xEC + float flUpVelocity; //0xF0 + float m_flSpeedNormalized; //0xF4 //from 0 to 1 + float m_flFeetSpeedForwardsOrSideWays; //0xF8 //from 0 to 2. something is 1 when walking, 2.something when running, 0.653 when crouch walking + float m_flFeetSpeedUnknownForwardOrSideways; //0xFC //from 0 to 3. something + float m_flTimeSinceStartedMoving; //0x100 + float m_flTimeSinceStoppedMoving; //0x104 + unsigned char m_bOnGround; //0x108 + unsigned char m_bInHitGroundAnimation; //0x109 + char pad7[ 10 ]; + float m_flLastOriginZ; //0x114 + float m_flHeadHeightOrOffsetFromHittingGroundAnimation; //0x118 from 0 to 1, is 1 when standing + float m_flStopToFullRunningFraction; //0x11C from 0 to 1, doesnt change when walking or crouching, only running + char pad8[ 4 ]; //NaN + float m_flUnknownFraction; //0x124 affected while jumping and running, or when just jumping, 0 to 1 + char pad9[ 4 ]; //NaN + float m_flUnknown3; + char pad10[ 0x210 ]; +}; + +class VarMapEntry_t { +public: + unsigned short type; + unsigned short m_bNeedsToInterpolate; // Set to false when this var doesn't + // need Interpolate() called on it anymore. + void* data; + void* watcher; +}; + +struct VarMapping_t { + CUtlVector< VarMapEntry_t > m_Entries; + int m_nInterpolatedEntries; // +0x14 + float m_lastInterpolationTime; // +0x18 +}; + +struct ent_animdata_t { + std::array< C_AnimationLayer, 13 > m_animlayers; + std::array< C_AnimationLayer, 13 > m_last_layers; + std::array< float, 24 > m_poseparams; + matrix3x4 m_bones[ 128 ]; + int m_activity; + float m_simtime; + float m_last_simtime; + vec3_t m_last_interp_origin; + float m_fraction; + vec3_t m_interp_origin; + vec3_t m_last_origin; + vec3_t m_last_velocity; + vec3_t m_anim_velocity; + bool m_valid{ }; + float m_last_duck; +}; + +class c_base_player { +private: + static ent_animdata_t sm_animdata[ 65 ]; +public: + //NETVAR( m_YourFunctionName, "Name", "Table", extra, type ) + + NETVAR( m_nMoveType, "m_nRenderMode", "DT_BaseEntity", 1, MoveType_t ); + NETVAR( m_iAccount, "m_iAccount", "DT_CSPlayer", 0, int ); + NETVAR( m_iHealth, "m_iHealth", "DT_BasePlayer", 0, int ); + NETVAR( m_lifeState, "m_lifeState", "DT_BasePlayer", 0, uint8_t ); + NETVAR( m_nTickBase, "m_nTickBase", "DT_BasePlayer", 0, int ); + NETVAR( m_fFlags, "m_fFlags", "DT_BasePlayer", 0, int ); + NETVAR( m_vecVelocity, "m_vecVelocity[0]", "DT_BasePlayer", 0, vec3_t ); + NETVAR( m_nHitboxSet, "m_nHitboxSet", "DT_BaseAnimating", 0, int ); + NETVAR( m_vecOrigin, "m_vecOrigin", "DT_BaseEntity", 0, vec3_t ); + NETVAR( m_vecViewOffset, "m_vecViewOffset[0]", "DT_BasePlayer", 0, vec3_t ); + NETVAR( m_hActiveWeapon, "m_hActiveWeapon", "DT_BaseCombatCharacter", 0, ulong_t ); + NETVAR( m_iTeamNum, "m_iTeamNum", "DT_BaseEntity", 0, int ); + NETVAR( m_bHasHelmet, "m_bHasHelmet", "DT_CSPlayer", 0, bool ); + NETVAR( m_bHasDefuser, "m_bHasDefuser", "DT_CSPlayer", 0, bool ); + NETVAR( m_ArmorValue, "m_ArmorValue", "DT_CSPlayer", 0, int ); + NETVAR( m_flNextAttack, "m_flNextAttack", "DT_BaseCombatCharacter", 0, float ); + NETVAR( m_flLowerBodyYawTarget, "m_flLowerBodyYawTarget", "DT_CSPlayer", 0, float ); + NETVAR( m_angEyeAngles, "m_angEyeAngles[0]", "DT_CSPlayer", 0, vec3_t ); + NETVAR( m_AnimOverlay, "m_hLightingOrigin", "DT_BaseAnimating", 0x3c, CUtlVector< C_AnimationLayer > ); + NETVAR( m_flSimulationTime, "m_flSimulationTime", "DT_BaseEntity", 0, float ); + NETVAR( m_flCycle, "m_flCycle", "DT_BaseAnimating", 0, float ); + NETVAR( m_nSequence, "m_nSequence", "DT_BaseAnimating", 0, int ); + PNETVAR( m_flPoseParameter, "m_flPoseParameter", "DT_BaseAnimating", 0, float ); + NETVAR( m_bClientSideAnimation, "m_bClientSideAnimation", "DT_BaseAnimating", 0, bool ); + NETVAR( m_flLastBoneSetupTime, "m_hLightingOrigin", "DT_BaseAnimating", -0x20, float ); + NETVAR( m_iMostRecentModelBoneCounter, "m_nForceBone", "DT_BaseAnimating", 0x4, int ); + NETVAR( m_nWriteableBones, "m_nForceBone", "DT_BaseAnimating", 0x20, int ); + NETVAR( m_vecThirdpersonAngles, "deadflag", "DT_BasePlayer", 0x4, vec3_t ); + NETVAR( m_hObserverTarget, "m_hObserverTarget", "DT_BasePlayer", 0, uint32_t ); + NETVAR( m_iObserverMode, "m_iObserverMode", "DT_BasePlayer", 0, int ); + NETVAR( m_flOldSimulationTime, "m_flSimulationTime", "DT_BaseEntity", 0x4, float ); + NETVAR( m_CoordinateFrame, "m_CollisionGroup", "DT_BaseEntity", -0x30, matrix3x4 ); + NETVAR( m_vecMins, "m_vecMins", "DT_BaseEntity", 0, vec3_t ); + NETVAR( m_vecMaxs, "m_vecMaxs", "DT_BaseEntity", 0, vec3_t ); + NETVAR( m_bIsScoped, "m_bIsScoped", "DT_CSPlayer", 0, bool ); + NETVAR( m_viewPunchAngle, "m_viewPunchAngle", "DT_BasePlayer", 0, vec3_t ); + NETVAR( m_flMaxFlashAlpha, "m_flFlashMaxAlpha", "DT_CSPlayer", 0, float ); + NETVAR( m_flFlashDuration, "m_flFlashDuration", "DT_CSPlayer", 0, float ); + NETVAR( m_flFlashTime, "m_flFlashMaxAlpha", "DT_CSPlayer", -0x10, float ); + NETVAR( m_bGunGameImmunity, "m_bGunGameImmunity", "DT_CSPlayer", 0, bool ); + NETVAR( m_hViewModel, "m_hViewModel[0]", "DT_BasePlayer", 0, uint32_t ); + NETVAR( m_bSpotted, "m_bSpotted", "DT_CSPlayer", 0, bool ); + NETVAR( m_pSurfaceData, "m_flLaggedMovementValue", "DT_CSPlayer", 0x18, surfacedata_t* ); + NETVAR( m_vecBaseVelocity, "m_vecBaseVelocity", "DT_CSPlayer", 0, vec3_t ); + NETVAR( m_vecAbsVelocity, "m_vecVelocity", "DT_CSPlayer", 0x12, vec3_t ); + NETVAR( m_flGravity, "m_iTeamNum", "DT_CSPlayer", -0x14, float ); + NETVAR( m_surfaceFriction, "m_vecLadderNormal", "DT_CSPlayer", -0x4, float ); + NETVAR( m_flDuckAmount, "m_flDuckAmount", "DT_CSPlayer", 0, float ); + NETVAR( m_flDuckSpeed, "m_flDuckSpeed", "DT_CSPlayer", 0, float ); + PNETVAR( m_hMyWearables, "m_hMyWearables", "DT_BaseCombatCharacter", 0, uint32_t ); + PNETVAR( m_hMyWeapons, "m_hMyWeapons", "DT_BaseCombatCharacter", 0, uint32_t ); + NETVAR( m_hGroundEntity, "m_hGroundEntity", "DT_CSPlayer", 0, uint32_t ); + + + OFFSET( m_CachedBoneData, 0x28FC + sizeof( void* ), CUtlVector< matrix3x4 > ); + OFFSET( m_flSpawnTime, 0xa290, float ); + OFFSET( m_IKContext, 0x265c, IKContext* ); +public: + static uintptr_t get_player_resource( ); + static uintptr_t get_game_rules( ); + static bool& s_bInvalidateBoneCache( ); + static int& g_iModelBoneCounter( ); + + /*makes it much more organized: functions from IClientEntity + dont interfere with our defined functions*/ + + __forceinline IClientEntity* ce( ) { + return reinterpret_cast< IClientEntity* >( this ); + } + + __forceinline operator IClientEntity*( ) { + return reinterpret_cast< IClientEntity* >( this ); + } + + template < typename t > + __forceinline t& get( std::ptrdiff_t offset ) { + return *reinterpret_cast< t* >( uintptr_t( this ) + offset ); + } + + __forceinline auto& get_animdata( ) { + return sm_animdata[ ce( )->GetIndex( ) ]; + } + + __forceinline bool is_alive( ) { + return m_iHealth( ) > 0 && m_lifeState( ) == LIFE_ALIVE; + } + + __forceinline void update_ik_locks( float curtime ) { + return util::get_vfunc< 186, void >( this, curtime ); + } + + __forceinline void calculate_ik_locks( float curtime ) { + return util::get_vfunc< 187, void >( this, curtime ); + } + + __forceinline void standard_blending_rules( void* hdr, vec3_t* pos, void* q, float curtime, int bone_mask ) { + return util::get_vfunc< 200, void >( this, hdr, pos, q, curtime, bone_mask ); + } + + __forceinline void build_transformations( void* hdr, vec3_t* pos, void* q, const matrix3x4& transform, int bone_mask, char* computed ) { + return util::get_vfunc< 184, void >( this, hdr, pos, q, transform, bone_mask, computed ); + } + + __forceinline bool has_valid_anim( ) { + if( m_bClientSideAnimation( ) ) + return true; + + return sm_animdata[ ce( )->GetIndex( ) ].m_valid; + } + + bool is_flashed( ); + bool is_reloading( ); + + int get_ping( ); + + __forceinline auto& m_aimPunchAngle( bool real = false ) { + static vec3_t backup_var{ }; + static auto offset = g_netvars.get_netvar( fnv( "DT_BasePlayer" ), fnv( "m_aimPunchAngle" ) ); + if( g_settings.misc.no_recoil( ) && !real ) { + backup_var = { 0.f, 0.f, 0.f }; + return backup_var; + } + + return get< vec3_t >( offset ); + } + + void set_local_view_angles( vec3_t *angle ); + bool run_physics_think( int n ); + void pre_think( ); + void think( ); + + __forceinline vec3_t get_anim_velocity( ) { + auto index = ce( )->GetIndex( ); + return sm_animdata[ index ].m_anim_velocity; + } + + __forceinline CCSGOPlayerAnimState* get_animstate( ) { + static std::ptrdiff_t offset = g_netvars.get_netvar( fnv( "DT_CSPlayer" ), + fnv( "m_bIsScoped" ) ); + + if( !offset ) { + return nullptr; + } + + return *reinterpret_cast< CCSGOPlayerAnimState** >( uintptr_t( this ) + offset - 0xa ); + } + + __forceinline void update_clientside_animation( ) { + bool backup = m_bClientSideAnimation( ); + m_bClientSideAnimation( ) = true; + util::get_vfunc< 218, void >( this ); + m_bClientSideAnimation( ) = backup; + } + + void invalidate_bone_cache( ); + + __forceinline vec3_t get_eye_pos( ) { + vec3_t yes; + //fuck references Lol + util::get_vfunc< void( __thiscall* )( void*, vec3_t& ) >( this, 277 )( this, yes ); + + //thanks senator!! !11 + return yes; + } + + __forceinline bool is_player( ) { + if( !this ) + return false; + + ClientClass* client_class = ce( )->GetClientClass( ); + return client_class && client_class->m_class_id == CCSPlayer; + } + + __forceinline bool is_valid( ) { + return !!this && is_player( ) && !ce( )->IsDormant( ) && is_alive( ); + } + + bool is_fakewalking( ); + player_info_t get_info( ); + void get_name_safe( char* buf ); + c_base_weapon* get_weapon( ); + vec3_t get_hitbox_pos( int hitbox ); + vec3_t get_hitbox_mins( int hitbox ); + vec3_t get_hitbox_maxs( int hitbox ); + bool is_visible( int hitbox ); + bool can_attack( bool ignore_rapid = false ); + int get_choked_ticks( ); + float get_hitbox_radius( int hitbox ); + + void set_abs_origin( vec3_t origin ); + void set_abs_angles( vec3_t angles ); + void set_abs_velocity( vec3_t velocity ); + void calc_abs_velocity( ); + + void set_needs_interpolate( bool interp ); + void do_ent_interpolation( bool reset ); + + void invalidate_physics_recursive( int flags ); + void create_animstate( CCSGOPlayerAnimState* state ); + void setup_bones_ex( matrix3x4* matrix_out, int bone_mask, float curtime ); + int get_seq_activity( int sequence ); + + void fix_animations( bool reset = false, bool resolver_change = false ); + void validate_animation_layers( ); + void compute_move_cycle( bool reset, bool moving ); + void calculate_duckamount( bool reset ); + void cache_anim_data( ); + void restore_anim_data( bool layers = false ); + void handle_taser_animation( ); + void calc_anim_velocity( bool reset ); + + bool is_breaking_lc( ); +};
\ No newline at end of file diff --git a/internal_rewrite/c_base_weapon.cpp b/internal_rewrite/c_base_weapon.cpp new file mode 100644 index 0000000..ec6d420 --- /dev/null +++ b/internal_rewrite/c_base_weapon.cpp @@ -0,0 +1,51 @@ +#include "c_base_weapon.hpp" + +char c_base_weapon::get_hud_icon( ) { + if( is_knife( ) ) return 'J'; + + switch( m_iItemDefinitionIndex( ) ) { + case WEAPON_DEAGLE: return 'F'; + case WEAPON_ELITE: return 'S'; + case WEAPON_FIVESEVEN: return 'U'; + case WEAPON_GLOCK: return 'C'; + case WEAPON_AK47: return 'B'; + case WEAPON_AUG: return 'E'; + case WEAPON_AWP: return 'R'; + case WEAPON_FAMAS: return 'T'; + case WEAPON_G3SG1: return 'I'; + case WEAPON_GALILAR: return 'V'; + case WEAPON_M249: return 'Z'; + case WEAPON_M4A1: + case WEAPON_M4A1_SILENCER: + return 'W'; + case WEAPON_MAC10: return 'L'; + case WEAPON_P90: return 'M'; + case WEAPON_UMP45: return 'Q'; + case WEAPON_XM1014: return ']'; + case WEAPON_BIZON: return 'D'; + case WEAPON_MAG7: return 'K'; + case WEAPON_NEGEV: return 'Z'; + case WEAPON_SAWEDOFF: return 'K'; + case WEAPON_TEC9: return 'C'; + case WEAPON_TASER: return 'Y'; + case WEAPON_HKP2000: return 'Y'; + case WEAPON_MP7: return 'X'; + case WEAPON_MP9: return 'D'; + case WEAPON_NOVA: return 'K'; + case WEAPON_P250: return 'Y'; + case WEAPON_SCAR20: return 'I'; + case WEAPON_SG556: return '['; + case WEAPON_SSG08: return 'N'; + case WEAPON_FLASHBANG: return 'G'; + case WEAPON_HEGRENADE: return 'H'; + case WEAPON_SMOKEGRENADE: return 'P'; + case WEAPON_MOLOTOV: return 'H'; + case WEAPON_DECOY: return 'G'; + case WEAPON_INCGRENADE: return 'H'; + case WEAPON_C4: return '\\'; + case WEAPON_USP_SILENCER: return 'Y'; + case WEAPON_CZ75A: return 'C'; + case WEAPON_R8REVOLVER: return 'F'; + default: return 'J'; + } +}
\ No newline at end of file diff --git a/internal_rewrite/c_base_weapon.hpp b/internal_rewrite/c_base_weapon.hpp new file mode 100644 index 0000000..f56770e --- /dev/null +++ b/internal_rewrite/c_base_weapon.hpp @@ -0,0 +1,324 @@ +#pragma once
+#include "util.hpp"
+#include "IClientEntityList.hpp"
+#include "netvars.hpp"
+
+enum ItemDefinitionIndex_t {
+ WEAPON_NONE,
+ WEAPON_DEAGLE = 1,
+ WEAPON_ELITE = 2,
+ WEAPON_FIVESEVEN = 3,
+ WEAPON_GLOCK = 4,
+ WEAPON_AK47 = 7,
+ WEAPON_AUG = 8,
+ WEAPON_AWP = 9,
+ WEAPON_FAMAS = 10,
+ WEAPON_G3SG1 = 11,
+ WEAPON_GALILAR = 13,
+ WEAPON_M249 = 14,
+ WEAPON_M4A1 = 16,
+ WEAPON_MAC10 = 17,
+ WEAPON_P90 = 19,
+ WEAPON_UMP45 = 24,
+ WEAPON_XM1014 = 25,
+ WEAPON_BIZON = 26,
+ WEAPON_MAG7 = 27,
+ WEAPON_NEGEV = 28,
+ WEAPON_SAWEDOFF = 29,
+ WEAPON_TEC9 = 30,
+ WEAPON_TASER = 31,
+ WEAPON_HKP2000 = 32,
+ WEAPON_MP7 = 33,
+ WEAPON_MP9 = 34,
+ WEAPON_NOVA = 35,
+ WEAPON_P250 = 36,
+ WEAPON_SCAR20 = 38,
+ WEAPON_SG556 = 39,
+ WEAPON_SSG08 = 40,
+ WEAPON_KNIFEGG = 41,
+ WEAPON_KNIFE = 42,
+ WEAPON_FLASHBANG = 43,
+ WEAPON_HEGRENADE = 44,
+ WEAPON_SMOKEGRENADE = 45,
+ WEAPON_MOLOTOV = 46,
+ WEAPON_DECOY = 47,
+ WEAPON_INCGRENADE = 48,
+ WEAPON_C4 = 49,
+ WEAPON_KNIFE_T = 59,
+ WEAPON_M4A1_SILENCER = 60,
+ WEAPON_USP_SILENCER = 61,
+ WEAPON_CZ75A = 63,
+ WEAPON_R8REVOLVER = 64,
+ WEAPON_KNIFE_BAYONET = 500,
+ WEAPON_KNIFE_FLIP = 505,
+ WEAPON_KNIFE_GUT = 506,
+ WEAPON_KNIFE_KARAMBIT = 507,
+ WEAPON_KNIFE_M9_BAYONET = 508,
+ WEAPON_KNIFE_TACTICAL = 509,
+ WEAPON_KNIFE_FALCHION = 512,
+ WEAPON_KNIFE_BOWIE = 514,
+ WEAPON_KNIFE_BUTTERFLY = 515,
+ WEAPON_KNIFE_PUSH = 516,
+ GLOVE_STUDDED_BLOODHOUND = 5027,
+ GLOVE_T_SIDE = 5028,
+ GLOVE_CT_SIDE = 5029,
+ GLOVE_SPORTY = 5030,
+ GLOVE_SLICK = 5031,
+ GLOVE_LEATHER_WRAP = 5032,
+ GLOVE_MOTORCYCLE = 5033,
+ GLOVE_SPECIALIST = 5034,
+ GLOVE_HYDRA = 5035,
+};
+
+class weapon_info_t {
+public:
+ char pad_0000[ 4 ]; //0x0000
+ char* weapon_name; //0x0004
+ char pad_0008[ 12 ]; //0x0008
+ int max_clip_ammo; //0x0014
+ char pad_0018[ 12 ]; //0x0018
+ int max_ammo; //0x0024
+ char pad_0028[ 4 ]; //0x0028
+ char* world_model; //0x002C
+ char* view_model; //0x0030
+ char* dropped_model; //0x0034
+ char pad_0038[ 4 ]; //0x0038
+ char* N00000010; //0x003C
+ char pad_0040[ 56 ]; //0x0040
+ char* empty_sound; //0x0078
+ char pad_007C[ 4 ]; //0x007C
+ char* ammo_type; //0x0080
+ char pad_0084[ 4 ]; //0x0084
+ char* hud_name; //0x0088
+ char* weapon_name2; //0x008C
+ char pad_0090[ 60 ]; //0x0090
+ int type;
+ int price; //0x00CC
+ int kill_reward; //0x00D0
+ char* anim_prefix;
+ float cycle_time;
+ float cycle_time_alt;
+ float time_to_idle;
+ float idle_interval;
+
+ bool full_auto; //0x00E8
+ char pad_00E9[ 3 ]; //0x00E9
+ int damage; //0x00EC
+ float armor_ratio; //0x00F0
+ char pad_00F4[ 4 ]; //0x00F4
+ float penetration; //0x00F8
+ char pad_00FC[ 8 ]; //0x00FC
+ float range; //0x0104
+ float range_modifier; //0x0108
+ float throw_velocity;
+ char pad_010C[ 12 ]; //0x010C
+ bool has_silencer; //0x011C
+ char pad_011D[ 15 ]; //0x011D
+ float max_speed; //0x012C
+ float max_speed_alt; //0x0130
+ float spread; //0x0134
+ float spread_alt; //0x0138
+ float inaccuracy_crouch; //0x013C
+ float inaccuracy_crouch_alt; //0x0140
+ float inaccuracy_stand; //0x0144
+ float inaccuracy_stand_alt; //0x0148
+ float inaccuracy_jump_start; //0x014C
+ float inaccuracy_jump; //0x0150
+ float inaccuracy_jump_alt; //0x0154
+ float inaccuracy_land; //0x0158
+ float inaccuracy_land_alt; //0x015C
+ float inaccuracy_ladder; //0x0160
+ float inaccuracy_ladder_alt; //0x0164
+ float inaccuracy_fire; //0x0168
+ float inaccuracy_fire_alt; //0x016C
+ float inaccuracy_move; //0x0170
+ float inaccuracy_move_alt; //0x0174
+ float inaccuracy_reload; //0x0178
+ int recoil_seed; //0x017C
+ char pad_0180[ 60 ]; //0x0180
+ int zoom_levels; //0x01BC
+ int zoom_fov1; //0x01C0
+ int zoom_fov2; //0x01C4
+};
+
+enum quality_t {
+ Default,
+ Geniune,
+ Vintage,
+ Unusual,
+ Community = 5,
+ Developer,
+ Self_Made,
+ Customized,
+ Strange,
+ Completed,
+ Tournament = 12,
+};
+
+class c_base_weapon {
+public:
+ NETVAR( m_iItemDefinitionIndex, "m_iItemDefinitionIndex", "DT_BaseAttributableItem", 0, short );
+ NETVAR( m_iClip1, "m_iClip1", "DT_BaseCombatWeapon", 0, int );
+ NETVAR( m_flNextPrimaryAttack, "m_flNextPrimaryAttack", "DT_BaseCombatWeapon", 0, float );
+ NETVAR( m_flNextSecondaryAttack, "m_flNextPrimaryAttack", "DT_BaseCombatWeapon", 4, float );
+ NETVAR( m_flPostponeFireReadyTime, "m_flPostponeFireReadyTime", "DT_WeaponCSBase", 0, float );
+ NETVAR( m_fThrowTime, "m_fThrowTime", "DT_BaseCSGrenade", 0, float );
+ NETVAR( m_hOwner, "m_hOwner", "DT_BaseCombatWeapon", 0, uint32_t );
+ NETVAR( m_bPinPulled, "m_bPinPulled", "DT_BaseCSGrenade", 0, bool );
+ NETVAR( m_flThrowStrength, "m_flThrowStrength", "DT_BaseCSGrenade", 0, float );
+ NETVAR( m_nModelIndex, "m_nModelIndex", "DT_BaseEntity", 0, int );
+
+ NETVAR( m_iViewModelIndex, "m_iViewModelIndex", "DT_BaseCombatWeapon", 0, int );
+ NETVAR( m_iWorldModelIndex, "m_iWorldModelIndex", "DT_BaseCombatWeapon", 0, int );
+ NETVAR( m_iWorldDroppedModelIndex, "m_iWorldDroppedModelIndex", "DT_BaseCombatWeapon", 0, int );
+ NETVAR( m_hWeaponWorldModel, "m_hWeaponWorldModel", "DT_BaseCombatWeapon", 0, uint32_t );
+
+ NETVAR( m_iEntityQuality, "m_iEntityQuality", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_iItemIDHigh, "m_iItemIDHigh", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_iItemIDLow, "m_iItemIDLow", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_iAccountID, "m_iAccountID", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_szCustomName, "m_szCustomName", "DT_BaseAttributableItem", 0, char* );
+ NETVAR( m_OriginalOwnerXuidLow, "m_OriginalOwnerXuidLow", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_OriginalOwnerXuidHigh, "m_OriginalOwnerXuidHigh", "DT_BaseAttributableItem", 0, int );
+
+ NETVAR( m_nFallbackPaintKit, "m_nFallbackPaintKit", "DT_BaseAttributableItem" ,0, int );
+ NETVAR( m_nFallbackSeed, "m_nFallbackSeed", "DT_BaseAttributableItem", 0, int );
+ NETVAR( m_flFallbackWear, "m_flFallbackWear", "DT_BaseAttributableItem", 0, float );
+ NETVAR( m_nFallbackStatTrak, "m_nFallbackStatTrak", "DT_BaseAttributableItem", 0, int );
+
+ NETVAR( m_hOwnerEntity, "m_hOwnerEntity", "DT_BaseAttributableItem", 0, uint32_t );
+ NETVAR( m_flC4Blow, "m_flC4Blow", "DT_PlantedC4", 0, float );
+ NETVAR( m_bBombTicking, "m_bBombTicking", "DT_PlantedC4", 0, bool );
+ NETVAR( m_hBombDefuser, "m_hBombDefuser", "DT_PlantedC4", 0, uint32_t );
+ NETVAR( m_bBombDefused, "m_bBombDefused", "DT_PlantedC4", 0, bool );
+ NETVAR( m_flTimerLength, "m_flTimerLength", "DT_PlantedC4", 0, float );
+ NETVAR( m_flDefuseLength, "m_flDefuseLength", "DT_PlantedC4", 0, float );
+ NETVAR( m_flDefuseCountDown, "m_flDefuseCountDown", "DT_PlantedC4", 0, float );
+ NETVAR( m_fLastShotTime, "m_fLastShotTime", "DT_WeaponCSBaseGun", 0, float );
+
+ __forceinline IClientEntity* ce( ) {
+ return reinterpret_cast< IClientEntity* >( this );
+ }
+
+ __forceinline operator IClientEntity*( ) {
+ return reinterpret_cast< IClientEntity* >( this );
+ }
+
+ template < typename t >
+ __forceinline t& get( std::ptrdiff_t offset ) {
+ return *reinterpret_cast< t* >( uintptr_t( this ) + offset );
+ }
+
+ __forceinline weapon_info_t* get_wpn_info( ) {
+ return util::get_vfunc< 444, weapon_info_t* >( this );
+ }
+
+ __forceinline void update_accuracy_penalty( ) {
+ return util::get_vfunc< 468, void >( this );
+ }
+
+ __forceinline float get_spread( ) {
+ return util::get_vfunc< 436, float >( this );
+ }
+
+ __forceinline float get_inaccuracy( ) {
+ return util::get_vfunc< 467, float >( this );
+ }
+
+ __forceinline void set_glove_model( int model_index ) {
+ return util::get_vfunc< 75, void >( this, model_index );
+ }
+
+ bool is_pistol( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_DEAGLE:
+ case WEAPON_ELITE:
+ case WEAPON_FIVESEVEN:
+ case WEAPON_GLOCK:
+ case WEAPON_HKP2000:
+ case WEAPON_P250:
+ case WEAPON_TEC9:
+ case WEAPON_USP_SILENCER:
+ case WEAPON_R8REVOLVER:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ bool is_sniper( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_AWP:
+ case WEAPON_G3SG1:
+ case WEAPON_SCAR20:
+ case WEAPON_SSG08:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ bool is_knife( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_KNIFE:
+ case WEAPON_KNIFE_T:
+ case WEAPON_KNIFEGG:
+ case WEAPON_KNIFE_BAYONET:
+ case WEAPON_KNIFE_BUTTERFLY:
+ case WEAPON_KNIFE_FALCHION:
+ case WEAPON_KNIFE_FLIP:
+ case WEAPON_KNIFE_GUT:
+ case WEAPON_KNIFE_KARAMBIT:
+ case WEAPON_KNIFE_M9_BAYONET:
+ case WEAPON_KNIFE_PUSH:
+ case WEAPON_KNIFE_TACTICAL:
+ case WEAPON_KNIFE_BOWIE:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ bool is_grenade( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_FLASHBANG:
+ case WEAPON_HEGRENADE:
+ case WEAPON_SMOKEGRENADE:
+ case WEAPON_MOLOTOV:
+ case WEAPON_INCGRENADE:
+ case WEAPON_DECOY:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ bool is_shotgun( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_NOVA:
+ case WEAPON_SAWEDOFF:
+ case WEAPON_XM1014:
+ case WEAPON_MAG7:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ bool is_rifle( ) {
+ switch( m_iItemDefinitionIndex( ) ) {
+ case WEAPON_AK47:
+ case WEAPON_AUG:
+ case WEAPON_FAMAS:
+ case WEAPON_GALILAR:
+ case WEAPON_SG556:
+ case WEAPON_M4A1:
+ case WEAPON_M4A1_SILENCER:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ char get_hud_icon( );
+};
\ No newline at end of file diff --git a/internal_rewrite/chams.cpp b/internal_rewrite/chams.cpp new file mode 100644 index 0000000..c50e40e --- /dev/null +++ b/internal_rewrite/chams.cpp @@ -0,0 +1,319 @@ +#include "chams.hpp"
+#include "interface.hpp"
+#include "d3d.hpp"
+#include "context.hpp"
+#include "hooks.hpp"
+
+static auto chams_mat = xors_raw( (
+ R"("VertexLitGeneric"
+{
+ "$basetexture" "vgui/white_additive"
+ "$ignorez" "1"
+ "$nofog" "1"
+ "$model" "1"
+ "$nocull" "0"
+ "$selfillum" "1"
+ "$halflambert" "1"
+ "$znearer" "0"
+ "$flat" "1"
+ "$envmap" "env_cubemap"
+ "$envmaptint" "[.3 .3 .3]"
+ "$envmapcontrast" ".4"
+ "$envmapsaturation" "1.0"
+ "$phongexponent" "255.0"
+ "$normalmapalphaenvmask" "1"
+ "$phongboost" "6.0"
+ "$phongfresnelranges" "[0 0.5 1]"
+ "$BasemapAlphaPhongMask" "1"
+})"
+) );
+
+static auto chams_mat_shine = xors_raw( (
+ R"("VertexLitGeneric"
+{
+ "$basetexture" "vgui/white"
+ "$envmap" "env_cubemap"
+ "$envmaptint" "[.3 .3 .3]"
+ "$reflectivity" "[1.0 1.0 1.0]"
+ "$envmapcontrast" ".4"
+ "$envmapsaturation" "1.0"
+ "$model" "1"
+ "$flat" "0"
+ "$nocull" "1"
+ "$selfillum" "1"
+ "$halflambert" "1"
+ "$nofog" "1"
+ "$ignorez" "0"
+ "$znearer" "0"
+ "$wireframe" "0"
+})"
+) );
+
+static auto chams_mat_flat = xors_raw( (
+ R"("UnlitGeneric"
+{
+ "$basetexture" "vgui/white"
+ "$model" "1"
+ "$flat" "1"
+ "$nocull" "1"
+ "$selfillum" "1"
+ "$halflambert" "1"
+ "$nofog" "1"
+ "$ignorez" "0"
+ "$znearer" "0"
+ "$wireframe" "0"
+})"
+) );
+
+namespace features
+{
+ void c_materials::make_cham_buffer( char* buf, int len, int type ) {
+ switch ( type ) {
+ case 1:
+ sprintf_s( buf, len - 1, chams_mat_flat.decrypt( ) );
+ break;
+ case 2:
+ sprintf_s( buf, len - 1, chams_mat_shine.decrypt( ) );
+ break;
+ default:
+ sprintf_s( buf, len - 1, chams_mat.decrypt( ) );
+ }
+ }
+
+ void c_material::init( const char* name, const char* buf ) {
+ m_keyvalues = new KeyValues( name );
+ m_keyvalues->LoadFromBuffer( name, buf );
+
+ // CreateMaterial already increments ref counter
+ m_mat = g_csgo.m_mat_system( )->CreateMaterial( name, m_keyvalues );
+ }
+
+ void c_material::destroy( ) {
+ if( m_mat ) {
+ m_mat->DecrementReferenceCount( );
+ m_mat = nullptr;
+ }
+
+ if( m_keyvalues ) {
+ delete m_keyvalues;
+ m_keyvalues = nullptr;
+ }
+ }
+
+ void c_materials::force_material( IMaterial* mat, fclr_t clr ) {
+ if( !mat ) return;
+
+ float col[ ] = { clr.r( ), clr.g( ), clr.b( ) };
+ g_csgo.m_render_view( )->SetBlend( clr.a( ) );
+ g_csgo.m_render_view( )->SetColorModulation( col );
+
+ g_csgo.m_model_render( )->ForcedMaterialOverride( mat );
+ }
+
+ void c_materials::initialize_materials( ) {
+ char buffer[ 1024 ];
+
+ make_cham_buffer( buffer, sizeof( buffer ), 0 );
+ m_chams.init( xors( "chamsmat" ), buffer );
+ memset( buffer, 0, 1024 );
+
+ make_cham_buffer( buffer, sizeof( buffer ), 1 );
+ m_chams_flat.init( xors( "chamsmat_flat" ), buffer );
+ memset( buffer, 0, 1024 );
+ m_initialized = true;
+ }
+
+ void c_materials::destroy_materials( ) {
+ m_initialized = false;
+
+ m_chams.destroy( );
+ m_chams_flat.destroy( );
+ }
+
+ void c_materials::update_materials( ) {
+ if( !m_initialized ) return;
+ if( m_chams.m_mat->m_ref_count <= 0 ) return;
+
+ static float last_reflectivity{ };
+ static float last_shine{ };
+ static KeyValues* reflectivity;
+ static KeyValues* shine;
+
+ if( !reflectivity ) {
+ for( auto it = m_chams.m_keyvalues->m_pSub; !!it; it = it->m_pPeer ) {
+ if( it->m_iDataType != 1 ) continue;
+ if( strstr( it->m_sValue, xors( "[.3 .3 .3]" ) ) ) {
+ reflectivity = it;
+ }
+ }
+ }
+
+ if( !shine ) {
+ for( auto it = m_chams.m_keyvalues->m_pSub; !!it; it = it->m_pPeer ) {
+ if( it->m_flValue == 6.0f )
+ shine = it;
+ }
+ }
+
+ if( reflectivity ) {
+ if( last_reflectivity != g_settings.visuals.chams.reflectivity( ) ) {
+ char buf[ 32 ];
+ sprintf_s< 32 >( buf, xors( "[%1.1f %1.1f %1.1f]" ),
+ g_settings.visuals.chams.reflectivity( ),
+ g_settings.visuals.chams.reflectivity( ),
+ g_settings.visuals.chams.reflectivity( ) );
+
+ strcpy( reflectivity->m_sValue, buf );
+ m_chams.m_mat->Refresh( );
+ }
+ last_reflectivity = g_settings.visuals.chams.reflectivity( );
+ }
+
+ if( shine ) {
+ if( last_shine != g_settings.visuals.chams.shine( ) ) {
+ shine->m_flValue = g_settings.visuals.chams.shine( ) * 100.f;
+ m_chams.m_mat->Refresh( );
+ }
+ last_shine = g_settings.visuals.chams.shine( );
+ }
+ }
+
+ void c_chams::d3d_render_chams( c_base_player* ent, int type, int v_index, uint32_t min_index, uint32_t num_vert, uint32_t start_index, uint32_t prim_count ) {
+ static auto d3d_draw = g_csgo.m_d3d->get_old_function< decltype( &hooks::d3d::draw ) >( 82 );
+
+ int team = ent->m_iTeamNum( );
+ clr_t visible_col = team == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.chams.color_visible_friendly( ) : g_settings.visuals.chams.color_visible_enemy( );
+ clr_t hidden_col = team == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.chams.color_hidden_friendly( ) : g_settings.visuals.chams.color_hidden_enemy( );
+
+ if( team == g_ctx.m_local->m_iTeamNum( ) && !g_settings.visuals.chams.friendlies )
+ return;
+
+ fclr_t fcol_vis = visible_col.to_fclr( );
+ float value_vis[ 4 ] = { fcol_vis.r( ), fcol_vis.g( ), fcol_vis.b( ), fcol_vis.a( ) };
+
+ fclr_t fcol_hid = hidden_col.to_fclr( );
+ float value_hid[ 4 ] = { fcol_hid.r( ), fcol_hid.g( ), fcol_hid.b( ), fcol_hid.a( ) };
+
+ float def[ 4 ] = { 1.f, 1.f, 1.f, 1.f };
+
+ IDirect3DBaseTexture9* prev_texture;
+ IDirect3DSurface9* prev_surface;
+ ulong_t z_enable;
+
+ g_d3d.get_device( )->GetTexture( 0, &prev_texture );
+ g_d3d.get_device( )->GetRenderTarget( 0, &prev_surface );
+ g_d3d.get_device( )->GetRenderState( D3DRS_ZENABLE, &z_enable );
+
+ auto hr = g_d3d.get_device( )->SetRenderTarget( 0, g_d3d.m_surface );
+
+ //printf( "hr: %08x\n", hr );
+
+ if( g_settings.visuals.chams.ignore_z ) {
+ g_d3d.get_device( )->SetRenderState( D3DRS_ZENABLE, false );
+ g_d3d.get_device( )->SetPixelShaderConstantF( 0, value_hid, 1 );
+ g_d3d.get_device( )->SetPixelShaderConstantF( 1, value_hid, 1 );
+ //g_d3d.get_device( )->SetTexture( 0, nullptr );
+ d3d_draw( g_d3d.get_device( ), ( D3DPRIMITIVETYPE )type, v_index, min_index, num_vert, start_index, prim_count );
+ }
+
+ g_d3d.get_device( )->SetRenderState( D3DRS_ZENABLE, z_enable );
+ g_d3d.get_device( )->SetPixelShaderConstantF( 0, value_hid, 1 );
+ g_d3d.get_device( )->SetPixelShaderConstantF( 1, value_vis, 1 );
+ //g_d3d.get_device( )->SetTexture( 0, nullptr );
+
+ d3d_draw( g_d3d.get_device( ), ( D3DPRIMITIVETYPE )type, v_index, min_index, num_vert, start_index, prim_count );
+
+ g_d3d.get_device( )->SetPixelShaderConstantF( 0, def, 1 );
+ g_d3d.get_device( )->SetPixelShaderConstantF( 1, def, 1 );
+ g_d3d.get_device( )->SetRenderTarget( 0, prev_surface );
+ g_d3d.get_device( )->SetRenderState( D3DRS_ZENABLE, z_enable );
+
+ g_d3d.get_device( )->SetTexture( 0, prev_texture );
+
+ if( prev_texture )
+ prev_texture->Release( );
+
+ if( prev_surface )
+ prev_surface->Release( );
+ }
+
+ void c_chams::d3d_render_textures( ) {
+ if( !g_d3d.m_sil_txt )
+ return;
+
+ IDirect3DSurface9* backbuffer;
+ D3DSURFACE_DESC desc;
+
+ g_d3d.get_device( )->GetRenderTarget( 0, &backbuffer );
+ backbuffer->GetDesc( &desc );
+ //backbuffer->Release( );
+
+ struct tex_vertex {
+ float x, y, z, r, h, w;
+ };
+
+ tex_vertex v[ ] = {
+ { 0.f, 0.f, 0.f, 1.0f, 0.f, 0.f },
+ { ( float )desc.Width, 0.f, 0.f, 1.0f, 1.0f, 0.f },
+ { 0.f, ( float )desc.Height, 0.f, 1.0f, 0.0f, 1.0f },
+ { ( float )desc.Width, ( float )desc.Height, 0.f, 1.0f, 1.0f, 1.0f }
+ };
+
+ void* p;
+
+ g_d3d.m_buffer->Lock( 0, 0, &p, 0 );
+ memcpy( p, v, sizeof( v ) );
+ g_d3d.m_buffer->Unlock( );
+
+ void* pixel_shader;
+ void* texture;
+ void* stream_src;
+ uint32_t stride;
+ uint32_t offset;
+ ulong_t fvf;
+ ulong_t dest_blend;
+ ulong_t alpha_blend;
+
+ g_d3d.get_device( )->GetPixelShader( ( IDirect3DPixelShader9** )&pixel_shader );
+ g_d3d.get_device( )->GetTexture( 0, ( IDirect3DBaseTexture9** )&texture );
+ g_d3d.get_device( )->GetStreamSource( 0, ( IDirect3DVertexBuffer9** )&stream_src, &offset, &stride );
+ g_d3d.get_device( )->GetFVF( &fvf );
+ g_d3d.get_device( )->GetRenderState( D3DRS_DESTBLEND, &dest_blend );
+ g_d3d.get_device( )->GetRenderState( D3DRS_ALPHABLENDENABLE, &alpha_blend );
+
+ g_d3d.get_device( )->SetRenderTarget( 0, g_d3d.m_surface );
+ g_d3d.get_device( )->SetFVF( D3DFVF_XYZRHW | D3DFVF_TEX1 );
+ g_d3d.get_device( )->SetPixelShader( nullptr );
+ g_d3d.get_device( )->SetTexture( 0, g_d3d.m_sil_txt );
+ g_d3d.get_device( )->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
+ g_d3d.get_device( )->SetRenderState( D3DRS_ALPHABLENDENABLE, true );
+
+ g_d3d.get_device( )->SetStreamSource( 0, g_d3d.m_buffer, 0, sizeof( tex_vertex ) );
+ g_d3d.get_device( )->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
+
+ //D3DXSaveSurfaceToFileA( "backbuffer_1.bmp", D3DXIFF_BMP, backbuffer, 0, 0 );
+ //D3DXSaveSurfaceToFileA( "backbuffer_2.bmp", D3DXIFF_BMP, g_d3d.m_surface, 0, 0 );
+
+
+ D3DRECT bar_rect{ };
+ D3DCOLOR col{ };
+
+ bar_rect.x1 = 0;
+ bar_rect.y1 = 0;
+ bar_rect.x2 = desc.Width;
+ bar_rect.y2 = desc.Height;
+
+ g_d3d.get_device( )->SetPixelShader( ( IDirect3DPixelShader9* )pixel_shader );
+ g_d3d.get_device( )->SetTexture( 0, ( IDirect3DTexture9* )texture );
+ g_d3d.get_device( )->SetRenderState( D3DRS_DESTBLEND, dest_blend );
+ g_d3d.get_device( )->SetRenderState( D3DRS_ALPHABLENDENABLE, alpha_blend );
+ g_d3d.get_device( )->SetStreamSource( 0, ( IDirect3DVertexBuffer9* )stream_src, offset, stride );
+ g_d3d.get_device( )->SetFVF( fvf );
+
+ //g_d3d.get_device( )->Clear( 1, &bar_rect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, col, 0, 0 );
+ g_d3d.get_device( )->SetRenderTarget( 0, backbuffer );
+ backbuffer->Release( );
+
+
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/chams.hpp b/internal_rewrite/chams.hpp new file mode 100644 index 0000000..d7eb023 --- /dev/null +++ b/internal_rewrite/chams.hpp @@ -0,0 +1,49 @@ +#pragma once + +#include "sdk.hpp" + +namespace features +{ + enum ChamBufferType_t { + TYPE_NORMAL, + TYPE_FLAT, + TYPE_SHINE + }; + + class c_material { + public: + c_material( ) = default; + + void init( const char* mat, const char* buf ); + void destroy( ); + + operator IMaterial*( ) { + return m_mat; + } + + public: + IMaterial* m_mat; + KeyValues* m_keyvalues; + }; + + class c_materials { + public: + c_material m_chams{ }; + c_material m_chams_flat{ }; + + void make_cham_buffer( char* buf, int len, int type ); //type, 0 = normal, 1 = flat, 2 = shine + public: + void initialize_materials( ); + void destroy_materials( ); + void force_material( IMaterial* material, fclr_t color ); + void update_materials( ); + bool m_initialized{ }; + }; + + class c_chams { + public: + c_materials m_materials; + void d3d_render_textures( ); + void d3d_render_chams( c_base_player* ent, int type, int v_index, uint32_t min_index, uint32_t num_vert, uint32_t start_index, uint32_t prim_count ); + }; +}
\ No newline at end of file diff --git a/internal_rewrite/color.hpp b/internal_rewrite/color.hpp new file mode 100644 index 0000000..49112dd --- /dev/null +++ b/internal_rewrite/color.hpp @@ -0,0 +1,278 @@ +#pragma once +#include <cmath> +#include <cinttypes> + +//this is a fucking mess + +class fclr_t { + float R, G, B, A; +public: + fclr_t( ) : R( 0 ), G( 0 ), B( 0 ), A( 0 ) { } + + fclr_t( float r, float g, float b, float a ) : R( r ), G( g ), B( b ), A( a ) { } + + fclr_t( float r, float g, float b ) : R( r ), G( g ), B( b ), A( 255 ) { } + + float& r( ) { return R; } + float& g( ) { return G; } + float& b( ) { return B; } + float& a( ) { return A; } + + fclr_t& operator =( fclr_t& c ) { + R = c.r( ); + G = c.g( ); + B = c.b( ); + A = c.a( ); + return *this; + } + + fclr_t operator+( const fclr_t& v ) const { + return fclr_t( R + v.R, G + v.G, B + v.B, A + v.A ); + } + + explicit operator bool( ) const noexcept { + return ( R > 0 || G > 0 || B > 0 || A > 0 ); + } + + bool operator==( fclr_t& c ) const { + return ( R == c.r( ) && G == c.g( ) && B == c.b( ) ); + } +}; + +class clr_t { + uint8_t R, G, B, A; +public: + clr_t( ) : R( 0 ), G( 0 ), B( 0 ), A( 0 ) { } + + clr_t( uint8_t r, uint8_t g, uint8_t b, uint8_t a ) : R( r ), G( g ), B( b ), A( a ) { } + + clr_t( uint8_t r, uint8_t g, uint8_t b ) : R( r ), G( g ), B( b ), A( 255 ) { } + + uint8_t& r( ) { return R; } + uint8_t& g( ) { return G; } + uint8_t& b( ) { return B; } + uint8_t& a( ) { return A; } + + clr_t& operator =( clr_t& c ) { + R = c.r( ); + G = c.g( ); + B = c.b( ); + A = c.a( ); + return *this; + } + + clr_t operator+( const clr_t& v ) const { + return clr_t( R + v.R, G + v.G, B + v.B, A + v.A ); + } + + clr_t operator*( float f ) { + return clr_t( uint8_t( R * f ), uint8_t( G * f ), uint8_t( B * f ), A ); + } + + explicit operator bool( ) const noexcept { + return ( R > 0 || G > 0 || B > 0 || A > 0 ); + } + + float brightness( ) { + typedef struct { + float h, s, v; + } hsv; + hsv out; + + float min = static_cast<float>( R < G ? R : G ); + min = static_cast<float>( min < B ? min : B ); + + float max = static_cast<float>( R > G ? R : G ); + max = static_cast<float>( max > B ? max : B ); + + out.v = max; + float delta = max - min; + if ( delta < 0.0010f ) { + out.s = 0.f; + out.h = 0.f; + return out.h; + } + if ( max > 0.0f ) { + out.s = delta / max; + } + else { + out.s = 0.0f; + out.h = NAN; + return out.h; + } + if ( R >= max ) + out.h = static_cast<float>( G - B ) / delta; + else if ( G >= max ) + out.h = 2.0f + static_cast<float>( B - R ) / delta; + else + out.h = 4.0f + static_cast<float>( R - G ) / delta; + + out.h *= 60.0f; + out.h /= 360.f; + + if ( out.h < 0.0f ) + out.h += 360.0f; + + return out.v; + } + + float saturation( ) { + typedef struct { + float h, s, v; + } hsv; + hsv out; + + float min = static_cast<float>( R < G ? R : G ); + min = static_cast<float>( min < B ? min : B ); + + float max = static_cast<float>( R > G ? R : G ); + max = static_cast<float>( max > B ? max : B ); + + out.v = max; + float delta = max - min; + if ( delta < 0.0010f ) { + out.s = 0.f; + out.h = 0.f; + return out.h; + } + if ( max > 0.0f ) { + out.s = delta / max; + } + else { + out.s = 0.0f; + out.h = NAN; + return out.h; + } + if ( R >= max ) + out.h = static_cast<float>( G - B ) / delta; + else if ( G >= max ) + out.h = 2.0f + static_cast<float>( B - R ) / delta; + else + out.h = 4.0f + static_cast<float>( R - G ) / delta; + + out.h *= 60.0f; + out.h /= 360.f; + + if ( out.h < 0.0f ) + out.h += 360.0f; + + return out.s; + } + + static clr_t from_hsb( float hue, float saturation, float brightness ) { + float h = hue == 1.0f ? 0 : hue * 6.0f; + float f = h - ( int )h; + float p = brightness * ( 1.0f - saturation ); + float q = brightness * ( 1.0f - saturation * f ); + float t = brightness * ( 1.0f - ( saturation * ( 1.0f - f ) ) ); + + if ( h < 1 ) { + return clr_t( + ( unsigned char )( brightness * 255 ), + ( unsigned char )( t * 255 ), + ( unsigned char )( p * 255 ) + ); + } + else if ( h < 2 ) { + return clr_t( + ( unsigned char )( q * 255 ), + ( unsigned char )( brightness * 255 ), + ( unsigned char )( p * 255 ) + ); + } + else if ( h < 3 ) { + return clr_t( + ( unsigned char )( p * 255 ), + ( unsigned char )( brightness * 255 ), + ( unsigned char )( t * 255 ) + ); + } + else if ( h < 4 ) { + return clr_t( + ( unsigned char )( p * 255 ), + ( unsigned char )( q * 255 ), + ( unsigned char )( brightness * 255 ) + ); + } + else if ( h < 5 ) { + return clr_t( + ( unsigned char )( t * 255 ), + ( unsigned char )( p * 255 ), + ( unsigned char )( brightness * 255 ) + ); + } + else { + return clr_t( + ( unsigned char )( brightness * 255 ), + ( unsigned char )( p * 255 ), + ( unsigned char )( q * 255 ) + ); + } + } + + static clr_t blend( clr_t first, clr_t second, float t ) { + return clr_t( + first.r( ) + static_cast< int >( t * ( second.r( ) - first.r( ) ) ), + first.g( ) + static_cast< int >( t * ( second.g( ) - first.g( ) ) ), + first.b( ) + static_cast< int >( t * ( second.b( ) - first.b( ) ) ), + first.a( ) + static_cast< int >( t * ( second.a( ) - first.a( ) ) ) + ); + } + + float hue( ) { + typedef struct { + float h, s, v; + } hsv; + hsv out; + float min, max, delta; + + min = static_cast< float >( R < G ? R : G ); + min = static_cast< float >( min < B ? min : B ); + + max = static_cast< float >( R > G ? R : G ); + max = static_cast< float >( max > B ? max : B ); + + out.v = max; + delta = max - min; + if ( delta < 0.0010f ) { + out.s = 0.f; + out.h = 0.f; + return out.h; + } + if ( max > 0.0f ) { + out.s = ( delta / max ); + } + else { + out.s = 0.0f; + out.h = ( float )NAN; + return out.h; + } + if ( R >= max ) + out.h = static_cast< float >( G - B ) / delta; + else + if ( G >= max ) + out.h = 2.0f + static_cast< float >( B - R ) / delta; + else + out.h = 4.0f + static_cast< float >( R - G ) / delta; + + out.h *= 60.0f; + out.h /= 360.f; + + if ( out.h < 0.0f ) + out.h += 360.0f; + + return out.h; + } + + fclr_t to_fclr( ) { + return fclr_t{ R / 255.f, G / 255.f, B / 255.f, A / 255.f }; + } + + operator fclr_t( ) { + return this->to_fclr( ); + } + + bool operator==( clr_t& c ) const { + return ( R == c.r( ) && G == c.g( ) && B == c.b( ) ); + } +};
\ No newline at end of file diff --git a/internal_rewrite/con_alias.hpp b/internal_rewrite/con_alias.hpp new file mode 100644 index 0000000..62812f1 --- /dev/null +++ b/internal_rewrite/con_alias.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include <string> +#include "simple_settings.hpp" + +template< typename var_type = bool > +class con_alias : public ISetting { +public: + con_alias( hash_t hash, con_var< var_type >* var ) : + m_var( var ), + m_value( var_type{ } ), + m_name( hash ), + m_is_var( true ) { }; + + con_alias( hash_t hash ) : + m_name( hash ), + m_value( 0 ), + m_var( nullptr ), + m_is_var( false ) { }; + + con_alias( hash_t hash, var_type&& rhs ) : + m_name( hash ), + m_value( rhs ), + m_var( nullptr ), + m_is_var( false ) { }; + + virtual std::string get_string( ) override { + if( m_is_var ) + return m_var->get_string( ); + else + return std::to_string( m_value ); + } + + virtual void set_value( int value ) override { + set_value_internal( value ); + } + + virtual void set_value( float value ) override { + set_value_internal( value ); + } + + virtual void set_value( ulong_t value ) override { + set_value_internal( value ); + } + +private: + template < typename t > + void set_value_internal( t&& val ) { + if( m_is_var ) + m_var->set( val ); + else + m_value = ( var_type )( val ); + } + +private: + bool m_is_var; + hash_t m_name; + var_type m_value; + con_var< var_type >* m_var; +};
\ No newline at end of file diff --git a/internal_rewrite/con_fn.hpp b/internal_rewrite/con_fn.hpp new file mode 100644 index 0000000..c71cc08 --- /dev/null +++ b/internal_rewrite/con_fn.hpp @@ -0,0 +1,172 @@ +#pragma once +#include <functional> + +#include "simple_settings.hpp" + +//KEEP THIS UP TO DATE!! +enum ConFnVarType_t { + TYPE_NULL = 0, + TYPE_FLOAT = 'F', + TYPE_STRING = 'S', + TYPE_INTEGER = 'D', + TYPE_HEX = 'X' +}; + +class con_fn_base { +public: + virtual bool execute( const char* str ) = 0; + virtual const char* get_syntax( ) = 0; + virtual hash_t get_hash( ) = 0; +}; + +class con_fn : public con_fn_base { +public: + con_fn( hash_t hash, std::function< void __cdecl( const char*, const char* ) > function, const char* syntax ) { + m_hash = hash; + m_function = function; + strcpy_s< 64 >( m_syntax, syntax ); + for( size_t i{ }; i < strlen( m_syntax ); ++i ) { + if( m_syntax[ i ] == '%' ) { + m_args++; + } + } + } + + static ConFnVarType_t get_var_type( size_t arg, const char* syntax ) { + size_t cur_arg = 0; + for( size_t i{ }; i < strlen( syntax ); ++i ) { + if( syntax[ i ] == '%' ) { + if( cur_arg++ == arg ) { + return ( ConFnVarType_t )( syntax[ i + 1 ] ); + } + } + } + + return TYPE_NULL; + } + + template < typename t > + static t get_arg( const char* str, size_t arg_index, const char* syntax ) { + auto arg_type = get_var_type( arg_index, syntax ); + + size_t cur_arg = 0; + for( size_t i{ }; i < strlen( str ); ++i ) { + if( str[ i ] == ' ' ) { + if( cur_arg++ == arg_index ) { + size_t start = i + 1; + size_t end = strlen( str ); + for( size_t i2 = start; i2 < strlen( str ); ++i2 ) { + if( str[ i2 ] == ' ' ) { + end = i2; + break; + } + } + + std::string str( str + start, end - start ); + + char* end_ptr = ( char* )str.c_str( ) + end; + if constexpr( std::is_integral_v< t > ) { + auto radix = get_var_type( arg_index, syntax ) == TYPE_HEX ? 16 : 10; + return std::strtol( str.c_str( ), &end_ptr, radix ); + } + + if constexpr( std::is_floating_point_v< t > ) { + return std::strtof( str.c_str( ), &end_ptr ); + } + + return ( t )str.c_str( ); + } + } + } + + return t{ }; + } + + virtual const char* get_syntax( ) override { + return m_syntax; + } + + virtual hash_t get_hash( ) override { + return m_hash; + } + + ConFnVarType_t get_var_type( size_t arg ) { + size_t cur_arg = 0; + for( size_t i{ }; i < strlen( m_syntax ); ++i ) { + if( m_syntax[ i ] == '%' ) { + if( cur_arg++ == arg ) { + return ( ConFnVarType_t )( m_syntax[ i + 1 ] ); + } + } + } + + return TYPE_NULL; + } + + //returns false on failed execution + virtual bool execute( const char* str ) override { + size_t arg_count{ }; + for( size_t i{ }; i < strlen( str ); ++i ) { + if( str[ i ] == ' ' ) { + arg_count++; + } + } + + if( arg_count != m_args ) { + return false; + } + + std::string pass_str( " " ); + + size_t cur_arg = 0; + for( size_t i{ }; i < strlen( str ); ++i ) { + if( str[ i ] == ' ' ) { + size_t end = strlen( str ); + for( size_t i2 = i + 2; i2 < strlen( str ); ++i2 ) { + if( str[ i2 ] == ' ' ) { + end = i2; + } + } + + char* end_ptr = ( char* )( str + i + end ); + switch( get_var_type( cur_arg ) ) { + case TYPE_FLOAT: { + pass_str += std::to_string( strtof( str + i, &end_ptr ) ); + break; + } + case TYPE_INTEGER: { + pass_str += std::to_string( strtol( str + i, &end_ptr, 10 ) ); + break; + } + case TYPE_HEX: { + char buf[ 10 ]; + sprintf_s< 10 >( buf, "%08x", strtol( str + i, &end_ptr, 16 ) ); + pass_str += buf; + break; + } + case TYPE_STRING: { + std::string add_str( str + i, end - i ); + pass_str += add_str; + break; + } + default: + return false; + } + + if( end != strlen( str ) ) { + pass_str += ' '; + } + ++cur_arg; + } + } + + m_function( pass_str.c_str( ), m_syntax ); + return true; + } + +private: + hash_t m_hash{ }; + size_t m_args{ }; + char m_syntax[ 64 ]{ }; + std::function< void( __cdecl )( const char*, const char* ) > m_function{ }; +};
\ No newline at end of file diff --git a/internal_rewrite/console.cpp b/internal_rewrite/console.cpp new file mode 100644 index 0000000..d922af3 --- /dev/null +++ b/internal_rewrite/console.cpp @@ -0,0 +1,324 @@ +#include "console.hpp" +#include "interface.hpp" +#include "settings.hpp" +#include "d3d.hpp" +#include "ui_draw.h" + +std::shared_ptr< console > g_con = std::make_shared< console >( ); + + +void console::draw_text( int x, int y, bool greyed, const char* fmt, ... ) { + va_list args; + char buf[ 512 ]; + + __crt_va_start( args, fmt ); + vsprintf_s< 512 >( buf, fmt, args ); + __crt_va_end( args ); + + g_d3d.draw_text< ALIGN_LEFT >( d3d::fonts.f_con, greyed ? clr_t( 160, 160, 160 ) : clr_t( 255, 255, 255 ), x, y, D3DFONTFLAG_DROPSHADOW, "%s", buf ); + //g_d3d.draw_text< ALIGN_LEFT >( d3d::fonts.f_con, greyed ? clr_t( 160, 160, 160 ) : clr_t( 255, 255, 255 ), x, y, D3DFONTFLAG_DROPSHADOW, buf ); +} + +void console::draw_text( int x, int y, const char* fmt, ... ) { + va_list args; + char buf[ 512 ]; + + __crt_va_start( args, fmt ); + vsprintf_s< 512 >( buf, fmt, args ); + __crt_va_end( args ); + + g_d3d.draw_text< ALIGN_LEFT >( d3d::fonts.f_con, clr_t( 255, 255, 255 ), x, y, D3DFONTFLAG_DROPSHADOW, buf ); +} + +void console::draw_rect( int x, int y, int w, int h, clr_t col ) { + g_d3d.draw_filled_rect( col, x, y, w, h ); +} + +void console::register_alias( std::shared_ptr< ISetting >& alias ) { + m_aliases.push_back( alias ); +} + +void console::capture_command( ) { + float current_time = GetTickCount( ) * 0.001f; + size_t length = strlen( m_cur_cmd ); + + for( size_t i{ }; i < 0xfe; ++i ) { + if( m_input->is_key_pressed( i ) ) { + float delta_time = current_time - m_last_key_input[ i ]; + if( fabs( delta_time ) > 0.2f ) { + if( i == KEYS_BACK ) { + m_cur_cmd[ length - 1 ] = 0; + m_last_key_input[ i ] = current_time; + continue; + } + + m_key_states[ i ] = 0xf0; + wchar_t pressed_char; + const auto scan = MapVirtualKeyA( i, 2 ); + auto ret = ToAscii( i, scan, ( BYTE* )m_key_states, ( LPWORD )&pressed_char, 1 ); + + if( ret == 1 ) { + if( length < 200 ) { + m_cur_cmd[ length ] = ( char )( pressed_char ); + m_cur_cmd[ length + 1 ] = 0; + } + } + m_last_key_input[ i ] = current_time; + } + } + else { + m_last_key_input[ i ] = 0.f; + m_key_states[ i ] = 0; + } + } +} + +ISetting* console::find_var( hash_t var ) { + for( auto& it : data::holder_.get_nodes( ) ) { + auto setting = static_cast< ISetting* >( it ); + if( var == setting->get_hash( ) ) { + return setting; + } + } + + return nullptr; +} + +ISetting* console::find_alias( hash_t alias ) { + for( auto& it : m_aliases ) { + if( it->get_hash( ) == alias ) + return it.get( ); + } + + return nullptr; +} + +con_fn_base* console::find_fn( hash_t name ) { + for( auto& it : m_functions ) { + if( it->get_hash( ) == name ) { + return it; + } + } + + return nullptr; +} + +std::string console::impl_alias_str( std::string str ) { + for( size_t i{ }; i < str.length( ); ++i ) { + if( str[ i ] == ' ' && str[ i + 1 ] != ' ' ) { + size_t end = 0; + for( size_t i2{ i + 1 }; i2 < str.length( ); ++i ) { + if( str[ i2 ] == ' ' ) + end = i2; + } + + if( end ) { + std::string alias_str( str.c_str( ) + i, end - i ); + auto alias = find_alias( hash::fnv1a( alias_str ) ); + if( alias ) { + str.replace( alias_str.begin( ), alias_str.end( ), alias->get_string( ) ); + } + else { + g_con->log( xors( "couldnt find alias %s" ), alias_str.c_str( ) ); + } + } + } + } + + return str; +} + +void console::execute_command( const char* cmd ) { + if( !cmd[ 0 ] ) return; + std::string first_param( cmd, strlen( cmd ) ); + + size_t end{ }; + bool one_arg = true; + for( size_t i{ }; i < strlen( cmd ); ++i ) { + if( cmd[ i ] == ' ' ) { + first_param.resize( i ); + end = i; + one_arg = false; + break; + } + } + + if( one_arg ) { + first_param.resize( first_param.length( ) - 1 ); + } + + //find a command to execute + auto fn = find_fn( hash::fnv1a( first_param ) ); + if( fn ) { + //std::string alias_cmd = impl_alias_str( cmd ); + + if( !fn->execute( cmd ) ) { + log( xors( "invalid syntax" ) ); + } + return; + } + + //command not found, we're managing vars + if( !one_arg ) { + std::string second_param = ( cmd + end + 1 ); + bool is_floating_point = second_param.find( '.' ) != std::string::npos; + auto var = find_var( hash::fnv1a( first_param ) ); + + if( var ) { + auto setting_cast = static_cast< con_var< void* >* >( var ); + if( !setting_cast->is_integral( ) && !setting_cast->is_floating_point( ) ) { + auto value = std::strtol( second_param.c_str( ), 0, 16 ); + printf( xors( "value: %08x\n" ), value ); + var->set( value ); + } + + if( is_floating_point ) { + float value = std::strtof( second_param.c_str( ), 0 ); + var->set( value ); + } + else { + int value = std::strtol( second_param.c_str( ), 0, 10 ); + var->set( value ); + } + log( xors( "%s %s\n" ), first_param.c_str( ), second_param.c_str( ) ); + return; + } + } + + + log( xors( "unknown command: %s" ), first_param.c_str( ) ); +} + +void console::input( ) { + static int drag_x, drag_y; + int cursor_x, cursor_y; + int x = m_x, y = m_y; + bool clicked = m_input->is_key_pressed( KEYS_MOUSE1 ); + static bool is_hovered{ }; + m_input->get_cursor_pos( cursor_x, cursor_y ); + + auto is_top_hovered = [ &x, &y, + &cursor_x, &cursor_y ]( ) { + return cursor_x > x && cursor_x < x + WIDTH + && cursor_y > y && cursor_y < y + TOP_HEIGHT; + }; + + auto is_window_hovered = [ &x, &y, + &cursor_x, &cursor_y ]( ) { + return cursor_x > x && cursor_x < x + WIDTH + && cursor_y > y && cursor_y < y + HEIGHT; + }; + + auto is_bottom_hovered = [ &x, &y, + &cursor_x, &cursor_y ]( ) { + return cursor_x > x && cursor_x < x + WIDTH + && cursor_y > y + HEIGHT - TOP_HEIGHT + && cursor_y < y + HEIGHT; + }; + + if( clicked ) { + //m_consuming_input = is_window_hovered( ); + } + + if( !clicked && is_top_hovered( ) ) { + drag_x = cursor_x - m_x; + drag_y = cursor_y - m_y; + } + + if( clicked && is_hovered ) { + is_hovered = true; + m_x = cursor_x - drag_x; + m_y = cursor_y - drag_y; + } + else { + is_hovered = is_top_hovered( ); + } + + if( clicked ) { + m_active = is_bottom_hovered( ); + } + + if( m_active ) { + capture_command( ); + + static bool was_held{ }; + if( m_input->is_key_pressed( KEYS_RETURN ) ) { + if( !was_held ) { + execute_command( m_cur_cmd ); + m_cur_cmd[ 0 ] = 0; + } + was_held = true; + } + else was_held = false; + } +} + +void console::draw( ) { + if( !m_open ) { + m_consuming_input = false; + m_active = false; + return; + } + + static clr_t col = clr_t( 31, 31, 31, 255 ); + + input( ); + + RECT prev_rect{ }; + RECT new_rect{ m_x - 1, m_y - 1, + m_x + WIDTH + 1, m_y + HEIGHT + 1 }; + g_d3d.get_device( )->GetScissorRect( &prev_rect ); + + g_d3d.get_device( )->SetScissorRect( &new_rect ); + + draw_rect( m_x - 1, m_y - 1, WIDTH + 2, HEIGHT + 2, ui::ui_get_accent_col( ) ); + draw_rect( m_x, m_y, WIDTH, HEIGHT, col ); + draw_rect( m_x + 1, m_y, WIDTH - 2, TOP_HEIGHT, clr_t( 41, 41, 41 ) ); + + draw_rect( m_x + 1, m_y + HEIGHT - TOP_HEIGHT, WIDTH - 2, TOP_HEIGHT, clr_t( 41, 41, 41 ) ); + if( m_active ) { + draw_rect( m_x + 2, m_y + HEIGHT - TOP_HEIGHT + 1, WIDTH - 4, TOP_HEIGHT - 2, clr_t( 31, 31, 31 ) ); + auto fn = find_fn( hash::fnv1a( m_cur_cmd ) ); + if( fn ) { + std::string fn_str = m_cur_cmd; + fn_str += ' '; + fn_str += fn->get_syntax( ); + + draw_text( m_x + 2, m_y + HEIGHT - TOP_HEIGHT / 2 - 3, true, "%s", fn_str.c_str( ) ); + } + + else { + auto var = find_var( hash::fnv1a( m_cur_cmd ) ); + if( var ) { + std::string var_str = m_cur_cmd; + var_str += ' '; + + var_str += var->get_string( ); + + draw_text( m_x + 2, m_y + HEIGHT - TOP_HEIGHT / 2 - 3, true, var_str.c_str( ) ); + } + } + } + + std::string cur_cmd_str = m_cur_cmd; + if( m_active ) { + cur_cmd_str += '_'; + } + draw_text( m_x + 2, m_y + HEIGHT - TOP_HEIGHT / 2 - 3, cur_cmd_str.c_str( ) ); + draw_text( m_x + 3, m_y + TOP_HEIGHT / 2 - 3, xors( "console" ) ); + + int cur_y = m_y + HEIGHT - TOP_HEIGHT; + for( int i = m_logs.size( ) - 1; i >= 0; --i ) { + constexpr int LINE_HEIGHT = 14; + auto& log = m_logs.at( i ); + + if( cur_y - LINE_HEIGHT < m_y + TOP_HEIGHT ) { + m_logs.erase( m_logs.begin( ) + i ); + continue; + } + + draw_text( m_x + 2, cur_y -= LINE_HEIGHT, log.m_msg ); + } + + g_d3d.get_device( )->SetScissorRect( &prev_rect ); +}
\ No newline at end of file diff --git a/internal_rewrite/console.hpp b/internal_rewrite/console.hpp new file mode 100644 index 0000000..5226607 --- /dev/null +++ b/internal_rewrite/console.hpp @@ -0,0 +1,125 @@ +#pragma once +#include <memory> +#include <Windows.h> +#include <vector> +#include <functional> + +#include "con_fn.hpp" +#include "con_alias.hpp" +#include "input_system.hpp" +#include "math.hpp" + +#pragma warning(disable: 4996) + +class console { +public: + console( ) { + m_input = std::make_shared< util::c_input_manager >( ); + } + + static constexpr size_t TOP_HEIGHT = 22; + static constexpr size_t WIDTH = 400; + static constexpr size_t HEIGHT = 450; + + bool m_consuming_input{ }; + bool m_active{ }; + bool m_open{ }; + + struct con_log { + float m_time; + char m_msg[ 128 ]; + }; + + void draw_text( int x, int y, bool greyed, const char* msg, ... ); + void draw_text( int x, int y, const char* msg, ... ); + void draw_rect( int x, int y, int w, int h, clr_t col ); + void register_fn( con_fn_base* fn ) { m_functions.push_back( fn ); } + + void input( ); + void draw( ); + + auto& get_input( ) { + return m_input; + } + + void log( const char* fmt, ... ) { + va_list args; + char buf[ 128 ]; + + __crt_va_start( args, fmt ); + vsprintf_s< 128 >( buf, fmt, args ); + __crt_va_end( args ); + + con_log log; + log.m_time = ( float )GetTickCount( ) * 0.001f; + memcpy( log.m_msg, buf, 128 ); + + print( "%s\n", buf ); + + m_logs.push_back( log ); + } + + void print( const char* fmt, ... ) { + va_list args; + va_start( args, fmt ); + vprintf_s( fmt, args ); + va_end( args ); + } + + void create( ) { +#ifdef _DEBUG + AllocConsole( ); + freopen( xors( "CONOUT$" ), "w", stdout ); + const char* hack_names[ ] = { + xors( "dunk hack" ), + xors( "dweeb dumpster" ), + xors( "nova killER" ), + xors( "moms credit card" ), + xors( "dad hook" ), + xors( "retard remover" ), + xors( "slam hook" ), + xors( "swoosh" ), + xors( "retard remover" ), + xors( "shotgun hack" ), + }; + + SetConsoleTitleA( hack_names[ math::random_number( 0, 9 ) ] ); +#endif + game_console_print = reinterpret_cast< msg_t >( GetProcAddress( GetModuleHandleA( "tier0.dll" ), "Msg" ) ); + } + + void destroy( ) { +#ifdef _DEBUG + FreeConsole( ); + fclose( stdout ); +#endif + } + + std::vector< con_log > m_logs; + std::vector< con_fn_base* > m_functions; + std::vector< std::shared_ptr< ISetting > > m_aliases; + + void register_alias( std::shared_ptr< ISetting >& alias ); + + using msg_t = void( __cdecl* )( const char*, ... ); + msg_t game_console_print; + +private: + ISetting* find_var( hash_t name ); + ISetting* find_alias( hash_t name ); + + std::string impl_alias_str( std::string str ); + + con_fn_base* find_fn( hash_t name ); + void capture_command( ); + void execute_command( const char* cmd ); + + int m_x{ 100 }, m_y{ 100 }; + + char m_cur_cmd[ 200 ]{ }; + uint8_t m_key_states[ 256 ]{ }; + float m_last_key_input[ 256 ]{ }; + std::shared_ptr< util::c_input_manager > m_input; +}; + +extern std::shared_ptr< console > g_con;
\ No newline at end of file diff --git a/internal_rewrite/context.cpp b/internal_rewrite/context.cpp new file mode 100644 index 0000000..cf0f9ee --- /dev/null +++ b/internal_rewrite/context.cpp @@ -0,0 +1,221 @@ +#include "context.hpp" +#include "console.hpp" +#include "hooks.hpp" +#include "base_cheat.hpp" + +context::c_context g_ctx; + +NAMESPACE_REGION( context ) + +bool c_context::run_frame( ) { + m_local = g_csgo.m_entlist( )->GetClientEntity< >( + g_csgo.m_engine( )->GetLocalPlayer( ) ); + + return !!m_local; +} + +void c_context::on_cmove_end( user_cmd_t* cmd ) { + if( g_settings.menu.anti_untrusted ) + cmd->clamp( ); + + auto send = g_cheat.m_lagmgr.get_state( ); + + if( send ) { + m_last_fakeangle = cmd->m_viewangles; + m_last_origin = m_local->m_vecOrigin( ); + } + else { + m_last_realangle = cmd->m_viewangles; + m_last_realangle.x = m_last_fakeangle.x; + } + + if( !g_cheat.m_lagmgr.get_choked( ) ) { + m_thirdperson_angle = m_last_realangle; + } + + m_thirdperson_angle.x = std::clamp( cmd->m_viewangles.x, -89.f, 89.f ); + if( g_cheat.m_lagmgr.get_sent( ) > 1 ) { + m_thirdperson_angle.y = m_last_fakeangle.y; + } + + //auto anim_state = g_cheat.m_ragebot.m_antiaim->get_animstate( ); + + + if( ( cmd->m_buttons & IN_ATTACK ) && m_local->can_attack( ) ) { + auto weap = m_local->get_weapon( ); + if( !weap->is_knife( ) && weap->m_iItemDefinitionIndex( ) != WEAPON_TASER && !weap->is_grenade( ) ) { + if( !m_has_incremented_shots && !m_has_fired_this_frame ) { + shot_data_t new_shot{ }; + new_shot.m_angle = cmd->m_viewangles; + new_shot.m_local_pos = m_local->get_eye_pos( ); + + m_last_shot++; + m_last_shot %= 128; + m_shot_data[ m_last_shot ] = new_shot; + + + //g_con->log( "incrementing shots( in attack )" ); + m_has_incremented_shots = true; + } + + m_has_fired_this_frame = true; + } + } + + weapon_info_t* wpn_info = m_local->get_weapon( )->get_wpn_info( ); + if( wpn_info && m_has_fired_this_frame ) + m_local->get_weapon( )->m_flNextPrimaryAttack( ) += wpn_info->cycle_time; + + if( g_settings.misc.log_hits( ) ) { + for( auto& it : m_shot_data ) { + if( !it.m_enemy_index ) + continue; + + if( !it.m_handled ) + break; + + if( !it.m_logged ) { + char print_str[ 100 ]{ 0 }; + memset( print_str, 0, 100 ); + + if( it.m_hit ) { + player_info_t info; + if( !g_csgo.m_engine( )->GetPlayerInfo( it.m_enemy_index, &info ) ) + continue; + + char name[ 32 ]; + auto ent = g_csgo.m_entlist( )->GetClientEntity( it.m_enemy_index ); + + ent->get_name_safe( name ); + + strenc::w_sprintf_s( print_str, 100, "[\3moneybot\1] hit %s in %s for %d\0", name, util::hitgroup_to_string( it.m_hit ).c_str( ), it.m_damage ); + } + else if( it.m_missed ) + strenc::w_sprintf_s( print_str, 100, "[\3moneybot\1] missed shot due to spread\0" ); + + g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, print_str ); + g_con->game_console_print( "%s\n", print_str ); + } + + it.m_logged = true; + } + } + + static float last_shot = 0.f; + if( m_has_fired_this_frame ) + last_shot = g_csgo.m_globals->m_curtime; + else if( auto weapon = g_ctx.m_local->get_weapon( ) ) { + float fire_rate = weapon->get_wpn_info( )->cycle_time; + float tolerance = util::get_total_latency( ) * 2.f + fire_rate + TICK_INTERVAL( ); + if( std::abs( last_shot - g_csgo.m_globals->m_curtime ) > tolerance ) { + reset_shot_queue( ); + last_shot = g_csgo.m_globals->m_curtime; + } + } + + + m_has_incremented_shots = false; + if( std::abs( m_last_shot - m_last_shot_ack ) >= 10 ) + reset_shot_queue( ); + + *get_last_cmd( ) = *cmd; +} + +void c_context::reset_shot_queue( ) { + auto last_shot = m_shot_data[ m_last_shot ]; + m_last_shot = m_last_shot_ack = 0; + m_shot_data = { }; + m_shot_data[ 0 ] = last_shot; +} + +void c_context::update_local_hook( ) { + if( !run_frame( ) ) + return; + + auto func = util::get_vfunc< void* >( m_local, 218 ); + if( func != &hooks::update_clientside_animation || g_csgo.m_local( ) != m_local ) { + g_csgo.m_local( m_local ); + g_csgo.m_local->hook( 218, &hooks::update_clientside_animation ); + } +} + +//predicted servertime of player, use this for breaking lby etc +float c_context::pred_time( ) { + calculate_tickbase( ); + + return m_tickbase * g_csgo.m_globals->m_interval_per_tick; +} + +//calculate tickbase depending on whether last ucmd was predicted +bool c_context::calculate_tickbase( ) { + if ( !m_local ) { + return false; + } + + //get current tickbase + auto player_tickbase = m_local->m_nTickBase( ); + + //disabled due to our engine pred being shit + m_tickbase = player_tickbase; + return true; + + if ( m_snapshot.empty( ) ) { + m_tickbase = player_tickbase; + return false; + } + + //if cmd wasnt predicted increment tickbase + auto snap_cmd = &m_snapshot.front( ); + if ( !snap_cmd->m_predicted ) { + if ( !m_tickbase ) { + m_tickbase = player_tickbase; + } + + m_tickbase++; + snap_cmd->m_predicted = true; + } + else { + m_tickbase = player_tickbase; + } + + return true; +} + +bool c_context::precache_model( const char* model ) { + + auto cache_table = g_csgo.m_string_table( )->FindTable( "modelprecache" ); + + if( !cache_table ) + return true; + + g_csgo.m_model_info( )->FindOrLoadModel( model ); + + int string_index = cache_table->AddString( false, model ); + + if( string_index == -1 ) + return false; + + return true; +} + +//save snapshots of usercommands +bool c_context::create_snapshot( user_cmd_t* ucmd ) { + user_cmd_t ucmd_copy; + + while ( m_snapshot.size( ) >= 64 ) { + m_snapshot.pop_back( ); + } + + if ( !ucmd ) { + return false; + } + + memcpy( &ucmd_copy, + ucmd, + sizeof( ucmd_copy ) ); + + m_snapshot.push_front( ucmd_copy ); + return true; +} + +END_REGION
\ No newline at end of file diff --git a/internal_rewrite/context.hpp b/internal_rewrite/context.hpp new file mode 100644 index 0000000..c813aba --- /dev/null +++ b/internal_rewrite/context.hpp @@ -0,0 +1,80 @@ +#pragma once
+#include <deque>
+
+#include "util.hpp"
+#include "sdk.hpp"
+
+NAMESPACE_REGION( context )
+
+struct shot_data_t {
+ vec3_t m_local_pos;
+ vec3_t m_angle;
+ vec3_t m_enemy_pos;
+ int m_enemy_index;
+ int m_resolver_shots;
+ bool m_resolver_state;
+ bool m_missed{ false };
+ struct {
+ vec3_t min;
+ vec3_t max;
+ float radius;
+ } m_hitbox;
+ int m_hitgroup;
+ bool m_handled{ };
+ int m_hit{ };
+ int m_damage{ };
+ bool m_logged{ };
+};
+
+//replacement to the old global:: namespace
+class c_context {
+public:
+ //run localplayer check, pointer, is valid etc
+ bool run_frame( );
+ float pred_time( );
+
+ void update_local_hook( );
+
+ void on_cmove_end( user_cmd_t* cmd );
+ bool create_snapshot( user_cmd_t* );
+ //calculate accurate tickbase
+ bool calculate_tickbase( );
+
+ user_cmd_t* get_last_cmd( ) {
+ return m_snapshot.empty( ) ? nullptr : &m_snapshot.front( );
+ }
+
+ bool precache_model( const char* model );
+
+public:
+ c_base_player* m_local{ };
+ int m_stage{ };
+ //accurate tickbase
+ int m_tickbase{ };
+
+ bool m_drawing_postscreenspace{ };
+ bool m_has_incremented_shots{ };
+ bool m_drawing_screneend{ };
+
+ bool m_has_fired_this_frame{ };
+
+ vec3_t m_last_realangle{ };
+ vec3_t m_last_fakeangle{ };
+ vec3_t m_thirdperson_angle{ };
+ vec3_t m_last_origin{ };
+
+ float m_fov{ 90.f };
+public:
+ void reset_shot_queue( );
+
+ int m_last_shot_ack;
+ int m_last_shot;
+
+ std::array< shot_data_t, 128 > m_shot_data;
+private:
+ std::deque< user_cmd_t > m_snapshot;
+};
+
+END_REGION
+
+extern context::c_context g_ctx;
\ No newline at end of file diff --git a/internal_rewrite/create_move.cpp b/internal_rewrite/create_move.cpp new file mode 100644 index 0000000..7c6aefa --- /dev/null +++ b/internal_rewrite/create_move.cpp @@ -0,0 +1,128 @@ +#include <intrin.h> + +#include "hooks.hpp" +#include "mem.hpp" +#include "interface.hpp" +#include "context.hpp" +#include "input_system.hpp" +#include "math.hpp" + +#include "base_cheat.hpp" + +/* +void __declspec( naked ) __stdcall hooks::hl_create_move_gate( int sequence_number, float input_sample_time, bool active ) { + __asm { + push ebp + mov ebp, esp + push ebx //push ebx (sendpacket) to the top of the stack + push esp //push the stack (with sendpacket on top) + push active + push input_sample_time + push sequence_number + call hl_create_move + pop ebx + pop ebp + ret 0xc + } +} +*/ + +bool __fastcall hooks::create_move( void* ecx_, void* edx_, float input_sample_frametime, user_cmd_t* ucmd ) { + static auto create_move_o = g_csgo.m_clientmode->get_old_function< decltype( &hooks::create_move ) >( 24 ); + + stack_t stack( get_baseptr( ) ); + byte* send_packet = stack.next( ).local< byte* >( 0x1c ); + + bool ret = create_move_o( ecx_, edx_, input_sample_frametime, ucmd ); + + if( !ucmd->m_tick_count || !ucmd->m_cmd_nr ) + return ret; + + // when switching to non automatic weapons, it will sometimes not shoot when aimbotting so we reset attack flag + bool is_switching_weapon = false; + if( g_csgo.m_input( )->m_hSelectedWeapon != -1 ) { + is_switching_weapon = true; + } + + //g_csgo.m_input( )->CreateMove( sequence_number, input_sample_time, active ); + + + if( ret ) + g_csgo.m_engine( )->SetViewAngles( ucmd->m_viewangles ); + + // FIX ME NAVE + // ok love + // yes thank u + + g_ctx.create_snapshot( ucmd ); + g_cheat.m_extra.update_netchannel( ); + g_cheat.m_identity( ); + + if( g_ctx.run_frame( ) && g_ctx.m_local->is_alive( ) ) { + g_ctx.update_local_hook( ); + static int last_frame = g_csgo.m_globals->m_framecount; + if( last_frame != g_csgo.m_globals->m_framecount ) + g_ctx.m_has_fired_this_frame = false; + + last_frame = g_csgo.m_globals->m_framecount; + + g_cheat.m_legitbot.sample_angle_data( ucmd->m_viewangles ); + + // Okay, this implementation was REALLY fucking gay. + // g_cheat.m_prediction.local_pred( ucmd ); + + // Yeah. + g_cheat.m_movement( ucmd ); + + // This should account for the majority of FPS related bugs. + g_cheat.m_prediction.pre_run_command( ); + + // Actual implementation of RunCommand. + g_cheat.m_prediction.run_command( ucmd ); + + g_cheat.m_legitbot.m_lagcomp( ucmd ); + g_cheat.m_legitbot.triggerbot( ucmd ); + + g_cheat.m_lagmgr( ucmd, send_packet ); + + g_cheat.m_visuals.update_hit_flags( ); + + g_cheat.m_ragebot( ucmd ); + g_cheat.m_extra.auto_revolver( ucmd ); + + g_cheat.m_extra.no_recoil( ucmd ); + + // Restores globals. + g_cheat.m_prediction.post_run_command( ); + + g_cheat.m_move_rec( ucmd ); + + g_cheat.m_visuals.radar( ); + + g_cheat.m_extra.rank_reveal( ucmd ); + + if( g_cheat.m_lagmgr.get_choked( ) > 15 ) { + g_cheat.m_lagmgr.set_state( true ); + } + + g_cheat.m_lagmgr.on_cmove_end( ); + g_ctx.on_cmove_end( ucmd ); + } + else { + g_ctx.reset_shot_queue( ); + } + + if( is_switching_weapon ) { + ucmd->m_buttons &= ~IN_ATTACK; + } + + + + //m_bIsValveDS + //if( *( bool* )( c_base_player::get_game_rules( ) + 0x75 ) ) + //g_settings.menu.anti_untrusted = true; + + ucmd->clamp( g_settings.menu.anti_untrusted ); + + return false; +}
\ No newline at end of file diff --git a/internal_rewrite/d3d.cpp b/internal_rewrite/d3d.cpp new file mode 100644 index 0000000..e9df4fa --- /dev/null +++ b/internal_rewrite/d3d.cpp @@ -0,0 +1,387 @@ +#include "d3d.hpp" +#include "interface.hpp" +#include "math.hpp" +#include "d3d_sprite.hpp" + +d3d::c_renderer g_d3d; +d3d::d3d_fonts_t d3d::fonts; + + +//theres shit still left to add like drawrect etc but thats really simple +//this is the base and it works so thats ok +//love +// - nave + +// note - dex; probably better idea to batch all calls up into one DrawPrimitive / DrawIndexedPrimitive call each (if you want to have index buffers too) +// DrawPrimitiveUP for each object will slow stuff down eventually +// dont know much about DrawIndexedPrimitive myself but msdn suggests to use strips over anything else + +namespace d3d +{ + void d3d_fonts_t::release( ) { + if( f_12 ) f_12->Release( ); + if( f_esp_small ) f_esp_small->Release( ); + if( f_16 ) f_16->Release( ); + if( f_18 ) f_18->Release( ); + if( f_menu ) f_menu->Release( ); + if( f_con ) f_con->Release( ); + + f_12 = f_esp_small = f_16 = f_18 = f_menu = f_con = nullptr; + } + + void d3d_fonts_t::create( IDirect3DDevice9* device ) { + auto create_font = [ & ]( ID3DXFont** font, const char* font_name, int width, int size, int weight ) { + //auto wide_str = util::ascii_to_unicode( std::string( font_name ) ); + + auto code = D3DXCreateFontA( device, size, width, weight, 0, false, DEFAULT_CHARSET, + OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, font_name, font ); + + if( code < 0 ) throw xors( "fuck d3d" ); + }; + + create_font( &f_12,
+#ifndef COMIC_SANS
+ xors( "Tahoma" )
+#else
+ xors( "Comic Sans MS" )
+#endif + , 0, 12, 0 ); //change this idc + create_font( &f_esp_small, xors( "Tahoma" ), 0, 11, 500 ); + create_font( &f_16, xors( "Verdana" ), 0, 16, 0 ); + create_font( &f_18, xors( "Verdana" ), 0, 18, 900 ); + create_font( &f_menu, +#ifndef COMIC_SANS
+ xors( "Tahoma" )
+#else
+ xors( "Comic Sans MS" )
+#endif + , 0, 12, +#ifndef COMIC_SANS + 300 +#else + 600 +#endif + ); + create_font( &f_con, xors( "Consolas" ), 6, 12, 300 ); + } + + + c_renderer::c_renderer( IDirect3DDevice9* device ) : m_device( device ) { + create_objects( ); + } + + bool c_renderer::run_frame( IDirect3DDevice9* device ) { + if( g_csgo.m_panic ) { + return false; + } + + if( !m_device ) { + m_device = device; + create_objects( ); + return false; + } + + return true; + } + + c_renderer::~c_renderer( ) { + if( !m_device ) + return; + + invalidate_objects( ); + } + + void c_renderer::on_device_lost( ) { + if( !m_device ) + return; + + invalidate_objects( ); + } + + void c_renderer::on_device_reset( ) { + if( !m_device ) + return; + + create_objects( ); + } + + void c_renderer::invalidate_objects( ) { + if( m_block ) m_block->Release( ); + fonts.release( ); + //m_buffer->Release( ); + //m_sil_txt->Release( ); + //m_surface->Release( ); + } + + void c_renderer::create_objects( ) { + D3DVIEWPORT9 viewport; + + if( !m_device ) return; + + if( m_device->GetViewport( &viewport ) < 0 ) { + return; + } + + if( m_device->CreateStateBlock( D3DSBT_ALL, &m_block ) < 0 ) { + return; + } + + if( !m_block ) { + return; + } + + // get display size. + m_width = viewport.Width; + m_height = viewport.Height; + + fonts.create( m_device ); + + /*IDirect3DSurface9* backbuffer; + D3DSURFACE_DESC desc; + + m_device->GetRenderTarget( 0, &backbuffer ); + backbuffer->GetDesc( &desc ); + backbuffer->Release( ); + + m_device->CreateTexture( desc.Width, desc.Height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_sil_txt, 0 ); + m_sil_txt->GetSurfaceLevel( 0, &m_surface ); + + m_device->CreateVertexBuffer( 4 * 24, 0, D3DFVF_XYZRHW | D3DFVF_TEX1, D3DPOOL_MANAGED, &m_buffer, nullptr );*/ + } + + void c_renderer::begin( ) { + if( !m_device ) return; + + D3DVIEWPORT9 vp{ 0, 0, m_width, m_height, 0.f, 1.f }; + + m_device->SetViewport( &vp ); + + //m_sil_txt->GetSurfaceLevel( 0, &m_surface ); + + m_block->Capture( ); + + // set vertex stream declaration. + m_device->SetVertexShader( nullptr ); + m_device->SetPixelShader( nullptr ); + m_device->SetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ); + + m_device->SetRenderState( D3DRS_LIGHTING, false ); + m_device->SetRenderState( D3DRS_FOGENABLE, false ); + m_device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ); + m_device->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); + + m_device->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); + m_device->SetRenderState( D3DRS_SCISSORTESTENABLE, true ); + m_device->SetRenderState( D3DRS_ZWRITEENABLE, false ); + m_device->SetRenderState( D3DRS_STENCILENABLE, false ); + + m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, false ); + m_device->SetRenderState( D3DRS_ANTIALIASEDLINEENABLE, true ); + + m_device->SetRenderState( D3DRS_ALPHABLENDENABLE, true ); + m_device->SetRenderState( D3DRS_ALPHATESTENABLE, false ); + m_device->SetRenderState( D3DRS_SEPARATEALPHABLENDENABLE, true ); + + m_device->SetTexture( 0, nullptr ); + m_device->SetTexture( 1, nullptr ); + m_device->SetTexture( 2, nullptr ); + m_device->SetTexture( 3, nullptr ); + + m_device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); + m_device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); + m_device->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); + m_device->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE ); + m_device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE ); + m_device->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE ); + m_device->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 ); + m_device->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE ); + m_device->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE ); + m_device->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE ); + + m_device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); + m_device->SetRenderState( D3DRS_SRCBLENDALPHA, D3DBLEND_INVDESTALPHA ); + m_device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); + m_device->SetRenderState( D3DRS_DESTBLENDALPHA, D3DBLEND_ONE ); + m_device->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD ); + + m_device->SetRenderState( D3DRS_SRGBWRITEENABLE, false ); + m_device->SetRenderState( D3DRS_COLORWRITEENABLE, 0xffffffff ); + /* commented out until further notice */ + //m_device->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR ); + //m_device->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR ); + // todo - dex; if we use textures, need to set those rendering states too + } + + void c_renderer::end( ) { + //m_device->SetTexture( 0, nullptr ); + //m_device->SetTexture( 1, nullptr ); + //m_device->SetTexture( 2, nullptr ); + //m_device->SetTexture( 3, nullptr ); + m_block->Apply( ); + //m_block->Release( ); + } + + void c_renderer::draw_line( clr_t color, int x0, int y0, int x1, int y1 ) { + d3d_vertex_t v[ 2 ] = { + d3d_vertex_t( float( x0 ), float( y0 ), 1.0f, color ), //because fuck you thats why + d3d_vertex_t( float( x1 ), float( y1 ), 1.0f, color ) + }; //edit: do we wanna use z for shit? i mean we could for like menu stuff + //so it renders above other stuff + + m_device->DrawPrimitiveUP( D3DPT_LINELIST, 1, v, VERTEX_SIZE ); + } + + void c_renderer::draw_rect( clr_t color, int x, int y, int w, int h ) { + d3d_vertex_t v[ 5 ] = { + d3d_vertex_t( float( x ), float( y ), 1.0f, color ), + d3d_vertex_t( float( x + w ), float( y ), 1.0f, color ), + d3d_vertex_t( float( x + w ), float( y + h ), 1.0f, color ), + d3d_vertex_t( float( x ), float( y + h ), 1.0f, color ), + d3d_vertex_t( float( x ), float( y ), 1.0f, color ) + }; + + m_device->DrawPrimitiveUP( D3DPT_LINESTRIP, 4, v, VERTEX_SIZE ); + } + + void c_renderer::draw_filled_rect( clr_t color, int x, int y, int w, int h ) { + d3d_vertex_t v[ 6 ] = { + d3d_vertex_t( float( x + w ), float( y ), 1.0f, color ), + d3d_vertex_t( float( x ), float( y + h ), 1.0f, color ), + d3d_vertex_t( float( x + w ), float( y + h ), 1.0f, color ), + d3d_vertex_t( float( x ), float( y ), 1.0f, color ), + d3d_vertex_t( float( x ), float( y + h ), 1.0f, color ), + d3d_vertex_t( float( x + w ), float( y ), 1.0f, color ) + }; + + m_device->DrawPrimitiveUP( D3DPT_TRIANGLELIST, 2, v, VERTEX_SIZE ); + } + + void c_renderer::draw_gradient( clr_t start, clr_t end, int x, int y, int w, int h, GradientType_t type ) { + d3d_vertex_t v[ 4 ]; + + switch( type ) { + case GRADIENT_VERTICAL: + v[ 0 ] = { float( x ), float( y ), 1.0f, start }; + v[ 1 ] = { float( x + w ), float( y ), 1.0f, start }; + v[ 2 ] = { float( x ), float( y + h ), 1.0f, end }; + v[ 3 ] = { float( x + w ), float( y + h ), 1.0f, end }; + break; + case GRADIENT_HORIZONTAL: + v[ 0 ] = { float( x ), float( y ), 1.0f, start }; + v[ 1 ] = { float( x + w ), float( y ), 1.0f, end }; + v[ 2 ] = { float( x ), float( y + h ), 1.0f, start }; + v[ 3 ] = { float( x + w ), float( y + h ), 1.0f, end }; + break; + } + + //m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, true ); + m_device->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, &v, VERTEX_SIZE ); + //m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, false ); + } + + void c_renderer::draw_circle( clr_t color, int x, int y, int r, int res ) { + constexpr float PI = 3.1415926f; + const float step = PI * 2.0f / float( res ); + + int point_x = x + r, + point_y = y - r, + point_x_o{ }, + point_y_o{ }; + + m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, true ); + for( int i{ }; i <= res; i++ ) { + float theta = float( i ) * step; + + point_x = x + ( int )( r * cos( theta ) ); + point_y = y - ( int )( r * sin( theta ) ); + if( i ) draw_line( color, point_x, point_y, point_x_o, point_y_o ); + point_x_o = point_x; + point_y_o = point_y; + } + m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, false ); + } + + void c_renderer::draw_filled_circle( clr_t color, int x, int y, int r, int res ) { + d3d_vertex_t* v = ( d3d_vertex_t* )_alloca( VERTEX_SIZE * res ); + const float step = M_PI * 2.0f / res; + + for( size_t i{ }; i < res; ++i ) { + float theta = i * step; + float x_off = r * cos( theta ); + float y_off = r * sin( theta ); + + v[ i ] = { float( x + x_off ), float( y + y_off ), 1.0f, color }; + } + + m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, true ); + m_device->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, res, v, VERTEX_SIZE ); + m_device->SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, false ); + } + + void c_renderer::draw_text( ID3DXFont* font, clr_t color, + int x, int y, FontAlign_t align, long font_flags, const char* msg ) { + if( !msg ) return; + if( !font ) return; + + auto d3d_black = D3DCOLOR_RGBA( 0, 0, 0, color.a( ) ); + auto d3d_color = D3DCOLOR_RGBA( color.r( ), color.g( ), color.b( ), color.a( ) ); + auto buf = msg; + + if( align == ALIGN_CENTER ) x -= get_text_width( font, font_flags, msg ) / 2; + if( align == ALIGN_RIGHT ) x -= get_text_width( font, font_flags, msg ); + RECT rect{ x, y, 1000, 100 }; + + ulong_t flags = DT_NOCLIP | DT_LEFT | DT_TOP; + + if( font_flags & D3DFONTFLAG_DROPSHADOW ) { + RECT r{ rect }; + r.left++; + r.top++; + font->DrawTextA( 0, buf, -1, &r, flags, d3d_black ); + } + + if( font_flags & D3DFONTFLAG_OUTLINE ) { + for( int i = -1; i < 2; i++ ) { + if( !i ) continue; + RECT r{ rect }; + r.left += i; + r.top += i; + font->DrawTextA( 0, buf, -1, &r, flags, d3d_black ); + } + } + + font->DrawTextA( 0, buf, -1, &rect, flags, d3d_color ); + } + + int c_renderer::get_text_width( ID3DXFont* font, long flags, const char* msg, ... ) { + char* buffer = ( char* )_alloca( 2048 ); + va_list list{ }; + + memset( buffer, 0, 2048 ); + + __crt_va_start( list, msg ); + vsprintf_s( buffer, 2048, msg, list ); + __crt_va_end( list ); + + RECT temp{ }; + font->DrawTextA( 0, buffer, -1, &temp, DT_CALCRECT, 0x0 ); + + return ( temp.right - temp.left ); + } + + int c_renderer::get_text_height( ID3DXFont* font, long flags, const char* msg, ... ) { + char* buffer = ( char* )_alloca( 2048 ); + va_list list{ }; + + memset( buffer, 0, 2048 ); + + __crt_va_start( list, msg ); + vsprintf_s( buffer, 2048, msg, list ); + __crt_va_end( list ); + + RECT temp{ }; + font->DrawTextA( 0, buffer, -1, &temp, DT_CALCRECT, 0x0 ); + + return ( temp.bottom - temp.top ); + } +}
\ No newline at end of file diff --git a/internal_rewrite/d3d.hpp b/internal_rewrite/d3d.hpp new file mode 100644 index 0000000..36babe2 --- /dev/null +++ b/internal_rewrite/d3d.hpp @@ -0,0 +1,129 @@ +#ifndef D3D_HEADER //stackoverflow my niggas +#define D3D_HEADER + +#include <d3d9.h> +#include <d3dx9.h> + +#pragma comment(lib, "d3d9.lib") +#pragma comment(lib, "d3dx9.lib") +#pragma warning(disable : 4838) + +#include <xnamath.h> +#include <windows.h> + +#include <dwmapi.h> +#pragma comment(lib, "dwmapi.lib") + +#include "util.hpp" +#include "color.hpp" +#include "renderer.hpp" + +enum D3DFontFlags_t { + D3DFONTFLAG_OUTLINE = 0x10, + D3DFONTFLAG_DROPSHADOW = 0x100, +}; + +enum GradientType_t { + GRADIENT_HORIZONTAL, + GRADIENT_VERTICAL +}; + +namespace features { class c_chams; } + +//suck my dick +namespace d3d +{ + struct d3d_vertex_t { + d3d_vertex_t( float x, float y, float z, clr_t color ) : + m_x( x ), m_y( y ), m_z( z ), + m_clr( D3DCOLOR_RGBA( color.r( ), color.g( ), color.b( ), color.a( ) ) ) { }; + + d3d_vertex_t( ) : m_x( 0.f ), m_y( 0.f ), m_z( 0.f ), + m_clr( 0 ) { }; + + float m_x; + float m_y; + float m_z; + float m_rhw = 1.f; + D3DCOLOR m_clr; + }; + + constexpr size_t VERTEX_SIZE = sizeof( d3d_vertex_t ); + + struct d3d_fonts_t { + void release( ); + void create( IDirect3DDevice9* device ); + + ID3DXFont* f_12; + ID3DXFont* f_esp_small; + ID3DXFont* f_16; + ID3DXFont* f_18; + ID3DXFont* f_menu; + ID3DXFont* f_con; + }; + + class c_renderer { + private: + friend class features::c_chams; + + IDirect3DDevice9* m_device; + IDirect3DStateBlock9* m_block; + IDirect3DTexture9* m_chams; + IDirect3DTexture9* m_sil_txt; + IDirect3DVertexBuffer9* m_buffer; + IDirect3DSurface9* m_surface; + public: + ulong_t m_width; + ulong_t m_height; + + c_renderer( ) { }; + c_renderer( IDirect3DDevice9* device ); + ~c_renderer( ); + + void on_device_lost( ); + void on_device_reset( ); + auto get_device( ) { + return m_device; + } + + bool run_frame( IDirect3DDevice9* device ); + void begin( ); + void end( ); + + void draw_line( clr_t color, int x0, int y0, int x1, int y1 ); + void draw_rect( clr_t color, int x, int y, int w, int h ); + void draw_filled_rect( clr_t color, int x, int y, int w, int h ); + void draw_circle( clr_t color, int x, int y, int r, int steps = 48 ); + void draw_filled_circle( clr_t color, int x, int y, int r, int steps = 48 ); + void draw_gradient( clr_t start, clr_t end, int x, int y, int w, int h, GradientType_t type ); + + void draw_text( ID3DXFont* font, clr_t color, int x, int y, FontAlign_t align, long font_flags, const char* msg ); + + template < FontAlign_t align = ALIGN_CENTER > + void draw_text( ID3DXFont* font, clr_t color, int x, int y, long font_flags, const char* msg, ... ) { + char* buffer = ( char* )_alloca( 2048 ); + va_list list{ }; + + memset( buffer, 0, 2048 ); + + __crt_va_start( list, msg ); + vsprintf_s( buffer, 2048, msg, list ); + __crt_va_end( list ); + + draw_text( font, color, x, y, align, font_flags, buffer ); + } + + int get_text_width( ID3DXFont* font, long font_flags, const char* msg, ... ); + int get_text_height( ID3DXFont* font, long font_flags, const char* msg, ... ); + + private: + void invalidate_objects( ); + void create_objects( ); + }; + + extern d3d::d3d_fonts_t fonts; +} + +extern d3d::c_renderer g_d3d; + +#endif
\ No newline at end of file diff --git a/internal_rewrite/d3d_sprite.cpp b/internal_rewrite/d3d_sprite.cpp new file mode 100644 index 0000000..8c26c37 --- /dev/null +++ b/internal_rewrite/d3d_sprite.cpp @@ -0,0 +1,12 @@ +#include "d3d_sprite.hpp" + +std::vector< d3d::c_sprite* > d3d::sprites; + +namespace icons +{ + d3d::c_sprite sprite_legit; + d3d::c_sprite sprite_rage; + d3d::c_sprite sprite_visuals; + d3d::c_sprite sprite_misc; + d3d::c_sprite sprite_config; +}
\ No newline at end of file diff --git a/internal_rewrite/d3d_sprite.hpp b/internal_rewrite/d3d_sprite.hpp new file mode 100644 index 0000000..3cf46a6 --- /dev/null +++ b/internal_rewrite/d3d_sprite.hpp @@ -0,0 +1,158 @@ +#pragma once +#include "d3d.hpp" +#include "console.hpp" + + +namespace d3d +{ + class c_sprite; + + extern std::vector< c_sprite* > sprites; + + class c_sprite { + public: + size_t m_width{ }; + size_t m_height{ }; + + IDirect3DDevice9* m_device{ }; + ID3DXSprite* m_sprite{ }; + IDirect3DTexture9* m_texture{ }; + const byte* m_image{ }; + size_t m_image_size{ }; + + + public: + c_sprite::c_sprite( ) { + sprites.push_back( this ); + } + + c_sprite::~c_sprite( ) { + on_reset( ); + } + + void init( IDirect3DDevice9* device, const byte* file, size_t img_size, size_t width, size_t height ) { + m_width = width; + m_height = height; + + m_device = device; + m_image = file; + m_image_size = img_size; + } + + void begin( IDirect3DDevice9* device ) { + m_device = device; + + if( !m_device ) { + return; + } + + if( !m_sprite ) + D3DXCreateSprite( m_device, &m_sprite ); + + if( !m_texture ) { + auto hr = D3DXCreateTextureFromFileInMemoryEx( + m_device, m_image, m_image_size, + m_width, m_height, D3DX_DEFAULT, 0, D3DFMT_A8B8G8R8, + D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, + 0, 0, &m_texture ); + } + + if( m_sprite ) + m_sprite->Begin( D3DXSPRITE_DONOTMODIFY_RENDERSTATE ); + } + + void end( ) { + if( !m_device || !m_sprite || !m_texture ) return; + m_sprite->End( ); + } + + void on_reset( ) { + if( m_sprite && m_device && m_texture ) { + m_sprite->OnLostDevice( ); + m_texture->Release( ); + m_texture = nullptr; + } + } + + void on_reset_end( ) { + if( m_sprite && m_device ) + m_sprite->OnResetDevice( ); + } + + void draw( int x, int y, clr_t color ) { + if( !m_device || !m_texture || !m_sprite ) { + return; + } + + const float scale = 0.8f; + + ulong_t + fill_mode, + adaptive_tess, + dest_blend, + cull, + stencil, + vertex_blend, + alpha_test; + + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_FILLMODE, &fill_mode ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_ENABLEADAPTIVETESSELLATION, &adaptive_tess ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_DESTBLEND, &dest_blend ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_CULLMODE, &cull ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_STENCILENABLE, &stencil ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_VERTEXBLEND, &vertex_blend ); + m_device->GetRenderState( D3DRENDERSTATETYPE::D3DRS_ALPHATESTENABLE, &alpha_test ); + + ulong_t mag_filter; + ulong_t min_filter; + m_device->GetSamplerState( 0, D3DSAMPLERSTATETYPE::D3DSAMP_MAGFILTER, &mag_filter ); + m_device->GetSamplerState( 0, D3DSAMPLERSTATETYPE::D3DSAMP_MINFILTER, &min_filter ); + + m_device->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC ); + m_device->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC ); + + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_FILLMODE, D3DFILL_SOLID ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_ENABLEADAPTIVETESSELLATION, false ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_CULLMODE, D3DCULL_NONE ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_STENCILENABLE, false ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_VERTEXBLEND, false ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_ALPHATESTENABLE, D3DLINECAPS_ALPHACMP ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_MULTISAMPLEANTIALIAS, D3DMULTISAMPLE_4_SAMPLES ); + + + ulong_t hr; + D3DXVECTOR2 center = D3DXVECTOR2( ( m_width * scale ) * 0.5f, ( m_height * scale ) * 0.5f ); + D3DXVECTOR2 trans = D3DXVECTOR2( x - center.x, y - center.y ); + D3DXMATRIX matrix; + D3DXVECTOR2 scale_vec( scale, scale ); + D3DXMatrixTransformation2D( &matrix, 0, 0.f, &scale_vec, ¢er, 0.f, &trans ); + + hr = m_sprite->SetTransform( &matrix ); + + auto d3dcolor = D3DCOLOR_RGBA( color.r( ), + color.g( ), color.b( ), color.a( ) ); + hr = m_sprite->Draw( m_texture, 0, 0, 0, d3dcolor ); + + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_MULTISAMPLEANTIALIAS, false ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_FILLMODE, fill_mode ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_ENABLEADAPTIVETESSELLATION, adaptive_tess ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_DESTBLEND, dest_blend ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_CULLMODE, cull ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_STENCILENABLE, stencil ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_VERTEXBLEND, vertex_blend ); + m_device->SetRenderState( D3DRENDERSTATETYPE::D3DRS_ALPHATESTENABLE, alpha_test ); + + m_device->SetSamplerState( 0, D3DSAMPLERSTATETYPE::D3DSAMP_MAGFILTER, mag_filter ); + } + }; +} + +namespace icons +{ + extern d3d::c_sprite sprite_legit; + extern d3d::c_sprite sprite_rage; + extern d3d::c_sprite sprite_visuals; + extern d3d::c_sprite sprite_misc; + extern d3d::c_sprite sprite_config; +}
\ No newline at end of file diff --git a/internal_rewrite/debug_show_spread.cpp b/internal_rewrite/debug_show_spread.cpp new file mode 100644 index 0000000..1dd0c8c --- /dev/null +++ b/internal_rewrite/debug_show_spread.cpp @@ -0,0 +1,16 @@ +#include "hooks.hpp" +#include "context.hpp" + +int __fastcall hooks::debug_show_spread_get_int( void* ecx_, void* edx_ ) { + static auto original_fn = g_csgo.m_debug_show_spread->get_old_function< decltype( &debug_show_spread_get_int ) >( 13 ); + if( !g_settings.visuals.snipers_crosshair || !g_ctx.run_frame( ) || !g_ctx.m_local->is_valid( ) || g_ctx.m_local->m_bIsScoped( ) ) { + return original_fn( ecx_, 0 ); + } + + auto weapon = g_ctx.m_local->get_weapon( ); + if( !weapon || !weapon->is_sniper( ) ) { + return original_fn( ecx_, 0 ); + } + + return 3; +}
\ No newline at end of file diff --git a/internal_rewrite/directx.cpp b/internal_rewrite/directx.cpp new file mode 100644 index 0000000..2175e46 --- /dev/null +++ b/internal_rewrite/directx.cpp @@ -0,0 +1,249 @@ +#include <chrono>
+#include <thread>
+
+#include "settings.hpp"
+#include "hooks.hpp"
+#include "ui.h"
+#include "base_cheat.hpp"
+#include "context.hpp"
+#include "mem.hpp"
+
+using namespace d3d;
+
+float ui::get_csgo_frametime( ) {
+ return g_csgo.m_frametime;
+}
+
+float ui::anim_time;
+
+void on_d3d( IDirect3DDevice9* device ) {
+ constexpr float step = 1.0f / 2.f;
+ constexpr float fade_step = 1.0f / 7.f;
+ static float anim_time{ };
+ static bool flip{ };
+ static int anim_progress{ };
+
+ static bool sprites_init{ };
+ if( !sprites_init ) {
+ ui::setup_sprites( device );
+ sprites_init = true;
+ }
+
+ if( g_settings.misc.hide_from_obs )
+ g_cheat.m_visuals( );
+
+ if( g_settings.menu.open ) {
+ if( anim_time >= 0.95f ) {
+ flip = true;
+ }
+ if( anim_time <= 0.05f ) {
+ flip = false;
+ }
+
+ if( flip )
+ anim_time -= fade_step * ui::ui_get_frametime( );
+ else
+ anim_time += fade_step * ui::ui_get_frametime( );
+
+ anim_time = std::clamp( anim_time, 0.f, 1.0f );
+
+ ui::set_animtime( anim_time );
+
+ anim_progress += ui::ui_get_frametime( ) * step * 255;
+ anim_progress = std::clamp( anim_progress, 0, 50 );
+ g_d3d.draw_filled_rect( clr_t( 0, 0, 0, anim_progress ),
+ 0, 0, g_d3d.m_width, g_d3d.m_height );
+
+ ui::render( );
+ }
+ else {
+ anim_progress = 0;
+ }
+}
+
+long __stdcall hooks::d3d::draw( IDirect3DDevice9* device, D3DPRIMITIVETYPE type, int v_index, uint32_t min_index, uint32_t num_vert, uint32_t start_index, uint32_t prim_count ) {
+ static auto draw_o = g_csgo.m_d3d->get_old_function< decltype( &hooks::d3d::draw ) >( 82 );
+
+ static auto ret_addr = pattern::first_code_match( GetModuleHandleA( xors( "studiorender.dll" ) ), xors( "EB 1F FF 75 F0" ), -8 );
+
+ std::function< void*( void** ) > find_ent;
+ find_ent = [ & ]( void** ebp ) -> void* {
+ if( !ebp )
+ return nullptr;
+
+ void** next = *( void*** )( ebp );
+ if( ( uintptr_t )( ebp[ 1 ] ) == ret_addr )
+ return next[ 4 ];
+
+ return find_ent( next );
+ };
+
+ c_base_player* ent = ( c_base_player* )( find_ent( ( void** )( get_baseptr( ) ) ) );
+ if( g_ctx.m_local && !!ent && ent->m_iHealth( ) > 0 && ent->m_iTeamNum( ) > 1 && g_settings.visuals.chams.enabled( ) && g_settings.misc.hide_from_obs ) {
+ g_cheat.m_chams.d3d_render_chams( ent, type, v_index, min_index, num_vert, start_index, prim_count );
+ return true;
+ }
+
+ auto result = draw_o( device, type, v_index, min_index, num_vert, start_index, prim_count );
+ return result;
+}
+
+long __stdcall hooks::d3d::end_scene( IDirect3DDevice9* device ) {
+ static auto end_scene_o = g_csgo.m_d3d->get_old_function< decltype( &hooks::d3d::end_scene ) >( 42 );
+ if ( g_csgo.m_panic ) return end_scene_o( device );
+
+ static uintptr_t return_address = 0;
+ static uintptr_t gameoverlay_return_address = 0;
+
+ g_csgo.m_d3d_thread = std::this_thread::get_id( );
+
+ if( !return_address ) {
+ return_address = ( uintptr_t )( _ReturnAddress( ) );
+ }
+
+ if( !gameoverlay_return_address ) {
+ MEMORY_BASIC_INFORMATION info;
+ VirtualQuery( _ReturnAddress( ), &info, sizeof( MEMORY_BASIC_INFORMATION ) );
+
+ char mod[ MAX_PATH ];
+ GetModuleFileNameA( ( HMODULE )info.AllocationBase, mod, MAX_PATH );
+
+ if( strstr( mod, xors( "gameoverlay" ) ) )
+ gameoverlay_return_address = ( uintptr_t )( _ReturnAddress( ) );
+ }
+
+ if( return_address != ( uintptr_t )( _ReturnAddress( ) ) && !g_settings.misc.hide_from_obs )
+ return end_scene_o( device );
+
+ if( gameoverlay_return_address != ( uintptr_t )( _ReturnAddress( ) ) && g_settings.misc.hide_from_obs )
+ return end_scene_o( device );
+
+ if( !g_csgo.m_panic && g_d3d.run_frame( device ) ) {
+ for( auto& it : ::d3d::sprites )
+ it->begin( device );
+ g_d3d.begin( );
+
+ //if( g_settings.misc.hide_from_obs )
+ //g_cheat.m_chams.d3d_render_textures( );
+
+ on_d3d( device );
+
+ std::chrono::high_resolution_clock timer;
+ static auto last = timer.now( );
+ auto now = timer.now( );
+
+ std::chrono::duration< double > delta = now - last;
+ last = timer.now( );
+
+ g_csgo.m_frametime = delta.count( );
+
+ if( !g_con->m_logs.empty( ) && g_settings.menu.logs_enable ) {
+ auto& logs = g_con->m_logs;
+ float time = ( float )GetTickCount( ) * 0.001f;
+
+ auto data = logs.data( );
+
+ int cur_pos = 2;
+ for( int i = logs.size( ) - 1; i >= 0; --i ) {
+ if( cur_pos > g_d3d.m_height - 200 ) {
+ cur_pos -= 8;
+ break;
+ }
+
+ float delta = time - data[ i ].m_time;
+ if( delta >= 5.0f ) {
+ break;
+ }
+
+ clr_t col( 255, 255, 255 );
+ if( delta > 4.f ) col.a( ) *= ( 6.f - delta );
+
+ g_d3d.draw_text< ALIGN_RIGHT >( fonts.f_con, col, g_d3d.m_width - 5, cur_pos, D3DFONTFLAG_DROPSHADOW, data[ i ].m_msg );
+ cur_pos += 10;
+ }
+ }
+
+ if( g_settings.menu.open || g_con->m_open ) {
+ ui::ui_draw_cursor( );
+ }
+
+ for( auto& it : ::d3d::sprites )
+ it->end( );
+ g_d3d.end( );
+ }
+
+ return end_scene_o( device );
+}
+
+long __stdcall hooks::d3d::present( IDirect3DDevice9* device, RECT* source, RECT* dest, HWND wnd_override, RGNDATA* reg ) {
+ static auto present_o = g_csgo.m_d3d->get_old_function< decltype( &hooks::d3d::present ) >( 17 );
+
+ static uintptr_t return_address = 0;
+ if( !return_address ) {
+ return_address = ( uintptr_t )( _ReturnAddress( ) );
+ }
+
+ if( return_address && return_address != ( uintptr_t )( _ReturnAddress( ) ) )
+ return present_o( device, source, dest, wnd_override, reg );
+
+ if( g_d3d.run_frame( device ) ) {
+ g_d3d.begin( );
+ if( g_settings.misc.watermark ) {
+ static std::string date;
+ std::string str;
+
+ static bool transformed = false;
+ if( !transformed ) {
+ date += __DATE__;
+ std::transform( date.begin( ), date.end( ), date.begin( ),
+ [ ]( char c ) { return ::tolower( c ); } );
+
+ transformed = true;
+ }
+
+ str = xors( "moneybot | " );
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( nci ) {
+ char latency_str[ 32 ];
+ strenc::w_sprintf_s( latency_str, 32, xors( "lt: %1.2f + %1.2f | " ), nci->GetLatency( 0 ), nci->GetLatency( 1 ) );
+ str += latency_str;
+ }
+ else {
+ str += xors( "unconnected | " );
+ }
+
+ str += date;
+
+ g_d3d.draw_text< ALIGN_RIGHT >( ::d3d::fonts.f_menu,
+ ui::ui_get_text_col( ), g_d3d.m_width - 10, 8,
+ D3DFONTFLAG_DROPSHADOW, str.c_str( ) );
+ }
+
+ g_con->draw( );
+ if( ( g_settings.menu.open || g_con->m_open ) && !g_settings.misc.hide_from_obs ) {
+ ui::ui_draw_cursor( );
+ }
+ g_d3d.end( );
+ }
+
+ return present_o( device, source, dest, wnd_override, reg );
+}
+
+long __stdcall hooks::d3d::reset( IDirect3DDevice9* device, D3DPRESENT_PARAMETERS* params ) {
+ static auto reset_o = g_csgo.m_d3d->get_old_function< decltype( &hooks::d3d::reset ) >( 16 );
+ if ( g_csgo.m_panic ) {
+ return reset_o( device, params );
+ }
+
+ for( auto& sprite : ::d3d::sprites )
+ sprite->on_reset( );
+
+ g_d3d.on_device_lost( );
+ long result = reset_o( device, params );
+ g_d3d.on_device_reset( );
+
+ for( auto& sprite : ::d3d::sprites )
+ sprite->on_reset_end( );
+
+ return result;
+}
\ No newline at end of file diff --git a/internal_rewrite/do_post_screen_space_effects.cpp b/internal_rewrite/do_post_screen_space_effects.cpp new file mode 100644 index 0000000..7786dd8 --- /dev/null +++ b/internal_rewrite/do_post_screen_space_effects.cpp @@ -0,0 +1,17 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +bool __fastcall hooks::do_post_screen_space_effects( void* ecx_, void* edx_, CViewSetup* setup ) { + static auto old_fn = g_csgo.m_clientmode->get_old_function< decltype( &do_post_screen_space_effects ) >( 44 ); + + g_ctx.m_drawing_postscreenspace = true; + if( g_csgo.m_engine( )->IsInGame( ) && g_ctx.m_local ) { + g_cheat.m_visuals.update_glow( ); + } + + bool ret = old_fn( ecx_, 0, setup ); + g_ctx.m_drawing_postscreenspace = false; + + return ret; +}
\ No newline at end of file diff --git a/internal_rewrite/draw_model_execute.cpp b/internal_rewrite/draw_model_execute.cpp new file mode 100644 index 0000000..1ab2732 --- /dev/null +++ b/internal_rewrite/draw_model_execute.cpp @@ -0,0 +1,135 @@ +#include "hooks.hpp"
+#include "base_cheat.hpp"
+#include "context.hpp"
+#include "util.hpp"
+#include "settings.hpp"
+//this is so ugly dont even look at it
+
+//gets called once per frame for every entity
+void __fastcall hooks::draw_model_execute( IVModelRender* ecx_, void* edx_,
+ void* render_ctx, const DrawModelState_t& state,
+ const ModelRenderInfo_t& info, matrix3x4* bone_to_world ) {
+ static auto dme_o = g_csgo.m_model_render->get_old_function< decltype( &hooks::draw_model_execute ) >( 21 );
+
+ if( g_csgo.m_panic || g_ctx.m_drawing_postscreenspace || g_settings.misc.hide_from_obs )
+ return dme_o( ecx_, edx_, render_ctx, state, info, bone_to_world );
+
+ bool draw = true;
+ IMaterial* mat = g_settings.visuals.chams.flat( ) ? g_cheat.m_chams.m_materials.m_chams_flat : g_cheat.m_chams.m_materials.m_chams;
+ auto model_name = g_csgo.m_model_info( )->GetModelName( info.m_model );
+ auto local_index = g_csgo.m_engine( )->GetLocalPlayer( );
+ int local_team = 0;
+ if( g_ctx.m_local )
+ local_team = g_ctx.m_local->m_iTeamNum( );
+ int team = 0;
+ bool is_player = false;
+
+ if( strstr( model_name, xors( "models/player" ) ) && info.m_entity_index == local_index ) {
+ if( g_settings.misc.thirdperson( ) && g_ctx.m_local && g_ctx.m_local->is_valid( )
+ && g_ctx.m_local->m_bIsScoped( ) ) {
+ float clr[ ] = { 1.0f, 1.0f, 1.0f };
+ g_csgo.m_render_view( )->SetColorModulation( clr );
+ g_csgo.m_render_view( )->SetBlend( 0.5f );
+ return dme_o( ecx_, edx_, render_ctx, state, info, bone_to_world );
+ }
+ }
+
+ if( strstr( model_name, xors( "models/player" ) ) && info.m_entity_index ) {
+ auto player = g_csgo.m_entlist( )->GetClientEntity< >( info.m_entity_index );
+
+ if( player && player->is_valid( ) && !player->m_bGunGameImmunity( ) ) {
+ is_player = true;
+ team = player->m_iTeamNum( );
+
+ if( g_settings.visuals.chams.enabled ) {
+ if( g_settings.visuals.chams.ignore_z && !g_ctx.m_drawing_screneend && ( team != local_team || g_settings.visuals.chams.friendlies( ) ) && g_settings.visuals.chams.clear_occlusion )
+ draw = false;
+ else if( ( !g_settings.visuals.chams.ignore_z || !g_settings.visuals.chams.clear_occlusion ) && ( team != local_team || g_settings.visuals.chams.friendlies( ) ) ) {
+ fclr_t clr = team != local_team ? g_settings.visuals.chams.color_visible_enemy( ) : g_settings.visuals.chams.color_visible_friendly( );
+
+ if( g_settings.visuals.chams.ignore_z ) {
+ fclr_t clr = team != local_team ? g_settings.visuals.chams.color_hidden_enemy( ) : g_settings.visuals.chams.color_hidden_friendly( );
+
+ mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
+ g_cheat.m_chams.m_materials.force_material( mat, clr );
+ dme_o( ecx_, 0, render_ctx, state, info, bone_to_world );
+ }
+
+ mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
+ g_cheat.m_chams.m_materials.force_material( mat, clr );
+ dme_o( ecx_, 0, render_ctx, state, info, bone_to_world );
+
+ g_csgo.m_model_render( )->ForcedMaterialOverride( nullptr );
+ g_csgo.m_render_view( )->SetBlend( 1.0f );
+ draw = false;
+ }
+ }
+
+ }
+ }
+
+ if( g_settings.misc.transparent_vm && strstr( model_name, xors( "weapon" ) ) ) {
+ if( strstr( model_name, xors( "arms" ) ) ) {
+ g_csgo.m_render_view( )->SetBlend( 0.6f );
+ }
+ }
+
+ if( is_player ) {
+ bool should_draw = false;
+ if( g_settings.rage.enabled( ) && g_settings.rage.resolver( ) && g_settings.rage.bt_visualize( ) && ( team != local_team || g_settings.rage.friendlies( ) ) )
+ should_draw = true;
+ if( g_settings.legit.enabled( ) && g_settings.legit.backtracking_visualize( ) && ( team != local_team || g_settings.rage.friendlies( ) ) )
+ should_draw = true;
+
+
+ if( should_draw ) {
+ matrix3x4 render_matrix[ 128 ];
+
+ if( g_cheat.m_ragebot.m_lagcomp->get_render_record( info.m_entity_index, render_matrix ) ) {
+ fclr_t clr_hid = team != local_team ? g_settings.visuals.chams.color_hidden_enemy( ).to_fclr( ) : g_settings.visuals.chams.color_hidden_friendly( ).to_fclr( );
+
+ float backup_modulation[ 3 ]{ };
+ bool backup_ignorez = false;
+ bool wanted_ignorez = g_settings.visuals.chams.ignore_z( );
+ float backup_blend = 1.0f;
+
+ backup_blend = g_csgo.m_render_view( )->GetBlend( );
+ g_csgo.m_render_view( )->GetColorModulation( backup_modulation );
+
+ //BIG ROFL
+ if( backup_modulation[ 0 ] == clr_hid.r( ) && backup_modulation[ 1 ] == clr_hid.g( ) && backup_modulation[ 2 ] == clr_hid.b( )
+ && backup_blend == clr_hid.a( ) ) {
+ backup_ignorez = true;
+ }
+
+ if( backup_ignorez == wanted_ignorez || !backup_ignorez && !g_settings.visuals.chams.clear_occlusion( ) ) {
+ auto flat_mat = g_cheat.m_chams.m_materials.m_chams_flat.m_mat;
+ flat_mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, g_settings.visuals.chams.ignore_z && g_settings.visuals.chams.enabled );
+
+ clr_t bt_col = g_settings.legit.enabled( ) ? g_settings.legit.backtracking_col( ) : g_settings.rage.bt_col( );
+
+ g_cheat.m_chams.m_materials.force_material( g_cheat.m_chams.m_materials.m_chams_flat, bt_col );
+
+ dme_o( ecx_, edx_, render_ctx, state, info, render_matrix );
+ flat_mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, backup_ignorez );
+ }
+
+ g_csgo.m_render_view( )->SetBlend( backup_blend );
+ g_csgo.m_render_view( )->SetColorModulation( backup_modulation );
+ g_csgo.m_model_render( )->ForcedMaterialOverride( g_settings.visuals.chams.enabled( ) &&
+ ( team != local_team || g_settings.visuals.chams.friendlies( ) ) ? mat : nullptr );
+
+ if( draw ) {
+ dme_o( ecx_, edx_, render_ctx, state, info, bone_to_world );
+ draw = false;
+ }
+ }
+ }
+ }
+
+ if( draw ) {
+ dme_o( ecx_, 0, render_ctx, state, info, bone_to_world );
+ }
+
+ g_csgo.m_model_render( )->ForcedMaterialOverride( nullptr );
+}
\ No newline at end of file diff --git a/internal_rewrite/draw_small_entities.cpp b/internal_rewrite/draw_small_entities.cpp new file mode 100644 index 0000000..59f3ff0 --- /dev/null +++ b/internal_rewrite/draw_small_entities.cpp @@ -0,0 +1,28 @@ +#include <intrin.h> + +#include "hooks.hpp" +#include "context.hpp" +#include "settings.hpp" +#include "base_cheat.hpp" + +void __fastcall hooks::draw_small_entities( void* ecx, void* edx, bool state ) { + static auto draw_small_entities_o = g_csgo.m_clientleaf->get_old_function< decltype( &hooks::draw_small_entities ) >( 39 ); + + static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_chl.dll( ), "FF 90 ? ? ? ? FF 15 ? ? ? ? 84 C0 74 28", 6 ); + + // please shoot me + // i have given up + // i want to leave + if( _ReturnAddress( ) == ret_addr ) { + g_ctx.m_stage = FRAME_RENDER_END; + g_cheat.m_visuals.world_modulate( ); + + //g_con->game_console_print( "render end\n" ); + // FRAME_RENDER_END + g_cheat.m_ragebot.m_lagcomp->store_visuals( ); + g_cheat.m_chams.m_materials.update_materials( ); + g_cheat.m_extra.no_recoil( true ); + } + + draw_small_entities_o( ecx, edx, state ); +}
\ No newline at end of file diff --git a/internal_rewrite/emit_sound.cpp b/internal_rewrite/emit_sound.cpp new file mode 100644 index 0000000..79ed3f1 --- /dev/null +++ b/internal_rewrite/emit_sound.cpp @@ -0,0 +1,26 @@ +#include "base_cheat.hpp" +#include "hooks.hpp" +#include "settings.hpp" +void __fastcall hooks::emit_sound( void* ecx_, void* edx_, void* filter, int ent, int channel, const char* sound, uint32_t hash, + const char* sample, float volume, float attenuation, int seed, int flags, int pitch, const vec3_t* origin, + const vec3_t* direction, vec3_t* origins, bool update_pos, float sound_time, int speaker_entry ) { + static auto emit_sound_o = g_csgo.m_engine_sound->get_old_function< decltype( &hooks::emit_sound ) >( 5 ); + + if( !g_csgo.m_panic && origin ) { + auto entity = g_csgo.m_entlist( )->GetClientEntity< >( ent ); + if( entity && entity->is_player( ) && entity->ce( )->IsDormant( ) && + ent >= 0 && ent <= 64 ) + g_cheat.m_visuals.update_position( ent, *origin ); + } + + if( strstr( sample, xors( "weapon" ) ) && g_settings.misc.no_sound ) + volume = 0.f; + + if( ( strstr( sample, xors( "player/footsteps" ) ) || strstr( sample, xors( "player/land" ) ) ) && origin && g_settings.visuals.sound ) { + g_cheat.m_visuals.store_sound( ent, *origin ); + } + + emit_sound_o( ecx_, 0, filter, ent, channel, sound, hash, sample, + volume, attenuation, seed, flags, pitch, origin, direction, + origins, update_pos, sound_time, speaker_entry ); +}
\ No newline at end of file diff --git a/internal_rewrite/end_lock.cpp b/internal_rewrite/end_lock.cpp new file mode 100644 index 0000000..e0b30d8 --- /dev/null +++ b/internal_rewrite/end_lock.cpp @@ -0,0 +1,23 @@ +#include <intrin.h> + +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::end_lock( void* ecx, void* edx ) { // THIS IS PROLLY NOT ENDLOCK, BUT WHATEVER + static auto end_lock_o = g_csgo.m_mdl_cache->get_old_function< decltype( &hooks::end_lock ) >( 34 ); + + + // signature: + // search "CL_CallPostDataUpdates: missing ent %d" in engine.dll. + // where framestagenotify gets called + static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_engine.dll( ), "FF 50 18 FF 75 F0", 0x27 ); + if( _ReturnAddress( ) == ret_addr ) { + g_ctx.m_stage = FRAME_NET_UPDATE_POSTDATAUPDATE_END; + g_cheat.m_visuals.world_modulate( ); + + //g_con->game_console_print( "net postdataupdate end\n" ); + } + + end_lock_o( ecx, edx ); +}
\ No newline at end of file diff --git a/internal_rewrite/extra.cpp b/internal_rewrite/extra.cpp new file mode 100644 index 0000000..58fa03a --- /dev/null +++ b/internal_rewrite/extra.cpp @@ -0,0 +1,366 @@ +#include "base_cheat.hpp"
+#include "context.hpp"
+#include "input_system.hpp"
+#include "math.hpp"
+#include "hooks.hpp"
+#include "interface.hpp"
+#undef min
+
+
+namespace features
+{
+ void c_extra::rank_reveal( user_cmd_t* ucmd ) {
+ if( !( ucmd->m_buttons & IN_SCORE ) || !g_settings.misc.rank_reveal( ) ) return;
+
+ vec3_t a{ }; //stop this
+ static uintptr_t show_rank_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 8B 0D ? ? ? ? 68" ) );
+ //reinterpret_cast<bool( __cdecl* )( vec3_t* )>( show_rank_addr )( &a );
+
+ }
+
+ void c_extra::thirdperson( ) {
+ if( !g_ctx.m_local )
+ return;
+
+ static bool enabled = false;
+ static bool toggle = true;
+ static bool key_held = false;
+
+
+ if( g_input.is_key_pressed( ( VirtualKeys_t )g_settings.misc.thirdperson_key( ) ) ) {
+ if( !key_held ) {
+ toggle ^= 1;
+ }
+ key_held = true;
+ }
+ else {
+ key_held = false;
+ }
+
+ if( !g_settings.misc.thirdperson || !toggle ) {
+ if( enabled ) {
+ g_csgo.m_input( )->m_fCameraInThirdPerson = false;
+ enabled = false;
+ }
+
+ return;
+ }
+
+ vec3_t viewangles{ };
+ if( g_ctx.m_local->is_alive( ) ) {
+ g_csgo.m_engine( )->GetViewAngles( viewangles );
+ g_csgo.m_input( )->m_fCameraInThirdPerson = true;
+ g_csgo.m_input( )->m_vecCameraOffset = vec3_t( viewangles.x, viewangles.y, 150.0f );
+
+ constexpr float cam_hull_offset{ 16.f };
+
+ const vec3_t cam_hull_min( -cam_hull_offset, -cam_hull_offset, -cam_hull_offset );
+ const vec3_t cam_hull_max( cam_hull_offset, cam_hull_offset, cam_hull_offset );
+ vec3_t cam_forward, origin = g_ctx.m_local->get_eye_pos( );
+
+ cam_forward = math::angle_vectors( vec3_t( viewangles.x, viewangles.y, 0.f ) );
+
+ CTraceFilterWorldAndPropsOnly filter;
+ Ray_t ray;
+ CGameTrace tr;
+
+ ray.Init( origin, origin - ( cam_forward * 150.f ), cam_hull_min, cam_hull_max );
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SOLID & ~CONTENTS_MONSTER, &filter, &tr );
+ g_csgo.m_input( )->m_vecCameraOffset.z = 150.f * tr.fraction;
+
+ enabled = true;
+ }
+ else if( g_csgo.m_entlist( )->GetClientEntityFromHandle< >( g_ctx.m_local->m_hObserverTarget( ) ) ) {
+ g_csgo.m_input( )->m_fCameraInThirdPerson = false;
+ g_ctx.m_local->m_iObserverMode( ) = 5;
+ }
+ }
+
+ void c_extra::update_netchannel( ) {
+ if( !g_csgo.m_engine( )->IsInGame( ) || !g_ctx.m_local ||
+ !g_ctx.m_local->is_valid( ) ) {
+ return;
+ }
+
+ switch( g_settings.misc.net_fakelag ) {
+ case 0:
+ g_settings.misc.net_fakeping_active = false;
+ break;
+ case 1:
+ g_settings.misc.net_fakeping_active = g_input.is_key_pressed( g_settings.misc.net_fakeping_key );
+ break;
+ case 2: {
+ static bool held = false;
+ bool pressed = g_input.is_key_pressed( g_settings.misc.net_fakeping_key );
+ if( pressed ) {
+ if( !held )
+ g_settings.misc.net_fakeping_active ^= 1;
+ held = true;
+ }
+ else held = false;
+ }
+ break;
+ case 3:
+ g_settings.misc.net_fakeping_active = true;
+ break;
+ default:
+ g_settings.misc.net_fakeping_active = false;
+ break;
+ }
+
+ auto clientstate = g_csgo.m_global_state->get_client_state( );
+ if( clientstate ) {
+ // TODO: Change this to the non-homosexual way of hooking CNetChan functions.
+ // Actually, I'm too lazy. You can do this if you want.
+ /* + auto *base_net_channel = *memory::find_signature< uint32_t ** >( g_cl.m_engine.dll( ), "C7 07 ? ? ? ? E8 ? ? ? ? 83 BF", 2 ); + + VirtualProtect( &base_net_channel [ 46 ], 4, PAGE_EXECUTE_READWRITE, &o_prot ); + hooked::o_send_datagram = ( decltype( hooked::o_send_datagram ) ) base_net_channel [ 46 ]; + base_net_channel [ 46 ] = uint32_t( hooked::send_datagram ); + VirtualProtect( &base_net_channel [ 46 ], 4, o_prot, &o_prot );
+ */
+ auto netchannel = clientstate->m_netchannel;
+ if( netchannel ) {
+ auto old_netchannel = g_csgo.m_net_channel( );
+
+ if( old_netchannel != netchannel ||
+ ( old_netchannel &&
+ g_csgo.m_net_channel->get_function< void* >( 46 ) != &hooks::send_datagram ) ) {
+ g_csgo.m_net_channel( netchannel );
+ g_csgo.m_net_channel->hook( 46, &hooks::send_datagram );
+ }
+ }
+ }
+ }
+
+ void c_extra::add_latency( INetChannel* channel ) {
+ if ( g_ctx.m_local && g_ctx.m_local->is_valid( ) ) {
+ float latency = g_settings.misc.net_fakeping_amount( ) * 0.001f;
+
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( g_settings.misc.net_fakeping_active ) {
+ // I doubt that the code below is actually necessary to accomplish fake latency.
+ // In fact, it might be the thing that is breaking it.
+
+ // float latency_floor = std::floorf( nci->GetLatency( 1 ) * 10.f ) * 0.1f;
+ // if( g_csgo.m_globals->m_frametime > TICK_INTERVAL( ) || latency_floor <= latency + g_csgo.m_globals->m_frametime * 2.f )
+
+ channel->m_nInSequenceNr += 2 * 64 - ( 63 * latency );
+ }
+ }
+ }
+
+ void c_extra::no_recoil( user_cmd_t* cmd ) {
+ if( !g_settings.misc.no_recoil( ) )
+ return;
+
+ if( g_ctx.m_local && g_ctx.m_local->is_alive( ) ) {
+ static auto weapon_recoil_scale = g_csgo.m_cvar( )->FindVar( xors( "weapon_recoil_scale" ) );
+ cmd->m_viewangles -= g_ctx.m_local->m_aimPunchAngle( true ) * weapon_recoil_scale->get_float( );
+ cmd->m_viewangles.y = std::remainderf( cmd->m_viewangles.y, 360.f );
+ }
+ }
+
+ void c_extra::rich_presence_flex( ) {
+ g_csgo.m_steam_friends( )->set_rich_presence( "game:mode", "competitive" );
+ g_csgo.m_steam_friends( )->set_rich_presence( "game:mapgroupname", "mg_active" );
+ g_csgo.m_steam_friends( )->set_rich_presence( "game:score", "moneybot.cc" );
+ }
+
+ void c_extra::remove_rich_presence_flex( ) {
+ g_csgo.m_steam_friends( )->clear_rich_presence( );
+ }
+
+ // I am so, so, so, so sorry.
+ void c_extra::money_talk( IGameEvent *evt ) {
+ static float last_time = 0.0f;
+
+ if ( !g_csgo.m_engine( )->IsConnected( ) || !g_csgo.m_engine( )->IsInGame( ) ) {
+ last_time = 0.0f;
+ }
+
+ if ( !g_settings.misc.money_talk( ) )
+ return;
+
+ if ( evt && !strcmp( evt->GetName( ), xors( "player_death" ) ) ) {
+ const int player = g_csgo.m_engine( )->GetPlayerForUserID( evt->GetInt( xors( "attacker" ) ) );
+
+ if ( player == g_csgo.m_engine( )->GetLocalPlayer( ) ) {
+ if ( last_time <= g_csgo.m_globals->m_curtime ) {
+ g_csgo.m_engine( )->ClientCmd( xors( "say god i wish i had moneybot" ) );
+
+ last_time = g_csgo.m_globals->m_curtime + 0.1f;
+ }
+ }
+ }
+ }
+
+ void c_extra::no_recoil( bool original ) {
+ static bool restore = false;
+ static vec3_t punch{ };
+ static vec3_t view_punch{ };
+
+ if( !g_settings.misc.no_recoil( ) || !g_ctx.m_local || !g_ctx.m_local->is_alive( ) )
+ return;
+
+ if( !original ) {
+ punch = g_ctx.m_local->m_aimPunchAngle( true );
+ view_punch = g_ctx.m_local->m_viewPunchAngle( );
+
+ g_ctx.m_local->m_aimPunchAngle( true ) = vec3_t( );
+ g_ctx.m_local->m_viewPunchAngle( ) = vec3_t( );
+
+ restore = true;
+ }
+
+ if( original && restore ) {
+ g_ctx.m_local->m_aimPunchAngle( true ) = punch;
+ g_ctx.m_local->m_viewPunchAngle( ) = view_punch;
+
+ restore = false;
+ }
+ }
+
+ void c_extra::auto_revolver( user_cmd_t* cmd ) {
+ if( !g_settings.misc.auto_revolver ) return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon ) return;
+
+ int def_index = weapon->m_iItemDefinitionIndex( );
+ if( def_index != WEAPON_R8REVOLVER ) return;
+
+ if( !g_ctx.m_local->can_attack( ) ) {
+ cmd->m_buttons |= IN_ATTACK;
+ }
+ else if( !g_cheat.m_lagmgr.get_sent( ) ) {
+ g_cheat.m_lagmgr.set_state( true );
+ }
+ }
+
+ void c_extra::no_flash( ) {
+ static bool once = false;
+ if( !g_ctx.m_local || !g_ctx.m_local->is_valid( ) ) {
+ return;
+ }
+
+ if( !g_settings.misc.no_flash ) {
+ if( once ) {
+ g_ctx.m_local->m_flMaxFlashAlpha( ) = 255.f;
+ }
+ return;
+ }
+
+ once = true;
+
+ if( g_ctx.m_local->m_flFlashDuration( ) )
+ g_ctx.m_local->m_flMaxFlashAlpha( ) = std::numeric_limits< float >::min( );
+ }
+
+ //this is not how it works
+ void c_extra::disable_post_processing( ) {
+ static auto var = g_csgo.m_cvar( )->FindVar( xors( "mat_postprocess_enable" ) );
+ var->m_flags |= 0;
+ var->set_value( !g_settings.misc.disable_post_process( ) );
+ }
+
+ void c_extra::float_ragdolls( ) {
+ static bool once = true;;
+ static auto var = g_csgo.m_cvar( )->FindVar( xors( "cl_ragdoll_gravity" ) );
+
+ if( !g_settings.visuals.floating_ragdolls ) {
+ if( !once ) {
+ var->set_value( 600 );
+ }
+ once = true;
+ return;
+ }
+
+ once = false;
+ var->m_flags |= 0;
+ var->set_value( -100 );
+ }
+
+ /*void c_extra::print_overwatch_info( ) {
+ for( int i{}; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+ if( !ent->is_player( ) )
+ continue;
+
+ g_csgo.m_cvar( )->ConsolePrintf( "name: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "userid: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "steam3: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "steam64: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "steam community link: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "rank: " );
+ g_csgo.m_cvar( )->ConsolePrintf( "wins: " );
+ }
+ }*/
+
+ void c_extra::no_smoke( ) {
+ static bool set = false;
+ static bool last_setting = g_settings.misc.no_smoke;
+ if( !g_ctx.m_local || !g_csgo.m_engine( )->IsInGame( ) ) {
+ last_setting = !g_settings.misc.no_smoke;
+ return;
+ }
+
+ if( g_settings.misc.no_smoke || last_setting != g_settings.misc.no_smoke ) {
+ if( g_ctx.m_local && g_csgo.m_engine( )->IsInGame( ) ) {
+ static auto v_smoke_smokegrenade = g_csgo.m_mat_system( )->FindMaterial( xors( "particle\\vistasmokev1\\vistasmokev1_smokegrenade" ) );
+ bool draw = g_settings.misc.no_smoke( );
+
+ if( v_smoke_smokegrenade )
+ v_smoke_smokegrenade->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, draw );
+ }
+ }
+
+ last_setting = g_settings.misc.no_smoke;
+ }
+
+ void c_extra::server_information( ) {
+/* if( !g_settings.misc.server_information( ) )
+ return;
+
+ auto lobby = g_csgo.m_mm( )->GetMatchSession( );
+ if( !lobby )
+ return;
+
+ auto info = lobby->GetSessionSettings( );
+ if( !info )
+ return;
+
+ auto q = info->get_string( xors( "game/mmqueue" ), xors( "no queue!" ) );
+ if( !q || strcmp( q, xors( "reserved" ) ) )
+ return;
+
+ auto map = info->get_string( xors( "game/map" ), xors( "no map!" ) );
+ if( !map )
+ return;
+
+ auto location = info->get_string( xors( "game/loc" ), xors( "no location!" ) );
+
+ g_csgo.m_cvar( )->ConsoleColorPrintf( clr_t( 231, 105, 105 ), xors( "\n-----------------------\n" ) );
+ g_csgo.m_cvar( )->ConsoleColorPrintf( clr_t( 231, 105, 105 ), xors( "map: %s\n" ), map );
+ g_csgo.m_cvar( )->ConsoleColorPrintf( clr_t( 231, 105, 105 ), xors( "location: %s" ), location );
+ g_csgo.m_cvar( )->ConsoleColorPrintf( clr_t( 231, 105, 105 ), xors( "\n-----------------------\n" ) );
+ */
+ }
+
+ void c_extra::unlock_hidden_cvars( ) {
+ // Wouldn't this get you untrusted?
+ if ( g_settings.menu.anti_untrusted )
+ return;
+
+ auto it = g_csgo.m_cvar( )->FactoryInternalIterator( ); // genius code. list of cvars unlocked at https://github.com/saul/csgo-cvar-unhide/blob/master/cvarlist.md
+ for( it->SetFirst( ); it->IsValid( ); it->Next( ) ) {
+ auto cvar = ( cvar_t* )it->Get( );
+ if( cvar ) {
+ cvar->m_flags &= ~FCVAR_HIDDEN;
+ cvar->m_flags &= ~FCVAR_DEVELOPMENTONLY;
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/extra.hpp b/internal_rewrite/extra.hpp new file mode 100644 index 0000000..7f0ac98 --- /dev/null +++ b/internal_rewrite/extra.hpp @@ -0,0 +1,41 @@ +#pragma once
+#include <vector>
+#include <deque>
+
+namespace features
+{
+ class c_extra {
+ bool m_fire_next{ };
+
+ public:
+ void rank_reveal( user_cmd_t* ucmd );
+ void thirdperson( );
+
+ void update_netchannel( );
+ void add_latency( INetChannel* channel );
+
+ void float_ragdolls( );
+ void rich_presence_flex( );
+ void remove_rich_presence_flex( );
+
+ void no_recoil( bool original );
+ void no_recoil( user_cmd_t* cmd );
+
+ void no_smoke( );
+ void no_flash( );
+
+ void disable_post_processing( );
+
+ void auto_revolver( user_cmd_t* );
+
+ void money_talk( IGameEvent *evt );
+
+ void server_information( );
+
+ void unlock_hidden_cvars( );
+
+ private:
+ using grenade_trace_t = std::vector< vec3_t >;
+
+ };
+}
\ No newline at end of file diff --git a/internal_rewrite/factory.cpp b/internal_rewrite/factory.cpp new file mode 100644 index 0000000..0e7bc03 --- /dev/null +++ b/internal_rewrite/factory.cpp @@ -0,0 +1,110 @@ +#include "factory.hpp" +#ifndef IFACE_DLLMAIN +#include "fnv.hpp" + +#include <algorithm> + +NAMESPACE_REGION( factory ) +NAMESPACE_REGION( interfaces ) + +//iterate all exports inside of a module and find createinterface +uintptr_t c_interface_manager::find_createinterface( void* module_ ) { + IMAGE_DOS_HEADER* dos_header; + IMAGE_NT_HEADERS* nt_headers; + uintptr_t export_address; + IMAGE_EXPORT_DIRECTORY* export_dir; + const char* export_name; + uintptr_t* names; + uintptr_t* funcs; + uint16_t* ords; + uint32_t export_hash; + + dos_header = reinterpret_cast< decltype( dos_header ) >( uintptr_t( module_ ) ); + nt_headers = reinterpret_cast< decltype( nt_headers ) >( uintptr_t( module_ ) + dos_header->e_lfanew ); + + //find addresses of functions from nt headers + export_address = nt_headers->OptionalHeader.DataDirectory[ 0 ].VirtualAddress; + export_dir = reinterpret_cast< decltype( export_dir ) >( uintptr_t( module_ ) + export_address ); + + if ( !export_dir->NumberOfFunctions ) + return uintptr_t{ }; + + names = reinterpret_cast< uintptr_t* >( uintptr_t( module_ ) + export_dir->AddressOfNames ); + funcs = reinterpret_cast< uintptr_t* >( uintptr_t( module_ ) + export_dir->AddressOfFunctions ); + + ords = reinterpret_cast< uint16_t* >( uintptr_t( module_ ) + export_dir->AddressOfNameOrdinals ); + + if ( names && funcs && ords ) { + //iterate the exports + for ( size_t i{ }; i < export_dir->NumberOfNames; ++i ) { + export_name = reinterpret_cast< const char* >( uintptr_t( module_ ) + names[ i ] ); + export_hash = hash::fnv1a( export_name ); + + if ( export_hash == fnv( "CreateInterface" ) ) { + return uintptr_t( module_ ) + funcs[ ords[ i ] ]; + } + } + } + + return uintptr_t{ }; +} + +c_interface_manager::c_interface_manager( ) { + auto teb = reinterpret_cast< PTEB >( __readfsdword( uintptr_t( &static_cast< NT_TIB* >( nullptr )->Self ) ) ); + auto peb = teb->ProcessEnvironmentBlock; + + auto root = &peb->Ldr->InMemoryOrderModuleList; + //iterate module list + for ( auto entry = root->Flink->Flink->Flink->Flink; entry != root; entry = entry->Flink ) { + PLDR_DATA_TABLE_ENTRY data_table; + HMODULE module_base; + uintptr_t create_interface_export; + uintptr_t create_interface_; + uintptr_t* list_iterator_ptr; + interface_iterator_t* list_iterator; + + data_table = reinterpret_cast< PLDR_DATA_TABLE_ENTRY >( entry ); + module_base = reinterpret_cast< HMODULE >( data_table->Reserved2[ 0 ] ); + create_interface_export = find_createinterface( module_base ); + + if ( !create_interface_export || !is_createinterface_export( create_interface_export ) ) { + continue; + } + + //find the createinterface function + create_interface_ = follow_createinterface_export( create_interface_export ); + if ( !is_createinterface_fn( create_interface_ ) ) { + continue; + } + + //find the list iterator + list_iterator_ptr = find_list_ptr( create_interface_ ); + + //iterate the interface list + for ( list_iterator = reinterpret_cast< interface_iterator_t* >( + list_iterator_ptr ); + !!list_iterator; + list_iterator = list_iterator->m_next + ) { + std::string name( list_iterator->m_name ); + std::string module_name( util::unicode_to_ascii( + std::wstring( data_table->FullDllName.Buffer, data_table->FullDllName.Length ) ) ); + + uintptr_t ptr = static_cast< uintptr_t( *)( ) >( list_iterator->m_create_fn )( ); + + size_t version = [ & ]( ) { + std::string ret( name ); + ret.erase( std::remove_if( ret.begin( ), ret.end( ), + [ & ]( int i ) { return !::isdigit( i ); } + ), ret.end( ) ); + return atoi( ret.c_str( ) ); + }( ); + + m_interfaces.emplace_back( interface_data_t{ name, module_name, version, ptr } ); + } + } +} + +END_REGION +END_REGION +#endif
\ No newline at end of file diff --git a/internal_rewrite/factory.hpp b/internal_rewrite/factory.hpp new file mode 100644 index 0000000..9946f1b --- /dev/null +++ b/internal_rewrite/factory.hpp @@ -0,0 +1,155 @@ +#pragma once
+#include <memory>
+#include <Windows.h>
+#include <winternl.h>
+#include <fstream>
+#include "vmt.hpp"
+#include "util.hpp"
+#include "x86.hpp"
+#include "console.hpp"
+
+//IFACE_DLLMAIN - interfaces are passed through dllmain and below code doesnt need to be ran
+#ifndef _DEBUG
+#define IFACE_DLLMAIN
+#endif
+
+#ifdef IFACE_DLLMAIN
+#include "iface_dllmain_impl.hpp"
+#else
+
+NAMESPACE_REGION( factory )
+
+namespace interfaces
+{
+ struct interface_iterator_t {
+ void* m_create_fn;
+ char* m_name;
+
+ interface_iterator_t* m_next;
+ };
+
+ inline auto follow_createinterface_export( uintptr_t export_ ) {
+ /*
+ .text:006F5F00 CreateInterface proc near
+ .text:006F5F00 push ebp
+ .text:006F5F01 mov ebp, esp
+ .text:006F5F03 pop ebp
+ .text:006F5F04 jmp sub_6F5E90
+ */
+ uintptr_t jmp = export_ + 0x4;
+ uintptr_t jmp_target = jmp + *( uintptr_t* )( jmp + 0x1 ) + 0x5;
+
+ return jmp_target;
+ }
+
+ inline auto find_list_ptr( uintptr_t createinterface ) {
+ /*
+ .text:006F5E90 push ebp
+ .text:006F5E91 mov ebp, esp
+ .text:006F5E93 push esi
+ .text:006F5E94 mov esi, dword_2EEFDE4
+ .text:006F5E9A push edi
+ */
+ auto iterator_ptr = **( uintptr_t*** )( createinterface + 0x6 );
+
+ return iterator_ptr;
+ }
+
+ inline bool is_createinterface_export( uintptr_t export_ ) {
+ return *( uint8_t* )( export_ ) == x86::encode_push_reg( x86::reg::ebp )
+ && *( uint8_t* )( export_ + 4 ) == 0xe9
+ && *( uint8_t* )( export_ + 9 ) == 0xcc
+ && *( uint8_t* )( export_ + 10 ) == 0xcc;
+ }
+
+ inline bool is_createinterface_fn( uintptr_t fn_ ) {
+ return *( uint8_t* )( fn_ ) == x86::encode_push_reg( x86::reg::ebp )
+ && *( uint8_t* )( fn_ + 4 ) == 0x8b
+ && *( uint8_t* )( fn_ + 10 ) == x86::encode_push_reg( x86::reg::edi );
+ }
+
+ class c_interface_manager {
+ public:
+ struct interface_data_t {
+ std::string m_name;
+ std::string m_module;
+ size_t m_version;
+ uintptr_t m_ptr;
+
+ template < typename t > __forceinline t get( ) {
+ return reinterpret_cast< t >( m_ptr );
+ }
+ };
+
+ c_interface_manager( );
+
+ //iterate the interface list to find our desired version
+ template < typename t = void* >
+ t find_interface( const std::string& module_, std::string name ) {
+ //avoid finding interfaces with matching names
+ if( !::isdigit( name[ name.length( ) - 1 ] ) )
+ name += "0";
+
+ for( auto& it : m_interfaces ) {
+ if( !it.m_module.compare( module_ )
+ && !it.m_name.compare( name ) ) {
+ g_con->print( xors( "%s version %u found in %s at 0x%08x\n" ),
+ name.c_str( ),
+ it.m_version,
+ it.m_module.c_str( ),
+ it.m_ptr );
+
+ return it.get< t >( );
+ }
+ }
+
+ g_con->print( xors( "%s not found\n" ), name.c_str( ) );
+
+ return t{ };
+ }
+
+ template < typename t = void* >
+ t find_interface( std::string name ) {
+ //avoid finding interfaces with matching names
+ if( !::isdigit( name[ name.length( ) - 1 ] ) )
+ name += '0';
+
+ for( auto& it : m_interfaces ) {
+ if( strstr( it.m_name.c_str( ), name.c_str( ) ) ) {
+ g_con->print( xors( "%s version %u found in %s at 0x%08x\n" ),
+ name.c_str( ),
+ it.m_version,
+ it.m_module.c_str( ),
+ it.m_ptr );
+
+ return it.get< t >( );
+ }
+ }
+
+ g_con->print( xors( "%s not found\n" ), name.c_str( ) );
+
+ return t{ };
+ }
+
+ void dump_interface_list( ) {
+ for( auto& it : m_interfaces ) {
+ g_con->print( xors( "%s version %u in %s at 0x%08x\n" ),
+ it.m_name.c_str( ),
+ it.m_version,
+ it.m_module.c_str( ),
+ it.m_ptr );
+ }
+ }
+
+ private:
+ uintptr_t find_createinterface( void* module_ );
+
+ std::vector< interface_data_t > m_interfaces;
+ };
+}
+
+END_REGION
+#endif
+
+extern HMODULE g_dll;
+extern factory::interfaces::c_interface_manager g_factory;
\ No newline at end of file diff --git a/internal_rewrite/fire_event_clientside.cpp b/internal_rewrite/fire_event_clientside.cpp new file mode 100644 index 0000000..02faace --- /dev/null +++ b/internal_rewrite/fire_event_clientside.cpp @@ -0,0 +1,14 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +bool __fastcall hooks::fire_event_clientside( void* ecx_, void* edx, IGameEvent* event_ ) { + static auto original_fn = g_csgo.m_event_mgr->get_old_function< decltype( &fire_event_clientside ) >( 9 ); + + if( g_ctx.m_local && g_ctx.m_local->is_valid( ) && strstr( event_->GetName( ), xors( "player_death" ) ) ) + g_cheat.m_skins.replace_deaths( event_ ); + + g_cheat.m_extra.money_talk( event_ ); + + return original_fn( ecx_, edx, event_ ); +}
\ No newline at end of file diff --git a/internal_rewrite/fnv.hpp b/internal_rewrite/fnv.hpp new file mode 100644 index 0000000..08a478b --- /dev/null +++ b/internal_rewrite/fnv.hpp @@ -0,0 +1,64 @@ +#pragma once + +#pragma warning( disable : 4307 ) // '*': integral constant overflow +#pragma warning( disable : 4244 ) // possible loss of data + +#include <cstdint> +#include <string> + +using hash_t = unsigned int; + +// used for compile-time FNV-1a 32bit hashes. +#define fnv( str ) \ + [&]() { \ + constexpr hash_t out = hash::fnv1a( str ); \ + \ + return out; \ + }() + +// used for compile-time FNV-1a 32bit hashes when above macro cant be used for constexpr variables. +#define fnv_const( str ) Hash::fnv1a_32( str ) + +namespace hash // FNV-1a ( Fowler-Noll-Vo hash ). +{ + // FNV-1a constants. + enum : hash_t { + FNV1A_PRIME = 0x1000193, + FNV1A_BASIS = 0x811C9DC5 + }; + + // compile-time strlen. + __forceinline constexpr size_t ct_strlen( const char *str ) { + size_t out = 1; + + for( ; str[ out ] != '\0'; ++out ); + + return out; + } + + // hash data. + __forceinline constexpr hash_t fnv1a( const uint8_t *data, const size_t len ) { + hash_t out = FNV1A_BASIS; + + for( size_t i = 0; i < len; ++i ) + out = ( out ^ data[ i ] ) * FNV1A_PRIME; + + return out; + } + + // hash c-style string. + __forceinline constexpr hash_t fnv1a( const char *str ) { + hash_t out = FNV1A_BASIS; + size_t len = ct_strlen( str ); + + for( size_t i = 0; i < len; ++i ) + out = ( out ^ str[ i ] ) * FNV1A_PRIME; + + return out; + } + + // hash C++-style string ( runtime only ). + __forceinline hash_t fnv1a( const std::string &str ) { + return fnv1a( ( uint8_t* )str.c_str( ), str.length( ) ); + } +}
\ No newline at end of file diff --git a/internal_rewrite/frame_stage_notify.cpp b/internal_rewrite/frame_stage_notify.cpp new file mode 100644 index 0000000..959a8e8 --- /dev/null +++ b/internal_rewrite/frame_stage_notify.cpp @@ -0,0 +1,97 @@ +#include "hooks.hpp"
+#include "context.hpp"
+#include "settings.hpp"
+#include "base_cheat.hpp"
+
+#if 0
+const char* crash_str = R"("
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+398274 entities in bone setup array.Should have been cleaned up by now
+")";
+#endif
+
+void __fastcall hooks::frame_stage_notify( void* ecx_, void* edx_, ClientFrameStage_t stage ) {
+ static auto frame_stage_notify_o = g_csgo.m_chl->get_old_function< decltype( &hooks::frame_stage_notify ) >( 36 );
+ if ( g_csgo.m_panic ) return frame_stage_notify_o( ecx_, edx_, stage );
+ g_ctx.m_stage = stage;
+ g_cheat.m_visuals.world_modulate( );
+
+ static bool rich_presence_active = false;
+
+ switch ( stage ) {
+ case FRAME_NET_UPDATE_START:
+ g_ctx.run_frame( );
+ g_cheat.m_ragebot.m_lagcomp->fsn_net_update_start( );
+
+ if( g_settings.misc.rich_presence( ) ) {
+ g_cheat.m_extra.rich_presence_flex( );
+ rich_presence_active = true;
+ }
+ else if( rich_presence_active ) {
+ if( !g_settings.misc.rich_presence( ) )
+ g_cheat.m_extra.remove_rich_presence_flex( );
+
+ rich_presence_active = false;
+ }
+ g_cheat.m_visuals.draw_sound( );
+ g_cheat.m_visuals.draw_tracers( );
+ frame_stage_notify_o( ecx_, 0, stage );
+
+ return;
+
+ case FRAME_NET_UPDATE_POSTDATAUPDATE_START:
+ g_cheat.m_extra.float_ragdolls( );
+
+ g_cheat.m_player_mgr.frame_stage_notify( );
+ g_cheat.m_prediction.frame_stage_notify( );
+ g_cheat.m_ragebot.m_resolver->frame_stage_notify( );
+ g_cheat.m_ragebot.m_lagcomp->fsn_render_start( );
+ g_cheat.m_skins( );
+ frame_stage_notify_o( ecx_, 0, stage );
+
+ return;
+
+ case FRAME_RENDER_START:
+ g_cheat.m_extra.disable_post_processing( );
+ g_cheat.m_extra.no_flash( );
+ g_cheat.m_extra.no_recoil( false );
+ util::disable_pvs( );
+ g_cheat.m_ragebot.m_lagcomp->fsn_render_start( );
+ //g_cheat.m_ragebot.m_lagcomp->invalidate_bone_caches( );
+ if( g_csgo.m_input( )->m_fCameraInThirdPerson ) {
+ bool real_yaw = g_settings.rage.anti_aim( );
+ if( g_ctx.get_last_cmd( ) && g_ctx.m_local && g_ctx.m_local->is_valid( ) ) {
+ g_ctx.m_local->m_vecThirdpersonAngles( ) = ( real_yaw ? g_ctx.m_thirdperson_angle : g_ctx.get_last_cmd( )->m_viewangles );
+ }
+ }
+
+ g_cheat.m_extra.no_smoke( );
+ if( g_settings.misc.no_smoke ) {
+ static auto smoke_count = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "55 8B EC 83 EC 08 8B 15 ? ? ? ? 0F 57 C0" ) );
+ **reinterpret_cast< int** >( smoke_count + 0x8 ) = 0;
+ }
+ break;
+
+ case FRAME_RENDER_END:
+ //if( g_ctx.run_frame( ) ) {
+ //
+ //}
+ g_cheat.m_ragebot.m_lagcomp->store_visuals( );
+ frame_stage_notify_o( ecx_, 0, stage );
+ g_cheat.m_chams.m_materials.update_materials( );
+ g_cheat.m_extra.no_recoil( true );
+ return;
+ }
+
+ frame_stage_notify_o( ecx_, 0, stage );
+}
\ No newline at end of file diff --git a/internal_rewrite/get_player_info.cpp b/internal_rewrite/get_player_info.cpp new file mode 100644 index 0000000..0cd121a --- /dev/null +++ b/internal_rewrite/get_player_info.cpp @@ -0,0 +1,10 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" + +bool __fastcall hooks::get_player_info( void* ecx_, void* edx, int ent_num, player_info_t* info ) { + static auto original_fn = g_csgo.m_engine->get_old_function< decltype( &get_player_info ) >( 8 ); + + + + return original_fn( ecx_, edx, ent_num, info ); +}
\ No newline at end of file diff --git a/internal_rewrite/get_screen_size.cpp b/internal_rewrite/get_screen_size.cpp new file mode 100644 index 0000000..1b89b24 --- /dev/null +++ b/internal_rewrite/get_screen_size.cpp @@ -0,0 +1,37 @@ +#include "hooks.hpp" +#include "settings.hpp" + +#include <intrin.h> +#include "context.hpp" +#include "mem.hpp" + +void __fastcall hooks::get_screen_size( void* ecx, void* edx, int& w, int& h ) { + static auto get_screen_size_o = g_csgo.m_surface->get_old_function< decltype( &hooks::get_screen_size ) >( 44 ); + static auto draw_crosshair_h = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "8B 4C 24 10 0F 57 D2 99" ) ); + + stack_t stack( get_baseptr( ) ); + auto ret = stack.next( ).return_address( ); + //call original + get_screen_size_o( ecx, edx, w, h ); + + //alter screen width and height to adjust the crosshair position on screen + if( g_settings.visuals.recoil_crosshair && g_ctx.m_local ) { + if( ret == draw_crosshair_h || ret == draw_crosshair_h - 14 /* width call is 14 bytes above height call*/ ) { + w /= 2; + h /= 2; + + vec3_t punch_angles = g_ctx.m_local->m_aimPunchAngle( ) * 2.f; + + if( punch_angles.x < -0.1f ) { + float fov = g_ctx.m_fov; + float angle_step = h / fov; + + w -= int( punch_angles.y * angle_step ); + h += int( punch_angles.x * angle_step ); + } + + w *= 2; + h *= 2; + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/get_viewmodel_fov.cpp b/internal_rewrite/get_viewmodel_fov.cpp new file mode 100644 index 0000000..050399c --- /dev/null +++ b/internal_rewrite/get_viewmodel_fov.cpp @@ -0,0 +1,8 @@ +#include "hooks.hpp" +#include "settings.hpp" + +float __fastcall hooks::get_viewmodel_fov( void* ecx, void* edx ) { + static auto get_viewmodel_fov_o = g_csgo.m_clientmode->get_old_function< decltype( &hooks::get_viewmodel_fov ) >( 35 ); + + return get_viewmodel_fov_o( ecx, nullptr ) + float( g_settings.misc.viewmodel_fov ); +} diff --git a/internal_rewrite/hooks.cpp b/internal_rewrite/hooks.cpp new file mode 100644 index 0000000..9a2aea1 --- /dev/null +++ b/internal_rewrite/hooks.cpp @@ -0,0 +1,57 @@ +#include "hooks.hpp" +#include "interface.hpp" + +hooks::c_netvar_proxy hooks::lby_proxy; +hooks::c_netvar_proxy hooks::last_shot_proxy; + +bool hooks::commit( factory::c_csgo* instance ) { + while ( !( instance->m_hwnd = FindWindowA( xors( "Valve001" ), 0 ) ) ) + Sleep( 100 ); + + window_procedure_o = reinterpret_cast< decltype( window_procedure_o ) >( + SetWindowLongA( instance->m_hwnd, GWLP_WNDPROC, + ( long )window_procedure ) + ); + + lby_proxy.init( g_netvars.get_prop( fnv( "DT_CSPlayer" ), fnv( "m_flLowerBodyYawTarget" ) ), &lby_proxy_fn ); + last_shot_proxy.init( g_netvars.get_prop( fnv( "DT_WeaponCSBaseGun" ), fnv( "m_fLastShotTime" ) ), &last_shot_proxy_fn ); + + instance->m_d3d->hook( 42, &hooks::d3d::end_scene ); + instance->m_d3d->hook( 16, &hooks::d3d::reset ); + instance->m_d3d->hook( 17, &hooks::d3d::present ); + //instance->m_d3d->hook( 82, &hooks::d3d::draw ); + //instance->m_engine->hook( 93, &hooks::is_hltv_proxy ); + //instance->m_engine->hook( 90, &hooks::is_paused ); + //instance->m_engine->hook( 27, &hooks::is_connected ); + instance->m_panel->hook( 41, &hooks::paint_traverse ); + instance->m_clientmode->hook( 24, &hooks::create_move ); + instance->m_clientmode->hook( 23, &hooks::override_mouse_input ); + instance->m_clientmode->hook( 35, &hooks::get_viewmodel_fov ); + instance->m_clientmode->hook( 44, &hooks::do_post_screen_space_effects ); + instance->m_clientmode->hook( 18, &hooks::override_view ); + instance->m_surface->hook( 67, &hooks::lock_cursor ); + //instance->m_input->hook( 3, &hooks::hl_create_move ); + //instance->m_chl->hook( 36, &hooks::frame_stage_notify ); + //instance->m_chl->hook( 10, &hooks::hud_process_input ); + instance->m_prediction->hook( 19, &hooks::run_command ); + instance->m_prediction->hook( 14, &hooks::in_prediction ); + instance->m_model_render->hook( 21, &hooks::draw_model_execute ); + instance->m_render_view->hook( 9, &hooks::scene_end ); + instance->m_surface->hook( 44, &hooks::get_screen_size ); + instance->m_surface->hook( 116, &hooks::on_screen_size_changed ); + instance->m_surface->hook( 82, &hooks::play_sound ); + //instance->m_engine_sound->hook( 6, &hooks::emit_sound ); + instance->m_debug_show_spread->hook( 13, &hooks::debug_show_spread_get_int ); + instance->m_interpolate->hook( 13, &hooks::cl_interpolate_get_int ); + //instance->m_event_mgr->hook( 9, &hooks::fire_event_clientside ); + instance->m_mat_system->hook( 21, &hooks::material_system ); + instance->m_partition->hook( 16, &hooks::suppress_lists ); + instance->m_clientleaf->hook( 39, &hooks::draw_small_entities ); + instance->m_engine_vgui->hook( 39, &hooks::simulate ); + instance->m_mdl_cache->hook( 33, &hooks::begin_lock ); + instance->m_mdl_cache->hook( 34, &hooks::end_lock ); + instance->m_netshowfragments->hook( 13, &hooks::net_showfragments_get_int ); + //instance->m_trace->hook( 5, &hooks::trace_ray ); + + return true; +} diff --git a/internal_rewrite/hooks.hpp b/internal_rewrite/hooks.hpp new file mode 100644 index 0000000..4e8a736 --- /dev/null +++ b/internal_rewrite/hooks.hpp @@ -0,0 +1,73 @@ +#pragma once +#include <windows.h> + +#include "util.hpp" +#include "d3d.hpp" +#include "interface.hpp" +#include "netvar_proxy.hpp" + +namespace hooks +{ + //hook like the hooker that u are + + long __stdcall window_procedure( HWND, uint32_t, uint32_t, long ); + extern decltype( &window_procedure ) window_procedure_o; + + void __fastcall paint_traverse( void*, void*, unsigned int, bool, bool ); + bool __fastcall create_move( void*, void*, float, user_cmd_t* ); + //void __fastcall hl_create_move( void*, void*, int, float, bool ); + void __fastcall frame_stage_notify( void*, void*, ClientFrameStage_t ); + void __fastcall suppress_lists( void*, void*, int, bool ); + void __fastcall draw_small_entities( void*, void*, bool ); + void __fastcall begin_lock( void*, void* ); + void __fastcall end_lock( void*, void* ); + void __fastcall simulate( void*, void* ); + void __fastcall run_command( void*, void*, IClientEntity*, user_cmd_t*, IMoveHelper* ); + void __fastcall override_mouse_input( void*, void*, float*, float* ); + void __fastcall draw_model_execute( IVModelRender*, void*, void*, const DrawModelState_t&, const ModelRenderInfo_t&, matrix3x4* ); + void __fastcall scene_end( void*, void* ); + bool __fastcall is_hltv_proxy( void*, void* ); + bool __fastcall is_hltv( void* thisptr, uintptr_t pvs_entity ); + float __fastcall get_viewmodel_fov( void*, void* ); + void __fastcall get_screen_size( void*, void*, int&, int& ); + void __fastcall override_view( void* ecx_, void* edx_, CViewSetup* setup ); + void __fastcall emit_sound( void* ecx_, void* edx_, void* filter, int ent, int channel, const char* sound, uint32_t hash, + const char* sample, float volume, float attenuation, int seed, int flags, int pitch, const vec3_t* origin, + const vec3_t* direction, vec3_t* origins, bool update_pos, float sound_time, int speaker_entry ); + void __fastcall shut_down( void* ecx_, void* edx_ ); + void __fastcall lock_cursor( void* ecx_, void* edx_ ); + + bool __fastcall is_connected( void* ecx_, void* edx_ ); + + bool __fastcall in_prediction( void* ecx_, void* edx_ ); + void __fastcall update_clientside_animation( void* ecx_, void* edx_ ); + + bool __fastcall material_system( void* ecx_, void* edx_, IMaterialSystem_Config_t* config, bool forceupdate ); + bool __fastcall fire_event_clientside( void* ecx_, void* edx, IGameEvent* event ); + void __cdecl lby_proxy_fn( const CRecvProxyData* proxy_data_const, void* entity, void* output ); + void __cdecl last_shot_proxy_fn( const CRecvProxyData* proxy_data_const, void* entity, void* output ); + int __fastcall send_datagram( INetChannel* channel, void* edx, void* datagram ); + bool __fastcall is_paused( void* ecx_, void* edx_ ); + bool __fastcall do_post_screen_space_effects( void* ecx_, void* edx_, CViewSetup* setup ); + void __fastcall on_screen_size_changed( void* ecx_, void* edx_, int old_h, int old_w ); + void __fastcall play_sound( void* ecx_, void* edx_, const char* name ); + void __fastcall hud_process_input( void* ecx_, void* edx_, bool repaint ); + void __fastcall trace_ray( void* ecx_, void* edx_, const Ray_t& ray, unsigned int fMask, ITraceFilter* pTraceFilter, CBaseTrace* pTrace ); + + int __fastcall debug_show_spread_get_int( void* ecx_, void* edx_ ); + int __fastcall cl_interpolate_get_int( void* ecx_, void* edx_ ); + int __fastcall net_showfragments_get_int( void* ecx_, void* edx_ ); + + extern c_netvar_proxy lby_proxy; + extern c_netvar_proxy last_shot_proxy; + + //do we wanna only run menu in d3d or visuals too? + namespace d3d { + long __stdcall end_scene( IDirect3DDevice9* ); + long __stdcall reset( IDirect3DDevice9*, D3DPRESENT_PARAMETERS* ); + long __stdcall present( IDirect3DDevice9*, RECT*, RECT*, HWND, RGNDATA* ); + long __stdcall draw( IDirect3DDevice9*, D3DPRIMITIVETYPE, int, uint32_t, uint32_t, uint32_t, uint32_t ); + } + + extern bool commit( factory::c_csgo* ); +}
\ No newline at end of file diff --git a/internal_rewrite/hud_process_input.cpp b/internal_rewrite/hud_process_input.cpp new file mode 100644 index 0000000..548d05f --- /dev/null +++ b/internal_rewrite/hud_process_input.cpp @@ -0,0 +1,11 @@ +#include "context.hpp" +#include "hooks.hpp" + +void __fastcall hooks::hud_process_input( void* ecx_, void* edx_, bool active ) { + static auto hud_update_o = g_csgo.m_chl->get_old_function< decltype( &hooks::hud_process_input ) >( 10 ); + + //todo: hook hudupdate + //g_csgo.m_prediction( )->SetLocalViewAngles( g_ctx.m_last_fakeangle ); + + return hud_update_o( ecx_, 0, active ); +}
\ No newline at end of file diff --git a/internal_rewrite/icons.hpp b/internal_rewrite/icons.hpp new file mode 100644 index 0000000..840a413 --- /dev/null +++ b/internal_rewrite/icons.hpp @@ -0,0 +1,5 @@ +#include "icons/legit.hpp" +#include "icons/rage.hpp" +#include "icons/visuals.hpp" +#include "icons/misc.hpp" +#include "icons/config.hpp"
\ No newline at end of file diff --git a/internal_rewrite/icons/config.hpp b/internal_rewrite/icons/config.hpp new file mode 100644 index 0000000..d488e6a --- /dev/null +++ b/internal_rewrite/icons/config.hpp @@ -0,0 +1,1752 @@ +/* E:\Users\admin\Desktop\stuff\icons\config.png (4/1/2018 10:00:36 PM) + StartOffset: 00000000, EndOffset: 0000519A, Length: 0000519B */ + +namespace icons { +constexpr static size_t config_size = 20891; +namespace raw { +static unsigned char config[20891] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x39, 0x64, 0x36, 0xD2, 0x00, 0x00, 0x00, + 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23, 0x00, 0x00, 0x2E, + 0x23, 0x01, 0x78, 0xA5, 0x3F, 0x76, 0x00, 0x00, 0x0A, 0x4F, 0x69, 0x43, + 0x43, 0x50, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, + 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x00, + 0x00, 0x78, 0xDA, 0x9D, 0x53, 0x67, 0x54, 0x53, 0xE9, 0x16, 0x3D, 0xF7, + 0xDE, 0xF4, 0x42, 0x4B, 0x88, 0x80, 0x94, 0x4B, 0x6F, 0x52, 0x15, 0x08, + 0x20, 0x52, 0x42, 0x8B, 0x80, 0x14, 0x91, 0x26, 0x2A, 0x21, 0x09, 0x10, + 0x4A, 0x88, 0x21, 0xA1, 0xD9, 0x15, 0x51, 0xC1, 0x11, 0x45, 0x45, 0x04, + 0x1B, 0xC8, 0xA0, 0x88, 0x03, 0x8E, 0x8E, 0x80, 0x8C, 0x15, 0x51, 0x2C, + 0x0C, 0x8A, 0x0A, 0xD8, 0x07, 0xE4, 0x21, 0xA2, 0x8E, 0x83, 0xA3, 0x88, + 0x8A, 0xCA, 0xFB, 0xE1, 0x7B, 0xA3, 0x6B, 0xD6, 0xBC, 0xF7, 0xE6, 0xCD, + 0xFE, 0xB5, 0xD7, 0x3E, 0xE7, 0xAC, 0xF3, 0x9D, 0xB3, 0xCF, 0x07, 0xC0, + 0x08, 0x0C, 0x96, 0x48, 0x33, 0x51, 0x35, 0x80, 0x0C, 0xA9, 0x42, 0x1E, + 0x11, 0xE0, 0x83, 0xC7, 0xC4, 0xC6, 0xE1, 0xE4, 0x2E, 0x40, 0x81, 0x0A, + 0x24, 0x70, 0x00, 0x10, 0x08, 0xB3, 0x64, 0x21, 0x73, 0xFD, 0x23, 0x01, + 0x00, 0xF8, 0x7E, 0x3C, 0x3C, 0x2B, 0x22, 0xC0, 0x07, 0xBE, 0x00, 0x01, + 0x78, 0xD3, 0x0B, 0x08, 0x00, 0xC0, 0x4D, 0x9B, 0xC0, 0x30, 0x1C, 0x87, + 0xFF, 0x0F, 0xEA, 0x42, 0x99, 0x5C, 0x01, 0x80, 0x84, 0x01, 0xC0, 0x74, + 0x91, 0x38, 0x4B, 0x08, 0x80, 0x14, 0x00, 0x40, 0x7A, 0x8E, 0x42, 0xA6, + 0x00, 0x40, 0x46, 0x01, 0x80, 0x9D, 0x98, 0x26, 0x53, 0x00, 0xA0, 0x04, + 0x00, 0x60, 0xCB, 0x63, 0x62, 0xE3, 0x00, 0x50, 0x2D, 0x00, 0x60, 0x27, + 0x7F, 0xE6, 0xD3, 0x00, 0x80, 0x9D, 0xF8, 0x99, 0x7B, 0x01, 0x00, 0x5B, + 0x94, 0x21, 0x15, 0x01, 0xA0, 0x91, 0x00, 0x20, 0x13, 0x65, 0x88, 0x44, + 0x00, 0x68, 0x3B, 0x00, 0xAC, 0xCF, 0x56, 0x8A, 0x45, 0x00, 0x58, 0x30, + 0x00, 0x14, 0x66, 0x4B, 0xC4, 0x39, 0x00, 0xD8, 0x2D, 0x00, 0x30, 0x49, + 0x57, 0x66, 0x48, 0x00, 0xB0, 0xB7, 0x00, 0xC0, 0xCE, 0x10, 0x0B, 0xB2, + 0x00, 0x08, 0x0C, 0x00, 0x30, 0x51, 0x88, 0x85, 0x29, 0x00, 0x04, 0x7B, + 0x00, 0x60, 0xC8, 0x23, 0x23, 0x78, 0x00, 0x84, 0x99, 0x00, 0x14, 0x46, + 0xF2, 0x57, 0x3C, 0xF1, 0x2B, 0xAE, 0x10, 0xE7, 0x2A, 0x00, 0x00, 0x78, + 0x99, 0xB2, 0x3C, 0xB9, 0x24, 0x39, 0x45, 0x81, 0x5B, 0x08, 0x2D, 0x71, + 0x07, 0x57, 0x57, 0x2E, 0x1E, 0x28, 0xCE, 0x49, 0x17, 0x2B, 0x14, 0x36, + 0x61, 0x02, 0x61, 0x9A, 0x40, 0x2E, 0xC2, 0x79, 0x99, 0x19, 0x32, 0x81, + 0x34, 0x0F, 0xE0, 0xF3, 0xCC, 0x00, 0x00, 0xA0, 0x91, 0x15, 0x11, 0xE0, + 0x83, 0xF3, 0xFD, 0x78, 0xCE, 0x0E, 0xAE, 0xCE, 0xCE, 0x36, 0x8E, 0xB6, + 0x0E, 0x5F, 0x2D, 0xEA, 0xBF, 0x06, 0xFF, 0x22, 0x62, 0x62, 0xE3, 0xFE, + 0xE5, 0xCF, 0xAB, 0x70, 0x40, 0x00, 0x00, 0xE1, 0x74, 0x7E, 0xD1, 0xFE, + 0x2C, 0x2F, 0xB3, 0x1A, 0x80, 0x3B, 0x06, 0x80, 0x6D, 0xFE, 0xA2, 0x25, + 0xEE, 0x04, 0x68, 0x5E, 0x0B, 0xA0, 0x75, 0xF7, 0x8B, 0x66, 0xB2, 0x0F, + 0x40, 0xB5, 0x00, 0xA0, 0xE9, 0xDA, 0x57, 0xF3, 0x70, 0xF8, 0x7E, 0x3C, + 0x3C, 0x45, 0xA1, 0x90, 0xB9, 0xD9, 0xD9, 0xE5, 0xE4, 0xE4, 0xD8, 0x4A, + 0xC4, 0x42, 0x5B, 0x61, 0xCA, 0x57, 0x7D, 0xFE, 0x67, 0xC2, 0x5F, 0xC0, + 0x57, 0xFD, 0x6C, 0xF9, 0x7E, 0x3C, 0xFC, 0xF7, 0xF5, 0xE0, 0xBE, 0xE2, + 0x24, 0x81, 0x32, 0x5D, 0x81, 0x47, 0x04, 0xF8, 0xE0, 0xC2, 0xCC, 0xF4, + 0x4C, 0xA5, 0x1C, 0xCF, 0x92, 0x09, 0x84, 0x62, 0xDC, 0xE6, 0x8F, 0x47, + 0xFC, 0xB7, 0x0B, 0xFF, 0xFC, 0x1D, 0xD3, 0x22, 0xC4, 0x49, 0x62, 0xB9, + 0x58, 0x2A, 0x14, 0xE3, 0x51, 0x12, 0x71, 0x8E, 0x44, 0x9A, 0x8C, 0xF3, + 0x32, 0xA5, 0x22, 0x89, 0x42, 0x92, 0x29, 0xC5, 0x25, 0xD2, 0xFF, 0x64, + 0xE2, 0xDF, 0x2C, 0xFB, 0x03, 0x3E, 0xDF, 0x35, 0x00, 0xB0, 0x6A, 0x3E, + 0x01, 0x7B, 0x91, 0x2D, 0xA8, 0x5D, 0x63, 0x03, 0xF6, 0x4B, 0x27, 0x10, + 0x58, 0x74, 0xC0, 0xE2, 0xF7, 0x00, 0x00, 0xF2, 0xBB, 0x6F, 0xC1, 0xD4, + 0x28, 0x08, 0x03, 0x80, 0x68, 0x83, 0xE1, 0xCF, 0x77, 0xFF, 0xEF, 0x3F, + 0xFD, 0x47, 0xA0, 0x25, 0x00, 0x80, 0x66, 0x49, 0x92, 0x71, 0x00, 0x00, + 0x5E, 0x44, 0x24, 0x2E, 0x54, 0xCA, 0xB3, 0x3F, 0xC7, 0x08, 0x00, 0x00, + 0x44, 0xA0, 0x81, 0x2A, 0xB0, 0x41, 0x1B, 0xF4, 0xC1, 0x18, 0x2C, 0xC0, + 0x06, 0x1C, 0xC1, 0x05, 0xDC, 0xC1, 0x0B, 0xFC, 0x60, 0x36, 0x84, 0x42, + 0x24, 0xC4, 0xC2, 0x42, 0x10, 0x42, 0x0A, 0x64, 0x80, 0x1C, 0x72, 0x60, + 0x29, 0xAC, 0x82, 0x42, 0x28, 0x86, 0xCD, 0xB0, 0x1D, 0x2A, 0x60, 0x2F, + 0xD4, 0x40, 0x1D, 0x34, 0xC0, 0x51, 0x68, 0x86, 0x93, 0x70, 0x0E, 0x2E, + 0xC2, 0x55, 0xB8, 0x0E, 0x3D, 0x70, 0x0F, 0xFA, 0x61, 0x08, 0x9E, 0xC1, + 0x28, 0xBC, 0x81, 0x09, 0x04, 0x41, 0xC8, 0x08, 0x13, 0x61, 0x21, 0xDA, + 0x88, 0x01, 0x62, 0x8A, 0x58, 0x23, 0x8E, 0x08, 0x17, 0x99, 0x85, 0xF8, + 0x21, 0xC1, 0x48, 0x04, 0x12, 0x8B, 0x24, 0x20, 0xC9, 0x88, 0x14, 0x51, + 0x22, 0x4B, 0x91, 0x35, 0x48, 0x31, 0x52, 0x8A, 0x54, 0x20, 0x55, 0x48, + 0x1D, 0xF2, 0x3D, 0x72, 0x02, 0x39, 0x87, 0x5C, 0x46, 0xBA, 0x91, 0x3B, + 0xC8, 0x00, 0x32, 0x82, 0xFC, 0x86, 0xBC, 0x47, 0x31, 0x94, 0x81, 0xB2, + 0x51, 0x3D, 0xD4, 0x0C, 0xB5, 0x43, 0xB9, 0xA8, 0x37, 0x1A, 0x84, 0x46, + 0xA2, 0x0B, 0xD0, 0x64, 0x74, 0x31, 0x9A, 0x8F, 0x16, 0xA0, 0x9B, 0xD0, + 0x72, 0xB4, 0x1A, 0x3D, 0x8C, 0x36, 0xA1, 0xE7, 0xD0, 0xAB, 0x68, 0x0F, + 0xDA, 0x8F, 0x3E, 0x43, 0xC7, 0x30, 0xC0, 0xE8, 0x18, 0x07, 0x33, 0xC4, + 0x6C, 0x30, 0x2E, 0xC6, 0xC3, 0x42, 0xB1, 0x38, 0x2C, 0x09, 0x93, 0x63, + 0xCB, 0xB1, 0x22, 0xAC, 0x0C, 0xAB, 0xC6, 0x1A, 0xB0, 0x56, 0xAC, 0x03, + 0xBB, 0x89, 0xF5, 0x63, 0xCF, 0xB1, 0x77, 0x04, 0x12, 0x81, 0x45, 0xC0, + 0x09, 0x36, 0x04, 0x77, 0x42, 0x20, 0x61, 0x1E, 0x41, 0x48, 0x58, 0x4C, + 0x58, 0x4E, 0xD8, 0x48, 0xA8, 0x20, 0x1C, 0x24, 0x34, 0x11, 0xDA, 0x09, + 0x37, 0x09, 0x03, 0x84, 0x51, 0xC2, 0x27, 0x22, 0x93, 0xA8, 0x4B, 0xB4, + 0x26, 0xBA, 0x11, 0xF9, 0xC4, 0x18, 0x62, 0x32, 0x31, 0x87, 0x58, 0x48, + 0x2C, 0x23, 0xD6, 0x12, 0x8F, 0x13, 0x2F, 0x10, 0x7B, 0x88, 0x43, 0xC4, + 0x37, 0x24, 0x12, 0x89, 0x43, 0x32, 0x27, 0xB9, 0x90, 0x02, 0x49, 0xB1, + 0xA4, 0x54, 0xD2, 0x12, 0xD2, 0x46, 0xD2, 0x6E, 0x52, 0x23, 0xE9, 0x2C, + 0xA9, 0x9B, 0x34, 0x48, 0x1A, 0x23, 0x93, 0xC9, 0xDA, 0x64, 0x6B, 0xB2, + 0x07, 0x39, 0x94, 0x2C, 0x20, 0x2B, 0xC8, 0x85, 0xE4, 0x9D, 0xE4, 0xC3, + 0xE4, 0x33, 0xE4, 0x1B, 0xE4, 0x21, 0xF2, 0x5B, 0x0A, 0x9D, 0x62, 0x40, + 0x71, 0xA4, 0xF8, 0x53, 0xE2, 0x28, 0x52, 0xCA, 0x6A, 0x4A, 0x19, 0xE5, + 0x10, 0xE5, 0x34, 0xE5, 0x06, 0x65, 0x98, 0x32, 0x41, 0x55, 0xA3, 0x9A, + 0x52, 0xDD, 0xA8, 0xA1, 0x54, 0x11, 0x35, 0x8F, 0x5A, 0x42, 0xAD, 0xA1, + 0xB6, 0x52, 0xAF, 0x51, 0x87, 0xA8, 0x13, 0x34, 0x75, 0x9A, 0x39, 0xCD, + 0x83, 0x16, 0x49, 0x4B, 0xA5, 0xAD, 0xA2, 0x95, 0xD3, 0x1A, 0x68, 0x17, + 0x68, 0xF7, 0x69, 0xAF, 0xE8, 0x74, 0xBA, 0x11, 0xDD, 0x95, 0x1E, 0x4E, + 0x97, 0xD0, 0x57, 0xD2, 0xCB, 0xE9, 0x47, 0xE8, 0x97, 0xE8, 0x03, 0xF4, + 0x77, 0x0C, 0x0D, 0x86, 0x15, 0x83, 0xC7, 0x88, 0x67, 0x28, 0x19, 0x9B, + 0x18, 0x07, 0x18, 0x67, 0x19, 0x77, 0x18, 0xAF, 0x98, 0x4C, 0xA6, 0x19, + 0xD3, 0x8B, 0x19, 0xC7, 0x54, 0x30, 0x37, 0x31, 0xEB, 0x98, 0xE7, 0x99, + 0x0F, 0x99, 0x6F, 0x55, 0x58, 0x2A, 0xB6, 0x2A, 0x7C, 0x15, 0x91, 0xCA, + 0x0A, 0x95, 0x4A, 0x95, 0x26, 0x95, 0x1B, 0x2A, 0x2F, 0x54, 0xA9, 0xAA, + 0xA6, 0xAA, 0xDE, 0xAA, 0x0B, 0x55, 0xF3, 0x55, 0xCB, 0x54, 0x8F, 0xA9, + 0x5E, 0x53, 0x7D, 0xAE, 0x46, 0x55, 0x33, 0x53, 0xE3, 0xA9, 0x09, 0xD4, + 0x96, 0xAB, 0x55, 0xAA, 0x9D, 0x50, 0xEB, 0x53, 0x1B, 0x53, 0x67, 0xA9, + 0x3B, 0xA8, 0x87, 0xAA, 0x67, 0xA8, 0x6F, 0x54, 0x3F, 0xA4, 0x7E, 0x59, + 0xFD, 0x89, 0x06, 0x59, 0xC3, 0x4C, 0xC3, 0x4F, 0x43, 0xA4, 0x51, 0xA0, + 0xB1, 0x5F, 0xE3, 0xBC, 0xC6, 0x20, 0x0B, 0x63, 0x19, 0xB3, 0x78, 0x2C, + 0x21, 0x6B, 0x0D, 0xAB, 0x86, 0x75, 0x81, 0x35, 0xC4, 0x26, 0xB1, 0xCD, + 0xD9, 0x7C, 0x76, 0x2A, 0xBB, 0x98, 0xFD, 0x1D, 0xBB, 0x8B, 0x3D, 0xAA, + 0xA9, 0xA1, 0x39, 0x43, 0x33, 0x4A, 0x33, 0x57, 0xB3, 0x52, 0xF3, 0x94, + 0x66, 0x3F, 0x07, 0xE3, 0x98, 0x71, 0xF8, 0x9C, 0x74, 0x4E, 0x09, 0xE7, + 0x28, 0xA7, 0x97, 0xF3, 0x7E, 0x8A, 0xDE, 0x14, 0xEF, 0x29, 0xE2, 0x29, + 0x1B, 0xA6, 0x34, 0x4C, 0xB9, 0x31, 0x65, 0x5C, 0x6B, 0xAA, 0x96, 0x97, + 0x96, 0x58, 0xAB, 0x48, 0xAB, 0x51, 0xAB, 0x47, 0xEB, 0xBD, 0x36, 0xAE, + 0xED, 0xA7, 0x9D, 0xA6, 0xBD, 0x45, 0xBB, 0x59, 0xFB, 0x81, 0x0E, 0x41, + 0xC7, 0x4A, 0x27, 0x5C, 0x27, 0x47, 0x67, 0x8F, 0xCE, 0x05, 0x9D, 0xE7, + 0x53, 0xD9, 0x53, 0xDD, 0xA7, 0x0A, 0xA7, 0x16, 0x4D, 0x3D, 0x3A, 0xF5, + 0xAE, 0x2E, 0xAA, 0x6B, 0xA5, 0x1B, 0xA1, 0xBB, 0x44, 0x77, 0xBF, 0x6E, + 0xA7, 0xEE, 0x98, 0x9E, 0xBE, 0x5E, 0x80, 0x9E, 0x4C, 0x6F, 0xA7, 0xDE, + 0x79, 0xBD, 0xE7, 0xFA, 0x1C, 0x7D, 0x2F, 0xFD, 0x54, 0xFD, 0x6D, 0xFA, + 0xA7, 0xF5, 0x47, 0x0C, 0x58, 0x06, 0xB3, 0x0C, 0x24, 0x06, 0xDB, 0x0C, + 0xCE, 0x18, 0x3C, 0xC5, 0x35, 0x71, 0x6F, 0x3C, 0x1D, 0x2F, 0xC7, 0xDB, + 0xF1, 0x51, 0x43, 0x5D, 0xC3, 0x40, 0x43, 0xA5, 0x61, 0x95, 0x61, 0x97, + 0xE1, 0x84, 0x91, 0xB9, 0xD1, 0x3C, 0xA3, 0xD5, 0x46, 0x8D, 0x46, 0x0F, + 0x8C, 0x69, 0xC6, 0x5C, 0xE3, 0x24, 0xE3, 0x6D, 0xC6, 0x6D, 0xC6, 0xA3, + 0x26, 0x06, 0x26, 0x21, 0x26, 0x4B, 0x4D, 0xEA, 0x4D, 0xEE, 0x9A, 0x52, + 0x4D, 0xB9, 0xA6, 0x29, 0xA6, 0x3B, 0x4C, 0x3B, 0x4C, 0xC7, 0xCD, 0xCC, + 0xCD, 0xA2, 0xCD, 0xD6, 0x99, 0x35, 0x9B, 0x3D, 0x31, 0xD7, 0x32, 0xE7, + 0x9B, 0xE7, 0x9B, 0xD7, 0x9B, 0xDF, 0xB7, 0x60, 0x5A, 0x78, 0x5A, 0x2C, + 0xB6, 0xA8, 0xB6, 0xB8, 0x65, 0x49, 0xB2, 0xE4, 0x5A, 0xA6, 0x59, 0xEE, + 0xB6, 0xBC, 0x6E, 0x85, 0x5A, 0x39, 0x59, 0xA5, 0x58, 0x55, 0x5A, 0x5D, + 0xB3, 0x46, 0xAD, 0x9D, 0xAD, 0x25, 0xD6, 0xBB, 0xAD, 0xBB, 0xA7, 0x11, + 0xA7, 0xB9, 0x4E, 0x93, 0x4E, 0xAB, 0x9E, 0xD6, 0x67, 0xC3, 0xB0, 0xF1, + 0xB6, 0xC9, 0xB6, 0xA9, 0xB7, 0x19, 0xB0, 0xE5, 0xD8, 0x06, 0xDB, 0xAE, + 0xB6, 0x6D, 0xB6, 0x7D, 0x61, 0x67, 0x62, 0x17, 0x67, 0xB7, 0xC5, 0xAE, + 0xC3, 0xEE, 0x93, 0xBD, 0x93, 0x7D, 0xBA, 0x7D, 0x8D, 0xFD, 0x3D, 0x07, + 0x0D, 0x87, 0xD9, 0x0E, 0xAB, 0x1D, 0x5A, 0x1D, 0x7E, 0x73, 0xB4, 0x72, + 0x14, 0x3A, 0x56, 0x3A, 0xDE, 0x9A, 0xCE, 0x9C, 0xEE, 0x3F, 0x7D, 0xC5, + 0xF4, 0x96, 0xE9, 0x2F, 0x67, 0x58, 0xCF, 0x10, 0xCF, 0xD8, 0x33, 0xE3, + 0xB6, 0x13, 0xCB, 0x29, 0xC4, 0x69, 0x9D, 0x53, 0x9B, 0xD3, 0x47, 0x67, + 0x17, 0x67, 0xB9, 0x73, 0x83, 0xF3, 0x88, 0x8B, 0x89, 0x4B, 0x82, 0xCB, + 0x2E, 0x97, 0x3E, 0x2E, 0x9B, 0x1B, 0xC6, 0xDD, 0xC8, 0xBD, 0xE4, 0x4A, + 0x74, 0xF5, 0x71, 0x5D, 0xE1, 0x7A, 0xD2, 0xF5, 0x9D, 0x9B, 0xB3, 0x9B, + 0xC2, 0xED, 0xA8, 0xDB, 0xAF, 0xEE, 0x36, 0xEE, 0x69, 0xEE, 0x87, 0xDC, + 0x9F, 0xCC, 0x34, 0x9F, 0x29, 0x9E, 0x59, 0x33, 0x73, 0xD0, 0xC3, 0xC8, + 0x43, 0xE0, 0x51, 0xE5, 0xD1, 0x3F, 0x0B, 0x9F, 0x95, 0x30, 0x6B, 0xDF, + 0xAC, 0x7E, 0x4F, 0x43, 0x4F, 0x81, 0x67, 0xB5, 0xE7, 0x23, 0x2F, 0x63, + 0x2F, 0x91, 0x57, 0xAD, 0xD7, 0xB0, 0xB7, 0xA5, 0x77, 0xAA, 0xF7, 0x61, + 0xEF, 0x17, 0x3E, 0xF6, 0x3E, 0x72, 0x9F, 0xE3, 0x3E, 0xE3, 0x3C, 0x37, + 0xDE, 0x32, 0xDE, 0x59, 0x5F, 0xCC, 0x37, 0xC0, 0xB7, 0xC8, 0xB7, 0xCB, + 0x4F, 0xC3, 0x6F, 0x9E, 0x5F, 0x85, 0xDF, 0x43, 0x7F, 0x23, 0xFF, 0x64, + 0xFF, 0x7A, 0xFF, 0xD1, 0x00, 0xA7, 0x80, 0x25, 0x01, 0x67, 0x03, 0x89, + 0x81, 0x41, 0x81, 0x5B, 0x02, 0xFB, 0xF8, 0x7A, 0x7C, 0x21, 0xBF, 0x8E, + 0x3F, 0x3A, 0xDB, 0x65, 0xF6, 0xB2, 0xD9, 0xED, 0x41, 0x8C, 0xA0, 0xB9, + 0x41, 0x15, 0x41, 0x8F, 0x82, 0xAD, 0x82, 0xE5, 0xC1, 0xAD, 0x21, 0x68, + 0xC8, 0xEC, 0x90, 0xAD, 0x21, 0xF7, 0xE7, 0x98, 0xCE, 0x91, 0xCE, 0x69, + 0x0E, 0x85, 0x50, 0x7E, 0xE8, 0xD6, 0xD0, 0x07, 0x61, 0xE6, 0x61, 0x8B, + 0xC3, 0x7E, 0x0C, 0x27, 0x85, 0x87, 0x85, 0x57, 0x86, 0x3F, 0x8E, 0x70, + 0x88, 0x58, 0x1A, 0xD1, 0x31, 0x97, 0x35, 0x77, 0xD1, 0xDC, 0x43, 0x73, + 0xDF, 0x44, 0xFA, 0x44, 0x96, 0x44, 0xDE, 0x9B, 0x67, 0x31, 0x4F, 0x39, + 0xAF, 0x2D, 0x4A, 0x35, 0x2A, 0x3E, 0xAA, 0x2E, 0x6A, 0x3C, 0xDA, 0x37, + 0xBA, 0x34, 0xBA, 0x3F, 0xC6, 0x2E, 0x66, 0x59, 0xCC, 0xD5, 0x58, 0x9D, + 0x58, 0x49, 0x6C, 0x4B, 0x1C, 0x39, 0x2E, 0x2A, 0xAE, 0x36, 0x6E, 0x6C, + 0xBE, 0xDF, 0xFC, 0xED, 0xF3, 0x87, 0xE2, 0x9D, 0xE2, 0x0B, 0xE3, 0x7B, + 0x17, 0x98, 0x2F, 0xC8, 0x5D, 0x70, 0x79, 0xA1, 0xCE, 0xC2, 0xF4, 0x85, + 0xA7, 0x16, 0xA9, 0x2E, 0x12, 0x2C, 0x3A, 0x96, 0x40, 0x4C, 0x88, 0x4E, + 0x38, 0x94, 0xF0, 0x41, 0x10, 0x2A, 0xA8, 0x16, 0x8C, 0x25, 0xF2, 0x13, + 0x77, 0x25, 0x8E, 0x0A, 0x79, 0xC2, 0x1D, 0xC2, 0x67, 0x22, 0x2F, 0xD1, + 0x36, 0xD1, 0x88, 0xD8, 0x43, 0x5C, 0x2A, 0x1E, 0x4E, 0xF2, 0x48, 0x2A, + 0x4D, 0x7A, 0x92, 0xEC, 0x91, 0xBC, 0x35, 0x79, 0x24, 0xC5, 0x33, 0xA5, + 0x2C, 0xE5, 0xB9, 0x84, 0x27, 0xA9, 0x90, 0xBC, 0x4C, 0x0D, 0x4C, 0xDD, + 0x9B, 0x3A, 0x9E, 0x16, 0x9A, 0x76, 0x20, 0x6D, 0x32, 0x3D, 0x3A, 0xBD, + 0x31, 0x83, 0x92, 0x91, 0x90, 0x71, 0x42, 0xAA, 0x21, 0x4D, 0x93, 0xB6, + 0x67, 0xEA, 0x67, 0xE6, 0x66, 0x76, 0xCB, 0xAC, 0x65, 0x85, 0xB2, 0xFE, + 0xC5, 0x6E, 0x8B, 0xB7, 0x2F, 0x1E, 0x95, 0x07, 0xC9, 0x6B, 0xB3, 0x90, + 0xAC, 0x05, 0x59, 0x2D, 0x0A, 0xB6, 0x42, 0xA6, 0xE8, 0x54, 0x5A, 0x28, + 0xD7, 0x2A, 0x07, 0xB2, 0x67, 0x65, 0x57, 0x66, 0xBF, 0xCD, 0x89, 0xCA, + 0x39, 0x96, 0xAB, 0x9E, 0x2B, 0xCD, 0xED, 0xCC, 0xB3, 0xCA, 0xDB, 0x90, + 0x37, 0x9C, 0xEF, 0x9F, 0xFF, 0xED, 0x12, 0xC2, 0x12, 0xE1, 0x92, 0xB6, + 0xA5, 0x86, 0x4B, 0x57, 0x2D, 0x1D, 0x58, 0xE6, 0xBD, 0xAC, 0x6A, 0x39, + 0xB2, 0x3C, 0x71, 0x79, 0xDB, 0x0A, 0xE3, 0x15, 0x05, 0x2B, 0x86, 0x56, + 0x06, 0xAC, 0x3C, 0xB8, 0x8A, 0xB6, 0x2A, 0x6D, 0xD5, 0x4F, 0xAB, 0xED, + 0x57, 0x97, 0xAE, 0x7E, 0xBD, 0x26, 0x7A, 0x4D, 0x6B, 0x81, 0x5E, 0xC1, + 0xCA, 0x82, 0xC1, 0xB5, 0x01, 0x6B, 0xEB, 0x0B, 0x55, 0x0A, 0xE5, 0x85, + 0x7D, 0xEB, 0xDC, 0xD7, 0xED, 0x5D, 0x4F, 0x58, 0x2F, 0x59, 0xDF, 0xB5, + 0x61, 0xFA, 0x86, 0x9D, 0x1B, 0x3E, 0x15, 0x89, 0x8A, 0xAE, 0x14, 0xDB, + 0x17, 0x97, 0x15, 0x7F, 0xD8, 0x28, 0xDC, 0x78, 0xE5, 0x1B, 0x87, 0x6F, + 0xCA, 0xBF, 0x99, 0xDC, 0x94, 0xB4, 0xA9, 0xAB, 0xC4, 0xB9, 0x64, 0xCF, + 0x66, 0xD2, 0x66, 0xE9, 0xE6, 0xDE, 0x2D, 0x9E, 0x5B, 0x0E, 0x96, 0xAA, + 0x97, 0xE6, 0x97, 0x0E, 0x6E, 0x0D, 0xD9, 0xDA, 0xB4, 0x0D, 0xDF, 0x56, + 0xB4, 0xED, 0xF5, 0xF6, 0x45, 0xDB, 0x2F, 0x97, 0xCD, 0x28, 0xDB, 0xBB, + 0x83, 0xB6, 0x43, 0xB9, 0xA3, 0xBF, 0x3C, 0xB8, 0xBC, 0x65, 0xA7, 0xC9, + 0xCE, 0xCD, 0x3B, 0x3F, 0x54, 0xA4, 0x54, 0xF4, 0x54, 0xFA, 0x54, 0x36, + 0xEE, 0xD2, 0xDD, 0xB5, 0x61, 0xD7, 0xF8, 0x6E, 0xD1, 0xEE, 0x1B, 0x7B, + 0xBC, 0xF6, 0x34, 0xEC, 0xD5, 0xDB, 0x5B, 0xBC, 0xF7, 0xFD, 0x3E, 0xC9, + 0xBE, 0xDB, 0x55, 0x01, 0x55, 0x4D, 0xD5, 0x66, 0xD5, 0x65, 0xFB, 0x49, + 0xFB, 0xB3, 0xF7, 0x3F, 0xAE, 0x89, 0xAA, 0xE9, 0xF8, 0x96, 0xFB, 0x6D, + 0x5D, 0xAD, 0x4E, 0x6D, 0x71, 0xED, 0xC7, 0x03, 0xD2, 0x03, 0xFD, 0x07, + 0x23, 0x0E, 0xB6, 0xD7, 0xB9, 0xD4, 0xD5, 0x1D, 0xD2, 0x3D, 0x54, 0x52, + 0x8F, 0xD6, 0x2B, 0xEB, 0x47, 0x0E, 0xC7, 0x1F, 0xBE, 0xFE, 0x9D, 0xEF, + 0x77, 0x2D, 0x0D, 0x36, 0x0D, 0x55, 0x8D, 0x9C, 0xC6, 0xE2, 0x23, 0x70, + 0x44, 0x79, 0xE4, 0xE9, 0xF7, 0x09, 0xDF, 0xF7, 0x1E, 0x0D, 0x3A, 0xDA, + 0x76, 0x8C, 0x7B, 0xAC, 0xE1, 0x07, 0xD3, 0x1F, 0x76, 0x1D, 0x67, 0x1D, + 0x2F, 0x6A, 0x42, 0x9A, 0xF2, 0x9A, 0x46, 0x9B, 0x53, 0x9A, 0xFB, 0x5B, + 0x62, 0x5B, 0xBA, 0x4F, 0xCC, 0x3E, 0xD1, 0xD6, 0xEA, 0xDE, 0x7A, 0xFC, + 0x47, 0xDB, 0x1F, 0x0F, 0x9C, 0x34, 0x3C, 0x59, 0x79, 0x4A, 0xF3, 0x54, + 0xC9, 0x69, 0xDA, 0xE9, 0x82, 0xD3, 0x93, 0x67, 0xF2, 0xCF, 0x8C, 0x9D, + 0x95, 0x9D, 0x7D, 0x7E, 0x2E, 0xF9, 0xDC, 0x60, 0xDB, 0xA2, 0xB6, 0x7B, + 0xE7, 0x63, 0xCE, 0xDF, 0x6A, 0x0F, 0x6F, 0xEF, 0xBA, 0x10, 0x74, 0xE1, + 0xD2, 0x45, 0xFF, 0x8B, 0xE7, 0x3B, 0xBC, 0x3B, 0xCE, 0x5C, 0xF2, 0xB8, + 0x74, 0xF2, 0xB2, 0xDB, 0xE5, 0x13, 0x57, 0xB8, 0x57, 0x9A, 0xAF, 0x3A, + 0x5F, 0x6D, 0xEA, 0x74, 0xEA, 0x3C, 0xFE, 0x93, 0xD3, 0x4F, 0xC7, 0xBB, + 0x9C, 0xBB, 0x9A, 0xAE, 0xB9, 0x5C, 0x6B, 0xB9, 0xEE, 0x7A, 0xBD, 0xB5, + 0x7B, 0x66, 0xF7, 0xE9, 0x1B, 0x9E, 0x37, 0xCE, 0xDD, 0xF4, 0xBD, 0x79, + 0xF1, 0x16, 0xFF, 0xD6, 0xD5, 0x9E, 0x39, 0x3D, 0xDD, 0xBD, 0xF3, 0x7A, + 0x6F, 0xF7, 0xC5, 0xF7, 0xF5, 0xDF, 0x16, 0xDD, 0x7E, 0x72, 0x27, 0xFD, + 0xCE, 0xCB, 0xBB, 0xD9, 0x77, 0x27, 0xEE, 0xAD, 0xBC, 0x4F, 0xBC, 0x5F, + 0xF4, 0x40, 0xED, 0x41, 0xD9, 0x43, 0xDD, 0x87, 0xD5, 0x3F, 0x5B, 0xFE, + 0xDC, 0xD8, 0xEF, 0xDC, 0x7F, 0x6A, 0xC0, 0x77, 0xA0, 0xF3, 0xD1, 0xDC, + 0x47, 0xF7, 0x06, 0x85, 0x83, 0xCF, 0xFE, 0x91, 0xF5, 0x8F, 0x0F, 0x43, + 0x05, 0x8F, 0x99, 0x8F, 0xCB, 0x86, 0x0D, 0x86, 0xEB, 0x9E, 0x38, 0x3E, + 0x39, 0x39, 0xE2, 0x3F, 0x72, 0xFD, 0xE9, 0xFC, 0xA7, 0x43, 0xCF, 0x64, + 0xCF, 0x26, 0x9E, 0x17, 0xFE, 0xA2, 0xFE, 0xCB, 0xAE, 0x17, 0x16, 0x2F, + 0x7E, 0xF8, 0xD5, 0xEB, 0xD7, 0xCE, 0xD1, 0x98, 0xD1, 0xA1, 0x97, 0xF2, + 0x97, 0x93, 0xBF, 0x6D, 0x7C, 0xA5, 0xFD, 0xEA, 0xC0, 0xEB, 0x19, 0xAF, + 0xDB, 0xC6, 0xC2, 0xC6, 0x1E, 0xBE, 0xC9, 0x78, 0x33, 0x31, 0x5E, 0xF4, + 0x56, 0xFB, 0xED, 0xC1, 0x77, 0xDC, 0x77, 0x1D, 0xEF, 0xA3, 0xDF, 0x0F, + 0x4F, 0xE4, 0x7C, 0x20, 0x7F, 0x28, 0xFF, 0x68, 0xF9, 0xB1, 0xF5, 0x53, + 0xD0, 0xA7, 0xFB, 0x93, 0x19, 0x93, 0x93, 0xFF, 0x04, 0x03, 0x98, 0xF3, + 0xFC, 0x63, 0x33, 0x2D, 0xDB, 0x00, 0x00, 0x3A, 0xFD, 0x69, 0x54, 0x58, + 0x74, 0x58, 0x4D, 0x4C, 0x3A, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x78, 0x6D, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D, + 0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, + 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63, 0x7A, 0x6B, 0x63, 0x39, + 0x64, 0x22, 0x3F, 0x3E, 0x0A, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, + 0x65, 0x74, 0x61, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, + 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65, + 0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, + 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x58, 0x4D, 0x50, 0x20, + 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, + 0x38, 0x20, 0x37, 0x39, 0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, + 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D, + 0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, + 0x31, 0x39, 0x39, 0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, + 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E, 0x73, + 0x23, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, + 0x3D, 0x22, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x6D, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, + 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, + 0x6E, 0x73, 0x3A, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3D, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, + 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, + 0x30, 0x2F, 0x6D, 0x6D, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, + 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, + 0x73, 0x54, 0x79, 0x70, 0x65, 0x2F, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x23, 0x22, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, + 0x6C, 0x6E, 0x73, 0x3A, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x2F, 0x31, 0x2E, 0x30, + 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x64, 0x63, 0x3D, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x70, 0x75, 0x72, 0x6C, + 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x64, 0x63, 0x2F, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2F, 0x31, 0x2E, 0x31, 0x2F, 0x22, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, + 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x74, 0x69, 0x66, 0x66, 0x3D, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x2F, + 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, + 0x65, 0x78, 0x69, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, + 0x6D, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6F, 0x72, 0x54, + 0x6F, 0x6F, 0x6C, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, + 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, + 0x29, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6F, 0x72, 0x54, 0x6F, 0x6F, 0x6C, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, + 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, + 0x30, 0x3A, 0x33, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, + 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, + 0x33, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, + 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, + 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, 0x33, 0x33, + 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, + 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x66, + 0x32, 0x30, 0x35, 0x37, 0x36, 0x34, 0x39, 0x2D, 0x37, 0x30, 0x65, 0x34, + 0x2D, 0x39, 0x35, 0x34, 0x39, 0x2D, 0x62, 0x65, 0x38, 0x61, 0x2D, 0x32, + 0x37, 0x63, 0x64, 0x38, 0x65, 0x38, 0x34, 0x34, 0x64, 0x31, 0x64, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, + 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x44, + 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x3E, 0x61, 0x64, + 0x6F, 0x62, 0x65, 0x3A, 0x64, 0x6F, 0x63, 0x69, 0x64, 0x3A, 0x70, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x30, 0x36, 0x32, 0x33, + 0x62, 0x65, 0x64, 0x36, 0x2D, 0x33, 0x35, 0x62, 0x35, 0x2D, 0x31, 0x31, + 0x65, 0x38, 0x2D, 0x39, 0x31, 0x61, 0x34, 0x2D, 0x38, 0x38, 0x34, 0x37, + 0x30, 0x37, 0x30, 0x65, 0x31, 0x35, 0x34, 0x62, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, + 0x69, 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x37, + 0x61, 0x32, 0x34, 0x30, 0x39, 0x32, 0x30, 0x2D, 0x63, 0x66, 0x39, 0x35, + 0x2D, 0x64, 0x39, 0x34, 0x38, 0x2D, 0x39, 0x62, 0x38, 0x66, 0x2D, 0x36, + 0x66, 0x66, 0x39, 0x62, 0x39, 0x31, 0x35, 0x37, 0x35, 0x39, 0x64, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, 0x69, + 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, + 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, + 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, + 0x20, 0x72, 0x64, 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x3D, 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, + 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x37, 0x61, 0x32, 0x34, 0x30, 0x39, + 0x32, 0x30, 0x2D, 0x63, 0x66, 0x39, 0x35, 0x2D, 0x64, 0x39, 0x34, 0x38, + 0x2D, 0x39, 0x62, 0x38, 0x66, 0x2D, 0x36, 0x66, 0x66, 0x39, 0x62, 0x39, + 0x31, 0x35, 0x37, 0x35, 0x39, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, + 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, + 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, + 0x3A, 0x33, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, + 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, + 0x74, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, + 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, + 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x20, 0x72, 0x64, + 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3D, + 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, + 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x73, 0x61, 0x76, 0x65, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, + 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, + 0x3A, 0x66, 0x32, 0x30, 0x35, 0x37, 0x36, 0x34, 0x39, 0x2D, 0x37, 0x30, + 0x65, 0x34, 0x2D, 0x39, 0x35, 0x34, 0x39, 0x2D, 0x62, 0x65, 0x38, 0x61, + 0x2D, 0x32, 0x37, 0x63, 0x64, 0x38, 0x65, 0x38, 0x34, 0x34, 0x64, 0x31, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, + 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, + 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, + 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, 0x33, 0x33, 0x2B, 0x30, + 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x41, 0x64, 0x6F, + 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, + 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, + 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x64, 0x3E, 0x2F, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, + 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, + 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, 0x67, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x39, 0x30, 0x39, 0x62, 0x39, 0x65, + 0x35, 0x32, 0x2D, 0x39, 0x37, 0x62, 0x64, 0x2D, 0x34, 0x32, 0x39, 0x33, + 0x2D, 0x38, 0x30, 0x64, 0x32, 0x2D, 0x31, 0x31, 0x64, 0x65, 0x62, 0x64, + 0x36, 0x61, 0x33, 0x33, 0x65, 0x62, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, + 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, + 0x67, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, + 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, + 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, + 0x6F, 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, + 0x3E, 0x33, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x49, 0x43, 0x43, + 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, 0x73, 0x52, 0x47, 0x42, + 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, + 0x31, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x3A, 0x49, 0x43, 0x43, 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, + 0x63, 0x3A, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0x2F, 0x70, 0x6E, 0x67, 0x3C, 0x2F, 0x64, 0x63, 0x3A, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, + 0x69, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, 0x69, 0x65, 0x6E, 0x74, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, + 0x3E, 0x32, 0x3C, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, + 0x63, 0x65, 0x3E, 0x31, 0x3C, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x3A, 0x43, + 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, 0x63, 0x65, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, + 0x6D, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, 0x66, 0x3A, + 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x0A, 0x3C, 0x2F, + 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x64, + 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0x55, 0x32, 0xFE, 0xAE, 0x00, 0x00, + 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x25, 0x00, 0x00, + 0x80, 0x83, 0x00, 0x00, 0xF9, 0xFF, 0x00, 0x00, 0x80, 0xE9, 0x00, 0x00, + 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, + 0x17, 0x6F, 0x92, 0x5F, 0xC5, 0x46, 0x00, 0x00, 0x0B, 0xBD, 0x49, 0x44, + 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9D, 0x7B, 0x90, 0x95, 0x65, 0x1D, 0xC7, + 0x3F, 0xE7, 0xEC, 0xC2, 0xDE, 0x61, 0x59, 0x59, 0x02, 0x44, 0x28, 0x58, + 0xC0, 0x58, 0x09, 0x2C, 0x15, 0x44, 0x25, 0x35, 0x75, 0x6C, 0x14, 0xBB, + 0x20, 0x3A, 0x89, 0x63, 0xD9, 0xFD, 0xDE, 0x4C, 0xC3, 0x54, 0x96, 0x8D, + 0x91, 0x35, 0x43, 0x6A, 0x37, 0x2D, 0x29, 0x13, 0xB5, 0x2C, 0x2A, 0x8B, + 0xA9, 0x94, 0xA9, 0x2C, 0xBB, 0xDF, 0x30, 0x1C, 0xE4, 0xB2, 0x54, 0xC8, + 0x2D, 0x10, 0x01, 0xB9, 0x2E, 0xEC, 0xB2, 0xF7, 0x73, 0x9E, 0xFE, 0xF8, + 0xFD, 0x8E, 0x6E, 0xDC, 0xDE, 0xE7, 0x3D, 0x97, 0xF7, 0x76, 0x9E, 0xEF, + 0xCC, 0x99, 0xDD, 0x85, 0xF7, 0x3D, 0xE7, 0x3D, 0xEF, 0xF7, 0x7D, 0x9E, + 0xE7, 0x77, 0xF9, 0xFE, 0x7E, 0x4F, 0xCA, 0x18, 0x83, 0x43, 0x72, 0x91, + 0x76, 0xB7, 0xC0, 0x11, 0xEC, 0xE0, 0x08, 0x76, 0x70, 0x04, 0x3B, 0x38, + 0x82, 0x1D, 0x1C, 0xC1, 0x0E, 0x8E, 0x60, 0x07, 0x47, 0x70, 0x19, 0xA1, + 0x32, 0x61, 0xDF, 0xA7, 0x0A, 0x38, 0x13, 0xA8, 0x05, 0x1A, 0x80, 0x61, + 0xFA, 0xB3, 0x6E, 0xD0, 0xC3, 0x9C, 0x01, 0x8E, 0x01, 0x47, 0xF5, 0xD5, + 0x01, 0x74, 0x01, 0xCF, 0xEB, 0xFF, 0x39, 0x82, 0x23, 0x86, 0x51, 0xC0, + 0x6B, 0xF4, 0xE7, 0xAB, 0x81, 0x69, 0x40, 0x35, 0x50, 0xAF, 0xC4, 0xD6, + 0xEA, 0xDF, 0x29, 0x3D, 0x3E, 0x0B, 0xF4, 0x00, 0xDD, 0x40, 0xA7, 0xBE, + 0xBA, 0x80, 0xF5, 0xC0, 0x73, 0xC0, 0x3E, 0xE0, 0x59, 0xE0, 0x48, 0x12, + 0x08, 0x4E, 0xC5, 0x34, 0x54, 0x59, 0x0D, 0xCC, 0x00, 0xCE, 0x03, 0x66, + 0x02, 0xD3, 0x81, 0x26, 0x7D, 0x35, 0x28, 0x99, 0x69, 0x7D, 0xA5, 0x4E, + 0xF1, 0x1E, 0x46, 0xC9, 0xCE, 0xEA, 0xEF, 0xED, 0xC0, 0x21, 0xE0, 0x30, + 0xF0, 0x0C, 0xB0, 0x01, 0x78, 0x1A, 0x68, 0xD3, 0x63, 0x1C, 0xC1, 0x01, + 0xA0, 0x1E, 0xB8, 0x18, 0x98, 0x0B, 0xCC, 0x02, 0xA6, 0x02, 0x8D, 0x40, + 0x4D, 0x11, 0xED, 0x89, 0xAC, 0x4E, 0xE1, 0x87, 0x80, 0x8D, 0xC0, 0xDF, + 0x81, 0xBF, 0xEA, 0xCF, 0x7E, 0x47, 0x70, 0x69, 0x30, 0x14, 0xB8, 0x0C, + 0xB8, 0x0A, 0x78, 0x3D, 0x30, 0x51, 0x47, 0x6A, 0xA9, 0x97, 0x98, 0x01, + 0x1D, 0xD1, 0x9B, 0x81, 0xA7, 0x80, 0x27, 0x81, 0x7F, 0xE8, 0x88, 0x77, + 0x04, 0x17, 0x09, 0xD3, 0x80, 0xEB, 0x81, 0x6B, 0x74, 0xC4, 0x36, 0x84, + 0x60, 0xFD, 0x67, 0x95, 0xE8, 0x36, 0xE0, 0x71, 0x60, 0x05, 0xB0, 0xC3, + 0x11, 0x5C, 0xB8, 0x01, 0x78, 0x25, 0xF0, 0x7E, 0x60, 0x36, 0x30, 0x32, + 0x02, 0x6E, 0x5D, 0x06, 0xD8, 0x03, 0xFC, 0x11, 0x78, 0x10, 0xF8, 0x93, + 0x23, 0x38, 0x3F, 0x8C, 0x04, 0xDE, 0x09, 0xDC, 0xA0, 0x16, 0xF2, 0x90, + 0x88, 0x5D, 0x5F, 0x17, 0xB0, 0x16, 0x58, 0x06, 0xFC, 0x48, 0xFF, 0x76, + 0x6E, 0x92, 0x25, 0x26, 0x01, 0x1F, 0x07, 0xAE, 0x03, 0xC6, 0x46, 0x34, + 0x18, 0x53, 0xAB, 0x46, 0xDE, 0x19, 0xC0, 0x78, 0xE0, 0x9B, 0xC0, 0x7E, + 0x37, 0x82, 0xBD, 0x71, 0x0E, 0x70, 0x3B, 0xF0, 0x46, 0x0D, 0x52, 0x14, + 0x82, 0x0E, 0xF5, 0x65, 0xBB, 0x4E, 0x12, 0xC0, 0x18, 0xA2, 0x24, 0x35, + 0xEA, 0xCF, 0x7C, 0x61, 0xD4, 0x6F, 0x5E, 0x01, 0xDC, 0x09, 0xEC, 0x75, + 0x04, 0x9F, 0xDE, 0x98, 0x5A, 0x02, 0x5C, 0xA1, 0x6E, 0x4F, 0x3E, 0xD8, + 0xA1, 0x16, 0xEF, 0x0B, 0x1A, 0xB8, 0xD8, 0xA7, 0x24, 0x67, 0x4E, 0x32, + 0x73, 0x8D, 0x00, 0x5E, 0xA1, 0xFE, 0xF4, 0x68, 0x0D, 0x92, 0x8C, 0xC9, + 0xF3, 0x73, 0x8F, 0x02, 0x8F, 0x01, 0x77, 0x00, 0xBB, 0x1D, 0xC1, 0x27, + 0x62, 0x22, 0x70, 0x8F, 0x5A, 0xCA, 0x43, 0x7D, 0x9E, 0xDB, 0xA7, 0xAE, + 0xCB, 0x7A, 0x60, 0x95, 0x12, 0xDC, 0xAE, 0x53, 0x66, 0xAF, 0xBA, 0x3A, + 0xC7, 0x7F, 0xC9, 0x94, 0x7E, 0x4E, 0xB5, 0xAE, 0xF7, 0x8D, 0xFA, 0x80, + 0x9D, 0x0F, 0x9C, 0xAB, 0x46, 0x5D, 0x3E, 0x33, 0xC6, 0x72, 0xE0, 0xB3, + 0x51, 0x9A, 0xAE, 0xA3, 0x40, 0xF0, 0x08, 0xE0, 0x6E, 0x60, 0xA1, 0xDE, + 0x70, 0x3F, 0xF8, 0x3D, 0xF0, 0x3B, 0xB5, 0x6A, 0x77, 0x68, 0x70, 0xA2, + 0x17, 0x7F, 0x91, 0xA7, 0x94, 0xBE, 0x6A, 0x74, 0x4D, 0x7D, 0x25, 0x70, + 0xB5, 0xCE, 0x24, 0xE7, 0xFB, 0xBC, 0x9E, 0x76, 0xE0, 0x3E, 0x9D, 0xAE, + 0xFB, 0x1D, 0xC1, 0x50, 0x01, 0xDC, 0x06, 0x2C, 0x02, 0x86, 0xFB, 0x38, + 0xEF, 0x3F, 0xC0, 0x4F, 0x81, 0x95, 0x3A, 0x62, 0x4F, 0x36, 0x0D, 0x17, + 0x72, 0x4D, 0x67, 0x00, 0xAD, 0xC0, 0x5B, 0x80, 0xF9, 0x6A, 0xEC, 0xD9, + 0x62, 0x17, 0xB0, 0x58, 0xDD, 0xA8, 0xB2, 0x27, 0x78, 0x3E, 0xF0, 0x15, + 0xB5, 0x44, 0x6D, 0xF1, 0x2B, 0x60, 0xA9, 0x4E, 0xC7, 0x07, 0x29, 0x5D, + 0x9C, 0xB8, 0x02, 0xC9, 0x4C, 0xCD, 0x05, 0xDE, 0x87, 0x84, 0x48, 0x6D, + 0xF1, 0x6F, 0x75, 0xF3, 0x56, 0x95, 0x33, 0xC1, 0x13, 0x75, 0xCD, 0xBA, + 0x80, 0x53, 0x27, 0x04, 0x8E, 0xB7, 0x58, 0x97, 0x02, 0x0F, 0xEB, 0x7A, + 0xDB, 0x17, 0xD0, 0x75, 0xD6, 0x00, 0xAF, 0x03, 0x3E, 0x0A, 0x2C, 0xB0, + 0x3C, 0x27, 0xAB, 0xB3, 0xCB, 0x2D, 0x84, 0x9C, 0x95, 0xAA, 0x0C, 0xF1, + 0x73, 0x3F, 0xAC, 0x37, 0xCE, 0x86, 0xDC, 0x8C, 0x8E, 0xF4, 0xA5, 0xBA, + 0xD6, 0x06, 0x99, 0xDD, 0xE9, 0x56, 0x23, 0xAE, 0x5D, 0xAD, 0xE5, 0x77, + 0x59, 0x9C, 0x93, 0x46, 0xA2, 0x70, 0x6F, 0x07, 0xEE, 0x0D, 0x93, 0xE0, + 0xB0, 0x82, 0x08, 0x17, 0x02, 0x6F, 0xF3, 0xF1, 0x80, 0xDD, 0x03, 0x7C, + 0x1D, 0xD8, 0x4E, 0x38, 0xA9, 0xBB, 0x0C, 0x92, 0x59, 0x5A, 0xE2, 0x63, + 0x6D, 0xAD, 0xD1, 0xA9, 0x7D, 0x7A, 0xB9, 0x11, 0x5C, 0x0B, 0x7C, 0x40, + 0x7D, 0x4F, 0x1B, 0x3C, 0xA8, 0x96, 0xE9, 0x0B, 0x21, 0x2F, 0x67, 0x06, + 0xD8, 0x0A, 0x7C, 0x49, 0xA7, 0x5F, 0x1B, 0x4C, 0x05, 0x6E, 0x2E, 0x30, + 0x98, 0x12, 0x2B, 0x82, 0x2B, 0x90, 0x10, 0xDF, 0xD5, 0x96, 0xC7, 0xFF, + 0x41, 0xA7, 0xE6, 0xB0, 0xC9, 0x3D, 0x19, 0xC9, 0x1B, 0x2C, 0xBF, 0xEF, + 0x0D, 0xC0, 0xAB, 0xCA, 0x85, 0xE0, 0x34, 0xF0, 0x0E, 0xF5, 0x7D, 0xBD, + 0xF0, 0xBC, 0xFA, 0xC7, 0x9B, 0x88, 0x16, 0x0C, 0xA2, 0xF4, 0xB8, 0x0B, + 0x91, 0xFB, 0x78, 0x61, 0x82, 0x0F, 0xE3, 0x2C, 0xF6, 0x04, 0x4F, 0xF1, + 0x31, 0x7A, 0x1F, 0x45, 0xD2, 0x71, 0x51, 0x94, 0xCB, 0xF4, 0xEB, 0x34, + 0xFD, 0x43, 0xCB, 0x40, 0xCA, 0x8D, 0x48, 0xC4, 0xAC, 0x22, 0xE9, 0x04, + 0xCF, 0x07, 0x9A, 0x2D, 0x8E, 0x5B, 0x45, 0xC4, 0xD3, 0x70, 0x6A, 0x55, + 0x7F, 0x57, 0x0D, 0x3F, 0x2F, 0xB4, 0x00, 0xD7, 0x86, 0xF1, 0xB0, 0x06, + 0x49, 0x70, 0x35, 0x22, 0xB9, 0xB1, 0x71, 0x8B, 0x1E, 0x8E, 0xE0, 0xD4, + 0x7C, 0x32, 0x3C, 0x6B, 0x39, 0x8A, 0x2B, 0x91, 0xF4, 0xA7, 0x49, 0x32, + 0xC1, 0xB3, 0x81, 0xC9, 0x16, 0xC7, 0xAD, 0x47, 0x62, 0xCB, 0x7D, 0x31, + 0x20, 0xB8, 0x0B, 0x91, 0xF0, 0xD8, 0x64, 0x90, 0x5A, 0x81, 0x71, 0x49, + 0x26, 0x78, 0x0E, 0x92, 0xB5, 0xF1, 0xC2, 0x13, 0xC0, 0x4E, 0xE2, 0x83, + 0x8D, 0x48, 0xF8, 0xD4, 0x0B, 0x63, 0x10, 0xC1, 0x60, 0x62, 0x09, 0x9E, + 0x84, 0xB7, 0xF4, 0xE6, 0x00, 0x92, 0x21, 0xEA, 0x89, 0x11, 0xC1, 0x9D, + 0xD8, 0x69, 0xB3, 0xEA, 0x10, 0xF9, 0x51, 0x22, 0x09, 0x1E, 0xAE, 0x4E, + 0xBF, 0xD7, 0xFA, 0xBB, 0x5A, 0x47, 0x44, 0xDC, 0xB0, 0x0E, 0x51, 0x5C, + 0x7A, 0x59, 0xD3, 0x89, 0x9D, 0xA2, 0xA7, 0x5A, 0x3A, 0xFB, 0x5B, 0x90, + 0x0C, 0x51, 0xDC, 0xB0, 0x1D, 0x11, 0xE1, 0x79, 0x11, 0x3C, 0xC9, 0xD2, + 0x8B, 0x88, 0x1D, 0xC1, 0x63, 0x90, 0xAA, 0x04, 0xAF, 0x00, 0xC2, 0x26, + 0x44, 0x81, 0x11, 0x37, 0x74, 0x5A, 0x1A, 0x5A, 0x13, 0x80, 0xB3, 0x93, + 0x48, 0x70, 0xBD, 0x85, 0x93, 0xFF, 0x22, 0x92, 0x47, 0x8D, 0x23, 0x8C, + 0xCE, 0x3E, 0x5E, 0x0F, 0x67, 0xAD, 0xA5, 0xA1, 0x19, 0x3B, 0x82, 0xEB, + 0x2C, 0x3E, 0x6B, 0x3F, 0x22, 0x92, 0x8B, 0x2B, 0xB6, 0xE3, 0x9D, 0xFB, + 0xCD, 0x69, 0xC1, 0x12, 0x47, 0xF0, 0x30, 0x8B, 0xCF, 0xEA, 0x8C, 0x99, + 0xF5, 0x7C, 0x3C, 0x8E, 0x20, 0xD1, 0x2D, 0x2F, 0x82, 0xAB, 0x92, 0x48, + 0xB0, 0xCD, 0x97, 0xEA, 0x25, 0x86, 0xD5, 0x7B, 0x83, 0xD0, 0x87, 0x88, + 0x03, 0xBC, 0x30, 0x24, 0x89, 0x04, 0x1B, 0xBC, 0xC3, 0x74, 0x71, 0x6F, + 0x27, 0x91, 0xB6, 0xFC, 0x0E, 0xA9, 0x24, 0x12, 0xDC, 0x6B, 0x41, 0x70, + 0x25, 0xF1, 0xEE, 0x38, 0x90, 0xB2, 0xB8, 0xFE, 0x6C, 0xD0, 0xCB, 0x50, + 0x50, 0x04, 0x77, 0xE0, 0x2D, 0x6B, 0xAD, 0x0F, 0xDA, 0x00, 0x29, 0x32, + 0x9A, 0x2D, 0x7D, 0xDC, 0x81, 0x24, 0x12, 0xDC, 0x65, 0x31, 0x82, 0xC7, + 0x22, 0xA2, 0xF3, 0xB8, 0x62, 0x32, 0xDE, 0xDA, 0xEE, 0x34, 0x01, 0xA7, + 0x0C, 0x83, 0x24, 0xD8, 0xCB, 0x0F, 0x6E, 0x44, 0x04, 0x01, 0x71, 0x85, + 0x4D, 0xFD, 0x72, 0x07, 0x01, 0x27, 0x52, 0x82, 0x22, 0x78, 0x0B, 0x52, + 0x21, 0xEF, 0xB5, 0x06, 0x9F, 0x19, 0x53, 0x63, 0x6B, 0x04, 0x12, 0x86, + 0xF4, 0x32, 0x34, 0xB7, 0x03, 0xDB, 0x92, 0x48, 0xF0, 0x36, 0xA4, 0xC4, + 0xC4, 0x0B, 0xE7, 0x91, 0x7F, 0x85, 0x5F, 0x98, 0x18, 0x0F, 0x5C, 0x64, + 0x71, 0xDC, 0x2E, 0x02, 0x16, 0xC2, 0x07, 0x45, 0xF0, 0x31, 0xFD, 0x72, + 0x5E, 0x78, 0xAD, 0xC5, 0x48, 0x88, 0x22, 0x5A, 0xF1, 0x2E, 0xBF, 0x31, + 0x48, 0xBC, 0x3A, 0x93, 0x44, 0x82, 0x0D, 0x12, 0x67, 0xEE, 0xF5, 0x38, + 0x6E, 0x38, 0xF0, 0x86, 0x98, 0x91, 0x5B, 0x83, 0x94, 0xBD, 0x7A, 0xD9, + 0x18, 0x9D, 0xC0, 0x9F, 0xC3, 0x70, 0xCE, 0x83, 0xC2, 0x53, 0xD8, 0x89, + 0xE8, 0xAE, 0x27, 0x44, 0x1D, 0x71, 0x1E, 0x98, 0x01, 0x5C, 0x6E, 0x71, + 0xDC, 0x51, 0x44, 0x6E, 0x9B, 0x58, 0x82, 0xDB, 0xB0, 0x53, 0x20, 0x4E, + 0x41, 0x5A, 0x38, 0xC4, 0xC1, 0xD8, 0xAA, 0x42, 0x94, 0xA2, 0xA3, 0x2C, + 0x8E, 0x5D, 0x45, 0x08, 0x85, 0xE1, 0x41, 0xDE, 0xC4, 0x2E, 0xEC, 0x15, + 0x88, 0xEF, 0x45, 0x44, 0x02, 0x51, 0xC7, 0x4C, 0x44, 0xD4, 0x6E, 0x73, + 0x1F, 0x1F, 0x23, 0x84, 0x58, 0x7B, 0xD0, 0xA3, 0xE4, 0xB7, 0xD8, 0xA5, + 0x04, 0x5B, 0x91, 0xFA, 0x5A, 0x08, 0x41, 0x2C, 0x6E, 0x89, 0x6A, 0xA4, + 0x1B, 0xD0, 0x59, 0x16, 0xC7, 0x6E, 0xC4, 0x5B, 0xF1, 0x91, 0x08, 0x82, + 0xB7, 0x22, 0xAA, 0x49, 0x9B, 0x51, 0x7C, 0x93, 0x4E, 0x7F, 0x51, 0x6B, + 0xF1, 0x9B, 0xCB, 0x06, 0xDD, 0xEA, 0x63, 0x29, 0xF9, 0x09, 0x21, 0x35, + 0x67, 0x09, 0x9A, 0xE0, 0x63, 0xC0, 0xF7, 0x2C, 0x47, 0xF1, 0x18, 0xE0, + 0x33, 0x48, 0x53, 0x94, 0x28, 0xA1, 0x1F, 0x98, 0x07, 0x7C, 0x0C, 0x69, + 0xAB, 0x68, 0x33, 0x7A, 0x7F, 0x4E, 0x48, 0x55, 0x1A, 0x41, 0x13, 0x6C, + 0x80, 0x35, 0x96, 0xA3, 0x38, 0x85, 0xC8, 0x4C, 0x17, 0x23, 0x5A, 0xA6, + 0x28, 0xAD, 0xBB, 0xB7, 0x23, 0xE5, 0x28, 0x36, 0x58, 0x81, 0xF4, 0xA1, + 0x36, 0xE5, 0x40, 0x70, 0xCE, 0x1F, 0x5C, 0x66, 0x19, 0xF8, 0xA8, 0x50, + 0xBF, 0xF8, 0x73, 0x48, 0x18, 0x33, 0x6C, 0x4C, 0x47, 0x2A, 0x1E, 0x67, + 0x5A, 0xDA, 0x06, 0x1B, 0x91, 0x66, 0x31, 0xDD, 0x61, 0x5D, 0x70, 0x58, + 0xAE, 0xC8, 0x1A, 0xE0, 0x01, 0xCB, 0x63, 0x6B, 0x75, 0x2D, 0xFE, 0x2A, + 0xD2, 0xAC, 0x2C, 0x2C, 0x5C, 0x08, 0x7C, 0x03, 0xB8, 0x04, 0xBB, 0xB4, + 0x66, 0x2F, 0xD2, 0xBE, 0xE1, 0xB9, 0x30, 0x9F, 0xC8, 0xB0, 0x08, 0xEE, + 0x45, 0x2A, 0xF3, 0x7E, 0x69, 0x79, 0x7C, 0x03, 0x12, 0x2D, 0xBA, 0xCF, + 0x32, 0xA8, 0x50, 0x6C, 0x2C, 0x00, 0xBE, 0xA6, 0x24, 0xDB, 0x6A, 0xAA, + 0x96, 0xEB, 0xF4, 0xDC, 0x1B, 0x26, 0xC1, 0x61, 0x76, 0xD9, 0x49, 0xEB, + 0xF4, 0xFB, 0x00, 0xF6, 0x79, 0xE0, 0x7E, 0xA4, 0x47, 0xD6, 0x32, 0xBD, + 0x81, 0xA5, 0x0E, 0x1C, 0x8C, 0x47, 0x9A, 0xAE, 0xDC, 0xAC, 0x76, 0x80, + 0xAD, 0xCB, 0xB6, 0x1A, 0xF8, 0x08, 0x21, 0x44, 0xAE, 0xA2, 0x44, 0x30, + 0x48, 0x1C, 0x77, 0xA1, 0x8E, 0x4C, 0xDB, 0x2E, 0x77, 0x59, 0xB5, 0xC2, + 0x9F, 0x06, 0x1E, 0x02, 0xFE, 0x82, 0x77, 0x2A, 0xD2, 0x2F, 0xC6, 0xE8, + 0x4C, 0x71, 0xAB, 0xAE, 0xB7, 0x4D, 0xD8, 0x6B, 0xA9, 0xF6, 0x22, 0x81, + 0x9A, 0x27, 0x89, 0x40, 0x85, 0x64, 0x14, 0x5A, 0x19, 0x0E, 0x57, 0x97, + 0x63, 0xB1, 0xCF, 0xF3, 0x7A, 0x90, 0x36, 0x0F, 0xFF, 0x04, 0x7E, 0xA6, + 0x81, 0x84, 0xAD, 0x05, 0x5E, 0x4B, 0x2B, 0x92, 0xB2, 0x7C, 0x13, 0x92, + 0xD9, 0x1A, 0x8B, 0x3F, 0x15, 0x64, 0xBF, 0x8E, 0xDC, 0x47, 0x89, 0x48, + 0xF1, 0x7A, 0x54, 0x9A, 0x91, 0x8E, 0x46, 0x9A, 0x78, 0x7E, 0x30, 0x0F, + 0xB7, 0xAB, 0x4B, 0x47, 0xF4, 0x66, 0xA4, 0x32, 0x71, 0x27, 0x52, 0x98, + 0xBD, 0xC3, 0xC2, 0x7A, 0xAD, 0x53, 0x52, 0xA7, 0x20, 0x69, 0xCA, 0xAB, + 0x90, 0x02, 0xB1, 0x51, 0xBA, 0xD6, 0xFA, 0x55, 0x40, 0xDE, 0x86, 0xF4, + 0xF2, 0x8A, 0xCC, 0x96, 0x3C, 0x51, 0x21, 0x38, 0xA5, 0x6B, 0xDC, 0x22, + 0xE0, 0x43, 0x79, 0xFA, 0xD7, 0xFD, 0x7A, 0x63, 0xBB, 0x95, 0xEC, 0x5C, + 0xD7, 0xD9, 0xBE, 0x53, 0x1C, 0x9F, 0x6B, 0x3E, 0x3A, 0x4D, 0x5D, 0xB0, + 0x3A, 0x44, 0x36, 0x94, 0xCE, 0x83, 0xD8, 0x2C, 0xF0, 0x45, 0xB5, 0x9A, + 0x0F, 0x44, 0x29, 0x2A, 0x13, 0xA5, 0x7E, 0xD1, 0x29, 0x44, 0x95, 0x78, + 0xAD, 0x92, 0x3C, 0x33, 0x4F, 0x2B, 0x3F, 0x47, 0x76, 0x0F, 0x12, 0xE6, + 0xCC, 0x9E, 0xC6, 0xC8, 0xAB, 0x54, 0xA2, 0x2B, 0xC8, 0x4F, 0xAF, 0x3C, + 0x00, 0xFC, 0x0D, 0xB8, 0x1F, 0x49, 0x87, 0x1E, 0x22, 0x62, 0x88, 0x92, + 0x0E, 0x39, 0xD7, 0x3D, 0xFD, 0x80, 0x92, 0x93, 0x2A, 0xE0, 0x41, 0x19, + 0x4A, 0x30, 0x12, 0xDC, 0x14, 0x12, 0x7E, 0x7D, 0x31, 0x8A, 0xE4, 0x46, + 0x69, 0x04, 0xB7, 0x20, 0xF1, 0xDD, 0x59, 0xBA, 0x16, 0xB6, 0x10, 0x70, + 0x15, 0x5E, 0x01, 0xD8, 0xAF, 0xCB, 0xC1, 0x36, 0x64, 0xF3, 0xAC, 0x5F, + 0x10, 0xA1, 0xAE, 0xEF, 0x61, 0x13, 0x3C, 0x47, 0xA7, 0xE4, 0xCB, 0x91, + 0xB4, 0x5B, 0x93, 0x5A, 0xAD, 0x69, 0x02, 0x2E, 0xF1, 0x28, 0x00, 0xB9, + 0xED, 0xF1, 0xFA, 0x91, 0xE2, 0xF5, 0x2D, 0x48, 0x5A, 0x74, 0x25, 0xD2, + 0x50, 0xA6, 0x2C, 0x09, 0x9E, 0xA6, 0x01, 0x84, 0x2B, 0xD5, 0x15, 0x69, + 0x8C, 0x19, 0xA9, 0x5E, 0xEB, 0x7F, 0xBB, 0x12, 0xFD, 0x1B, 0x0D, 0xE4, + 0xEC, 0x29, 0x17, 0x82, 0x1B, 0x94, 0xD8, 0x85, 0x48, 0x25, 0x40, 0x18, + 0xBB, 0x98, 0x05, 0x85, 0x01, 0x44, 0x87, 0xB5, 0x01, 0x78, 0x04, 0x69, + 0xEC, 0xD6, 0x93, 0x64, 0x82, 0x2F, 0x02, 0x3E, 0x89, 0xF4, 0xCB, 0x6A, + 0x22, 0xBA, 0x4A, 0x8D, 0x62, 0x23, 0xA3, 0xEB, 0xF4, 0xAF, 0x91, 0x78, + 0xF6, 0xBA, 0xA4, 0x11, 0x3C, 0x04, 0x78, 0x37, 0xD2, 0x00, 0xBC, 0x85, + 0x78, 0x17, 0x98, 0x15, 0x82, 0x4E, 0x44, 0x78, 0xF8, 0x65, 0x24, 0x85, + 0x98, 0xB3, 0xC2, 0x4D, 0x9C, 0x09, 0x6E, 0x46, 0x54, 0x19, 0x37, 0x22, + 0xD1, 0xA1, 0x62, 0x4D, 0xC7, 0xFD, 0x1A, 0xD0, 0x18, 0x1C, 0xC4, 0xC8, + 0x6D, 0x80, 0x55, 0x45, 0x7E, 0x5B, 0xF3, 0xF4, 0xEA, 0xAC, 0x52, 0x7B, + 0x9C, 0xBB, 0x55, 0x4D, 0xF1, 0x8A, 0xB6, 0x07, 0x74, 0x3D, 0xBE, 0x1F, + 0x69, 0x70, 0xDE, 0x1D, 0xE7, 0x11, 0x3C, 0x01, 0xF8, 0x3C, 0xB2, 0x73, + 0x49, 0x43, 0x81, 0xEF, 0xB5, 0x67, 0x90, 0xAF, 0xB9, 0x1A, 0x91, 0xDF, + 0x1E, 0xD6, 0x51, 0x91, 0x1D, 0xE4, 0xAE, 0xF4, 0xAB, 0xC1, 0x56, 0x8F, + 0x7D, 0x15, 0x5F, 0x5A, 0xDF, 0xA7, 0x5D, 0x89, 0x6C, 0x1E, 0xF4, 0xEF, + 0x0D, 0xBA, 0x9C, 0x4C, 0x46, 0x62, 0xD3, 0x4D, 0x48, 0x22, 0x62, 0x64, + 0x81, 0x86, 0xD8, 0x61, 0x44, 0x61, 0x7A, 0x07, 0x25, 0x6E, 0x1B, 0x55, + 0x2A, 0x82, 0x27, 0x20, 0xED, 0xEF, 0xE7, 0x21, 0x21, 0xC0, 0x7C, 0x70, + 0x48, 0xFD, 0xCA, 0xAD, 0x48, 0x63, 0xF0, 0x2D, 0x3A, 0x4A, 0x8F, 0xE8, + 0x88, 0xCB, 0x45, 0xA9, 0xCC, 0xA0, 0xB5, 0xCE, 0xE8, 0x28, 0x4C, 0xFB, + 0x98, 0xFA, 0x52, 0xFA, 0x3E, 0x19, 0xFD, 0xBD, 0x62, 0xD0, 0xBF, 0xA7, + 0xF5, 0xEF, 0x6A, 0x25, 0x7B, 0x18, 0x22, 0xE7, 0x9D, 0xAB, 0xCB, 0xCD, + 0x9C, 0x02, 0x1E, 0xDE, 0x0E, 0xE0, 0x07, 0xC0, 0xA7, 0x29, 0x7E, 0x36, + 0xAC, 0xA4, 0x04, 0x8F, 0x43, 0x3A, 0xA2, 0xBF, 0x99, 0xFC, 0x5A, 0xD9, + 0xB7, 0x21, 0x42, 0x80, 0x35, 0x48, 0xA6, 0xA8, 0x53, 0x6F, 0x46, 0x1F, + 0x76, 0xAD, 0x20, 0x4A, 0x76, 0xAF, 0x78, 0xB9, 0x89, 0x4A, 0xBD, 0xCE, + 0x14, 0xB3, 0x91, 0x8D, 0x45, 0xAE, 0xC1, 0x5E, 0xA3, 0x75, 0x3C, 0xC9, + 0xDF, 0xD7, 0x65, 0xEC, 0x70, 0x1C, 0x08, 0x1E, 0x81, 0x04, 0xDC, 0xDF, + 0x9A, 0x07, 0xB9, 0xEB, 0x80, 0x1F, 0xEB, 0x68, 0xDD, 0xA4, 0x2E, 0x45, + 0x0F, 0xD1, 0xDD, 0x6D, 0x3B, 0xB7, 0x5B, 0x5A, 0x35, 0x22, 0x0E, 0xBC, + 0x42, 0x6D, 0x0D, 0xBF, 0x44, 0x77, 0x02, 0xDF, 0xD6, 0x91, 0xDC, 0x17, + 0x65, 0x82, 0xAB, 0xF4, 0x22, 0x17, 0xF9, 0x24, 0xF7, 0x20, 0x2F, 0xCB, + 0x5B, 0xD6, 0x22, 0xB1, 0xDD, 0xB8, 0x75, 0xBB, 0x1B, 0xA2, 0x4B, 0xD1, + 0x2C, 0x25, 0xF9, 0x26, 0xFC, 0xB5, 0x4B, 0x3A, 0xAC, 0x2E, 0xE4, 0x77, + 0xA2, 0x4C, 0xF0, 0x3C, 0x44, 0x4A, 0xD3, 0xEC, 0x73, 0xD4, 0xDE, 0x85, + 0xE4, 0x71, 0x0F, 0x12, 0xEF, 0x36, 0x4A, 0xB9, 0x87, 0x7C, 0xA4, 0x4E, + 0xD9, 0x9F, 0xC0, 0x5F, 0x29, 0xEC, 0x26, 0xE0, 0x3D, 0x88, 0x42, 0xA5, + 0x78, 0x30, 0xC6, 0x14, 0xE3, 0xD5, 0x62, 0x8C, 0x59, 0x6B, 0xFC, 0xE1, + 0x21, 0x63, 0xCC, 0x0C, 0x63, 0x4C, 0x8D, 0x31, 0x26, 0x55, 0xA4, 0xEB, + 0x88, 0xC2, 0x2B, 0x65, 0x8C, 0xA9, 0x33, 0xC6, 0x5C, 0x60, 0x8C, 0x59, + 0xE9, 0xE3, 0x7E, 0x0C, 0x18, 0x63, 0x1E, 0x37, 0xC6, 0x8C, 0x2B, 0xE6, + 0xF5, 0x14, 0xC3, 0x2F, 0x1D, 0xA6, 0x4F, 0x5E, 0xAB, 0x0F, 0x5F, 0x70, + 0x89, 0xBA, 0x08, 0x6D, 0xEA, 0x0B, 0x1A, 0x92, 0x03, 0xA3, 0xCB, 0xCC, + 0x1A, 0x44, 0x8A, 0xF4, 0x88, 0xE5, 0x79, 0x15, 0x48, 0x6C, 0x7E, 0x5E, + 0xD4, 0xA6, 0xE8, 0x8B, 0x91, 0x14, 0x59, 0x93, 0x65, 0xD8, 0xEE, 0x0B, + 0xBA, 0xD6, 0xEC, 0x4E, 0x18, 0xB1, 0xA7, 0xF2, 0xB1, 0xC7, 0x23, 0x7A, + 0xB3, 0x5B, 0x2C, 0xCF, 0xF9, 0xAF, 0x1A, 0x6C, 0x5B, 0x8B, 0x75, 0x01, + 0x85, 0xA0, 0x1A, 0x51, 0x5F, 0x34, 0x59, 0x1E, 0x7F, 0x2F, 0xA2, 0x59, + 0x2A, 0x07, 0x72, 0x51, 0xFF, 0x7A, 0x27, 0x52, 0xEA, 0xB2, 0xC2, 0xF2, + 0x9C, 0xF1, 0xC8, 0x96, 0x78, 0xA9, 0x28, 0x10, 0x7C, 0x09, 0x70, 0x99, + 0xE5, 0xB1, 0x4F, 0x20, 0xBB, 0x98, 0xED, 0x2B, 0x13, 0x72, 0x07, 0x93, + 0xBC, 0x0B, 0xF8, 0x14, 0xF0, 0x8C, 0x25, 0x27, 0x0B, 0x28, 0x52, 0x97, + 0x83, 0x42, 0x09, 0xBE, 0xCE, 0xD2, 0x6A, 0xDE, 0xA9, 0xD3, 0xD4, 0xEE, + 0x32, 0x23, 0x77, 0xF0, 0xBA, 0xBC, 0x4D, 0x6D, 0x0F, 0x1B, 0xC5, 0xE5, + 0x59, 0x1A, 0x4B, 0x08, 0x95, 0xE0, 0x16, 0x1D, 0xC1, 0x36, 0xEF, 0xF1, + 0x2D, 0xA4, 0x10, 0x2B, 0x4B, 0xF9, 0x22, 0x8B, 0xA4, 0x0C, 0x97, 0x5B, + 0x1A, 0x5C, 0x97, 0x6A, 0x20, 0x25, 0x34, 0x82, 0xCF, 0xC5, 0xAE, 0x18, + 0x6C, 0x15, 0x22, 0x4C, 0xEF, 0xC1, 0xE1, 0x18, 0xB2, 0x9B, 0xAA, 0x8D, + 0x01, 0x35, 0x07, 0xD9, 0x3C, 0x3B, 0x34, 0x82, 0x5B, 0xF1, 0x56, 0x65, + 0x66, 0x90, 0xDC, 0xE7, 0x16, 0xC7, 0xED, 0x4B, 0xC8, 0x15, 0x84, 0xDB, + 0xB8, 0x9F, 0x67, 0x87, 0x45, 0x70, 0xA3, 0x9A, 0xF2, 0x5E, 0xE7, 0xB7, + 0x21, 0xB1, 0xE5, 0x01, 0xC7, 0xEB, 0x4B, 0xE8, 0x45, 0x36, 0xD2, 0xDA, + 0x6B, 0xC1, 0xCD, 0x39, 0x61, 0x11, 0x3C, 0x12, 0xBB, 0xC6, 0xA1, 0x9B, + 0x91, 0x12, 0x12, 0x87, 0xFF, 0xC7, 0xBF, 0xB0, 0xDB, 0x67, 0xE9, 0x52, + 0xEC, 0x37, 0xD2, 0x2E, 0x2A, 0xC1, 0xCD, 0x78, 0xAB, 0x26, 0x06, 0x90, + 0x0A, 0xC0, 0x76, 0xC7, 0xE7, 0x09, 0x68, 0xC7, 0x6E, 0x83, 0xE9, 0xD1, + 0x14, 0x28, 0x96, 0xC8, 0x97, 0xE0, 0xD1, 0x78, 0x8B, 0xE6, 0x0E, 0x21, + 0xBA, 0xE0, 0x8C, 0xE3, 0xF3, 0x04, 0x74, 0x23, 0x89, 0x16, 0xAF, 0xF4, + 0x60, 0xA5, 0xAE, 0xC5, 0x81, 0x13, 0x3C, 0xDC, 0xE2, 0xDC, 0xA3, 0xC4, + 0x73, 0x17, 0xB3, 0xA0, 0xB0, 0xCF, 0xC2, 0x27, 0x4E, 0x87, 0x45, 0x70, + 0x2D, 0xDE, 0xA1, 0xB4, 0x7E, 0xE2, 0xB1, 0x45, 0x6C, 0x98, 0x2E, 0x93, + 0xD7, 0xFD, 0x49, 0x91, 0x9F, 0x2A, 0xA6, 0x60, 0x82, 0xAB, 0x2D, 0x09, + 0x76, 0xD6, 0xF3, 0xE9, 0xEF, 0x8F, 0x4D, 0xE0, 0xC7, 0x84, 0x41, 0xB0, + 0x0D, 0x32, 0x94, 0x77, 0xE4, 0xCA, 0x0B, 0x7D, 0x04, 0x10, 0xB6, 0x2D, + 0x65, 0xF9, 0x68, 0x13, 0x92, 0xDB, 0x9C, 0x41, 0xC0, 0xBB, 0x7D, 0xC5, + 0x84, 0xDC, 0xE9, 0xE4, 0xAF, 0x38, 0x8D, 0x04, 0xC1, 0xE3, 0x80, 0x3B, + 0x29, 0xCF, 0xE4, 0x82, 0x0D, 0x2A, 0x08, 0xA0, 0xCA, 0xA3, 0xB2, 0xC4, + 0x5F, 0xA0, 0xC2, 0xF1, 0x18, 0x2E, 0xD2, 0xEE, 0x16, 0x38, 0x82, 0x1D, + 0x1C, 0xC1, 0x0E, 0x8E, 0x60, 0x07, 0x47, 0xB0, 0x43, 0x74, 0x08, 0xCE, + 0x15, 0x62, 0x39, 0x94, 0x16, 0x05, 0xDF, 0xE7, 0x7C, 0xDD, 0xA4, 0x23, + 0x48, 0x3D, 0x4D, 0x35, 0x2E, 0x5A, 0x55, 0xCA, 0xC1, 0xD7, 0x41, 0x81, + 0x45, 0xE2, 0x51, 0xEA, 0x74, 0xE7, 0xE0, 0xD6, 0x60, 0x07, 0x47, 0xB0, + 0x83, 0x23, 0xD8, 0x11, 0xEC, 0xE0, 0x08, 0x76, 0x70, 0x04, 0x3B, 0x38, + 0x82, 0x1D, 0x1C, 0xC1, 0x0E, 0x8E, 0x60, 0x07, 0x47, 0x70, 0xD9, 0xE2, + 0x7F, 0x03, 0x00, 0xFF, 0x90, 0x57, 0xA9, 0xA4, 0xD4, 0xE2, 0xD9, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 +}; +} +static unsigned char* config_icon = raw::config; +}
\ No newline at end of file diff --git a/internal_rewrite/icons/legit.hpp b/internal_rewrite/icons/legit.hpp new file mode 100644 index 0000000..13a06f4 --- /dev/null +++ b/internal_rewrite/icons/legit.hpp @@ -0,0 +1,1798 @@ +/* E:\Users\admin\Desktop\stuff\icons\legit.png (4/1/2018 9:59:16 PM) + StartOffset: 00000000, EndOffset: 000053B8, Length: 000053B9 */ + +namespace icons { +constexpr static size_t legit_size = 21433; +namespace raw { +static unsigned char legit[21433] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x39, 0x64, 0x36, 0xD2, 0x00, 0x00, 0x00, + 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23, 0x00, 0x00, 0x2E, + 0x23, 0x01, 0x78, 0xA5, 0x3F, 0x76, 0x00, 0x00, 0x0A, 0x4F, 0x69, 0x43, + 0x43, 0x50, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, + 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x00, + 0x00, 0x78, 0xDA, 0x9D, 0x53, 0x67, 0x54, 0x53, 0xE9, 0x16, 0x3D, 0xF7, + 0xDE, 0xF4, 0x42, 0x4B, 0x88, 0x80, 0x94, 0x4B, 0x6F, 0x52, 0x15, 0x08, + 0x20, 0x52, 0x42, 0x8B, 0x80, 0x14, 0x91, 0x26, 0x2A, 0x21, 0x09, 0x10, + 0x4A, 0x88, 0x21, 0xA1, 0xD9, 0x15, 0x51, 0xC1, 0x11, 0x45, 0x45, 0x04, + 0x1B, 0xC8, 0xA0, 0x88, 0x03, 0x8E, 0x8E, 0x80, 0x8C, 0x15, 0x51, 0x2C, + 0x0C, 0x8A, 0x0A, 0xD8, 0x07, 0xE4, 0x21, 0xA2, 0x8E, 0x83, 0xA3, 0x88, + 0x8A, 0xCA, 0xFB, 0xE1, 0x7B, 0xA3, 0x6B, 0xD6, 0xBC, 0xF7, 0xE6, 0xCD, + 0xFE, 0xB5, 0xD7, 0x3E, 0xE7, 0xAC, 0xF3, 0x9D, 0xB3, 0xCF, 0x07, 0xC0, + 0x08, 0x0C, 0x96, 0x48, 0x33, 0x51, 0x35, 0x80, 0x0C, 0xA9, 0x42, 0x1E, + 0x11, 0xE0, 0x83, 0xC7, 0xC4, 0xC6, 0xE1, 0xE4, 0x2E, 0x40, 0x81, 0x0A, + 0x24, 0x70, 0x00, 0x10, 0x08, 0xB3, 0x64, 0x21, 0x73, 0xFD, 0x23, 0x01, + 0x00, 0xF8, 0x7E, 0x3C, 0x3C, 0x2B, 0x22, 0xC0, 0x07, 0xBE, 0x00, 0x01, + 0x78, 0xD3, 0x0B, 0x08, 0x00, 0xC0, 0x4D, 0x9B, 0xC0, 0x30, 0x1C, 0x87, + 0xFF, 0x0F, 0xEA, 0x42, 0x99, 0x5C, 0x01, 0x80, 0x84, 0x01, 0xC0, 0x74, + 0x91, 0x38, 0x4B, 0x08, 0x80, 0x14, 0x00, 0x40, 0x7A, 0x8E, 0x42, 0xA6, + 0x00, 0x40, 0x46, 0x01, 0x80, 0x9D, 0x98, 0x26, 0x53, 0x00, 0xA0, 0x04, + 0x00, 0x60, 0xCB, 0x63, 0x62, 0xE3, 0x00, 0x50, 0x2D, 0x00, 0x60, 0x27, + 0x7F, 0xE6, 0xD3, 0x00, 0x80, 0x9D, 0xF8, 0x99, 0x7B, 0x01, 0x00, 0x5B, + 0x94, 0x21, 0x15, 0x01, 0xA0, 0x91, 0x00, 0x20, 0x13, 0x65, 0x88, 0x44, + 0x00, 0x68, 0x3B, 0x00, 0xAC, 0xCF, 0x56, 0x8A, 0x45, 0x00, 0x58, 0x30, + 0x00, 0x14, 0x66, 0x4B, 0xC4, 0x39, 0x00, 0xD8, 0x2D, 0x00, 0x30, 0x49, + 0x57, 0x66, 0x48, 0x00, 0xB0, 0xB7, 0x00, 0xC0, 0xCE, 0x10, 0x0B, 0xB2, + 0x00, 0x08, 0x0C, 0x00, 0x30, 0x51, 0x88, 0x85, 0x29, 0x00, 0x04, 0x7B, + 0x00, 0x60, 0xC8, 0x23, 0x23, 0x78, 0x00, 0x84, 0x99, 0x00, 0x14, 0x46, + 0xF2, 0x57, 0x3C, 0xF1, 0x2B, 0xAE, 0x10, 0xE7, 0x2A, 0x00, 0x00, 0x78, + 0x99, 0xB2, 0x3C, 0xB9, 0x24, 0x39, 0x45, 0x81, 0x5B, 0x08, 0x2D, 0x71, + 0x07, 0x57, 0x57, 0x2E, 0x1E, 0x28, 0xCE, 0x49, 0x17, 0x2B, 0x14, 0x36, + 0x61, 0x02, 0x61, 0x9A, 0x40, 0x2E, 0xC2, 0x79, 0x99, 0x19, 0x32, 0x81, + 0x34, 0x0F, 0xE0, 0xF3, 0xCC, 0x00, 0x00, 0xA0, 0x91, 0x15, 0x11, 0xE0, + 0x83, 0xF3, 0xFD, 0x78, 0xCE, 0x0E, 0xAE, 0xCE, 0xCE, 0x36, 0x8E, 0xB6, + 0x0E, 0x5F, 0x2D, 0xEA, 0xBF, 0x06, 0xFF, 0x22, 0x62, 0x62, 0xE3, 0xFE, + 0xE5, 0xCF, 0xAB, 0x70, 0x40, 0x00, 0x00, 0xE1, 0x74, 0x7E, 0xD1, 0xFE, + 0x2C, 0x2F, 0xB3, 0x1A, 0x80, 0x3B, 0x06, 0x80, 0x6D, 0xFE, 0xA2, 0x25, + 0xEE, 0x04, 0x68, 0x5E, 0x0B, 0xA0, 0x75, 0xF7, 0x8B, 0x66, 0xB2, 0x0F, + 0x40, 0xB5, 0x00, 0xA0, 0xE9, 0xDA, 0x57, 0xF3, 0x70, 0xF8, 0x7E, 0x3C, + 0x3C, 0x45, 0xA1, 0x90, 0xB9, 0xD9, 0xD9, 0xE5, 0xE4, 0xE4, 0xD8, 0x4A, + 0xC4, 0x42, 0x5B, 0x61, 0xCA, 0x57, 0x7D, 0xFE, 0x67, 0xC2, 0x5F, 0xC0, + 0x57, 0xFD, 0x6C, 0xF9, 0x7E, 0x3C, 0xFC, 0xF7, 0xF5, 0xE0, 0xBE, 0xE2, + 0x24, 0x81, 0x32, 0x5D, 0x81, 0x47, 0x04, 0xF8, 0xE0, 0xC2, 0xCC, 0xF4, + 0x4C, 0xA5, 0x1C, 0xCF, 0x92, 0x09, 0x84, 0x62, 0xDC, 0xE6, 0x8F, 0x47, + 0xFC, 0xB7, 0x0B, 0xFF, 0xFC, 0x1D, 0xD3, 0x22, 0xC4, 0x49, 0x62, 0xB9, + 0x58, 0x2A, 0x14, 0xE3, 0x51, 0x12, 0x71, 0x8E, 0x44, 0x9A, 0x8C, 0xF3, + 0x32, 0xA5, 0x22, 0x89, 0x42, 0x92, 0x29, 0xC5, 0x25, 0xD2, 0xFF, 0x64, + 0xE2, 0xDF, 0x2C, 0xFB, 0x03, 0x3E, 0xDF, 0x35, 0x00, 0xB0, 0x6A, 0x3E, + 0x01, 0x7B, 0x91, 0x2D, 0xA8, 0x5D, 0x63, 0x03, 0xF6, 0x4B, 0x27, 0x10, + 0x58, 0x74, 0xC0, 0xE2, 0xF7, 0x00, 0x00, 0xF2, 0xBB, 0x6F, 0xC1, 0xD4, + 0x28, 0x08, 0x03, 0x80, 0x68, 0x83, 0xE1, 0xCF, 0x77, 0xFF, 0xEF, 0x3F, + 0xFD, 0x47, 0xA0, 0x25, 0x00, 0x80, 0x66, 0x49, 0x92, 0x71, 0x00, 0x00, + 0x5E, 0x44, 0x24, 0x2E, 0x54, 0xCA, 0xB3, 0x3F, 0xC7, 0x08, 0x00, 0x00, + 0x44, 0xA0, 0x81, 0x2A, 0xB0, 0x41, 0x1B, 0xF4, 0xC1, 0x18, 0x2C, 0xC0, + 0x06, 0x1C, 0xC1, 0x05, 0xDC, 0xC1, 0x0B, 0xFC, 0x60, 0x36, 0x84, 0x42, + 0x24, 0xC4, 0xC2, 0x42, 0x10, 0x42, 0x0A, 0x64, 0x80, 0x1C, 0x72, 0x60, + 0x29, 0xAC, 0x82, 0x42, 0x28, 0x86, 0xCD, 0xB0, 0x1D, 0x2A, 0x60, 0x2F, + 0xD4, 0x40, 0x1D, 0x34, 0xC0, 0x51, 0x68, 0x86, 0x93, 0x70, 0x0E, 0x2E, + 0xC2, 0x55, 0xB8, 0x0E, 0x3D, 0x70, 0x0F, 0xFA, 0x61, 0x08, 0x9E, 0xC1, + 0x28, 0xBC, 0x81, 0x09, 0x04, 0x41, 0xC8, 0x08, 0x13, 0x61, 0x21, 0xDA, + 0x88, 0x01, 0x62, 0x8A, 0x58, 0x23, 0x8E, 0x08, 0x17, 0x99, 0x85, 0xF8, + 0x21, 0xC1, 0x48, 0x04, 0x12, 0x8B, 0x24, 0x20, 0xC9, 0x88, 0x14, 0x51, + 0x22, 0x4B, 0x91, 0x35, 0x48, 0x31, 0x52, 0x8A, 0x54, 0x20, 0x55, 0x48, + 0x1D, 0xF2, 0x3D, 0x72, 0x02, 0x39, 0x87, 0x5C, 0x46, 0xBA, 0x91, 0x3B, + 0xC8, 0x00, 0x32, 0x82, 0xFC, 0x86, 0xBC, 0x47, 0x31, 0x94, 0x81, 0xB2, + 0x51, 0x3D, 0xD4, 0x0C, 0xB5, 0x43, 0xB9, 0xA8, 0x37, 0x1A, 0x84, 0x46, + 0xA2, 0x0B, 0xD0, 0x64, 0x74, 0x31, 0x9A, 0x8F, 0x16, 0xA0, 0x9B, 0xD0, + 0x72, 0xB4, 0x1A, 0x3D, 0x8C, 0x36, 0xA1, 0xE7, 0xD0, 0xAB, 0x68, 0x0F, + 0xDA, 0x8F, 0x3E, 0x43, 0xC7, 0x30, 0xC0, 0xE8, 0x18, 0x07, 0x33, 0xC4, + 0x6C, 0x30, 0x2E, 0xC6, 0xC3, 0x42, 0xB1, 0x38, 0x2C, 0x09, 0x93, 0x63, + 0xCB, 0xB1, 0x22, 0xAC, 0x0C, 0xAB, 0xC6, 0x1A, 0xB0, 0x56, 0xAC, 0x03, + 0xBB, 0x89, 0xF5, 0x63, 0xCF, 0xB1, 0x77, 0x04, 0x12, 0x81, 0x45, 0xC0, + 0x09, 0x36, 0x04, 0x77, 0x42, 0x20, 0x61, 0x1E, 0x41, 0x48, 0x58, 0x4C, + 0x58, 0x4E, 0xD8, 0x48, 0xA8, 0x20, 0x1C, 0x24, 0x34, 0x11, 0xDA, 0x09, + 0x37, 0x09, 0x03, 0x84, 0x51, 0xC2, 0x27, 0x22, 0x93, 0xA8, 0x4B, 0xB4, + 0x26, 0xBA, 0x11, 0xF9, 0xC4, 0x18, 0x62, 0x32, 0x31, 0x87, 0x58, 0x48, + 0x2C, 0x23, 0xD6, 0x12, 0x8F, 0x13, 0x2F, 0x10, 0x7B, 0x88, 0x43, 0xC4, + 0x37, 0x24, 0x12, 0x89, 0x43, 0x32, 0x27, 0xB9, 0x90, 0x02, 0x49, 0xB1, + 0xA4, 0x54, 0xD2, 0x12, 0xD2, 0x46, 0xD2, 0x6E, 0x52, 0x23, 0xE9, 0x2C, + 0xA9, 0x9B, 0x34, 0x48, 0x1A, 0x23, 0x93, 0xC9, 0xDA, 0x64, 0x6B, 0xB2, + 0x07, 0x39, 0x94, 0x2C, 0x20, 0x2B, 0xC8, 0x85, 0xE4, 0x9D, 0xE4, 0xC3, + 0xE4, 0x33, 0xE4, 0x1B, 0xE4, 0x21, 0xF2, 0x5B, 0x0A, 0x9D, 0x62, 0x40, + 0x71, 0xA4, 0xF8, 0x53, 0xE2, 0x28, 0x52, 0xCA, 0x6A, 0x4A, 0x19, 0xE5, + 0x10, 0xE5, 0x34, 0xE5, 0x06, 0x65, 0x98, 0x32, 0x41, 0x55, 0xA3, 0x9A, + 0x52, 0xDD, 0xA8, 0xA1, 0x54, 0x11, 0x35, 0x8F, 0x5A, 0x42, 0xAD, 0xA1, + 0xB6, 0x52, 0xAF, 0x51, 0x87, 0xA8, 0x13, 0x34, 0x75, 0x9A, 0x39, 0xCD, + 0x83, 0x16, 0x49, 0x4B, 0xA5, 0xAD, 0xA2, 0x95, 0xD3, 0x1A, 0x68, 0x17, + 0x68, 0xF7, 0x69, 0xAF, 0xE8, 0x74, 0xBA, 0x11, 0xDD, 0x95, 0x1E, 0x4E, + 0x97, 0xD0, 0x57, 0xD2, 0xCB, 0xE9, 0x47, 0xE8, 0x97, 0xE8, 0x03, 0xF4, + 0x77, 0x0C, 0x0D, 0x86, 0x15, 0x83, 0xC7, 0x88, 0x67, 0x28, 0x19, 0x9B, + 0x18, 0x07, 0x18, 0x67, 0x19, 0x77, 0x18, 0xAF, 0x98, 0x4C, 0xA6, 0x19, + 0xD3, 0x8B, 0x19, 0xC7, 0x54, 0x30, 0x37, 0x31, 0xEB, 0x98, 0xE7, 0x99, + 0x0F, 0x99, 0x6F, 0x55, 0x58, 0x2A, 0xB6, 0x2A, 0x7C, 0x15, 0x91, 0xCA, + 0x0A, 0x95, 0x4A, 0x95, 0x26, 0x95, 0x1B, 0x2A, 0x2F, 0x54, 0xA9, 0xAA, + 0xA6, 0xAA, 0xDE, 0xAA, 0x0B, 0x55, 0xF3, 0x55, 0xCB, 0x54, 0x8F, 0xA9, + 0x5E, 0x53, 0x7D, 0xAE, 0x46, 0x55, 0x33, 0x53, 0xE3, 0xA9, 0x09, 0xD4, + 0x96, 0xAB, 0x55, 0xAA, 0x9D, 0x50, 0xEB, 0x53, 0x1B, 0x53, 0x67, 0xA9, + 0x3B, 0xA8, 0x87, 0xAA, 0x67, 0xA8, 0x6F, 0x54, 0x3F, 0xA4, 0x7E, 0x59, + 0xFD, 0x89, 0x06, 0x59, 0xC3, 0x4C, 0xC3, 0x4F, 0x43, 0xA4, 0x51, 0xA0, + 0xB1, 0x5F, 0xE3, 0xBC, 0xC6, 0x20, 0x0B, 0x63, 0x19, 0xB3, 0x78, 0x2C, + 0x21, 0x6B, 0x0D, 0xAB, 0x86, 0x75, 0x81, 0x35, 0xC4, 0x26, 0xB1, 0xCD, + 0xD9, 0x7C, 0x76, 0x2A, 0xBB, 0x98, 0xFD, 0x1D, 0xBB, 0x8B, 0x3D, 0xAA, + 0xA9, 0xA1, 0x39, 0x43, 0x33, 0x4A, 0x33, 0x57, 0xB3, 0x52, 0xF3, 0x94, + 0x66, 0x3F, 0x07, 0xE3, 0x98, 0x71, 0xF8, 0x9C, 0x74, 0x4E, 0x09, 0xE7, + 0x28, 0xA7, 0x97, 0xF3, 0x7E, 0x8A, 0xDE, 0x14, 0xEF, 0x29, 0xE2, 0x29, + 0x1B, 0xA6, 0x34, 0x4C, 0xB9, 0x31, 0x65, 0x5C, 0x6B, 0xAA, 0x96, 0x97, + 0x96, 0x58, 0xAB, 0x48, 0xAB, 0x51, 0xAB, 0x47, 0xEB, 0xBD, 0x36, 0xAE, + 0xED, 0xA7, 0x9D, 0xA6, 0xBD, 0x45, 0xBB, 0x59, 0xFB, 0x81, 0x0E, 0x41, + 0xC7, 0x4A, 0x27, 0x5C, 0x27, 0x47, 0x67, 0x8F, 0xCE, 0x05, 0x9D, 0xE7, + 0x53, 0xD9, 0x53, 0xDD, 0xA7, 0x0A, 0xA7, 0x16, 0x4D, 0x3D, 0x3A, 0xF5, + 0xAE, 0x2E, 0xAA, 0x6B, 0xA5, 0x1B, 0xA1, 0xBB, 0x44, 0x77, 0xBF, 0x6E, + 0xA7, 0xEE, 0x98, 0x9E, 0xBE, 0x5E, 0x80, 0x9E, 0x4C, 0x6F, 0xA7, 0xDE, + 0x79, 0xBD, 0xE7, 0xFA, 0x1C, 0x7D, 0x2F, 0xFD, 0x54, 0xFD, 0x6D, 0xFA, + 0xA7, 0xF5, 0x47, 0x0C, 0x58, 0x06, 0xB3, 0x0C, 0x24, 0x06, 0xDB, 0x0C, + 0xCE, 0x18, 0x3C, 0xC5, 0x35, 0x71, 0x6F, 0x3C, 0x1D, 0x2F, 0xC7, 0xDB, + 0xF1, 0x51, 0x43, 0x5D, 0xC3, 0x40, 0x43, 0xA5, 0x61, 0x95, 0x61, 0x97, + 0xE1, 0x84, 0x91, 0xB9, 0xD1, 0x3C, 0xA3, 0xD5, 0x46, 0x8D, 0x46, 0x0F, + 0x8C, 0x69, 0xC6, 0x5C, 0xE3, 0x24, 0xE3, 0x6D, 0xC6, 0x6D, 0xC6, 0xA3, + 0x26, 0x06, 0x26, 0x21, 0x26, 0x4B, 0x4D, 0xEA, 0x4D, 0xEE, 0x9A, 0x52, + 0x4D, 0xB9, 0xA6, 0x29, 0xA6, 0x3B, 0x4C, 0x3B, 0x4C, 0xC7, 0xCD, 0xCC, + 0xCD, 0xA2, 0xCD, 0xD6, 0x99, 0x35, 0x9B, 0x3D, 0x31, 0xD7, 0x32, 0xE7, + 0x9B, 0xE7, 0x9B, 0xD7, 0x9B, 0xDF, 0xB7, 0x60, 0x5A, 0x78, 0x5A, 0x2C, + 0xB6, 0xA8, 0xB6, 0xB8, 0x65, 0x49, 0xB2, 0xE4, 0x5A, 0xA6, 0x59, 0xEE, + 0xB6, 0xBC, 0x6E, 0x85, 0x5A, 0x39, 0x59, 0xA5, 0x58, 0x55, 0x5A, 0x5D, + 0xB3, 0x46, 0xAD, 0x9D, 0xAD, 0x25, 0xD6, 0xBB, 0xAD, 0xBB, 0xA7, 0x11, + 0xA7, 0xB9, 0x4E, 0x93, 0x4E, 0xAB, 0x9E, 0xD6, 0x67, 0xC3, 0xB0, 0xF1, + 0xB6, 0xC9, 0xB6, 0xA9, 0xB7, 0x19, 0xB0, 0xE5, 0xD8, 0x06, 0xDB, 0xAE, + 0xB6, 0x6D, 0xB6, 0x7D, 0x61, 0x67, 0x62, 0x17, 0x67, 0xB7, 0xC5, 0xAE, + 0xC3, 0xEE, 0x93, 0xBD, 0x93, 0x7D, 0xBA, 0x7D, 0x8D, 0xFD, 0x3D, 0x07, + 0x0D, 0x87, 0xD9, 0x0E, 0xAB, 0x1D, 0x5A, 0x1D, 0x7E, 0x73, 0xB4, 0x72, + 0x14, 0x3A, 0x56, 0x3A, 0xDE, 0x9A, 0xCE, 0x9C, 0xEE, 0x3F, 0x7D, 0xC5, + 0xF4, 0x96, 0xE9, 0x2F, 0x67, 0x58, 0xCF, 0x10, 0xCF, 0xD8, 0x33, 0xE3, + 0xB6, 0x13, 0xCB, 0x29, 0xC4, 0x69, 0x9D, 0x53, 0x9B, 0xD3, 0x47, 0x67, + 0x17, 0x67, 0xB9, 0x73, 0x83, 0xF3, 0x88, 0x8B, 0x89, 0x4B, 0x82, 0xCB, + 0x2E, 0x97, 0x3E, 0x2E, 0x9B, 0x1B, 0xC6, 0xDD, 0xC8, 0xBD, 0xE4, 0x4A, + 0x74, 0xF5, 0x71, 0x5D, 0xE1, 0x7A, 0xD2, 0xF5, 0x9D, 0x9B, 0xB3, 0x9B, + 0xC2, 0xED, 0xA8, 0xDB, 0xAF, 0xEE, 0x36, 0xEE, 0x69, 0xEE, 0x87, 0xDC, + 0x9F, 0xCC, 0x34, 0x9F, 0x29, 0x9E, 0x59, 0x33, 0x73, 0xD0, 0xC3, 0xC8, + 0x43, 0xE0, 0x51, 0xE5, 0xD1, 0x3F, 0x0B, 0x9F, 0x95, 0x30, 0x6B, 0xDF, + 0xAC, 0x7E, 0x4F, 0x43, 0x4F, 0x81, 0x67, 0xB5, 0xE7, 0x23, 0x2F, 0x63, + 0x2F, 0x91, 0x57, 0xAD, 0xD7, 0xB0, 0xB7, 0xA5, 0x77, 0xAA, 0xF7, 0x61, + 0xEF, 0x17, 0x3E, 0xF6, 0x3E, 0x72, 0x9F, 0xE3, 0x3E, 0xE3, 0x3C, 0x37, + 0xDE, 0x32, 0xDE, 0x59, 0x5F, 0xCC, 0x37, 0xC0, 0xB7, 0xC8, 0xB7, 0xCB, + 0x4F, 0xC3, 0x6F, 0x9E, 0x5F, 0x85, 0xDF, 0x43, 0x7F, 0x23, 0xFF, 0x64, + 0xFF, 0x7A, 0xFF, 0xD1, 0x00, 0xA7, 0x80, 0x25, 0x01, 0x67, 0x03, 0x89, + 0x81, 0x41, 0x81, 0x5B, 0x02, 0xFB, 0xF8, 0x7A, 0x7C, 0x21, 0xBF, 0x8E, + 0x3F, 0x3A, 0xDB, 0x65, 0xF6, 0xB2, 0xD9, 0xED, 0x41, 0x8C, 0xA0, 0xB9, + 0x41, 0x15, 0x41, 0x8F, 0x82, 0xAD, 0x82, 0xE5, 0xC1, 0xAD, 0x21, 0x68, + 0xC8, 0xEC, 0x90, 0xAD, 0x21, 0xF7, 0xE7, 0x98, 0xCE, 0x91, 0xCE, 0x69, + 0x0E, 0x85, 0x50, 0x7E, 0xE8, 0xD6, 0xD0, 0x07, 0x61, 0xE6, 0x61, 0x8B, + 0xC3, 0x7E, 0x0C, 0x27, 0x85, 0x87, 0x85, 0x57, 0x86, 0x3F, 0x8E, 0x70, + 0x88, 0x58, 0x1A, 0xD1, 0x31, 0x97, 0x35, 0x77, 0xD1, 0xDC, 0x43, 0x73, + 0xDF, 0x44, 0xFA, 0x44, 0x96, 0x44, 0xDE, 0x9B, 0x67, 0x31, 0x4F, 0x39, + 0xAF, 0x2D, 0x4A, 0x35, 0x2A, 0x3E, 0xAA, 0x2E, 0x6A, 0x3C, 0xDA, 0x37, + 0xBA, 0x34, 0xBA, 0x3F, 0xC6, 0x2E, 0x66, 0x59, 0xCC, 0xD5, 0x58, 0x9D, + 0x58, 0x49, 0x6C, 0x4B, 0x1C, 0x39, 0x2E, 0x2A, 0xAE, 0x36, 0x6E, 0x6C, + 0xBE, 0xDF, 0xFC, 0xED, 0xF3, 0x87, 0xE2, 0x9D, 0xE2, 0x0B, 0xE3, 0x7B, + 0x17, 0x98, 0x2F, 0xC8, 0x5D, 0x70, 0x79, 0xA1, 0xCE, 0xC2, 0xF4, 0x85, + 0xA7, 0x16, 0xA9, 0x2E, 0x12, 0x2C, 0x3A, 0x96, 0x40, 0x4C, 0x88, 0x4E, + 0x38, 0x94, 0xF0, 0x41, 0x10, 0x2A, 0xA8, 0x16, 0x8C, 0x25, 0xF2, 0x13, + 0x77, 0x25, 0x8E, 0x0A, 0x79, 0xC2, 0x1D, 0xC2, 0x67, 0x22, 0x2F, 0xD1, + 0x36, 0xD1, 0x88, 0xD8, 0x43, 0x5C, 0x2A, 0x1E, 0x4E, 0xF2, 0x48, 0x2A, + 0x4D, 0x7A, 0x92, 0xEC, 0x91, 0xBC, 0x35, 0x79, 0x24, 0xC5, 0x33, 0xA5, + 0x2C, 0xE5, 0xB9, 0x84, 0x27, 0xA9, 0x90, 0xBC, 0x4C, 0x0D, 0x4C, 0xDD, + 0x9B, 0x3A, 0x9E, 0x16, 0x9A, 0x76, 0x20, 0x6D, 0x32, 0x3D, 0x3A, 0xBD, + 0x31, 0x83, 0x92, 0x91, 0x90, 0x71, 0x42, 0xAA, 0x21, 0x4D, 0x93, 0xB6, + 0x67, 0xEA, 0x67, 0xE6, 0x66, 0x76, 0xCB, 0xAC, 0x65, 0x85, 0xB2, 0xFE, + 0xC5, 0x6E, 0x8B, 0xB7, 0x2F, 0x1E, 0x95, 0x07, 0xC9, 0x6B, 0xB3, 0x90, + 0xAC, 0x05, 0x59, 0x2D, 0x0A, 0xB6, 0x42, 0xA6, 0xE8, 0x54, 0x5A, 0x28, + 0xD7, 0x2A, 0x07, 0xB2, 0x67, 0x65, 0x57, 0x66, 0xBF, 0xCD, 0x89, 0xCA, + 0x39, 0x96, 0xAB, 0x9E, 0x2B, 0xCD, 0xED, 0xCC, 0xB3, 0xCA, 0xDB, 0x90, + 0x37, 0x9C, 0xEF, 0x9F, 0xFF, 0xED, 0x12, 0xC2, 0x12, 0xE1, 0x92, 0xB6, + 0xA5, 0x86, 0x4B, 0x57, 0x2D, 0x1D, 0x58, 0xE6, 0xBD, 0xAC, 0x6A, 0x39, + 0xB2, 0x3C, 0x71, 0x79, 0xDB, 0x0A, 0xE3, 0x15, 0x05, 0x2B, 0x86, 0x56, + 0x06, 0xAC, 0x3C, 0xB8, 0x8A, 0xB6, 0x2A, 0x6D, 0xD5, 0x4F, 0xAB, 0xED, + 0x57, 0x97, 0xAE, 0x7E, 0xBD, 0x26, 0x7A, 0x4D, 0x6B, 0x81, 0x5E, 0xC1, + 0xCA, 0x82, 0xC1, 0xB5, 0x01, 0x6B, 0xEB, 0x0B, 0x55, 0x0A, 0xE5, 0x85, + 0x7D, 0xEB, 0xDC, 0xD7, 0xED, 0x5D, 0x4F, 0x58, 0x2F, 0x59, 0xDF, 0xB5, + 0x61, 0xFA, 0x86, 0x9D, 0x1B, 0x3E, 0x15, 0x89, 0x8A, 0xAE, 0x14, 0xDB, + 0x17, 0x97, 0x15, 0x7F, 0xD8, 0x28, 0xDC, 0x78, 0xE5, 0x1B, 0x87, 0x6F, + 0xCA, 0xBF, 0x99, 0xDC, 0x94, 0xB4, 0xA9, 0xAB, 0xC4, 0xB9, 0x64, 0xCF, + 0x66, 0xD2, 0x66, 0xE9, 0xE6, 0xDE, 0x2D, 0x9E, 0x5B, 0x0E, 0x96, 0xAA, + 0x97, 0xE6, 0x97, 0x0E, 0x6E, 0x0D, 0xD9, 0xDA, 0xB4, 0x0D, 0xDF, 0x56, + 0xB4, 0xED, 0xF5, 0xF6, 0x45, 0xDB, 0x2F, 0x97, 0xCD, 0x28, 0xDB, 0xBB, + 0x83, 0xB6, 0x43, 0xB9, 0xA3, 0xBF, 0x3C, 0xB8, 0xBC, 0x65, 0xA7, 0xC9, + 0xCE, 0xCD, 0x3B, 0x3F, 0x54, 0xA4, 0x54, 0xF4, 0x54, 0xFA, 0x54, 0x36, + 0xEE, 0xD2, 0xDD, 0xB5, 0x61, 0xD7, 0xF8, 0x6E, 0xD1, 0xEE, 0x1B, 0x7B, + 0xBC, 0xF6, 0x34, 0xEC, 0xD5, 0xDB, 0x5B, 0xBC, 0xF7, 0xFD, 0x3E, 0xC9, + 0xBE, 0xDB, 0x55, 0x01, 0x55, 0x4D, 0xD5, 0x66, 0xD5, 0x65, 0xFB, 0x49, + 0xFB, 0xB3, 0xF7, 0x3F, 0xAE, 0x89, 0xAA, 0xE9, 0xF8, 0x96, 0xFB, 0x6D, + 0x5D, 0xAD, 0x4E, 0x6D, 0x71, 0xED, 0xC7, 0x03, 0xD2, 0x03, 0xFD, 0x07, + 0x23, 0x0E, 0xB6, 0xD7, 0xB9, 0xD4, 0xD5, 0x1D, 0xD2, 0x3D, 0x54, 0x52, + 0x8F, 0xD6, 0x2B, 0xEB, 0x47, 0x0E, 0xC7, 0x1F, 0xBE, 0xFE, 0x9D, 0xEF, + 0x77, 0x2D, 0x0D, 0x36, 0x0D, 0x55, 0x8D, 0x9C, 0xC6, 0xE2, 0x23, 0x70, + 0x44, 0x79, 0xE4, 0xE9, 0xF7, 0x09, 0xDF, 0xF7, 0x1E, 0x0D, 0x3A, 0xDA, + 0x76, 0x8C, 0x7B, 0xAC, 0xE1, 0x07, 0xD3, 0x1F, 0x76, 0x1D, 0x67, 0x1D, + 0x2F, 0x6A, 0x42, 0x9A, 0xF2, 0x9A, 0x46, 0x9B, 0x53, 0x9A, 0xFB, 0x5B, + 0x62, 0x5B, 0xBA, 0x4F, 0xCC, 0x3E, 0xD1, 0xD6, 0xEA, 0xDE, 0x7A, 0xFC, + 0x47, 0xDB, 0x1F, 0x0F, 0x9C, 0x34, 0x3C, 0x59, 0x79, 0x4A, 0xF3, 0x54, + 0xC9, 0x69, 0xDA, 0xE9, 0x82, 0xD3, 0x93, 0x67, 0xF2, 0xCF, 0x8C, 0x9D, + 0x95, 0x9D, 0x7D, 0x7E, 0x2E, 0xF9, 0xDC, 0x60, 0xDB, 0xA2, 0xB6, 0x7B, + 0xE7, 0x63, 0xCE, 0xDF, 0x6A, 0x0F, 0x6F, 0xEF, 0xBA, 0x10, 0x74, 0xE1, + 0xD2, 0x45, 0xFF, 0x8B, 0xE7, 0x3B, 0xBC, 0x3B, 0xCE, 0x5C, 0xF2, 0xB8, + 0x74, 0xF2, 0xB2, 0xDB, 0xE5, 0x13, 0x57, 0xB8, 0x57, 0x9A, 0xAF, 0x3A, + 0x5F, 0x6D, 0xEA, 0x74, 0xEA, 0x3C, 0xFE, 0x93, 0xD3, 0x4F, 0xC7, 0xBB, + 0x9C, 0xBB, 0x9A, 0xAE, 0xB9, 0x5C, 0x6B, 0xB9, 0xEE, 0x7A, 0xBD, 0xB5, + 0x7B, 0x66, 0xF7, 0xE9, 0x1B, 0x9E, 0x37, 0xCE, 0xDD, 0xF4, 0xBD, 0x79, + 0xF1, 0x16, 0xFF, 0xD6, 0xD5, 0x9E, 0x39, 0x3D, 0xDD, 0xBD, 0xF3, 0x7A, + 0x6F, 0xF7, 0xC5, 0xF7, 0xF5, 0xDF, 0x16, 0xDD, 0x7E, 0x72, 0x27, 0xFD, + 0xCE, 0xCB, 0xBB, 0xD9, 0x77, 0x27, 0xEE, 0xAD, 0xBC, 0x4F, 0xBC, 0x5F, + 0xF4, 0x40, 0xED, 0x41, 0xD9, 0x43, 0xDD, 0x87, 0xD5, 0x3F, 0x5B, 0xFE, + 0xDC, 0xD8, 0xEF, 0xDC, 0x7F, 0x6A, 0xC0, 0x77, 0xA0, 0xF3, 0xD1, 0xDC, + 0x47, 0xF7, 0x06, 0x85, 0x83, 0xCF, 0xFE, 0x91, 0xF5, 0x8F, 0x0F, 0x43, + 0x05, 0x8F, 0x99, 0x8F, 0xCB, 0x86, 0x0D, 0x86, 0xEB, 0x9E, 0x38, 0x3E, + 0x39, 0x39, 0xE2, 0x3F, 0x72, 0xFD, 0xE9, 0xFC, 0xA7, 0x43, 0xCF, 0x64, + 0xCF, 0x26, 0x9E, 0x17, 0xFE, 0xA2, 0xFE, 0xCB, 0xAE, 0x17, 0x16, 0x2F, + 0x7E, 0xF8, 0xD5, 0xEB, 0xD7, 0xCE, 0xD1, 0x98, 0xD1, 0xA1, 0x97, 0xF2, + 0x97, 0x93, 0xBF, 0x6D, 0x7C, 0xA5, 0xFD, 0xEA, 0xC0, 0xEB, 0x19, 0xAF, + 0xDB, 0xC6, 0xC2, 0xC6, 0x1E, 0xBE, 0xC9, 0x78, 0x33, 0x31, 0x5E, 0xF4, + 0x56, 0xFB, 0xED, 0xC1, 0x77, 0xDC, 0x77, 0x1D, 0xEF, 0xA3, 0xDF, 0x0F, + 0x4F, 0xE4, 0x7C, 0x20, 0x7F, 0x28, 0xFF, 0x68, 0xF9, 0xB1, 0xF5, 0x53, + 0xD0, 0xA7, 0xFB, 0x93, 0x19, 0x93, 0x93, 0xFF, 0x04, 0x03, 0x98, 0xF3, + 0xFC, 0x63, 0x33, 0x2D, 0xDB, 0x00, 0x00, 0x3A, 0xFD, 0x69, 0x54, 0x58, + 0x74, 0x58, 0x4D, 0x4C, 0x3A, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x78, 0x6D, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D, + 0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, + 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63, 0x7A, 0x6B, 0x63, 0x39, + 0x64, 0x22, 0x3F, 0x3E, 0x0A, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, + 0x65, 0x74, 0x61, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, + 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65, + 0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, + 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x58, 0x4D, 0x50, 0x20, + 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, + 0x38, 0x20, 0x37, 0x39, 0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, + 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D, + 0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, + 0x31, 0x39, 0x39, 0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, + 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E, 0x73, + 0x23, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, + 0x3D, 0x22, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x6D, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, + 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, + 0x6E, 0x73, 0x3A, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3D, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, + 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, + 0x30, 0x2F, 0x6D, 0x6D, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, + 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, + 0x73, 0x54, 0x79, 0x70, 0x65, 0x2F, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x23, 0x22, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, + 0x6C, 0x6E, 0x73, 0x3A, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x2F, 0x31, 0x2E, 0x30, + 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x64, 0x63, 0x3D, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x70, 0x75, 0x72, 0x6C, + 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x64, 0x63, 0x2F, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2F, 0x31, 0x2E, 0x31, 0x2F, 0x22, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, + 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x74, 0x69, 0x66, 0x66, 0x3D, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x2F, + 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, + 0x65, 0x78, 0x69, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, + 0x6D, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6F, 0x72, 0x54, + 0x6F, 0x6F, 0x6C, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, + 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, + 0x29, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6F, 0x72, 0x54, 0x6F, 0x6F, 0x6C, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, + 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, + 0x39, 0x3A, 0x31, 0x34, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, + 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, + 0x31, 0x34, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, + 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, + 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x31, 0x34, + 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, + 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x32, + 0x33, 0x31, 0x33, 0x66, 0x37, 0x35, 0x35, 0x2D, 0x32, 0x37, 0x39, 0x32, + 0x2D, 0x66, 0x33, 0x34, 0x39, 0x2D, 0x61, 0x62, 0x33, 0x63, 0x2D, 0x35, + 0x35, 0x37, 0x35, 0x64, 0x62, 0x32, 0x39, 0x36, 0x62, 0x30, 0x33, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, + 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x44, + 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x3E, 0x61, 0x64, + 0x6F, 0x62, 0x65, 0x3A, 0x64, 0x6F, 0x63, 0x69, 0x64, 0x3A, 0x70, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x64, 0x63, 0x38, 0x34, + 0x38, 0x37, 0x30, 0x30, 0x2D, 0x33, 0x35, 0x62, 0x34, 0x2D, 0x31, 0x31, + 0x65, 0x38, 0x2D, 0x39, 0x31, 0x61, 0x34, 0x2D, 0x38, 0x38, 0x34, 0x37, + 0x30, 0x37, 0x30, 0x65, 0x31, 0x35, 0x34, 0x62, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, + 0x69, 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x61, + 0x32, 0x66, 0x61, 0x64, 0x37, 0x64, 0x61, 0x2D, 0x66, 0x61, 0x64, 0x37, + 0x2D, 0x39, 0x66, 0x34, 0x30, 0x2D, 0x62, 0x64, 0x33, 0x31, 0x2D, 0x61, + 0x37, 0x35, 0x61, 0x36, 0x31, 0x30, 0x39, 0x31, 0x32, 0x32, 0x63, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, 0x69, + 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, + 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, + 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, + 0x20, 0x72, 0x64, 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x3D, 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, + 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x61, 0x32, 0x66, 0x61, 0x64, 0x37, + 0x64, 0x61, 0x2D, 0x66, 0x61, 0x64, 0x37, 0x2D, 0x39, 0x66, 0x34, 0x30, + 0x2D, 0x62, 0x64, 0x33, 0x31, 0x2D, 0x61, 0x37, 0x35, 0x61, 0x36, 0x31, + 0x30, 0x39, 0x31, 0x32, 0x32, 0x63, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, + 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, + 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, + 0x3A, 0x31, 0x34, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, + 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, + 0x74, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, + 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, + 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x20, 0x72, 0x64, + 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3D, + 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, + 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x73, 0x61, 0x76, 0x65, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, + 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, + 0x3A, 0x32, 0x33, 0x31, 0x33, 0x66, 0x37, 0x35, 0x35, 0x2D, 0x32, 0x37, + 0x39, 0x32, 0x2D, 0x66, 0x33, 0x34, 0x39, 0x2D, 0x61, 0x62, 0x33, 0x63, + 0x2D, 0x35, 0x35, 0x37, 0x35, 0x64, 0x62, 0x32, 0x39, 0x36, 0x62, 0x30, + 0x33, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, + 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, + 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, + 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x31, 0x34, 0x2B, 0x30, + 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x41, 0x64, 0x6F, + 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, + 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, + 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x64, 0x3E, 0x2F, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, + 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, + 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, 0x67, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x39, 0x30, 0x39, 0x62, 0x39, 0x65, + 0x35, 0x32, 0x2D, 0x39, 0x37, 0x62, 0x64, 0x2D, 0x34, 0x32, 0x39, 0x33, + 0x2D, 0x38, 0x30, 0x64, 0x32, 0x2D, 0x31, 0x31, 0x64, 0x65, 0x62, 0x64, + 0x36, 0x61, 0x33, 0x33, 0x65, 0x62, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, + 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, + 0x67, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, + 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, + 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, + 0x6F, 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, + 0x3E, 0x33, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x49, 0x43, 0x43, + 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, 0x73, 0x52, 0x47, 0x42, + 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, + 0x31, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x3A, 0x49, 0x43, 0x43, 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, + 0x63, 0x3A, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0x2F, 0x70, 0x6E, 0x67, 0x3C, 0x2F, 0x64, 0x63, 0x3A, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, + 0x69, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, 0x69, 0x65, 0x6E, 0x74, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, + 0x3E, 0x32, 0x3C, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, + 0x63, 0x65, 0x3E, 0x31, 0x3C, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x3A, 0x43, + 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, 0x63, 0x65, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, + 0x6D, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, 0x66, 0x3A, + 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x0A, 0x3C, 0x2F, + 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x64, + 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0x78, 0xE1, 0xB7, 0x9F, 0x00, 0x00, + 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x25, 0x00, 0x00, + 0x80, 0x83, 0x00, 0x00, 0xF9, 0xFF, 0x00, 0x00, 0x80, 0xE9, 0x00, 0x00, + 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, + 0x17, 0x6F, 0x92, 0x5F, 0xC5, 0x46, 0x00, 0x00, 0x0D, 0xDB, 0x49, 0x44, + 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9D, 0x79, 0x70, 0xD5, 0xD5, 0x15, 0xC7, + 0xBF, 0x2F, 0x21, 0x46, 0x88, 0x24, 0x84, 0x04, 0x15, 0xC4, 0x32, 0xE0, + 0x82, 0x88, 0x8A, 0x80, 0x48, 0x47, 0xAA, 0x8E, 0xD6, 0x05, 0x5C, 0xAA, + 0xA2, 0xD6, 0xB1, 0x08, 0x6A, 0xD5, 0x56, 0xB4, 0x75, 0x5F, 0x6A, 0xDD, + 0x82, 0x6B, 0xC5, 0xE2, 0x86, 0xB4, 0xD6, 0xDA, 0xD6, 0x8D, 0x8A, 0x75, + 0x5C, 0xC6, 0x1D, 0xB4, 0x3A, 0x50, 0xB7, 0xBA, 0x55, 0x45, 0x44, 0x91, + 0x28, 0x22, 0xAB, 0x52, 0x76, 0x49, 0x42, 0x96, 0x6F, 0xFF, 0xB8, 0xDF, + 0x37, 0xF3, 0x4C, 0x21, 0xF9, 0x9D, 0x9B, 0xDF, 0x7B, 0xEF, 0x17, 0x72, + 0xCF, 0xCC, 0x6F, 0x70, 0xCC, 0xFB, 0xBD, 0x7B, 0xDF, 0xFD, 0xFC, 0xCE, + 0xB9, 0xE7, 0xDE, 0x7B, 0xCE, 0xF9, 0xA5, 0x48, 0x22, 0xC8, 0x96, 0x2B, + 0x05, 0x61, 0x08, 0x02, 0xE0, 0x20, 0x01, 0x70, 0x90, 0x00, 0x38, 0x48, + 0x00, 0x1C, 0x24, 0x00, 0x0E, 0x12, 0x00, 0x07, 0x09, 0x80, 0x03, 0xE0, + 0x20, 0x01, 0x70, 0x90, 0x00, 0x38, 0x48, 0x00, 0x1C, 0x24, 0x00, 0x0E, + 0x12, 0x00, 0x07, 0x09, 0x80, 0x03, 0xE0, 0x20, 0x01, 0x70, 0x90, 0xF6, + 0x27, 0x9D, 0x12, 0xD2, 0x8F, 0x42, 0x00, 0x83, 0x00, 0x1C, 0x09, 0x60, + 0x00, 0x80, 0x62, 0x00, 0x5F, 0x01, 0x78, 0x0B, 0xC0, 0x8B, 0x00, 0xBE, + 0x03, 0xD0, 0x98, 0x60, 0x25, 0xD9, 0x19, 0xC0, 0xF1, 0x00, 0x06, 0x02, + 0xD8, 0x06, 0xC0, 0x22, 0x00, 0xEF, 0x02, 0x78, 0x0A, 0xC0, 0xEA, 0x8E, + 0x0E, 0xB8, 0x04, 0xC0, 0xD1, 0x00, 0x2E, 0x05, 0x30, 0xA4, 0xD9, 0xDF, + 0x96, 0x01, 0x98, 0x0A, 0xE0, 0x3E, 0x00, 0x9F, 0x01, 0x48, 0x5A, 0x7C, + 0x51, 0x31, 0x80, 0x91, 0xEA, 0xFB, 0x88, 0x66, 0x7F, 0x5B, 0x07, 0xA0, + 0x3F, 0x80, 0x5B, 0x01, 0xAC, 0xCC, 0x5B, 0x0F, 0x49, 0xE6, 0xFB, 0xDA, + 0x9D, 0xE4, 0x7B, 0xDC, 0xBC, 0x6C, 0x20, 0x79, 0x3B, 0xC9, 0x01, 0x24, + 0x53, 0x09, 0xE8, 0x6F, 0xFA, 0xEA, 0x42, 0xF2, 0xF8, 0x56, 0xFA, 0x5E, + 0x4F, 0xF2, 0x12, 0x92, 0x9D, 0xF2, 0xD5, 0xCF, 0x24, 0xCC, 0xC1, 0x7B, + 0x00, 0xD8, 0xBD, 0x85, 0xBF, 0x77, 0x06, 0x70, 0x2E, 0x80, 0x73, 0xA4, + 0x11, 0xA9, 0x04, 0xF4, 0xB9, 0x0B, 0x80, 0x23, 0x00, 0x5C, 0xB1, 0x09, + 0xAB, 0xD3, 0xDC, 0x42, 0x8E, 0x94, 0x95, 0xEA, 0xB0, 0x4E, 0x56, 0x5F, + 0x00, 0x5B, 0xB7, 0xF2, 0x99, 0x22, 0x00, 0xE3, 0x75, 0xED, 0x92, 0x10, + 0xB3, 0x7C, 0x25, 0x80, 0xA1, 0x11, 0x3E, 0xBF, 0x03, 0x80, 0xD2, 0x8E, + 0x0C, 0x38, 0xAA, 0xF3, 0x54, 0x28, 0xC0, 0xE7, 0x49, 0x93, 0xF3, 0x21, + 0x5B, 0x4B, 0x73, 0xAF, 0x06, 0xB0, 0x77, 0xC4, 0x7B, 0x9A, 0xF2, 0xE9, + 0x3B, 0x24, 0x01, 0xF0, 0xE7, 0x00, 0xD6, 0x47, 0xFC, 0x6C, 0x11, 0x80, + 0x33, 0x01, 0x5C, 0x98, 0x07, 0xC8, 0xC5, 0x00, 0x46, 0x01, 0xA8, 0x32, + 0xC0, 0x05, 0x80, 0x2F, 0x01, 0xAC, 0xED, 0xC8, 0x80, 0x3F, 0x00, 0xF0, + 0x86, 0xE1, 0x29, 0x2F, 0x06, 0x70, 0x1A, 0x80, 0x8B, 0x00, 0xEC, 0x96, + 0xA3, 0x39, 0x39, 0x6D, 0x96, 0x27, 0x00, 0xD8, 0xCB, 0x70, 0xDF, 0x72, + 0x00, 0x33, 0x00, 0xD4, 0x75, 0x64, 0xC0, 0x5F, 0x03, 0xB8, 0x01, 0xC0, + 0x6C, 0x83, 0xB9, 0x2E, 0x06, 0x70, 0x86, 0x96, 0x27, 0x03, 0x65, 0xBE, + 0xB3, 0x25, 0x5B, 0x01, 0xF8, 0x89, 0xFA, 0xB8, 0xA7, 0xE1, 0xBE, 0xD5, + 0x00, 0xEE, 0x01, 0x30, 0x0D, 0x40, 0x7D, 0x47, 0x5E, 0x26, 0xA5, 0xAF, + 0xFD, 0x49, 0xBE, 0x4F, 0xB2, 0x81, 0xD1, 0xA5, 0x9E, 0xE4, 0xBD, 0x24, + 0x07, 0x91, 0x2C, 0xCC, 0x42, 0x9F, 0x8A, 0x49, 0x9E, 0x48, 0xF2, 0x23, + 0xDA, 0x64, 0x25, 0xC9, 0xEB, 0x49, 0x6E, 0x9B, 0xEF, 0x71, 0x4D, 0x12, + 0xE0, 0x34, 0xE4, 0xF7, 0x3C, 0x20, 0xFF, 0x99, 0xE4, 0xE0, 0x98, 0x21, + 0x77, 0x26, 0x79, 0x12, 0xC9, 0x8F, 0x8D, 0x70, 0x57, 0x90, 0x9C, 0x40, + 0xB2, 0x22, 0x09, 0x63, 0x9A, 0x34, 0xC0, 0x20, 0xB9, 0x1F, 0xC9, 0x77, + 0x8D, 0x90, 0x1B, 0x05, 0x79, 0x08, 0xC9, 0xA2, 0x18, 0xFA, 0x50, 0x42, + 0x72, 0x0C, 0xC9, 0xB9, 0x46, 0xB8, 0xDF, 0x08, 0x6E, 0x59, 0x52, 0xC6, + 0x33, 0x5B, 0x5F, 0x9C, 0x22, 0x59, 0xA0, 0x2B, 0x57, 0x90, 0x99, 0x01, + 0xB9, 0x2D, 0x3B, 0x47, 0xDB, 0x90, 0x1C, 0x47, 0xF2, 0x13, 0x63, 0xDB, + 0xCB, 0x48, 0x5E, 0x4B, 0xB2, 0x7B, 0x92, 0x14, 0x26, 0x15, 0x73, 0xFA, + 0x68, 0xA1, 0x36, 0xDB, 0xCB, 0xB5, 0xDB, 0x03, 0x2D, 0x81, 0x56, 0xE9, + 0xC0, 0xA0, 0xC9, 0xF0, 0x5D, 0x23, 0x00, 0x4C, 0x02, 0xB0, 0x8F, 0xC1, + 0x89, 0x6A, 0x02, 0xF0, 0x17, 0x00, 0xF7, 0xCA, 0x3B, 0x6F, 0x30, 0xF6, + 0xBF, 0x14, 0xC0, 0x71, 0x19, 0xCE, 0x5B, 0x54, 0x59, 0x06, 0x60, 0x0A, + 0x80, 0xC9, 0x00, 0xD6, 0x18, 0xC7, 0xAB, 0x44, 0xFF, 0x52, 0xFD, 0x8F, + 0xF5, 0x60, 0x25, 0x4E, 0xC0, 0x85, 0xDA, 0x65, 0x1A, 0x07, 0xE0, 0x30, + 0x00, 0x83, 0x35, 0xC0, 0x6F, 0x03, 0x78, 0x16, 0xC0, 0x63, 0x00, 0x16, + 0x1A, 0x07, 0x7D, 0x18, 0x80, 0x3B, 0x00, 0x0C, 0x37, 0x7A, 0xCA, 0x0F, + 0x00, 0xF8, 0x03, 0x80, 0xF7, 0x0D, 0xED, 0x75, 0xD3, 0x89, 0xD0, 0x25, + 0x5A, 0x7E, 0x45, 0xF2, 0x51, 0x01, 0x2C, 0x01, 0x70, 0xB7, 0xAE, 0xF5, + 0x86, 0x3E, 0x96, 0xC8, 0x2B, 0x3F, 0x04, 0xC0, 0xF6, 0xEA, 0xE7, 0x5A, + 0x00, 0xCF, 0x68, 0x6F, 0x60, 0x4D, 0x2C, 0x1B, 0x24, 0x31, 0x9A, 0x83, + 0x3E, 0x24, 0xA7, 0xB6, 0x60, 0xC2, 0x1E, 0x22, 0x39, 0xCC, 0x63, 0x8E, + 0xDC, 0x97, 0xE4, 0xDB, 0x1E, 0xE6, 0xFA, 0xAF, 0x24, 0x87, 0x46, 0x34, + 0xD7, 0x65, 0x24, 0x7F, 0x4E, 0xF2, 0x53, 0xC3, 0xF7, 0x37, 0x91, 0x5C, + 0x4C, 0xF2, 0xB7, 0x24, 0xBB, 0x1A, 0x7F, 0x53, 0x19, 0xC9, 0xD3, 0xF5, + 0xBB, 0x9A, 0xCB, 0xDB, 0x24, 0xCF, 0x8E, 0x6B, 0x1E, 0x8F, 0xD3, 0xE3, + 0xBC, 0x3A, 0xC2, 0xA0, 0x4C, 0xF5, 0x84, 0x3C, 0x9C, 0xE4, 0x9B, 0x1E, + 0x90, 0xFF, 0x26, 0xEF, 0xBA, 0x25, 0xC8, 0xDD, 0x34, 0xD8, 0x56, 0xB8, + 0x8B, 0x04, 0x77, 0x1B, 0xE3, 0x6F, 0x29, 0x27, 0x79, 0x16, 0xC9, 0xEA, + 0x16, 0xBE, 0x7F, 0xAE, 0x56, 0x14, 0xA9, 0xA4, 0x00, 0xEE, 0x4E, 0xF2, + 0xB9, 0x88, 0x83, 0xF3, 0xA8, 0x80, 0x59, 0x1D, 0xA1, 0xA1, 0x24, 0x5F, + 0xD7, 0xB2, 0xC8, 0x22, 0x7F, 0x27, 0xB9, 0xCF, 0x66, 0xDA, 0x2B, 0xD3, + 0x60, 0xCF, 0x37, 0xC2, 0xFD, 0x5A, 0xC7, 0x80, 0x25, 0x1E, 0x70, 0xCF, + 0xD5, 0xC3, 0xD1, 0x9A, 0xDC, 0x11, 0xC7, 0x8A, 0x20, 0x2E, 0xC0, 0x95, + 0x24, 0x9F, 0x37, 0x0C, 0xD2, 0x23, 0xF2, 0x76, 0xAD, 0xEB, 0xD6, 0x7D, + 0x48, 0xBE, 0xE1, 0x01, 0x79, 0xDA, 0x26, 0xDA, 0x2B, 0x25, 0x79, 0x06, + 0xC9, 0xCF, 0x8D, 0x70, 0x97, 0x90, 0xBC, 0x4C, 0xE7, 0xC1, 0x96, 0xBE, + 0x97, 0xCA, 0xF4, 0x2E, 0x8C, 0xD8, 0xD6, 0x73, 0x24, 0xB7, 0x4A, 0x0A, + 0xE0, 0x72, 0x92, 0x4F, 0x19, 0x07, 0xFD, 0x61, 0x92, 0x7B, 0x7B, 0x40, + 0x1E, 0xE6, 0x09, 0x79, 0x6A, 0x06, 0xE4, 0x2E, 0x24, 0x4F, 0x25, 0x39, + 0xCF, 0x08, 0x77, 0x29, 0xC9, 0x2B, 0x3C, 0xE6, 0xDC, 0xF4, 0xC3, 0x54, + 0x6D, 0x68, 0xEF, 0x49, 0x92, 0x5B, 0x27, 0x05, 0x70, 0x21, 0xC9, 0x5F, + 0x91, 0xAC, 0x35, 0x0E, 0xD8, 0x63, 0x32, 0xBD, 0xD6, 0x27, 0x75, 0x08, + 0xC9, 0x59, 0x24, 0x37, 0x7A, 0x40, 0xDE, 0x83, 0xE4, 0xC9, 0x46, 0xCD, + 0x6D, 0x94, 0xE6, 0x5E, 0xE2, 0xA1, 0xB9, 0xE5, 0x46, 0xCD, 0x4D, 0xB7, + 0x77, 0x77, 0x92, 0x34, 0x18, 0x24, 0x7B, 0x92, 0x7C, 0x96, 0x64, 0x9D, + 0x71, 0xD0, 0x1F, 0x6F, 0x61, 0x8E, 0x6C, 0xE9, 0xDA, 0x9B, 0xE4, 0x4C, + 0x23, 0xE4, 0x26, 0x92, 0xCF, 0x78, 0x3A, 0x54, 0x17, 0xCB, 0x99, 0xB4, + 0x6A, 0xEE, 0x99, 0x11, 0xE7, 0xDC, 0x4C, 0xB8, 0xD5, 0x24, 0x47, 0x24, + 0xC9, 0xC9, 0xCA, 0x1C, 0xF4, 0x7F, 0x7A, 0x40, 0x9E, 0x26, 0x4D, 0xB6, + 0x3A, 0x15, 0x83, 0x3D, 0x35, 0xD9, 0x3A, 0xE7, 0xFA, 0x38, 0x54, 0x5D, + 0x49, 0x9E, 0x66, 0x34, 0xCB, 0x8D, 0xD2, 0xF4, 0x5F, 0x7B, 0x58, 0x8A, + 0x9C, 0x6D, 0x55, 0x0E, 0x22, 0x39, 0xC3, 0x13, 0xF2, 0x0F, 0x3D, 0xE6, + 0x9D, 0xC1, 0x24, 0x5F, 0xC9, 0x02, 0xE4, 0xC6, 0x0C, 0x6F, 0xD9, 0xBA, + 0x14, 0x4A, 0xAF, 0x73, 0x2D, 0xD3, 0x40, 0x03, 0xC9, 0x05, 0x9A, 0xEA, + 0x4A, 0x93, 0xBE, 0x17, 0xBD, 0x9B, 0xBC, 0xC0, 0x5A, 0xE3, 0xA0, 0x3E, + 0x4D, 0xF2, 0x40, 0x0F, 0x53, 0xB8, 0x17, 0xC9, 0x97, 0x3C, 0x1E, 0xAA, + 0x96, 0x06, 0xFB, 0x4B, 0x92, 0xE7, 0x79, 0x3C, 0x70, 0x15, 0x9E, 0x73, + 0xEE, 0x7C, 0x92, 0xBF, 0xD4, 0x11, 0x65, 0xBB, 0x38, 0x4D, 0x1A, 0xE0, + 0x09, 0xF9, 0x09, 0x4F, 0xC8, 0x83, 0x48, 0xBE, 0x1C, 0x03, 0xE4, 0x06, + 0x92, 0x5F, 0xC8, 0x4C, 0x5A, 0x07, 0xBB, 0xBB, 0x20, 0x2D, 0xF4, 0x98, + 0x73, 0xCF, 0x8D, 0x1B, 0x6E, 0x2E, 0x8E, 0x0B, 0x07, 0xC8, 0xF1, 0xAA, + 0xF1, 0x70, 0xBC, 0xF6, 0xF7, 0x98, 0x87, 0x06, 0xC9, 0x07, 0xA8, 0xCD, + 0x31, 0xDC, 0x54, 0x86, 0xE6, 0x7E, 0x65, 0x6C, 0x6F, 0xBE, 0xEE, 0xEB, + 0xC2, 0x76, 0x7A, 0x1E, 0xDC, 0x5F, 0xC0, 0x6A, 0x3C, 0xCC, 0xF5, 0xC1, + 0x1E, 0xF3, 0xDF, 0x40, 0x92, 0x2F, 0x78, 0x40, 0x6E, 0xD0, 0xBA, 0x78, + 0xBC, 0xD1, 0xD9, 0x4B, 0x29, 0x72, 0xE3, 0x02, 0xCD, 0xD9, 0x96, 0xF6, + 0xE6, 0x6A, 0xAE, 0xDE, 0x8A, 0xED, 0xFC, 0xC0, 0x7F, 0x67, 0x6D, 0x84, + 0x58, 0x21, 0x3F, 0x4B, 0xF2, 0x10, 0x0F, 0x73, 0x3D, 0x90, 0xE4, 0x74, + 0x03, 0xE4, 0x46, 0x92, 0x9F, 0x49, 0x93, 0xAC, 0x70, 0x7B, 0x90, 0xBC, + 0x50, 0xDE, 0xB6, 0xF5, 0x61, 0x3A, 0xBD, 0x0D, 0x67, 0xE6, 0x89, 0x8B, + 0xE8, 0xE8, 0xAF, 0x35, 0xA8, 0x15, 0xF2, 0x93, 0x9A, 0x93, 0xAD, 0xCE, + 0xCE, 0x1E, 0xF2, 0xE6, 0x5B, 0xF3, 0xAE, 0x9B, 0x32, 0xCC, 0xA4, 0x15, + 0x6E, 0x25, 0xC9, 0xF3, 0x75, 0xAA, 0x64, 0x85, 0x7B, 0x56, 0xB6, 0xE1, + 0xE6, 0x23, 0x64, 0x67, 0x27, 0x99, 0xEB, 0x0D, 0x1E, 0xE6, 0xFA, 0x20, + 0x0F, 0xC8, 0xBB, 0x93, 0xFC, 0x57, 0x2B, 0xDB, 0x9A, 0x8B, 0x65, 0x96, + 0x3B, 0x79, 0x98, 0xE5, 0x8B, 0x8C, 0x70, 0xEB, 0x15, 0xE3, 0x75, 0x3A, + 0x73, 0x94, 0x67, 0x95, 0x8F, 0x30, 0x92, 0x7E, 0x9E, 0xE6, 0x7A, 0x3A, + 0xC9, 0x03, 0x3C, 0xCC, 0xF5, 0x01, 0xDA, 0xBB, 0x5E, 0x2F, 0x6D, 0x6D, + 0xD2, 0xF7, 0xD5, 0xC9, 0xAC, 0x5E, 0xEE, 0xA1, 0xB9, 0xDB, 0x69, 0x67, + 0x6B, 0xB9, 0x51, 0x73, 0x3F, 0x21, 0x39, 0x76, 0x4B, 0x88, 0xC9, 0x8A, + 0x32, 0x27, 0x3F, 0xED, 0x01, 0xF9, 0x05, 0x01, 0xB3, 0x2E, 0x27, 0x06, + 0x91, 0x7C, 0x40, 0xA6, 0x78, 0x81, 0x3C, 0xDD, 0xE9, 0x3A, 0xE4, 0xB7, + 0x3A, 0x38, 0x95, 0x9A, 0x73, 0x2D, 0x70, 0x1B, 0xB5, 0x3D, 0x7A, 0x5A, + 0x7B, 0x8F, 0xC9, 0xB2, 0xC8, 0x4E, 0x8A, 0xB9, 0x3A, 0x4C, 0x19, 0x84, + 0x51, 0xE5, 0x45, 0x00, 0x37, 0x29, 0x14, 0xC8, 0x92, 0x31, 0x50, 0xA1, + 0x50, 0x9C, 0x46, 0xA5, 0xC0, 0x2C, 0x50, 0xD0, 0x3D, 0x8C, 0xDF, 0x31, + 0x16, 0xC0, 0x65, 0x00, 0x7A, 0x1A, 0x72, 0xAF, 0xAA, 0x01, 0xDC, 0x0C, + 0xE0, 0x21, 0xE4, 0x3A, 0x91, 0x3D, 0xCF, 0x51, 0x7F, 0xFD, 0xE4, 0x44, + 0x59, 0xE7, 0xE4, 0xE7, 0x3D, 0x1D, 0xAF, 0xB6, 0x44, 0x89, 0x56, 0x68, + 0x29, 0x64, 0xF5, 0x96, 0xE7, 0x4A, 0x73, 0xF3, 0x92, 0x23, 0x9C, 0x84, + 0xD0, 0xCE, 0x3E, 0xDA, 0xBD, 0xB2, 0x42, 0x9E, 0xA1, 0x25, 0x54, 0x97, + 0x1C, 0xC0, 0xDD, 0x56, 0x66, 0xF9, 0x1B, 0xA3, 0x59, 0x4E, 0xC3, 0xCD, + 0x5B, 0xE2, 0x7A, 0x52, 0xE2, 0x77, 0xFB, 0xEA, 0x6C, 0x78, 0x9D, 0x11, + 0xF2, 0xCB, 0x24, 0x0F, 0xCD, 0x22, 0xE4, 0x34, 0x5C, 0x1F, 0x87, 0x6A, + 0x2E, 0x5D, 0x7C, 0x75, 0x51, 0x3E, 0xC7, 0x36, 0x49, 0x19, 0x0D, 0xFD, + 0x14, 0xCA, 0x63, 0x85, 0xFC, 0x12, 0xC9, 0x51, 0x1E, 0x51, 0x16, 0x51, + 0xE0, 0xF6, 0xD4, 0x69, 0x92, 0xC5, 0x2C, 0xA7, 0x97, 0x42, 0x63, 0xB3, + 0xB9, 0x43, 0xD5, 0x1E, 0x01, 0x67, 0x86, 0xDE, 0x5A, 0x21, 0xCF, 0x22, + 0x39, 0x32, 0xC6, 0x79, 0xAE, 0x80, 0xE4, 0x8E, 0x74, 0x09, 0x64, 0x2B, + 0x8C, 0x70, 0x67, 0x2B, 0x62, 0xA4, 0x30, 0x09, 0x63, 0x9A, 0xC4, 0xDC, + 0xA4, 0xDE, 0x24, 0x1F, 0xF4, 0x80, 0xFC, 0x38, 0xC9, 0xED, 0x63, 0xEA, + 0x43, 0x0F, 0x92, 0x37, 0x69, 0x1E, 0xB5, 0xC0, 0xFD, 0x90, 0x2E, 0x61, + 0x2D, 0x31, 0xE3, 0x99, 0xC4, 0x42, 0x68, 0x8B, 0x54, 0xFF, 0xE2, 0x29, + 0xD8, 0x6A, 0x4C, 0x1D, 0x0B, 0x57, 0x63, 0x2B, 0x0E, 0xD9, 0x53, 0x49, + 0xE6, 0x51, 0xC7, 0x67, 0xA3, 0xF2, 0x9B, 0x6F, 0x06, 0xF0, 0x68, 0x92, + 0x06, 0x33, 0xA9, 0x95, 0xEE, 0xBE, 0x06, 0x70, 0x1D, 0x80, 0xD7, 0x0C, + 0xE9, 0x1B, 0x4D, 0xCA, 0x89, 0x8A, 0x43, 0xB6, 0x37, 0xAC, 0x73, 0x1B, + 0x00, 0x7C, 0xA4, 0x04, 0xF1, 0x69, 0x49, 0x1B, 0xC8, 0xA4, 0x02, 0x2E, + 0x03, 0xD0, 0x4B, 0x1B, 0x19, 0x51, 0x01, 0xA7, 0x94, 0xBF, 0x14, 0x47, + 0x49, 0x87, 0x72, 0x43, 0xBB, 0x0D, 0x00, 0x66, 0x01, 0x78, 0x39, 0x89, + 0x03, 0x99, 0x44, 0xC0, 0x25, 0x4A, 0xC8, 0xBA, 0x45, 0xC9, 0x60, 0x51, + 0xFB, 0xB8, 0x0C, 0xC0, 0x17, 0x31, 0x55, 0xB4, 0x59, 0x21, 0xB3, 0x1B, + 0x35, 0xE9, 0xEE, 0x47, 0x00, 0xC6, 0x00, 0xD8, 0x36, 0x69, 0x83, 0xD9, + 0x29, 0x81, 0x70, 0x0F, 0x56, 0x81, 0x95, 0xE1, 0x86, 0xFB, 0x6A, 0x00, + 0x3C, 0x01, 0x60, 0x71, 0x4C, 0xFD, 0xF8, 0x1C, 0xC0, 0x5C, 0x44, 0xAB, + 0xA6, 0x53, 0x04, 0x60, 0x5F, 0x00, 0xBD, 0x95, 0x32, 0xFB, 0x20, 0x80, + 0x6F, 0x83, 0x06, 0xFF, 0xBF, 0x74, 0x05, 0x70, 0x28, 0x5C, 0xF5, 0xB8, + 0xFD, 0x0C, 0xF7, 0xAD, 0x07, 0x30, 0x1D, 0xC0, 0x44, 0x55, 0xB5, 0x89, + 0x43, 0xE6, 0x2B, 0xCF, 0x78, 0xA9, 0xC1, 0x22, 0xF4, 0xD2, 0x83, 0x39, + 0x0E, 0x40, 0x0F, 0x24, 0xA3, 0x22, 0x5F, 0x62, 0x96, 0x49, 0x5D, 0x49, + 0x8E, 0x66, 0xCB, 0x75, 0x1F, 0x37, 0x25, 0x6B, 0x48, 0xDE, 0x4F, 0xB2, + 0x57, 0x16, 0xFA, 0x54, 0xA4, 0xBD, 0xE7, 0x6A, 0xDA, 0xB2, 0x1A, 0x97, + 0x90, 0xBC, 0x54, 0x3B, 0x60, 0xA9, 0xB0, 0x0E, 0x76, 0x31, 0x57, 0xC7, + 0x91, 0x7C, 0xC7, 0x08, 0x77, 0x35, 0xC9, 0xFB, 0xB4, 0x66, 0xCD, 0xE6, + 0x3E, 0xF4, 0x38, 0x92, 0x73, 0x8C, 0x90, 0x17, 0xD3, 0x25, 0xA8, 0xF5, + 0xCC, 0x37, 0xE4, 0x7C, 0x82, 0x4D, 0x29, 0x40, 0x7C, 0x34, 0xC9, 0x7F, + 0x1B, 0xE1, 0xAE, 0x24, 0x79, 0x8F, 0xCE, 0x66, 0x73, 0xD1, 0xD7, 0xB1, + 0xDA, 0x7E, 0xB4, 0x42, 0xBE, 0x5C, 0x1B, 0x37, 0x1D, 0xEE, 0xB0, 0x21, + 0xA5, 0x18, 0xE2, 0x31, 0x74, 0xC5, 0x56, 0x2C, 0xF2, 0x5F, 0xBA, 0xDC, + 0xD9, 0x6E, 0x6D, 0x68, 0xDB, 0xE7, 0xBE, 0x93, 0x49, 0x7E, 0xE0, 0x61, + 0xAE, 0xAF, 0xD4, 0xB6, 0x67, 0x5E, 0x20, 0xE7, 0xCB, 0x8B, 0x2E, 0x87, + 0xAB, 0xFB, 0x78, 0x11, 0x5A, 0x2E, 0xC7, 0xDB, 0x5C, 0x56, 0xC2, 0x15, + 0x08, 0x9F, 0x60, 0xD8, 0xE5, 0x4A, 0xC1, 0x55, 0xAB, 0xEB, 0xAC, 0x02, + 0x31, 0x05, 0x00, 0x36, 0xE8, 0xAA, 0x31, 0x38, 0x51, 0x8F, 0xE8, 0xDF, + 0xCB, 0xB4, 0xD3, 0x15, 0xA5, 0x66, 0x48, 0x4F, 0xB8, 0x52, 0xC8, 0x94, + 0x77, 0xBD, 0xC4, 0x58, 0x88, 0xA6, 0xDD, 0x2D, 0x93, 0x52, 0x2A, 0x76, + 0x32, 0x12, 0xC0, 0xF9, 0x9E, 0x70, 0xAB, 0xE0, 0xAA, 0xF6, 0x44, 0x6D, + 0xAF, 0x52, 0xCB, 0x9D, 0xBD, 0x00, 0xF4, 0x13, 0xEC, 0xC5, 0x00, 0x3E, + 0x01, 0xF0, 0x8E, 0x0A, 0xC3, 0x44, 0x8D, 0xB2, 0x78, 0x54, 0xB0, 0x2E, + 0x37, 0x42, 0x1E, 0xAF, 0xFF, 0x7E, 0x58, 0xBB, 0x74, 0xDC, 0x12, 0xBD, + 0xE8, 0x74, 0x98, 0xE9, 0x29, 0x74, 0x25, 0x0B, 0x2D, 0xB2, 0x9C, 0xE4, + 0xEF, 0x3D, 0xCC, 0x72, 0x05, 0xC9, 0x5F, 0xC8, 0xB4, 0x6E, 0xEA, 0x3B, + 0x27, 0x29, 0x3E, 0xCC, 0x7A, 0xF2, 0x73, 0x92, 0x7E, 0x83, 0x25, 0x09, + 0x7D, 0x29, 0xC9, 0x6B, 0x72, 0x6D, 0xAE, 0x73, 0x09, 0xB8, 0x92, 0x2E, + 0xAB, 0xFE, 0x03, 0x8F, 0x39, 0xF7, 0x56, 0xDA, 0xAB, 0xCE, 0x74, 0x57, + 0x34, 0x45, 0x4B, 0xB9, 0xC0, 0x75, 0x24, 0x27, 0xEA, 0x2C, 0xBA, 0xC0, + 0x13, 0x72, 0x83, 0x11, 0xF2, 0x95, 0x24, 0x77, 0xD8, 0xD2, 0xC2, 0x66, + 0xCB, 0xE4, 0x89, 0xBE, 0xE7, 0x01, 0x77, 0x92, 0x51, 0x73, 0x53, 0xFA, + 0x7C, 0x54, 0x4B, 0xB1, 0x5A, 0xE7, 0xBE, 0x7D, 0x3C, 0x06, 0xFD, 0x44, + 0x0F, 0xC7, 0x6B, 0x19, 0x5D, 0x45, 0xA2, 0x9C, 0x40, 0xCE, 0x15, 0xDC, + 0x9F, 0x91, 0xFC, 0x8F, 0x11, 0xEE, 0x0A, 0x92, 0xB7, 0x19, 0x23, 0x35, + 0xD2, 0xC1, 0x71, 0x63, 0x75, 0x36, 0x6B, 0x79, 0x90, 0x6E, 0xF0, 0x84, + 0x7C, 0xBC, 0x7E, 0x9B, 0x05, 0xF2, 0xB7, 0x24, 0xAB, 0x72, 0xB1, 0x84, + 0xCA, 0x36, 0xDC, 0x6E, 0xDA, 0x28, 0xF8, 0xD0, 0x03, 0xEE, 0x24, 0xDA, + 0x13, 0xA1, 0x2B, 0x34, 0x0D, 0xCC, 0xF6, 0xC8, 0x2C, 0x5C, 0x25, 0x4D, + 0xF6, 0x99, 0x23, 0x4F, 0xF0, 0x84, 0x7C, 0xAD, 0x76, 0xE1, 0x52, 0xED, + 0x11, 0x70, 0x99, 0xD6, 0xB9, 0x1F, 0xE7, 0x40, 0x73, 0xD3, 0xED, 0x9D, + 0xE2, 0x61, 0x29, 0x36, 0x65, 0xAE, 0x7D, 0x21, 0x5B, 0xE7, 0xE4, 0x15, + 0x72, 0xBC, 0xB2, 0x66, 0xAE, 0xB3, 0x6D, 0x96, 0x3F, 0xF6, 0xD4, 0xDC, + 0x7C, 0xC0, 0x4D, 0xCB, 0x3A, 0x99, 0x6B, 0x1F, 0xC8, 0xC7, 0xCA, 0xCF, + 0xA8, 0x37, 0x4E, 0x0F, 0xD7, 0x65, 0xCB, 0xBB, 0xCE, 0x96, 0x59, 0x1E, + 0x43, 0x7B, 0x95, 0xF4, 0x6F, 0x3D, 0xE1, 0xA6, 0xDB, 0x9B, 0xCD, 0xF8, + 0x64, 0x4D, 0x1B, 0x20, 0x8F, 0xF6, 0x80, 0xBC, 0x8A, 0xAE, 0xCE, 0xF4, + 0x0F, 0xE2, 0x86, 0x1C, 0x37, 0xDC, 0x72, 0x2D, 0x4D, 0xE6, 0x78, 0xC0, + 0x9D, 0x48, 0x7B, 0xB2, 0x77, 0xDA, 0x5B, 0x9E, 0xC3, 0xF8, 0x65, 0x9D, + 0x02, 0xEF, 0xFA, 0x78, 0x42, 0x7E, 0xC7, 0x53, 0x93, 0x63, 0x85, 0x1C, + 0xF7, 0xF1, 0xDA, 0x4F, 0x69, 0xAB, 0x41, 0x45, 0x65, 0x0B, 0xFC, 0x8E, + 0xF6, 0x32, 0x45, 0x69, 0xB8, 0x16, 0xCD, 0x6D, 0x32, 0x46, 0x4A, 0xAE, + 0x25, 0x79, 0x8B, 0xD6, 0xC9, 0xD6, 0x41, 0x3F, 0x86, 0xE4, 0x5B, 0xB4, + 0x55, 0xFF, 0x59, 0x21, 0xCB, 0xD1, 0x97, 0x31, 0xE5, 0x0E, 0xC7, 0x05, + 0xB7, 0x80, 0xAE, 0x98, 0xD9, 0xEB, 0x46, 0xB8, 0x4B, 0x49, 0xDE, 0x6C, + 0xCC, 0x4C, 0x48, 0x65, 0x6C, 0x62, 0x58, 0xCD, 0xF2, 0x42, 0xF9, 0x05, + 0x35, 0x46, 0x4D, 0x4E, 0x6F, 0x86, 0x58, 0x77, 0xBC, 0x8E, 0xA6, 0x4B, + 0x5D, 0xDD, 0x68, 0xD4, 0xE4, 0x1B, 0xE9, 0x52, 0x54, 0x13, 0x03, 0xB8, + 0x84, 0xE4, 0x9D, 0x1E, 0x70, 0x6F, 0xF0, 0x30, 0xCB, 0x95, 0x74, 0xD5, + 0xE3, 0xE6, 0x7A, 0xB4, 0xF7, 0x1B, 0x79, 0xBB, 0xAF, 0xD2, 0x56, 0x8D, + 0x67, 0xAD, 0x20, 0xEF, 0xEA, 0x01, 0xF9, 0x18, 0x41, 0xAE, 0x33, 0x5A, + 0xB5, 0xD1, 0x4C, 0x50, 0xA5, 0xBB, 0x4A, 0xBA, 0xEA, 0x36, 0x96, 0xC1, + 0xAE, 0xA2, 0x3D, 0x99, 0xBB, 0x52, 0x7B, 0xCB, 0x9F, 0x7A, 0xC0, 0xBD, + 0x2E, 0x23, 0xF3, 0x61, 0x24, 0x5D, 0xE6, 0x7F, 0x9D, 0x51, 0x93, 0x6F, + 0xA7, 0xAB, 0x1C, 0x64, 0x85, 0x7C, 0x14, 0xC9, 0xD7, 0x8C, 0xED, 0xDD, + 0xCF, 0x04, 0x95, 0x13, 0xAE, 0xA0, 0x4B, 0xCE, 0xB6, 0xC0, 0xB5, 0x9A, + 0xE5, 0x4A, 0xBA, 0x1A, 0x54, 0x56, 0xCD, 0x5D, 0xA2, 0xF6, 0x9A, 0xA7, + 0x9A, 0x1E, 0xE1, 0x31, 0xE8, 0x6B, 0x75, 0x16, 0xDD, 0xDF, 0x63, 0x8E, + 0x4C, 0xB7, 0x17, 0xD5, 0xF1, 0x9A, 0xCE, 0x18, 0xEA, 0x66, 0xC5, 0x05, + 0xB8, 0x94, 0xAE, 0xBA, 0x7A, 0x94, 0xC1, 0x9E, 0x60, 0xD4, 0xDC, 0x14, + 0x5D, 0x4A, 0xCA, 0xD9, 0x74, 0x95, 0x70, 0x2C, 0xB2, 0x58, 0x1B, 0x09, + 0x9B, 0x7B, 0x98, 0x8E, 0xF4, 0x84, 0xEC, 0x7B, 0x0A, 0x75, 0x94, 0x1C, + 0xAF, 0x28, 0x90, 0xFF, 0xC1, 0x84, 0x95, 0x13, 0x3E, 0x91, 0x9B, 0x4F, + 0xB1, 0x4C, 0x17, 0xF5, 0xBC, 0xC6, 0xC3, 0x2C, 0x6F, 0x47, 0x57, 0x24, + 0x65, 0x9E, 0x87, 0xE6, 0x5E, 0x15, 0xA1, 0xBD, 0x51, 0x74, 0xC9, 0x6B, + 0x56, 0x73, 0x7D, 0x9B, 0xA7, 0x26, 0x1F, 0xC9, 0xD6, 0x2B, 0xD7, 0xD7, + 0x6A, 0xAC, 0x0A, 0x99, 0xA0, 0x65, 0x52, 0x67, 0x2D, 0x77, 0x16, 0xA9, + 0x83, 0x0D, 0xFA, 0x11, 0x35, 0x74, 0xD5, 0xE3, 0xAE, 0xA2, 0x5F, 0xDD, + 0xC7, 0x73, 0x3C, 0x34, 0x37, 0x0D, 0x37, 0x6A, 0xFA, 0xE6, 0xE1, 0x6C, + 0xBD, 0x1A, 0x4F, 0x73, 0xF9, 0x4E, 0x8E, 0xE5, 0x2E, 0x1E, 0xCE, 0x50, + 0xBA, 0xBD, 0xDA, 0xCD, 0xC0, 0x7D, 0x95, 0xAE, 0x42, 0x50, 0x9B, 0x9D, + 0xAC, 0xC2, 0xAA, 0xAA, 0xAA, 0xB8, 0x62, 0x07, 0x1A, 0x00, 0x7C, 0xA8, + 0x8C, 0x80, 0x0D, 0xCA, 0x0E, 0x58, 0x00, 0xF7, 0xFE, 0xA2, 0xA9, 0x70, + 0xAF, 0xB9, 0xA9, 0x35, 0xD6, 0xC3, 0x38, 0x01, 0xC0, 0x05, 0xB0, 0xBD, + 0x4A, 0x76, 0x29, 0xDC, 0x4B, 0x21, 0x27, 0x1A, 0xB2, 0x13, 0xAA, 0x15, + 0x53, 0xBD, 0x8B, 0xF2, 0x92, 0xA2, 0xC4, 0x8B, 0x17, 0x29, 0xAA, 0xA3, + 0x40, 0x81, 0xF2, 0x96, 0x44, 0xB9, 0x6A, 0x25, 0xD9, 0x55, 0x2A, 0x94, + 0x68, 0x23, 0xDC, 0xFB, 0x92, 0x56, 0x01, 0x78, 0x1D, 0xEE, 0x55, 0x42, + 0x6F, 0xC6, 0x12, 0x42, 0xC3, 0xEC, 0x14, 0x61, 0xE9, 0xAD, 0xCE, 0x37, + 0x29, 0xCA, 0x7F, 0xA9, 0xF1, 0xFE, 0x4A, 0xA5, 0xAD, 0x5C, 0x0C, 0xDB, + 0x1B, 0xBF, 0x33, 0xE1, 0xD6, 0x7A, 0xF4, 0x7B, 0x14, 0xDC, 0xCB, 0x9F, + 0x87, 0x2A, 0xB4, 0x27, 0x8A, 0x6C, 0x80, 0x7B, 0x11, 0xD7, 0x64, 0xB8, + 0x77, 0x05, 0x5B, 0x06, 0x74, 0x37, 0x7C, 0xFF, 0xBD, 0x49, 0x6B, 0x00, + 0x3C, 0x07, 0x60, 0x9E, 0x1E, 0x9C, 0xA6, 0xF6, 0x14, 0xB2, 0x63, 0x89, + 0xC4, 0x18, 0x4F, 0x5B, 0x21, 0xED, 0xB4, 0x59, 0xBE, 0x9A, 0x6D, 0xCF, + 0xAA, 0x3F, 0x54, 0x73, 0xB2, 0xC5, 0x5C, 0xD7, 0x91, 0xBC, 0xCB, 0xD3, + 0x5C, 0x77, 0xA8, 0x04, 0xF0, 0xEE, 0x5A, 0xE7, 0x5A, 0x1D, 0xAA, 0x74, + 0xBC, 0x53, 0x5C, 0xE5, 0x78, 0x0F, 0xA7, 0xFD, 0x15, 0x3E, 0x75, 0x24, + 0x27, 0x27, 0x0D, 0x72, 0x92, 0xE0, 0xF6, 0xD0, 0x3A, 0xD7, 0xEA, 0x50, + 0x2D, 0x92, 0xE6, 0xC6, 0x5D, 0x6B, 0x79, 0xA4, 0x20, 0x5B, 0xB6, 0x19, + 0x6B, 0x32, 0x1C, 0xAF, 0x82, 0x00, 0xF8, 0xFB, 0x4B, 0xA1, 0xF3, 0xE4, + 0x6D, 0x5B, 0xE1, 0x5E, 0xC1, 0xEC, 0xD5, 0xA0, 0xFA, 0xB1, 0x3C, 0x5A, + 0x4B, 0x69, 0xE2, 0x5A, 0x92, 0x53, 0xE4, 0x05, 0x77, 0x0A, 0x80, 0xDD, + 0xA9, 0x90, 0x15, 0x6E, 0xE6, 0xAB, 0xE5, 0xB2, 0x5D, 0xC9, 0xE6, 0x20, + 0xDA, 0x8B, 0x8C, 0xD7, 0x92, 0xFC, 0x23, 0x5D, 0x59, 0xE3, 0xBC, 0x42, + 0xCE, 0x77, 0xFA, 0x68, 0x01, 0x80, 0xFD, 0x15, 0x04, 0xDF, 0x37, 0xAA, + 0x5F, 0xA8, 0x60, 0xF5, 0x29, 0x70, 0xA5, 0x10, 0x37, 0x66, 0xB9, 0x8F, + 0xAF, 0x02, 0xB8, 0x51, 0xE5, 0x24, 0xA2, 0x96, 0x4E, 0x2C, 0x06, 0x70, + 0x2A, 0x80, 0x33, 0xB5, 0xDC, 0xEB, 0xB0, 0xF9, 0xC1, 0x65, 0x70, 0xB5, + 0x1F, 0xFB, 0x19, 0xEE, 0x59, 0x08, 0xE0, 0x4E, 0x00, 0xB7, 0xC2, 0x56, + 0xAB, 0xB2, 0x2D, 0xF2, 0x0A, 0x80, 0xEB, 0x55, 0xAA, 0x61, 0x43, 0xC4, + 0x7B, 0x3A, 0xEB, 0xB7, 0xF5, 0xED, 0xC8, 0x80, 0x7B, 0xC1, 0xBD, 0x00, + 0x3A, 0xAA, 0xE6, 0x7E, 0x05, 0xE0, 0x2E, 0x5D, 0x0D, 0x39, 0xEE, 0xEB, + 0x4C, 0x69, 0xF2, 0x2C, 0xC3, 0x83, 0x55, 0x01, 0x57, 0x74, 0xB5, 0xC3, + 0x96, 0x70, 0xE8, 0xA4, 0x1D, 0xA1, 0xA8, 0x70, 0x27, 0x0B, 0x6E, 0x63, + 0x9E, 0xFA, 0x3B, 0x33, 0x43, 0x31, 0x0E, 0x94, 0x29, 0x8E, 0x02, 0x39, + 0x9E, 0x4D, 0x8B, 0x76, 0x08, 0xF8, 0x3B, 0xED, 0x74, 0xF5, 0x6E, 0xE5, + 0x73, 0x0B, 0xB4, 0x7D, 0x37, 0x25, 0x8F, 0x70, 0x33, 0x21, 0x33, 0xC3, + 0x7F, 0x28, 0x6E, 0x65, 0xFB, 0x76, 0x49, 0x47, 0x36, 0xD1, 0xCB, 0x35, + 0xBF, 0xD5, 0xB7, 0xA2, 0xB9, 0xB7, 0x27, 0x04, 0x6E, 0x5A, 0x66, 0x69, + 0x4E, 0x9E, 0xD9, 0x82, 0xB9, 0x26, 0x80, 0x4F, 0x01, 0xCC, 0xC9, 0x69, + 0x36, 0x61, 0xC2, 0x34, 0x78, 0x1D, 0x5C, 0x91, 0xEC, 0x61, 0x00, 0x06, + 0xC3, 0x55, 0xD9, 0x49, 0x9B, 0xB3, 0x7A, 0x69, 0xEE, 0xBD, 0x3A, 0xA8, + 0x48, 0x0A, 0xDC, 0x4C, 0xC8, 0x54, 0x5F, 0x47, 0xC0, 0x55, 0xD8, 0x29, + 0xD4, 0xFF, 0xAB, 0x57, 0x8A, 0xEA, 0x9F, 0xE4, 0x14, 0xE6, 0x0D, 0x70, + 0x3E, 0x2B, 0xBE, 0x67, 0xCA, 0x21, 0x3A, 0x5C, 0x18, 0xA2, 0x8D, 0xF7, + 0x95, 0x70, 0x65, 0x8C, 0x66, 0x28, 0xA7, 0xB6, 0x01, 0xC9, 0x95, 0xE1, + 0x00, 0x4E, 0x51, 0xDF, 0x77, 0xD4, 0x81, 0xC1, 0x3C, 0xB8, 0xC2, 0x68, + 0x0F, 0xEB, 0x21, 0x46, 0x47, 0x07, 0x0C, 0xB8, 0xC4, 0xF0, 0xA1, 0x00, + 0x76, 0xD5, 0x51, 0xDA, 0xFB, 0x88, 0xAF, 0xEE, 0x55, 0xB6, 0xA5, 0x14, + 0x2E, 0xC9, 0x7C, 0x4F, 0x4D, 0x3B, 0xEF, 0xCA, 0xFA, 0xE4, 0x5D, 0x92, + 0x04, 0x38, 0xC8, 0x16, 0xE8, 0x64, 0x05, 0x09, 0x80, 0x83, 0x04, 0xC0, + 0x41, 0x02, 0xE0, 0x00, 0x38, 0x48, 0x00, 0x1C, 0x24, 0x00, 0x0E, 0x12, + 0x00, 0x07, 0x09, 0x80, 0x83, 0x04, 0xC0, 0x41, 0x02, 0xE0, 0x20, 0x01, + 0x70, 0x00, 0x1C, 0x24, 0x00, 0x0E, 0x12, 0x00, 0x07, 0x09, 0x80, 0x83, + 0x64, 0x47, 0xFE, 0x37, 0x00, 0x03, 0xCE, 0x9A, 0x67, 0x1F, 0xCC, 0x4A, + 0xE6, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, + 0x82 +}; +} +static unsigned char* legit_icon = raw::legit; +}
\ No newline at end of file diff --git a/internal_rewrite/icons/misc.hpp b/internal_rewrite/icons/misc.hpp new file mode 100644 index 0000000..a955fe0 --- /dev/null +++ b/internal_rewrite/icons/misc.hpp @@ -0,0 +1,1721 @@ +/* E:\Users\admin\Desktop\stuff\icons\misc.png (4/1/2018 10:00:14 PM) + StartOffset: 00000000, EndOffset: 00005025, Length: 00005026 */ + +namespace icons { +constexpr static size_t misc_size = 20518; +namespace raw { +static unsigned char misc[20518] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x39, 0x64, 0x36, 0xD2, 0x00, 0x00, 0x00, + 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23, 0x00, 0x00, 0x2E, + 0x23, 0x01, 0x78, 0xA5, 0x3F, 0x76, 0x00, 0x00, 0x0A, 0x4F, 0x69, 0x43, + 0x43, 0x50, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, + 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x00, + 0x00, 0x78, 0xDA, 0x9D, 0x53, 0x67, 0x54, 0x53, 0xE9, 0x16, 0x3D, 0xF7, + 0xDE, 0xF4, 0x42, 0x4B, 0x88, 0x80, 0x94, 0x4B, 0x6F, 0x52, 0x15, 0x08, + 0x20, 0x52, 0x42, 0x8B, 0x80, 0x14, 0x91, 0x26, 0x2A, 0x21, 0x09, 0x10, + 0x4A, 0x88, 0x21, 0xA1, 0xD9, 0x15, 0x51, 0xC1, 0x11, 0x45, 0x45, 0x04, + 0x1B, 0xC8, 0xA0, 0x88, 0x03, 0x8E, 0x8E, 0x80, 0x8C, 0x15, 0x51, 0x2C, + 0x0C, 0x8A, 0x0A, 0xD8, 0x07, 0xE4, 0x21, 0xA2, 0x8E, 0x83, 0xA3, 0x88, + 0x8A, 0xCA, 0xFB, 0xE1, 0x7B, 0xA3, 0x6B, 0xD6, 0xBC, 0xF7, 0xE6, 0xCD, + 0xFE, 0xB5, 0xD7, 0x3E, 0xE7, 0xAC, 0xF3, 0x9D, 0xB3, 0xCF, 0x07, 0xC0, + 0x08, 0x0C, 0x96, 0x48, 0x33, 0x51, 0x35, 0x80, 0x0C, 0xA9, 0x42, 0x1E, + 0x11, 0xE0, 0x83, 0xC7, 0xC4, 0xC6, 0xE1, 0xE4, 0x2E, 0x40, 0x81, 0x0A, + 0x24, 0x70, 0x00, 0x10, 0x08, 0xB3, 0x64, 0x21, 0x73, 0xFD, 0x23, 0x01, + 0x00, 0xF8, 0x7E, 0x3C, 0x3C, 0x2B, 0x22, 0xC0, 0x07, 0xBE, 0x00, 0x01, + 0x78, 0xD3, 0x0B, 0x08, 0x00, 0xC0, 0x4D, 0x9B, 0xC0, 0x30, 0x1C, 0x87, + 0xFF, 0x0F, 0xEA, 0x42, 0x99, 0x5C, 0x01, 0x80, 0x84, 0x01, 0xC0, 0x74, + 0x91, 0x38, 0x4B, 0x08, 0x80, 0x14, 0x00, 0x40, 0x7A, 0x8E, 0x42, 0xA6, + 0x00, 0x40, 0x46, 0x01, 0x80, 0x9D, 0x98, 0x26, 0x53, 0x00, 0xA0, 0x04, + 0x00, 0x60, 0xCB, 0x63, 0x62, 0xE3, 0x00, 0x50, 0x2D, 0x00, 0x60, 0x27, + 0x7F, 0xE6, 0xD3, 0x00, 0x80, 0x9D, 0xF8, 0x99, 0x7B, 0x01, 0x00, 0x5B, + 0x94, 0x21, 0x15, 0x01, 0xA0, 0x91, 0x00, 0x20, 0x13, 0x65, 0x88, 0x44, + 0x00, 0x68, 0x3B, 0x00, 0xAC, 0xCF, 0x56, 0x8A, 0x45, 0x00, 0x58, 0x30, + 0x00, 0x14, 0x66, 0x4B, 0xC4, 0x39, 0x00, 0xD8, 0x2D, 0x00, 0x30, 0x49, + 0x57, 0x66, 0x48, 0x00, 0xB0, 0xB7, 0x00, 0xC0, 0xCE, 0x10, 0x0B, 0xB2, + 0x00, 0x08, 0x0C, 0x00, 0x30, 0x51, 0x88, 0x85, 0x29, 0x00, 0x04, 0x7B, + 0x00, 0x60, 0xC8, 0x23, 0x23, 0x78, 0x00, 0x84, 0x99, 0x00, 0x14, 0x46, + 0xF2, 0x57, 0x3C, 0xF1, 0x2B, 0xAE, 0x10, 0xE7, 0x2A, 0x00, 0x00, 0x78, + 0x99, 0xB2, 0x3C, 0xB9, 0x24, 0x39, 0x45, 0x81, 0x5B, 0x08, 0x2D, 0x71, + 0x07, 0x57, 0x57, 0x2E, 0x1E, 0x28, 0xCE, 0x49, 0x17, 0x2B, 0x14, 0x36, + 0x61, 0x02, 0x61, 0x9A, 0x40, 0x2E, 0xC2, 0x79, 0x99, 0x19, 0x32, 0x81, + 0x34, 0x0F, 0xE0, 0xF3, 0xCC, 0x00, 0x00, 0xA0, 0x91, 0x15, 0x11, 0xE0, + 0x83, 0xF3, 0xFD, 0x78, 0xCE, 0x0E, 0xAE, 0xCE, 0xCE, 0x36, 0x8E, 0xB6, + 0x0E, 0x5F, 0x2D, 0xEA, 0xBF, 0x06, 0xFF, 0x22, 0x62, 0x62, 0xE3, 0xFE, + 0xE5, 0xCF, 0xAB, 0x70, 0x40, 0x00, 0x00, 0xE1, 0x74, 0x7E, 0xD1, 0xFE, + 0x2C, 0x2F, 0xB3, 0x1A, 0x80, 0x3B, 0x06, 0x80, 0x6D, 0xFE, 0xA2, 0x25, + 0xEE, 0x04, 0x68, 0x5E, 0x0B, 0xA0, 0x75, 0xF7, 0x8B, 0x66, 0xB2, 0x0F, + 0x40, 0xB5, 0x00, 0xA0, 0xE9, 0xDA, 0x57, 0xF3, 0x70, 0xF8, 0x7E, 0x3C, + 0x3C, 0x45, 0xA1, 0x90, 0xB9, 0xD9, 0xD9, 0xE5, 0xE4, 0xE4, 0xD8, 0x4A, + 0xC4, 0x42, 0x5B, 0x61, 0xCA, 0x57, 0x7D, 0xFE, 0x67, 0xC2, 0x5F, 0xC0, + 0x57, 0xFD, 0x6C, 0xF9, 0x7E, 0x3C, 0xFC, 0xF7, 0xF5, 0xE0, 0xBE, 0xE2, + 0x24, 0x81, 0x32, 0x5D, 0x81, 0x47, 0x04, 0xF8, 0xE0, 0xC2, 0xCC, 0xF4, + 0x4C, 0xA5, 0x1C, 0xCF, 0x92, 0x09, 0x84, 0x62, 0xDC, 0xE6, 0x8F, 0x47, + 0xFC, 0xB7, 0x0B, 0xFF, 0xFC, 0x1D, 0xD3, 0x22, 0xC4, 0x49, 0x62, 0xB9, + 0x58, 0x2A, 0x14, 0xE3, 0x51, 0x12, 0x71, 0x8E, 0x44, 0x9A, 0x8C, 0xF3, + 0x32, 0xA5, 0x22, 0x89, 0x42, 0x92, 0x29, 0xC5, 0x25, 0xD2, 0xFF, 0x64, + 0xE2, 0xDF, 0x2C, 0xFB, 0x03, 0x3E, 0xDF, 0x35, 0x00, 0xB0, 0x6A, 0x3E, + 0x01, 0x7B, 0x91, 0x2D, 0xA8, 0x5D, 0x63, 0x03, 0xF6, 0x4B, 0x27, 0x10, + 0x58, 0x74, 0xC0, 0xE2, 0xF7, 0x00, 0x00, 0xF2, 0xBB, 0x6F, 0xC1, 0xD4, + 0x28, 0x08, 0x03, 0x80, 0x68, 0x83, 0xE1, 0xCF, 0x77, 0xFF, 0xEF, 0x3F, + 0xFD, 0x47, 0xA0, 0x25, 0x00, 0x80, 0x66, 0x49, 0x92, 0x71, 0x00, 0x00, + 0x5E, 0x44, 0x24, 0x2E, 0x54, 0xCA, 0xB3, 0x3F, 0xC7, 0x08, 0x00, 0x00, + 0x44, 0xA0, 0x81, 0x2A, 0xB0, 0x41, 0x1B, 0xF4, 0xC1, 0x18, 0x2C, 0xC0, + 0x06, 0x1C, 0xC1, 0x05, 0xDC, 0xC1, 0x0B, 0xFC, 0x60, 0x36, 0x84, 0x42, + 0x24, 0xC4, 0xC2, 0x42, 0x10, 0x42, 0x0A, 0x64, 0x80, 0x1C, 0x72, 0x60, + 0x29, 0xAC, 0x82, 0x42, 0x28, 0x86, 0xCD, 0xB0, 0x1D, 0x2A, 0x60, 0x2F, + 0xD4, 0x40, 0x1D, 0x34, 0xC0, 0x51, 0x68, 0x86, 0x93, 0x70, 0x0E, 0x2E, + 0xC2, 0x55, 0xB8, 0x0E, 0x3D, 0x70, 0x0F, 0xFA, 0x61, 0x08, 0x9E, 0xC1, + 0x28, 0xBC, 0x81, 0x09, 0x04, 0x41, 0xC8, 0x08, 0x13, 0x61, 0x21, 0xDA, + 0x88, 0x01, 0x62, 0x8A, 0x58, 0x23, 0x8E, 0x08, 0x17, 0x99, 0x85, 0xF8, + 0x21, 0xC1, 0x48, 0x04, 0x12, 0x8B, 0x24, 0x20, 0xC9, 0x88, 0x14, 0x51, + 0x22, 0x4B, 0x91, 0x35, 0x48, 0x31, 0x52, 0x8A, 0x54, 0x20, 0x55, 0x48, + 0x1D, 0xF2, 0x3D, 0x72, 0x02, 0x39, 0x87, 0x5C, 0x46, 0xBA, 0x91, 0x3B, + 0xC8, 0x00, 0x32, 0x82, 0xFC, 0x86, 0xBC, 0x47, 0x31, 0x94, 0x81, 0xB2, + 0x51, 0x3D, 0xD4, 0x0C, 0xB5, 0x43, 0xB9, 0xA8, 0x37, 0x1A, 0x84, 0x46, + 0xA2, 0x0B, 0xD0, 0x64, 0x74, 0x31, 0x9A, 0x8F, 0x16, 0xA0, 0x9B, 0xD0, + 0x72, 0xB4, 0x1A, 0x3D, 0x8C, 0x36, 0xA1, 0xE7, 0xD0, 0xAB, 0x68, 0x0F, + 0xDA, 0x8F, 0x3E, 0x43, 0xC7, 0x30, 0xC0, 0xE8, 0x18, 0x07, 0x33, 0xC4, + 0x6C, 0x30, 0x2E, 0xC6, 0xC3, 0x42, 0xB1, 0x38, 0x2C, 0x09, 0x93, 0x63, + 0xCB, 0xB1, 0x22, 0xAC, 0x0C, 0xAB, 0xC6, 0x1A, 0xB0, 0x56, 0xAC, 0x03, + 0xBB, 0x89, 0xF5, 0x63, 0xCF, 0xB1, 0x77, 0x04, 0x12, 0x81, 0x45, 0xC0, + 0x09, 0x36, 0x04, 0x77, 0x42, 0x20, 0x61, 0x1E, 0x41, 0x48, 0x58, 0x4C, + 0x58, 0x4E, 0xD8, 0x48, 0xA8, 0x20, 0x1C, 0x24, 0x34, 0x11, 0xDA, 0x09, + 0x37, 0x09, 0x03, 0x84, 0x51, 0xC2, 0x27, 0x22, 0x93, 0xA8, 0x4B, 0xB4, + 0x26, 0xBA, 0x11, 0xF9, 0xC4, 0x18, 0x62, 0x32, 0x31, 0x87, 0x58, 0x48, + 0x2C, 0x23, 0xD6, 0x12, 0x8F, 0x13, 0x2F, 0x10, 0x7B, 0x88, 0x43, 0xC4, + 0x37, 0x24, 0x12, 0x89, 0x43, 0x32, 0x27, 0xB9, 0x90, 0x02, 0x49, 0xB1, + 0xA4, 0x54, 0xD2, 0x12, 0xD2, 0x46, 0xD2, 0x6E, 0x52, 0x23, 0xE9, 0x2C, + 0xA9, 0x9B, 0x34, 0x48, 0x1A, 0x23, 0x93, 0xC9, 0xDA, 0x64, 0x6B, 0xB2, + 0x07, 0x39, 0x94, 0x2C, 0x20, 0x2B, 0xC8, 0x85, 0xE4, 0x9D, 0xE4, 0xC3, + 0xE4, 0x33, 0xE4, 0x1B, 0xE4, 0x21, 0xF2, 0x5B, 0x0A, 0x9D, 0x62, 0x40, + 0x71, 0xA4, 0xF8, 0x53, 0xE2, 0x28, 0x52, 0xCA, 0x6A, 0x4A, 0x19, 0xE5, + 0x10, 0xE5, 0x34, 0xE5, 0x06, 0x65, 0x98, 0x32, 0x41, 0x55, 0xA3, 0x9A, + 0x52, 0xDD, 0xA8, 0xA1, 0x54, 0x11, 0x35, 0x8F, 0x5A, 0x42, 0xAD, 0xA1, + 0xB6, 0x52, 0xAF, 0x51, 0x87, 0xA8, 0x13, 0x34, 0x75, 0x9A, 0x39, 0xCD, + 0x83, 0x16, 0x49, 0x4B, 0xA5, 0xAD, 0xA2, 0x95, 0xD3, 0x1A, 0x68, 0x17, + 0x68, 0xF7, 0x69, 0xAF, 0xE8, 0x74, 0xBA, 0x11, 0xDD, 0x95, 0x1E, 0x4E, + 0x97, 0xD0, 0x57, 0xD2, 0xCB, 0xE9, 0x47, 0xE8, 0x97, 0xE8, 0x03, 0xF4, + 0x77, 0x0C, 0x0D, 0x86, 0x15, 0x83, 0xC7, 0x88, 0x67, 0x28, 0x19, 0x9B, + 0x18, 0x07, 0x18, 0x67, 0x19, 0x77, 0x18, 0xAF, 0x98, 0x4C, 0xA6, 0x19, + 0xD3, 0x8B, 0x19, 0xC7, 0x54, 0x30, 0x37, 0x31, 0xEB, 0x98, 0xE7, 0x99, + 0x0F, 0x99, 0x6F, 0x55, 0x58, 0x2A, 0xB6, 0x2A, 0x7C, 0x15, 0x91, 0xCA, + 0x0A, 0x95, 0x4A, 0x95, 0x26, 0x95, 0x1B, 0x2A, 0x2F, 0x54, 0xA9, 0xAA, + 0xA6, 0xAA, 0xDE, 0xAA, 0x0B, 0x55, 0xF3, 0x55, 0xCB, 0x54, 0x8F, 0xA9, + 0x5E, 0x53, 0x7D, 0xAE, 0x46, 0x55, 0x33, 0x53, 0xE3, 0xA9, 0x09, 0xD4, + 0x96, 0xAB, 0x55, 0xAA, 0x9D, 0x50, 0xEB, 0x53, 0x1B, 0x53, 0x67, 0xA9, + 0x3B, 0xA8, 0x87, 0xAA, 0x67, 0xA8, 0x6F, 0x54, 0x3F, 0xA4, 0x7E, 0x59, + 0xFD, 0x89, 0x06, 0x59, 0xC3, 0x4C, 0xC3, 0x4F, 0x43, 0xA4, 0x51, 0xA0, + 0xB1, 0x5F, 0xE3, 0xBC, 0xC6, 0x20, 0x0B, 0x63, 0x19, 0xB3, 0x78, 0x2C, + 0x21, 0x6B, 0x0D, 0xAB, 0x86, 0x75, 0x81, 0x35, 0xC4, 0x26, 0xB1, 0xCD, + 0xD9, 0x7C, 0x76, 0x2A, 0xBB, 0x98, 0xFD, 0x1D, 0xBB, 0x8B, 0x3D, 0xAA, + 0xA9, 0xA1, 0x39, 0x43, 0x33, 0x4A, 0x33, 0x57, 0xB3, 0x52, 0xF3, 0x94, + 0x66, 0x3F, 0x07, 0xE3, 0x98, 0x71, 0xF8, 0x9C, 0x74, 0x4E, 0x09, 0xE7, + 0x28, 0xA7, 0x97, 0xF3, 0x7E, 0x8A, 0xDE, 0x14, 0xEF, 0x29, 0xE2, 0x29, + 0x1B, 0xA6, 0x34, 0x4C, 0xB9, 0x31, 0x65, 0x5C, 0x6B, 0xAA, 0x96, 0x97, + 0x96, 0x58, 0xAB, 0x48, 0xAB, 0x51, 0xAB, 0x47, 0xEB, 0xBD, 0x36, 0xAE, + 0xED, 0xA7, 0x9D, 0xA6, 0xBD, 0x45, 0xBB, 0x59, 0xFB, 0x81, 0x0E, 0x41, + 0xC7, 0x4A, 0x27, 0x5C, 0x27, 0x47, 0x67, 0x8F, 0xCE, 0x05, 0x9D, 0xE7, + 0x53, 0xD9, 0x53, 0xDD, 0xA7, 0x0A, 0xA7, 0x16, 0x4D, 0x3D, 0x3A, 0xF5, + 0xAE, 0x2E, 0xAA, 0x6B, 0xA5, 0x1B, 0xA1, 0xBB, 0x44, 0x77, 0xBF, 0x6E, + 0xA7, 0xEE, 0x98, 0x9E, 0xBE, 0x5E, 0x80, 0x9E, 0x4C, 0x6F, 0xA7, 0xDE, + 0x79, 0xBD, 0xE7, 0xFA, 0x1C, 0x7D, 0x2F, 0xFD, 0x54, 0xFD, 0x6D, 0xFA, + 0xA7, 0xF5, 0x47, 0x0C, 0x58, 0x06, 0xB3, 0x0C, 0x24, 0x06, 0xDB, 0x0C, + 0xCE, 0x18, 0x3C, 0xC5, 0x35, 0x71, 0x6F, 0x3C, 0x1D, 0x2F, 0xC7, 0xDB, + 0xF1, 0x51, 0x43, 0x5D, 0xC3, 0x40, 0x43, 0xA5, 0x61, 0x95, 0x61, 0x97, + 0xE1, 0x84, 0x91, 0xB9, 0xD1, 0x3C, 0xA3, 0xD5, 0x46, 0x8D, 0x46, 0x0F, + 0x8C, 0x69, 0xC6, 0x5C, 0xE3, 0x24, 0xE3, 0x6D, 0xC6, 0x6D, 0xC6, 0xA3, + 0x26, 0x06, 0x26, 0x21, 0x26, 0x4B, 0x4D, 0xEA, 0x4D, 0xEE, 0x9A, 0x52, + 0x4D, 0xB9, 0xA6, 0x29, 0xA6, 0x3B, 0x4C, 0x3B, 0x4C, 0xC7, 0xCD, 0xCC, + 0xCD, 0xA2, 0xCD, 0xD6, 0x99, 0x35, 0x9B, 0x3D, 0x31, 0xD7, 0x32, 0xE7, + 0x9B, 0xE7, 0x9B, 0xD7, 0x9B, 0xDF, 0xB7, 0x60, 0x5A, 0x78, 0x5A, 0x2C, + 0xB6, 0xA8, 0xB6, 0xB8, 0x65, 0x49, 0xB2, 0xE4, 0x5A, 0xA6, 0x59, 0xEE, + 0xB6, 0xBC, 0x6E, 0x85, 0x5A, 0x39, 0x59, 0xA5, 0x58, 0x55, 0x5A, 0x5D, + 0xB3, 0x46, 0xAD, 0x9D, 0xAD, 0x25, 0xD6, 0xBB, 0xAD, 0xBB, 0xA7, 0x11, + 0xA7, 0xB9, 0x4E, 0x93, 0x4E, 0xAB, 0x9E, 0xD6, 0x67, 0xC3, 0xB0, 0xF1, + 0xB6, 0xC9, 0xB6, 0xA9, 0xB7, 0x19, 0xB0, 0xE5, 0xD8, 0x06, 0xDB, 0xAE, + 0xB6, 0x6D, 0xB6, 0x7D, 0x61, 0x67, 0x62, 0x17, 0x67, 0xB7, 0xC5, 0xAE, + 0xC3, 0xEE, 0x93, 0xBD, 0x93, 0x7D, 0xBA, 0x7D, 0x8D, 0xFD, 0x3D, 0x07, + 0x0D, 0x87, 0xD9, 0x0E, 0xAB, 0x1D, 0x5A, 0x1D, 0x7E, 0x73, 0xB4, 0x72, + 0x14, 0x3A, 0x56, 0x3A, 0xDE, 0x9A, 0xCE, 0x9C, 0xEE, 0x3F, 0x7D, 0xC5, + 0xF4, 0x96, 0xE9, 0x2F, 0x67, 0x58, 0xCF, 0x10, 0xCF, 0xD8, 0x33, 0xE3, + 0xB6, 0x13, 0xCB, 0x29, 0xC4, 0x69, 0x9D, 0x53, 0x9B, 0xD3, 0x47, 0x67, + 0x17, 0x67, 0xB9, 0x73, 0x83, 0xF3, 0x88, 0x8B, 0x89, 0x4B, 0x82, 0xCB, + 0x2E, 0x97, 0x3E, 0x2E, 0x9B, 0x1B, 0xC6, 0xDD, 0xC8, 0xBD, 0xE4, 0x4A, + 0x74, 0xF5, 0x71, 0x5D, 0xE1, 0x7A, 0xD2, 0xF5, 0x9D, 0x9B, 0xB3, 0x9B, + 0xC2, 0xED, 0xA8, 0xDB, 0xAF, 0xEE, 0x36, 0xEE, 0x69, 0xEE, 0x87, 0xDC, + 0x9F, 0xCC, 0x34, 0x9F, 0x29, 0x9E, 0x59, 0x33, 0x73, 0xD0, 0xC3, 0xC8, + 0x43, 0xE0, 0x51, 0xE5, 0xD1, 0x3F, 0x0B, 0x9F, 0x95, 0x30, 0x6B, 0xDF, + 0xAC, 0x7E, 0x4F, 0x43, 0x4F, 0x81, 0x67, 0xB5, 0xE7, 0x23, 0x2F, 0x63, + 0x2F, 0x91, 0x57, 0xAD, 0xD7, 0xB0, 0xB7, 0xA5, 0x77, 0xAA, 0xF7, 0x61, + 0xEF, 0x17, 0x3E, 0xF6, 0x3E, 0x72, 0x9F, 0xE3, 0x3E, 0xE3, 0x3C, 0x37, + 0xDE, 0x32, 0xDE, 0x59, 0x5F, 0xCC, 0x37, 0xC0, 0xB7, 0xC8, 0xB7, 0xCB, + 0x4F, 0xC3, 0x6F, 0x9E, 0x5F, 0x85, 0xDF, 0x43, 0x7F, 0x23, 0xFF, 0x64, + 0xFF, 0x7A, 0xFF, 0xD1, 0x00, 0xA7, 0x80, 0x25, 0x01, 0x67, 0x03, 0x89, + 0x81, 0x41, 0x81, 0x5B, 0x02, 0xFB, 0xF8, 0x7A, 0x7C, 0x21, 0xBF, 0x8E, + 0x3F, 0x3A, 0xDB, 0x65, 0xF6, 0xB2, 0xD9, 0xED, 0x41, 0x8C, 0xA0, 0xB9, + 0x41, 0x15, 0x41, 0x8F, 0x82, 0xAD, 0x82, 0xE5, 0xC1, 0xAD, 0x21, 0x68, + 0xC8, 0xEC, 0x90, 0xAD, 0x21, 0xF7, 0xE7, 0x98, 0xCE, 0x91, 0xCE, 0x69, + 0x0E, 0x85, 0x50, 0x7E, 0xE8, 0xD6, 0xD0, 0x07, 0x61, 0xE6, 0x61, 0x8B, + 0xC3, 0x7E, 0x0C, 0x27, 0x85, 0x87, 0x85, 0x57, 0x86, 0x3F, 0x8E, 0x70, + 0x88, 0x58, 0x1A, 0xD1, 0x31, 0x97, 0x35, 0x77, 0xD1, 0xDC, 0x43, 0x73, + 0xDF, 0x44, 0xFA, 0x44, 0x96, 0x44, 0xDE, 0x9B, 0x67, 0x31, 0x4F, 0x39, + 0xAF, 0x2D, 0x4A, 0x35, 0x2A, 0x3E, 0xAA, 0x2E, 0x6A, 0x3C, 0xDA, 0x37, + 0xBA, 0x34, 0xBA, 0x3F, 0xC6, 0x2E, 0x66, 0x59, 0xCC, 0xD5, 0x58, 0x9D, + 0x58, 0x49, 0x6C, 0x4B, 0x1C, 0x39, 0x2E, 0x2A, 0xAE, 0x36, 0x6E, 0x6C, + 0xBE, 0xDF, 0xFC, 0xED, 0xF3, 0x87, 0xE2, 0x9D, 0xE2, 0x0B, 0xE3, 0x7B, + 0x17, 0x98, 0x2F, 0xC8, 0x5D, 0x70, 0x79, 0xA1, 0xCE, 0xC2, 0xF4, 0x85, + 0xA7, 0x16, 0xA9, 0x2E, 0x12, 0x2C, 0x3A, 0x96, 0x40, 0x4C, 0x88, 0x4E, + 0x38, 0x94, 0xF0, 0x41, 0x10, 0x2A, 0xA8, 0x16, 0x8C, 0x25, 0xF2, 0x13, + 0x77, 0x25, 0x8E, 0x0A, 0x79, 0xC2, 0x1D, 0xC2, 0x67, 0x22, 0x2F, 0xD1, + 0x36, 0xD1, 0x88, 0xD8, 0x43, 0x5C, 0x2A, 0x1E, 0x4E, 0xF2, 0x48, 0x2A, + 0x4D, 0x7A, 0x92, 0xEC, 0x91, 0xBC, 0x35, 0x79, 0x24, 0xC5, 0x33, 0xA5, + 0x2C, 0xE5, 0xB9, 0x84, 0x27, 0xA9, 0x90, 0xBC, 0x4C, 0x0D, 0x4C, 0xDD, + 0x9B, 0x3A, 0x9E, 0x16, 0x9A, 0x76, 0x20, 0x6D, 0x32, 0x3D, 0x3A, 0xBD, + 0x31, 0x83, 0x92, 0x91, 0x90, 0x71, 0x42, 0xAA, 0x21, 0x4D, 0x93, 0xB6, + 0x67, 0xEA, 0x67, 0xE6, 0x66, 0x76, 0xCB, 0xAC, 0x65, 0x85, 0xB2, 0xFE, + 0xC5, 0x6E, 0x8B, 0xB7, 0x2F, 0x1E, 0x95, 0x07, 0xC9, 0x6B, 0xB3, 0x90, + 0xAC, 0x05, 0x59, 0x2D, 0x0A, 0xB6, 0x42, 0xA6, 0xE8, 0x54, 0x5A, 0x28, + 0xD7, 0x2A, 0x07, 0xB2, 0x67, 0x65, 0x57, 0x66, 0xBF, 0xCD, 0x89, 0xCA, + 0x39, 0x96, 0xAB, 0x9E, 0x2B, 0xCD, 0xED, 0xCC, 0xB3, 0xCA, 0xDB, 0x90, + 0x37, 0x9C, 0xEF, 0x9F, 0xFF, 0xED, 0x12, 0xC2, 0x12, 0xE1, 0x92, 0xB6, + 0xA5, 0x86, 0x4B, 0x57, 0x2D, 0x1D, 0x58, 0xE6, 0xBD, 0xAC, 0x6A, 0x39, + 0xB2, 0x3C, 0x71, 0x79, 0xDB, 0x0A, 0xE3, 0x15, 0x05, 0x2B, 0x86, 0x56, + 0x06, 0xAC, 0x3C, 0xB8, 0x8A, 0xB6, 0x2A, 0x6D, 0xD5, 0x4F, 0xAB, 0xED, + 0x57, 0x97, 0xAE, 0x7E, 0xBD, 0x26, 0x7A, 0x4D, 0x6B, 0x81, 0x5E, 0xC1, + 0xCA, 0x82, 0xC1, 0xB5, 0x01, 0x6B, 0xEB, 0x0B, 0x55, 0x0A, 0xE5, 0x85, + 0x7D, 0xEB, 0xDC, 0xD7, 0xED, 0x5D, 0x4F, 0x58, 0x2F, 0x59, 0xDF, 0xB5, + 0x61, 0xFA, 0x86, 0x9D, 0x1B, 0x3E, 0x15, 0x89, 0x8A, 0xAE, 0x14, 0xDB, + 0x17, 0x97, 0x15, 0x7F, 0xD8, 0x28, 0xDC, 0x78, 0xE5, 0x1B, 0x87, 0x6F, + 0xCA, 0xBF, 0x99, 0xDC, 0x94, 0xB4, 0xA9, 0xAB, 0xC4, 0xB9, 0x64, 0xCF, + 0x66, 0xD2, 0x66, 0xE9, 0xE6, 0xDE, 0x2D, 0x9E, 0x5B, 0x0E, 0x96, 0xAA, + 0x97, 0xE6, 0x97, 0x0E, 0x6E, 0x0D, 0xD9, 0xDA, 0xB4, 0x0D, 0xDF, 0x56, + 0xB4, 0xED, 0xF5, 0xF6, 0x45, 0xDB, 0x2F, 0x97, 0xCD, 0x28, 0xDB, 0xBB, + 0x83, 0xB6, 0x43, 0xB9, 0xA3, 0xBF, 0x3C, 0xB8, 0xBC, 0x65, 0xA7, 0xC9, + 0xCE, 0xCD, 0x3B, 0x3F, 0x54, 0xA4, 0x54, 0xF4, 0x54, 0xFA, 0x54, 0x36, + 0xEE, 0xD2, 0xDD, 0xB5, 0x61, 0xD7, 0xF8, 0x6E, 0xD1, 0xEE, 0x1B, 0x7B, + 0xBC, 0xF6, 0x34, 0xEC, 0xD5, 0xDB, 0x5B, 0xBC, 0xF7, 0xFD, 0x3E, 0xC9, + 0xBE, 0xDB, 0x55, 0x01, 0x55, 0x4D, 0xD5, 0x66, 0xD5, 0x65, 0xFB, 0x49, + 0xFB, 0xB3, 0xF7, 0x3F, 0xAE, 0x89, 0xAA, 0xE9, 0xF8, 0x96, 0xFB, 0x6D, + 0x5D, 0xAD, 0x4E, 0x6D, 0x71, 0xED, 0xC7, 0x03, 0xD2, 0x03, 0xFD, 0x07, + 0x23, 0x0E, 0xB6, 0xD7, 0xB9, 0xD4, 0xD5, 0x1D, 0xD2, 0x3D, 0x54, 0x52, + 0x8F, 0xD6, 0x2B, 0xEB, 0x47, 0x0E, 0xC7, 0x1F, 0xBE, 0xFE, 0x9D, 0xEF, + 0x77, 0x2D, 0x0D, 0x36, 0x0D, 0x55, 0x8D, 0x9C, 0xC6, 0xE2, 0x23, 0x70, + 0x44, 0x79, 0xE4, 0xE9, 0xF7, 0x09, 0xDF, 0xF7, 0x1E, 0x0D, 0x3A, 0xDA, + 0x76, 0x8C, 0x7B, 0xAC, 0xE1, 0x07, 0xD3, 0x1F, 0x76, 0x1D, 0x67, 0x1D, + 0x2F, 0x6A, 0x42, 0x9A, 0xF2, 0x9A, 0x46, 0x9B, 0x53, 0x9A, 0xFB, 0x5B, + 0x62, 0x5B, 0xBA, 0x4F, 0xCC, 0x3E, 0xD1, 0xD6, 0xEA, 0xDE, 0x7A, 0xFC, + 0x47, 0xDB, 0x1F, 0x0F, 0x9C, 0x34, 0x3C, 0x59, 0x79, 0x4A, 0xF3, 0x54, + 0xC9, 0x69, 0xDA, 0xE9, 0x82, 0xD3, 0x93, 0x67, 0xF2, 0xCF, 0x8C, 0x9D, + 0x95, 0x9D, 0x7D, 0x7E, 0x2E, 0xF9, 0xDC, 0x60, 0xDB, 0xA2, 0xB6, 0x7B, + 0xE7, 0x63, 0xCE, 0xDF, 0x6A, 0x0F, 0x6F, 0xEF, 0xBA, 0x10, 0x74, 0xE1, + 0xD2, 0x45, 0xFF, 0x8B, 0xE7, 0x3B, 0xBC, 0x3B, 0xCE, 0x5C, 0xF2, 0xB8, + 0x74, 0xF2, 0xB2, 0xDB, 0xE5, 0x13, 0x57, 0xB8, 0x57, 0x9A, 0xAF, 0x3A, + 0x5F, 0x6D, 0xEA, 0x74, 0xEA, 0x3C, 0xFE, 0x93, 0xD3, 0x4F, 0xC7, 0xBB, + 0x9C, 0xBB, 0x9A, 0xAE, 0xB9, 0x5C, 0x6B, 0xB9, 0xEE, 0x7A, 0xBD, 0xB5, + 0x7B, 0x66, 0xF7, 0xE9, 0x1B, 0x9E, 0x37, 0xCE, 0xDD, 0xF4, 0xBD, 0x79, + 0xF1, 0x16, 0xFF, 0xD6, 0xD5, 0x9E, 0x39, 0x3D, 0xDD, 0xBD, 0xF3, 0x7A, + 0x6F, 0xF7, 0xC5, 0xF7, 0xF5, 0xDF, 0x16, 0xDD, 0x7E, 0x72, 0x27, 0xFD, + 0xCE, 0xCB, 0xBB, 0xD9, 0x77, 0x27, 0xEE, 0xAD, 0xBC, 0x4F, 0xBC, 0x5F, + 0xF4, 0x40, 0xED, 0x41, 0xD9, 0x43, 0xDD, 0x87, 0xD5, 0x3F, 0x5B, 0xFE, + 0xDC, 0xD8, 0xEF, 0xDC, 0x7F, 0x6A, 0xC0, 0x77, 0xA0, 0xF3, 0xD1, 0xDC, + 0x47, 0xF7, 0x06, 0x85, 0x83, 0xCF, 0xFE, 0x91, 0xF5, 0x8F, 0x0F, 0x43, + 0x05, 0x8F, 0x99, 0x8F, 0xCB, 0x86, 0x0D, 0x86, 0xEB, 0x9E, 0x38, 0x3E, + 0x39, 0x39, 0xE2, 0x3F, 0x72, 0xFD, 0xE9, 0xFC, 0xA7, 0x43, 0xCF, 0x64, + 0xCF, 0x26, 0x9E, 0x17, 0xFE, 0xA2, 0xFE, 0xCB, 0xAE, 0x17, 0x16, 0x2F, + 0x7E, 0xF8, 0xD5, 0xEB, 0xD7, 0xCE, 0xD1, 0x98, 0xD1, 0xA1, 0x97, 0xF2, + 0x97, 0x93, 0xBF, 0x6D, 0x7C, 0xA5, 0xFD, 0xEA, 0xC0, 0xEB, 0x19, 0xAF, + 0xDB, 0xC6, 0xC2, 0xC6, 0x1E, 0xBE, 0xC9, 0x78, 0x33, 0x31, 0x5E, 0xF4, + 0x56, 0xFB, 0xED, 0xC1, 0x77, 0xDC, 0x77, 0x1D, 0xEF, 0xA3, 0xDF, 0x0F, + 0x4F, 0xE4, 0x7C, 0x20, 0x7F, 0x28, 0xFF, 0x68, 0xF9, 0xB1, 0xF5, 0x53, + 0xD0, 0xA7, 0xFB, 0x93, 0x19, 0x93, 0x93, 0xFF, 0x04, 0x03, 0x98, 0xF3, + 0xFC, 0x63, 0x33, 0x2D, 0xDB, 0x00, 0x00, 0x3A, 0xFD, 0x69, 0x54, 0x58, + 0x74, 0x58, 0x4D, 0x4C, 0x3A, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x78, 0x6D, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D, + 0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, + 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63, 0x7A, 0x6B, 0x63, 0x39, + 0x64, 0x22, 0x3F, 0x3E, 0x0A, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, + 0x65, 0x74, 0x61, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, + 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65, + 0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, + 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x58, 0x4D, 0x50, 0x20, + 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, + 0x38, 0x20, 0x37, 0x39, 0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, + 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D, + 0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, + 0x31, 0x39, 0x39, 0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, + 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E, 0x73, + 0x23, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, + 0x3D, 0x22, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x6D, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, + 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, + 0x6E, 0x73, 0x3A, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3D, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, + 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, + 0x30, 0x2F, 0x6D, 0x6D, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, + 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, + 0x73, 0x54, 0x79, 0x70, 0x65, 0x2F, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x23, 0x22, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, + 0x6C, 0x6E, 0x73, 0x3A, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x2F, 0x31, 0x2E, 0x30, + 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x64, 0x63, 0x3D, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x70, 0x75, 0x72, 0x6C, + 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x64, 0x63, 0x2F, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2F, 0x31, 0x2E, 0x31, 0x2F, 0x22, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, + 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x74, 0x69, 0x66, 0x66, 0x3D, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x2F, + 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, + 0x65, 0x78, 0x69, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, + 0x6D, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6F, 0x72, 0x54, + 0x6F, 0x6F, 0x6C, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, + 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, + 0x29, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6F, 0x72, 0x54, 0x6F, 0x6F, 0x6C, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, + 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, + 0x30, 0x3A, 0x31, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, + 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, + 0x31, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, + 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, + 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, 0x31, 0x33, + 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, + 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x61, + 0x36, 0x61, 0x62, 0x64, 0x39, 0x62, 0x36, 0x2D, 0x34, 0x65, 0x35, 0x37, + 0x2D, 0x33, 0x63, 0x34, 0x63, 0x2D, 0x61, 0x37, 0x38, 0x30, 0x2D, 0x63, + 0x62, 0x30, 0x63, 0x32, 0x33, 0x65, 0x39, 0x30, 0x61, 0x31, 0x64, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, + 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x44, + 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x3E, 0x61, 0x64, + 0x6F, 0x62, 0x65, 0x3A, 0x64, 0x6F, 0x63, 0x69, 0x64, 0x3A, 0x70, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x66, 0x66, 0x37, 0x34, + 0x35, 0x33, 0x62, 0x38, 0x2D, 0x33, 0x35, 0x62, 0x34, 0x2D, 0x31, 0x31, + 0x65, 0x38, 0x2D, 0x39, 0x31, 0x61, 0x34, 0x2D, 0x38, 0x38, 0x34, 0x37, + 0x30, 0x37, 0x30, 0x65, 0x31, 0x35, 0x34, 0x62, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, + 0x69, 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x34, + 0x34, 0x35, 0x36, 0x39, 0x37, 0x37, 0x61, 0x2D, 0x38, 0x38, 0x64, 0x63, + 0x2D, 0x37, 0x37, 0x34, 0x33, 0x2D, 0x61, 0x35, 0x37, 0x63, 0x2D, 0x63, + 0x65, 0x38, 0x65, 0x34, 0x36, 0x31, 0x36, 0x62, 0x63, 0x63, 0x37, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, 0x69, + 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, + 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, + 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, + 0x20, 0x72, 0x64, 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x3D, 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, + 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x34, 0x34, 0x35, 0x36, 0x39, 0x37, + 0x37, 0x61, 0x2D, 0x38, 0x38, 0x64, 0x63, 0x2D, 0x37, 0x37, 0x34, 0x33, + 0x2D, 0x61, 0x35, 0x37, 0x63, 0x2D, 0x63, 0x65, 0x38, 0x65, 0x34, 0x36, + 0x31, 0x36, 0x62, 0x63, 0x63, 0x37, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, + 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, + 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, + 0x3A, 0x31, 0x33, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, + 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, + 0x74, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, + 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, + 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x20, 0x72, 0x64, + 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3D, + 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, + 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x73, 0x61, 0x76, 0x65, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, + 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, + 0x3A, 0x61, 0x36, 0x61, 0x62, 0x64, 0x39, 0x62, 0x36, 0x2D, 0x34, 0x65, + 0x35, 0x37, 0x2D, 0x33, 0x63, 0x34, 0x63, 0x2D, 0x61, 0x37, 0x38, 0x30, + 0x2D, 0x63, 0x62, 0x30, 0x63, 0x32, 0x33, 0x65, 0x39, 0x30, 0x61, 0x31, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, + 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, + 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, + 0x31, 0x54, 0x32, 0x32, 0x3A, 0x30, 0x30, 0x3A, 0x31, 0x33, 0x2B, 0x30, + 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x41, 0x64, 0x6F, + 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, + 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, + 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x64, 0x3E, 0x2F, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, + 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, + 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, 0x67, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x39, 0x30, 0x39, 0x62, 0x39, 0x65, + 0x35, 0x32, 0x2D, 0x39, 0x37, 0x62, 0x64, 0x2D, 0x34, 0x32, 0x39, 0x33, + 0x2D, 0x38, 0x30, 0x64, 0x32, 0x2D, 0x31, 0x31, 0x64, 0x65, 0x62, 0x64, + 0x36, 0x61, 0x33, 0x33, 0x65, 0x62, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, + 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, + 0x67, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, + 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, + 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, + 0x6F, 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, + 0x3E, 0x33, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x49, 0x43, 0x43, + 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, 0x73, 0x52, 0x47, 0x42, + 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, + 0x31, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x3A, 0x49, 0x43, 0x43, 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, + 0x63, 0x3A, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0x2F, 0x70, 0x6E, 0x67, 0x3C, 0x2F, 0x64, 0x63, 0x3A, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, + 0x69, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, 0x69, 0x65, 0x6E, 0x74, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, + 0x3E, 0x32, 0x3C, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, + 0x63, 0x65, 0x3E, 0x31, 0x3C, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x3A, 0x43, + 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, 0x63, 0x65, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, + 0x6D, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, 0x66, 0x3A, + 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x0A, 0x3C, 0x2F, + 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x64, + 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0xCB, 0xA4, 0xEC, 0x39, 0x00, 0x00, + 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x25, 0x00, 0x00, + 0x80, 0x83, 0x00, 0x00, 0xF9, 0xFF, 0x00, 0x00, 0x80, 0xE9, 0x00, 0x00, + 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, + 0x17, 0x6F, 0x92, 0x5F, 0xC5, 0x46, 0x00, 0x00, 0x0A, 0x48, 0x49, 0x44, + 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9D, 0x6B, 0x8C, 0x5D, 0x55, 0x15, 0xC7, + 0x7F, 0xF7, 0xDE, 0x79, 0xF7, 0xE1, 0xB4, 0xB4, 0xA5, 0x6F, 0x3A, 0xA5, + 0x28, 0x32, 0xA5, 0x9D, 0x92, 0x52, 0x04, 0x15, 0x94, 0x8A, 0x90, 0x5A, + 0x2D, 0x11, 0xA2, 0x35, 0x4A, 0x04, 0xF1, 0x91, 0xF8, 0xC2, 0x10, 0xEB, + 0x2B, 0xD1, 0xF8, 0x41, 0xE1, 0x83, 0xD1, 0x84, 0x48, 0x22, 0x31, 0x8A, + 0x04, 0x11, 0xD4, 0x08, 0x0D, 0x6D, 0xAC, 0x96, 0x48, 0x85, 0xAA, 0xA1, + 0x45, 0x91, 0x42, 0x5B, 0xEB, 0x4C, 0x87, 0x16, 0x28, 0xED, 0x40, 0xA7, + 0xD3, 0x4E, 0x3B, 0x73, 0x67, 0xDA, 0x79, 0xDC, 0xED, 0x87, 0xB5, 0x4E, + 0xE8, 0x87, 0xCA, 0xD9, 0x67, 0xEE, 0xB9, 0xF7, 0xEC, 0x73, 0xCF, 0xFE, + 0x27, 0x27, 0x43, 0xE1, 0xD0, 0x39, 0xF7, 0xFE, 0xCE, 0xDE, 0x7B, 0xAD, + 0xFF, 0x5E, 0x7B, 0xEF, 0x9C, 0x31, 0x06, 0xAF, 0xDA, 0x55, 0xDE, 0x7F, + 0x05, 0x1E, 0xB0, 0x97, 0x07, 0xEC, 0xE5, 0x01, 0x7B, 0x79, 0xC0, 0x5E, + 0xF1, 0xAB, 0xCE, 0xC1, 0x67, 0xCA, 0x01, 0x05, 0x7D, 0xF9, 0xEA, 0x80, + 0x7A, 0xFD, 0x73, 0xCE, 0x91, 0xE7, 0x2B, 0x01, 0x63, 0x7A, 0x8D, 0x9F, + 0x75, 0x79, 0xC0, 0x21, 0x6A, 0x01, 0x26, 0x01, 0x8B, 0x81, 0x99, 0xFA, + 0xCF, 0xD3, 0x80, 0xA9, 0xFA, 0xDF, 0x1A, 0x1C, 0xE8, 0x71, 0x4A, 0xC0, + 0x19, 0xA0, 0x08, 0x9C, 0x04, 0x4E, 0xE9, 0xCF, 0xFD, 0xC0, 0x09, 0xE0, + 0x34, 0x30, 0xE4, 0x01, 0xBF, 0xA9, 0x06, 0x60, 0x06, 0xB0, 0x10, 0xB8, + 0x4C, 0x7F, 0xAE, 0x02, 0xCE, 0x07, 0x9A, 0x80, 0x29, 0x0A, 0xBA, 0xC1, + 0xA1, 0x97, 0x71, 0x54, 0x41, 0x16, 0x15, 0x66, 0x11, 0xF8, 0x2F, 0xD0, + 0x09, 0xBC, 0x06, 0xFC, 0x13, 0x38, 0x02, 0xF4, 0xE9, 0xBD, 0xC9, 0x76, + 0x87, 0x09, 0x19, 0x1D, 0x8D, 0xC0, 0x3C, 0xE0, 0x72, 0xE0, 0x6A, 0xA0, + 0x1D, 0xB8, 0x44, 0x5B, 0x6E, 0x5A, 0x35, 0x0E, 0x1C, 0x05, 0xF6, 0x02, + 0xBB, 0x81, 0xED, 0xC0, 0xBF, 0x81, 0xD7, 0x81, 0x91, 0xAC, 0x00, 0xAE, + 0xD7, 0xD6, 0x79, 0x35, 0x70, 0x3D, 0x70, 0x15, 0xB0, 0xA4, 0x46, 0xE3, + 0x9B, 0x7D, 0xC0, 0x53, 0xC0, 0x36, 0xE0, 0xEF, 0xC0, 0x31, 0x1D, 0xB7, + 0x6B, 0x16, 0x70, 0x8B, 0x82, 0x5D, 0x03, 0xAC, 0x05, 0xDA, 0x32, 0x12, + 0xC8, 0x76, 0x02, 0x9B, 0x80, 0xAD, 0xC0, 0x3F, 0xB4, 0x7B, 0xAF, 0x39, + 0xC0, 0x0B, 0x80, 0x1B, 0x80, 0xDB, 0x75, 0x8C, 0xCD, 0x91, 0x2D, 0x8D, + 0x6A, 0x97, 0xFD, 0x00, 0xB0, 0x59, 0x03, 0xB3, 0x9A, 0x08, 0xB2, 0x72, + 0xC0, 0x3B, 0x81, 0xCF, 0x00, 0xEB, 0x75, 0xDC, 0xCD, 0xA2, 0xEA, 0x81, + 0xD5, 0xC0, 0x05, 0xC0, 0x6C, 0xE0, 0x31, 0xE0, 0x40, 0xDA, 0x5B, 0x70, + 0x0E, 0xE8, 0x00, 0xEE, 0x04, 0x6E, 0x02, 0x9A, 0xBD, 0xED, 0x00, 0x9A, + 0x4E, 0xFD, 0x06, 0xF8, 0x29, 0xD0, 0x95, 0x66, 0xC0, 0xCB, 0x81, 0xEF, + 0x2A, 0xDC, 0x38, 0x64, 0x34, 0x0F, 0x4D, 0xCA, 0x54, 0x28, 0xE8, 0x65, + 0x62, 0x18, 0x62, 0x86, 0x81, 0x07, 0x81, 0x9F, 0x54, 0x1A, 0x72, 0x5D, + 0x85, 0x5A, 0xEE, 0xDB, 0x81, 0x0D, 0x65, 0xC0, 0x1D, 0x51, 0x13, 0xE1, + 0x18, 0x30, 0x70, 0x56, 0x9A, 0x31, 0x08, 0xF4, 0x27, 0x60, 0x78, 0x94, + 0x80, 0x56, 0x60, 0xB2, 0xFE, 0xB9, 0x59, 0x73, 0xF4, 0xF3, 0xF4, 0xDF, + 0x35, 0x44, 0xFC, 0xFB, 0x9A, 0x81, 0x4F, 0xEB, 0xD8, 0xFC, 0x63, 0xE0, + 0xE5, 0x34, 0x01, 0x6E, 0x03, 0xEE, 0xD0, 0x31, 0x37, 0x6A, 0x0B, 0xED, + 0x07, 0x5E, 0xD2, 0xB7, 0xFA, 0x45, 0xFD, 0xD9, 0x8F, 0xB8, 0x47, 0x39, + 0x35, 0x15, 0x8A, 0x09, 0xB5, 0xE0, 0x49, 0x9A, 0x09, 0xE4, 0xD4, 0x84, + 0x99, 0x0E, 0xBC, 0x03, 0x58, 0x06, 0x2C, 0xD5, 0xF8, 0x62, 0x6A, 0x84, + 0xBF, 0xAF, 0x09, 0xB8, 0x4D, 0x3F, 0xCF, 0x5D, 0xFA, 0x42, 0x3B, 0x0F, + 0xB8, 0x19, 0xB8, 0x05, 0xB8, 0x55, 0xBB, 0x33, 0x5B, 0x0D, 0x02, 0xCF, + 0x01, 0x4F, 0x03, 0x7F, 0x05, 0x5E, 0x01, 0x5E, 0xC5, 0x61, 0x8F, 0x57, + 0xD5, 0x00, 0x2C, 0xD2, 0x58, 0x63, 0x25, 0xF0, 0x7E, 0x35, 0x6C, 0x5A, + 0x22, 0xBC, 0x34, 0x9F, 0x47, 0x9C, 0xB0, 0x87, 0x2A, 0x91, 0x27, 0xC7, + 0x39, 0x06, 0xE7, 0x81, 0x0F, 0x03, 0xF7, 0x02, 0xF3, 0x2D, 0xFF, 0x9F, + 0x31, 0x85, 0xF9, 0x47, 0xE0, 0x11, 0xC4, 0x01, 0x2A, 0x92, 0x4E, 0xB5, + 0x2A, 0xE8, 0xF5, 0x9A, 0xEB, 0xCF, 0x8F, 0x30, 0x56, 0xEF, 0x56, 0xD0, + 0x3B, 0x5C, 0x6E, 0xC1, 0x41, 0xD7, 0x6C, 0x0B, 0x77, 0x58, 0x73, 0xC3, + 0x5F, 0x03, 0x4F, 0x00, 0xBD, 0x29, 0x8F, 0x8E, 0xFB, 0x11, 0xE7, 0xAA, + 0x0B, 0x78, 0x5E, 0xC7, 0xD8, 0x95, 0x9A, 0x22, 0x85, 0xE9, 0x52, 0xE0, + 0x73, 0x3A, 0x3C, 0xC5, 0xFB, 0x3D, 0x18, 0x63, 0xE2, 0xB8, 0xEA, 0x8C, + 0x31, 0x5F, 0x37, 0xC6, 0x8C, 0x19, 0x3B, 0x0D, 0x18, 0x63, 0x1E, 0x36, + 0xC6, 0xAC, 0x8A, 0xE9, 0xF7, 0xBB, 0x78, 0xAD, 0x36, 0xC6, 0x6C, 0x31, + 0xC6, 0x8C, 0x58, 0x7E, 0x27, 0xC7, 0x8D, 0x31, 0xB7, 0x1A, 0x63, 0x0A, + 0x71, 0x3E, 0x47, 0x5C, 0x2D, 0xF8, 0x22, 0xE0, 0x13, 0x96, 0xE3, 0xEE, + 0x88, 0x5A, 0x77, 0x77, 0x03, 0x7B, 0x6A, 0x38, 0xDF, 0x7D, 0x52, 0x87, + 0x9B, 0x3C, 0x70, 0x9D, 0x45, 0xE4, 0x3F, 0x0D, 0xF8, 0x24, 0xF0, 0x37, + 0x6D, 0xC9, 0xB1, 0x8D, 0x9B, 0x71, 0x04, 0x56, 0x6B, 0x35, 0xEF, 0xB5, + 0xD1, 0x36, 0xE0, 0x47, 0x35, 0x0E, 0x37, 0xD0, 0x0E, 0x8D, 0x90, 0x9F, + 0xB7, 0xBC, 0xFF, 0x5D, 0xC0, 0x35, 0xC4, 0x68, 0xE5, 0xC6, 0x01, 0xF8, + 0x02, 0xE0, 0x66, 0xCB, 0xD6, 0xDB, 0xA5, 0x2D, 0x77, 0x57, 0x86, 0x9C, + 0xAB, 0xED, 0xC0, 0x3D, 0xC0, 0x1B, 0x16, 0xF7, 0x4E, 0x46, 0x3C, 0xFB, + 0x69, 0xAE, 0x00, 0xCE, 0x6B, 0x80, 0xD0, 0x61, 0x71, 0xEF, 0x10, 0xF0, + 0x0B, 0xFD, 0xC0, 0x59, 0xD3, 0x63, 0x9A, 0x06, 0xD9, 0xA4, 0x7D, 0xD7, + 0x68, 0x7E, 0xED, 0x04, 0xE0, 0xC9, 0x9A, 0xFB, 0xD9, 0x38, 0x39, 0x3B, + 0xF5, 0x43, 0x66, 0x51, 0x45, 0xE0, 0x3E, 0x64, 0x8E, 0x38, 0x4C, 0xB3, + 0x90, 0x79, 0xF2, 0x7A, 0x17, 0x00, 0xB7, 0x02, 0xD7, 0x5A, 0x06, 0x56, + 0xBF, 0x05, 0x7A, 0xC8, 0xAE, 0xBA, 0x35, 0xD7, 0xB7, 0xD1, 0x07, 0x22, + 0xBA, 0x62, 0x15, 0x03, 0x3C, 0x0B, 0xBB, 0x29, 0xC0, 0xBD, 0xC8, 0x84, + 0x77, 0xD6, 0xB5, 0x11, 0xA9, 0xD7, 0x0A, 0xD3, 0xF2, 0xB8, 0xC6, 0xE1, + 0x72, 0x01, 0x2F, 0x43, 0xEA, 0xAB, 0xC2, 0xF4, 0x27, 0xA4, 0x20, 0x2D, + 0x97, 0x61, 0xB8, 0x39, 0xA4, 0xFA, 0xF2, 0x2F, 0x16, 0xF7, 0x4E, 0x05, + 0xE6, 0xBA, 0x00, 0xF8, 0x0A, 0x8B, 0xB1, 0x62, 0x14, 0x78, 0x46, 0x03, + 0x8C, 0x2C, 0x2F, 0x65, 0x34, 0x88, 0x35, 0xFB, 0xB4, 0xC5, 0xBD, 0x4D, + 0xC0, 0x8A, 0xA4, 0x01, 0xD7, 0x21, 0xD5, 0x09, 0x61, 0x3A, 0x40, 0x05, + 0xA7, 0xC3, 0x52, 0xA8, 0x43, 0x84, 0xFB, 0xED, 0x05, 0xED, 0x1D, 0x13, + 0x05, 0xDC, 0x64, 0x19, 0xE9, 0xED, 0xB5, 0x1C, 0x77, 0xDE, 0xAA, 0x6B, + 0x73, 0xB1, 0xBB, 0x2D, 0x07, 0xB0, 0x4D, 0xB9, 0xCE, 0x14, 0xA2, 0xCD, + 0xC8, 0xFD, 0xDF, 0x56, 0x38, 0x51, 0xD5, 0x63, 0x57, 0x86, 0xD3, 0x8B, + 0xCC, 0xE7, 0x46, 0x4D, 0xBF, 0xDA, 0x78, 0xB3, 0x00, 0xBE, 0xE4, 0x18, + 0xE0, 0xBC, 0xE6, 0xF5, 0x3D, 0xC0, 0x41, 0xA2, 0x55, 0x4A, 0x1E, 0x45, + 0xA6, 0x42, 0x2F, 0xB5, 0xB8, 0xB7, 0x40, 0x99, 0x53, 0xA6, 0xE5, 0x00, + 0x2E, 0x58, 0xE6, 0xBF, 0x51, 0xAB, 0xFB, 0xE7, 0x00, 0x1F, 0xD3, 0x54, + 0x61, 0x81, 0x02, 0x36, 0x0E, 0xB6, 0xE0, 0x21, 0x6D, 0x89, 0x9B, 0x80, + 0x47, 0xB1, 0x9F, 0xE6, 0x34, 0xC8, 0x4C, 0x9A, 0x0D, 0x9B, 0x7C, 0x92, + 0x2D, 0x38, 0x6F, 0xF9, 0x00, 0x51, 0x82, 0xAB, 0xA0, 0x94, 0xE5, 0x6B, + 0xDA, 0x7A, 0x5D, 0xD7, 0x0A, 0xC4, 0xC5, 0x1B, 0x57, 0xC8, 0xA7, 0x2D, + 0x5F, 0x8E, 0xAA, 0x0D, 0x4D, 0xF9, 0x18, 0xDE, 0xE4, 0x38, 0x75, 0x31, + 0x32, 0xF1, 0x9D, 0x06, 0xB8, 0x81, 0x2E, 0x04, 0xBE, 0x8A, 0x78, 0xF2, + 0x71, 0x47, 0xDD, 0x89, 0x03, 0x8E, 0x5B, 0x1D, 0x48, 0x09, 0x4C, 0xDA, + 0xB4, 0x14, 0xFB, 0x25, 0x38, 0xB9, 0x6A, 0x06, 0x8E, 0xAE, 0x01, 0x6E, + 0x75, 0x30, 0xA0, 0xB2, 0xD1, 0x98, 0x46, 0xBD, 0xCE, 0xC9, 0x35, 0xC0, + 0xBD, 0xB8, 0x5F, 0x68, 0x77, 0x2E, 0x8D, 0x00, 0xC7, 0x3D, 0xE0, 0x70, + 0xED, 0x43, 0x4C, 0xF9, 0xB4, 0x69, 0x0F, 0x55, 0x58, 0xA5, 0x50, 0x0B, + 0x80, 0x5F, 0x42, 0x16, 0x68, 0x1D, 0x4A, 0x49, 0x4B, 0x1E, 0xD3, 0x3C, + 0xF8, 0x7E, 0xC4, 0x6B, 0x77, 0x4E, 0xAE, 0xED, 0xD1, 0xD1, 0x0F, 0xFC, + 0x0A, 0x31, 0x46, 0xDE, 0x8B, 0xAC, 0xFA, 0xAF, 0x77, 0xF0, 0x7B, 0xCB, + 0x21, 0xAB, 0x2E, 0xFE, 0x83, 0xD4, 0x50, 0x6D, 0x24, 0x81, 0xB5, 0xBF, + 0x69, 0x04, 0x8C, 0x7E, 0x71, 0x3F, 0x07, 0xB6, 0x00, 0x57, 0x22, 0xC5, + 0xE1, 0x2E, 0x02, 0xEE, 0xD2, 0x1E, 0xA7, 0x87, 0xE8, 0x4E, 0x5D, 0xA6, + 0x01, 0xA3, 0x86, 0x41, 0xB7, 0x5E, 0x05, 0x47, 0x9F, 0x31, 0x15, 0xC1, + 0x60, 0x5D, 0x0A, 0x9E, 0x31, 0x8D, 0x51, 0xB5, 0x0F, 0xB2, 0xBC, 0x3C, + 0x60, 0x2F, 0x0F, 0xD8, 0xCB, 0x03, 0xF6, 0x80, 0xBD, 0x3C, 0x60, 0x2F, + 0x0F, 0xD8, 0xCB, 0x03, 0xF6, 0x4A, 0x40, 0x69, 0x30, 0x3A, 0x5C, 0xAD, + 0xAA, 0x2C, 0x79, 0xC0, 0x13, 0xD7, 0x64, 0x64, 0x51, 0xF9, 0x6C, 0xC4, + 0x8B, 0xCE, 0xE1, 0x4E, 0xE1, 0x5D, 0x00, 0xF7, 0x14, 0xB2, 0x93, 0xEC, + 0x7E, 0xAA, 0xBC, 0xFF, 0x64, 0xDA, 0x01, 0xCF, 0x45, 0xAA, 0x2A, 0x3F, + 0x88, 0x54, 0x55, 0x36, 0x3B, 0x0A, 0x78, 0x10, 0x29, 0x7F, 0xDD, 0x08, + 0xFC, 0x1E, 0xC7, 0x36, 0x02, 0x77, 0x15, 0x70, 0x13, 0x52, 0x55, 0x79, + 0x07, 0xE9, 0x28, 0xBC, 0xEB, 0x40, 0xEA, 0x9B, 0x47, 0x81, 0x3F, 0xE0, + 0xE0, 0xAC, 0x92, 0x6B, 0x41, 0x56, 0xB0, 0x71, 0x69, 0x9A, 0xAA, 0x2A, + 0xDB, 0x80, 0x2F, 0xE1, 0x68, 0xB1, 0xA0, 0x8B, 0x55, 0x95, 0x69, 0xDC, + 0x47, 0xBA, 0x1D, 0x29, 0x9F, 0xF5, 0x80, 0x43, 0xD4, 0x9A, 0xE2, 0x8C, + 0xC4, 0x57, 0x55, 0x5A, 0xA8, 0x17, 0x47, 0x4B, 0x5F, 0x42, 0x34, 0x82, + 0x6C, 0x13, 0xEC, 0x01, 0x87, 0x68, 0x2F, 0xB2, 0x6F, 0x63, 0xDA, 0xB4, + 0x0B, 0xBB, 0xFD, 0x37, 0x32, 0x0F, 0xB8, 0x1B, 0x29, 0xBA, 0x7B, 0x85, + 0x74, 0x54, 0x72, 0x8C, 0x6A, 0x1E, 0x7C, 0x3F, 0x70, 0xD8, 0xA7, 0x49, + 0xE1, 0x1A, 0x40, 0xF6, 0xAE, 0x3C, 0x83, 0xEC, 0xDE, 0x73, 0x19, 0xD1, + 0xF7, 0x62, 0xAE, 0x96, 0x86, 0x91, 0x9D, 0x83, 0x9E, 0x42, 0x56, 0x18, + 0x96, 0x3C, 0x60, 0x3B, 0x1D, 0x47, 0x6A, 0xA3, 0x9F, 0x44, 0x36, 0xF3, + 0x6C, 0x71, 0x14, 0xF0, 0x00, 0x72, 0x08, 0xD6, 0x61, 0x12, 0x3C, 0x17, + 0x29, 0x8D, 0x80, 0x41, 0xAC, 0xBF, 0xFD, 0x7A, 0xF9, 0xAA, 0xCA, 0x1A, + 0x04, 0x9C, 0xBA, 0x2F, 0xD2, 0x55, 0xF9, 0xE9, 0x42, 0x0F, 0xD8, 0xCB, + 0x03, 0xF6, 0xF2, 0x80, 0xBD, 0x3C, 0x60, 0x2F, 0x0F, 0xD8, 0xCB, 0x03, + 0xF6, 0xF2, 0x80, 0xB3, 0xA4, 0x34, 0x18, 0x1D, 0x2E, 0x3A, 0x59, 0xC1, + 0x41, 0x99, 0x1E, 0xF0, 0x04, 0x35, 0x05, 0x39, 0xB7, 0x60, 0x0E, 0x6E, + 0xAE, 0xF0, 0x37, 0x88, 0x17, 0xDD, 0x83, 0x4C, 0x6F, 0x0E, 0x7B, 0xC0, + 0xF6, 0x9A, 0x07, 0x7C, 0x1C, 0xB8, 0x5E, 0x01, 0x37, 0x39, 0xFA, 0xDD, + 0x0D, 0x22, 0xBB, 0xE8, 0x3E, 0x8E, 0x9C, 0x07, 0xEC, 0xAB, 0x2A, 0x2D, + 0xD4, 0x88, 0x1C, 0x6C, 0xF9, 0x65, 0xEC, 0xF6, 0xA2, 0x4E, 0x5A, 0x2B, + 0x90, 0x7A, 0xAC, 0x21, 0xEC, 0xF7, 0xAA, 0xCC, 0x74, 0x90, 0x75, 0x09, + 0x52, 0x36, 0x9B, 0x06, 0xB8, 0x81, 0x16, 0xE1, 0xAB, 0x2A, 0xAD, 0xD5, + 0x81, 0xA3, 0xD5, 0x89, 0x21, 0x6A, 0x07, 0x16, 0x7B, 0xC0, 0xE1, 0x6A, + 0x25, 0x9D, 0x07, 0x77, 0xE4, 0x88, 0xE9, 0x18, 0x9C, 0x5A, 0x07, 0xDC, + 0x8B, 0xC3, 0xD5, 0x11, 0x6F, 0xA1, 0x33, 0xF8, 0xBD, 0x2A, 0xAD, 0xB4, + 0x0F, 0xE8, 0x4C, 0x21, 0xE0, 0x5D, 0xD4, 0x68, 0x55, 0x65, 0xDC, 0x0B, + 0xC2, 0xBA, 0x90, 0x0A, 0xC5, 0x83, 0x29, 0x31, 0x12, 0xC6, 0x34, 0x0F, + 0x8E, 0x5A, 0x55, 0x59, 0xB5, 0x85, 0x74, 0xE5, 0xA4, 0x49, 0x25, 0xEC, + 0x8A, 0xD4, 0xA3, 0xBC, 0x44, 0x41, 0x55, 0xE5, 0x10, 0xB0, 0x1A, 0x29, + 0xBA, 0x73, 0xB9, 0x6E, 0xEC, 0x59, 0xE4, 0xA0, 0xAB, 0xCD, 0x11, 0x5E, + 0x48, 0xDB, 0x23, 0x0E, 0x4C, 0xD2, 0x80, 0xC7, 0xB1, 0x3B, 0x70, 0x23, + 0xAA, 0x51, 0x71, 0x5C, 0x21, 0x6F, 0xD7, 0xA8, 0xBA, 0x11, 0x37, 0x0F, + 0xE5, 0x28, 0x22, 0xE7, 0x02, 0x1F, 0x26, 0xDA, 0xAA, 0xC2, 0x46, 0xEC, + 0xDC, 0xB9, 0x52, 0x1C, 0x9F, 0xBB, 0x1C, 0xC0, 0xA3, 0xD8, 0xB9, 0x37, + 0xE7, 0x23, 0xD6, 0xE3, 0x50, 0xC4, 0xD6, 0xD1, 0xA9, 0x5D, 0x76, 0xDE, + 0x51, 0xC0, 0x13, 0x2D, 0x06, 0x9C, 0x83, 0xDD, 0x02, 0x3B, 0x43, 0x0C, + 0xCB, 0x78, 0xCA, 0x01, 0x7C, 0xDA, 0xF2, 0xCD, 0x6D, 0x07, 0x16, 0x62, + 0x77, 0x40, 0xF2, 0xB9, 0x3E, 0x64, 0xAD, 0x55, 0x55, 0xCE, 0xB3, 0xCC, + 0x99, 0x8F, 0xC5, 0xF1, 0xD9, 0xCB, 0x09, 0xB2, 0xC6, 0xB1, 0x5B, 0x70, + 0xB5, 0x48, 0x01, 0x7B, 0x89, 0x16, 0x10, 0x7E, 0xA0, 0x67, 0x89, 0x98, + 0x4E, 0x49, 0x2F, 0x07, 0xB0, 0x01, 0x9E, 0xB3, 0xE8, 0x46, 0x0A, 0xD8, + 0x9D, 0x10, 0x9E, 0x05, 0x35, 0x03, 0xEF, 0xB1, 0xB8, 0x6F, 0x18, 0x39, + 0x26, 0x20, 0xF1, 0x34, 0x69, 0x27, 0x32, 0xAB, 0x12, 0xA6, 0xB5, 0xA4, + 0x6B, 0xD5, 0x7E, 0xA5, 0xB4, 0x54, 0xB3, 0x83, 0x30, 0xF5, 0x11, 0xD3, + 0x61, 0xDA, 0xE5, 0x02, 0x3E, 0x8C, 0xAC, 0x04, 0x0C, 0xD3, 0x32, 0xE0, + 0x43, 0x19, 0x87, 0x9B, 0x07, 0x6E, 0xC2, 0x6E, 0x22, 0xE5, 0x05, 0x85, + 0x9C, 0x38, 0xE0, 0x53, 0xC8, 0xEA, 0x3A, 0x9B, 0xDF, 0x73, 0x1B, 0x30, + 0x3D, 0xC3, 0x80, 0x57, 0x00, 0xEB, 0x2C, 0xEF, 0x7D, 0xC2, 0xB2, 0x67, + 0xAC, 0x38, 0xE0, 0xD3, 0xFA, 0x30, 0x36, 0x15, 0x0D, 0x57, 0x20, 0x73, + 0xBD, 0x0D, 0x19, 0x84, 0xDB, 0x02, 0xDC, 0x8E, 0xEC, 0xFD, 0x15, 0xA6, + 0x5E, 0xE4, 0xA0, 0x8F, 0x92, 0x0B, 0x80, 0x8D, 0x76, 0x27, 0xCF, 0x58, + 0xDC, 0x5B, 0x8F, 0x4C, 0xE4, 0xAF, 0xC9, 0x18, 0xDC, 0x7A, 0x64, 0xDF, + 0xAF, 0x9B, 0xB1, 0xAB, 0x2F, 0xDB, 0x42, 0x8C, 0x67, 0x47, 0xC5, 0x31, + 0xD9, 0xF0, 0x3A, 0xF0, 0x3B, 0x4B, 0x33, 0xA2, 0x0D, 0xF8, 0x06, 0x70, + 0x79, 0x46, 0xE0, 0x16, 0x90, 0xD2, 0xA3, 0x3B, 0x81, 0x99, 0x96, 0x43, + 0xDE, 0xE3, 0xD8, 0x1F, 0x55, 0x5B, 0x15, 0xC0, 0xE3, 0xC0, 0x9F, 0x91, + 0xC5, 0xD0, 0x36, 0xBA, 0x12, 0xF8, 0x26, 0xB2, 0x27, 0x56, 0xAD, 0xC3, + 0xBD, 0x0E, 0xD8, 0x80, 0xDD, 0x61, 0xD0, 0x00, 0xDB, 0x80, 0x1D, 0x71, + 0x47, 0x76, 0x71, 0xE8, 0x55, 0xE4, 0xAC, 0x23, 0x5B, 0x4F, 0x76, 0x1D, + 0xF0, 0x43, 0xE0, 0x06, 0xDC, 0x3C, 0xF8, 0x2A, 0x8E, 0x31, 0xF7, 0x46, + 0xE0, 0xDB, 0xC8, 0x01, 0x5F, 0x36, 0x3A, 0x01, 0x3C, 0x18, 0x57, 0x7A, + 0x14, 0x28, 0xCE, 0x99, 0x9A, 0x4D, 0xFA, 0xA1, 0xD6, 0x5A, 0xFE, 0xDE, + 0x1B, 0x35, 0x37, 0x9E, 0x05, 0x6C, 0x65, 0x62, 0x56, 0xA6, 0x8B, 0x9A, + 0xAF, 0x2F, 0xF0, 0x67, 0x89, 0x66, 0xF0, 0x3C, 0xAA, 0x2D, 0x18, 0x57, + 0x01, 0xF7, 0x02, 0xF7, 0x21, 0x1B, 0xA7, 0xCC, 0xB5, 0xB8, 0x3F, 0x07, + 0x5C, 0x05, 0xCC, 0xD0, 0x3C, 0x79, 0x0B, 0xF0, 0x22, 0xE2, 0xC1, 0xA6, + 0x51, 0xB3, 0x81, 0xE5, 0xFA, 0xE2, 0xAE, 0x21, 0x9A, 0x3D, 0xBB, 0x0B, + 0xF8, 0x19, 0x70, 0x32, 0xEE, 0x87, 0xCA, 0x19, 0x13, 0xEB, 0x44, 0xCD, + 0x24, 0xE0, 0x2B, 0xC0, 0x77, 0x88, 0xB6, 0xF3, 0xDB, 0x00, 0xB0, 0x1B, + 0x99, 0x22, 0xDC, 0x89, 0xD8, 0x74, 0x47, 0x90, 0xF2, 0x1D, 0x57, 0x37, + 0x46, 0xAB, 0x43, 0xAC, 0xC7, 0x79, 0x3A, 0xC6, 0xBE, 0x1B, 0xB1, 0x21, + 0xDB, 0x89, 0x36, 0x45, 0xFA, 0x06, 0xF0, 0x2D, 0x64, 0xE3, 0x19, 0x5C, + 0x07, 0x0C, 0x70, 0x1E, 0xF0, 0x3D, 0xE0, 0x8B, 0x13, 0xE8, 0x21, 0x4E, + 0xEA, 0x78, 0xBE, 0x07, 0xF1, 0xB9, 0x4F, 0x00, 0x47, 0x75, 0x5C, 0x72, + 0xA1, 0x56, 0x2B, 0xAF, 0x31, 0xC3, 0x5C, 0x1D, 0x5A, 0x66, 0x6A, 0x8F, + 0xB5, 0x14, 0x99, 0x44, 0x88, 0xBA, 0x0A, 0x63, 0x10, 0xB8, 0x1B, 0xB8, + 0x57, 0x23, 0xE8, 0x54, 0x00, 0x06, 0x39, 0xCF, 0xFE, 0x2E, 0x60, 0xFD, + 0x04, 0x03, 0xB9, 0x31, 0x85, 0x3B, 0x84, 0x9C, 0x48, 0x1A, 0x00, 0x36, + 0x0E, 0x01, 0x6E, 0xD5, 0x60, 0x6A, 0xFA, 0x04, 0x3F, 0xE3, 0x19, 0x1D, + 0xD2, 0x7E, 0x50, 0xC9, 0x61, 0xA9, 0x52, 0x80, 0x01, 0x2E, 0x06, 0xBE, + 0x0F, 0x7C, 0x34, 0xA6, 0x48, 0xD9, 0xA5, 0x0D, 0xC1, 0xCB, 0x55, 0x11, + 0x78, 0x48, 0x33, 0x89, 0x43, 0x15, 0x7D, 0xD8, 0x0A, 0x02, 0x06, 0x59, + 0xA9, 0xB0, 0x01, 0x31, 0xD9, 0x9D, 0xDC, 0x8D, 0x35, 0x01, 0x1D, 0x05, + 0x1E, 0x06, 0xEE, 0x01, 0x5E, 0xAE, 0xF8, 0xDB, 0x58, 0x61, 0xC0, 0x00, + 0x4B, 0x80, 0x2F, 0x20, 0x0B, 0xCA, 0x16, 0x64, 0x1C, 0x6E, 0x37, 0xF0, + 0x4B, 0xCD, 0x77, 0x8F, 0x54, 0xA5, 0xBB, 0xA9, 0x02, 0xE0, 0x20, 0x85, + 0x58, 0x07, 0xDC, 0x82, 0xD8, 0x94, 0x59, 0x9B, 0x70, 0x28, 0x22, 0x13, + 0x08, 0x8F, 0xA8, 0x5F, 0xD0, 0x5F, 0xB5, 0xF1, 0xA4, 0x4A, 0x80, 0x03, + 0x77, 0x67, 0x25, 0xF0, 0x29, 0xE0, 0x7D, 0xC8, 0x1A, 0xA4, 0x5A, 0xDF, + 0x61, 0x60, 0x54, 0x5B, 0xED, 0x56, 0x85, 0xFB, 0x02, 0x55, 0x3E, 0xD7, + 0xA1, 0x9A, 0x80, 0x03, 0x2D, 0x56, 0xD0, 0x1F, 0xD1, 0xD6, 0x1C, 0x9C, + 0xAC, 0x52, 0x6B, 0x2D, 0xF6, 0x00, 0xE2, 0xCF, 0x6F, 0x06, 0xFE, 0x05, + 0xBC, 0x96, 0x48, 0x44, 0x98, 0x00, 0x60, 0x10, 0x23, 0xFE, 0x42, 0xCD, + 0x21, 0x57, 0x29, 0xE8, 0x85, 0x88, 0x75, 0xD9, 0x98, 0x52, 0xA8, 0x43, + 0x1A, 0x40, 0x05, 0x60, 0x9F, 0x45, 0x1C, 0xAA, 0x83, 0x49, 0x66, 0x00, + 0x49, 0x01, 0x0E, 0x54, 0xA7, 0x79, 0xE4, 0x45, 0x7A, 0xAD, 0x54, 0xF0, + 0x6F, 0x53, 0xC3, 0x64, 0x0A, 0x30, 0xCD, 0x51, 0xA0, 0x7D, 0x88, 0x03, + 0xD7, 0xA7, 0x39, 0x7B, 0x27, 0x52, 0x08, 0xDF, 0xAD, 0xD7, 0x49, 0x1C, + 0x70, 0xE1, 0x92, 0x06, 0x7C, 0xB6, 0x1A, 0x10, 0x77, 0x68, 0x86, 0x9A, + 0x08, 0x33, 0x35, 0x38, 0x5B, 0x82, 0x7B, 0x4B, 0x4A, 0x8D, 0x02, 0xED, + 0x51, 0x93, 0x22, 0x38, 0x05, 0xAD, 0x0F, 0xC7, 0xAC, 0x55, 0x97, 0x00, + 0x9F, 0xAB, 0x1B, 0x6F, 0xD2, 0xD6, 0xEC, 0xE2, 0xCA, 0x86, 0x7E, 0xA4, + 0x64, 0xC9, 0xE9, 0x45, 0x72, 0x2E, 0x03, 0xF6, 0x8A, 0x41, 0x7E, 0x23, + 0x34, 0x0F, 0xD8, 0xCB, 0x03, 0xF6, 0xF2, 0x80, 0xBD, 0x92, 0xD1, 0xFF, + 0x06, 0x00, 0x3D, 0x67, 0xD1, 0x66, 0xCA, 0xCF, 0x19, 0x9B, 0x00, 0x00, + 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 +}; +} +static unsigned char* misc_icon = raw::misc; +}
\ No newline at end of file diff --git a/internal_rewrite/icons/rage.hpp b/internal_rewrite/icons/rage.hpp new file mode 100644 index 0000000..0bc349b --- /dev/null +++ b/internal_rewrite/icons/rage.hpp @@ -0,0 +1,1630 @@ +/* E:\Users\admin\Desktop\stuff\icons\rage.png (4/1/2018 9:59:32 PM) + StartOffset: 00000000, EndOffset: 00004BD9, Length: 00004BDA */ + +namespace icons { +constexpr static size_t rage_size = 19418; +namespace raw { +static unsigned char rage[19418] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x39, 0x64, 0x36, 0xD2, 0x00, 0x00, 0x00, + 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23, 0x00, 0x00, 0x2E, + 0x23, 0x01, 0x78, 0xA5, 0x3F, 0x76, 0x00, 0x00, 0x0A, 0x4F, 0x69, 0x43, + 0x43, 0x50, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, + 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x00, + 0x00, 0x78, 0xDA, 0x9D, 0x53, 0x67, 0x54, 0x53, 0xE9, 0x16, 0x3D, 0xF7, + 0xDE, 0xF4, 0x42, 0x4B, 0x88, 0x80, 0x94, 0x4B, 0x6F, 0x52, 0x15, 0x08, + 0x20, 0x52, 0x42, 0x8B, 0x80, 0x14, 0x91, 0x26, 0x2A, 0x21, 0x09, 0x10, + 0x4A, 0x88, 0x21, 0xA1, 0xD9, 0x15, 0x51, 0xC1, 0x11, 0x45, 0x45, 0x04, + 0x1B, 0xC8, 0xA0, 0x88, 0x03, 0x8E, 0x8E, 0x80, 0x8C, 0x15, 0x51, 0x2C, + 0x0C, 0x8A, 0x0A, 0xD8, 0x07, 0xE4, 0x21, 0xA2, 0x8E, 0x83, 0xA3, 0x88, + 0x8A, 0xCA, 0xFB, 0xE1, 0x7B, 0xA3, 0x6B, 0xD6, 0xBC, 0xF7, 0xE6, 0xCD, + 0xFE, 0xB5, 0xD7, 0x3E, 0xE7, 0xAC, 0xF3, 0x9D, 0xB3, 0xCF, 0x07, 0xC0, + 0x08, 0x0C, 0x96, 0x48, 0x33, 0x51, 0x35, 0x80, 0x0C, 0xA9, 0x42, 0x1E, + 0x11, 0xE0, 0x83, 0xC7, 0xC4, 0xC6, 0xE1, 0xE4, 0x2E, 0x40, 0x81, 0x0A, + 0x24, 0x70, 0x00, 0x10, 0x08, 0xB3, 0x64, 0x21, 0x73, 0xFD, 0x23, 0x01, + 0x00, 0xF8, 0x7E, 0x3C, 0x3C, 0x2B, 0x22, 0xC0, 0x07, 0xBE, 0x00, 0x01, + 0x78, 0xD3, 0x0B, 0x08, 0x00, 0xC0, 0x4D, 0x9B, 0xC0, 0x30, 0x1C, 0x87, + 0xFF, 0x0F, 0xEA, 0x42, 0x99, 0x5C, 0x01, 0x80, 0x84, 0x01, 0xC0, 0x74, + 0x91, 0x38, 0x4B, 0x08, 0x80, 0x14, 0x00, 0x40, 0x7A, 0x8E, 0x42, 0xA6, + 0x00, 0x40, 0x46, 0x01, 0x80, 0x9D, 0x98, 0x26, 0x53, 0x00, 0xA0, 0x04, + 0x00, 0x60, 0xCB, 0x63, 0x62, 0xE3, 0x00, 0x50, 0x2D, 0x00, 0x60, 0x27, + 0x7F, 0xE6, 0xD3, 0x00, 0x80, 0x9D, 0xF8, 0x99, 0x7B, 0x01, 0x00, 0x5B, + 0x94, 0x21, 0x15, 0x01, 0xA0, 0x91, 0x00, 0x20, 0x13, 0x65, 0x88, 0x44, + 0x00, 0x68, 0x3B, 0x00, 0xAC, 0xCF, 0x56, 0x8A, 0x45, 0x00, 0x58, 0x30, + 0x00, 0x14, 0x66, 0x4B, 0xC4, 0x39, 0x00, 0xD8, 0x2D, 0x00, 0x30, 0x49, + 0x57, 0x66, 0x48, 0x00, 0xB0, 0xB7, 0x00, 0xC0, 0xCE, 0x10, 0x0B, 0xB2, + 0x00, 0x08, 0x0C, 0x00, 0x30, 0x51, 0x88, 0x85, 0x29, 0x00, 0x04, 0x7B, + 0x00, 0x60, 0xC8, 0x23, 0x23, 0x78, 0x00, 0x84, 0x99, 0x00, 0x14, 0x46, + 0xF2, 0x57, 0x3C, 0xF1, 0x2B, 0xAE, 0x10, 0xE7, 0x2A, 0x00, 0x00, 0x78, + 0x99, 0xB2, 0x3C, 0xB9, 0x24, 0x39, 0x45, 0x81, 0x5B, 0x08, 0x2D, 0x71, + 0x07, 0x57, 0x57, 0x2E, 0x1E, 0x28, 0xCE, 0x49, 0x17, 0x2B, 0x14, 0x36, + 0x61, 0x02, 0x61, 0x9A, 0x40, 0x2E, 0xC2, 0x79, 0x99, 0x19, 0x32, 0x81, + 0x34, 0x0F, 0xE0, 0xF3, 0xCC, 0x00, 0x00, 0xA0, 0x91, 0x15, 0x11, 0xE0, + 0x83, 0xF3, 0xFD, 0x78, 0xCE, 0x0E, 0xAE, 0xCE, 0xCE, 0x36, 0x8E, 0xB6, + 0x0E, 0x5F, 0x2D, 0xEA, 0xBF, 0x06, 0xFF, 0x22, 0x62, 0x62, 0xE3, 0xFE, + 0xE5, 0xCF, 0xAB, 0x70, 0x40, 0x00, 0x00, 0xE1, 0x74, 0x7E, 0xD1, 0xFE, + 0x2C, 0x2F, 0xB3, 0x1A, 0x80, 0x3B, 0x06, 0x80, 0x6D, 0xFE, 0xA2, 0x25, + 0xEE, 0x04, 0x68, 0x5E, 0x0B, 0xA0, 0x75, 0xF7, 0x8B, 0x66, 0xB2, 0x0F, + 0x40, 0xB5, 0x00, 0xA0, 0xE9, 0xDA, 0x57, 0xF3, 0x70, 0xF8, 0x7E, 0x3C, + 0x3C, 0x45, 0xA1, 0x90, 0xB9, 0xD9, 0xD9, 0xE5, 0xE4, 0xE4, 0xD8, 0x4A, + 0xC4, 0x42, 0x5B, 0x61, 0xCA, 0x57, 0x7D, 0xFE, 0x67, 0xC2, 0x5F, 0xC0, + 0x57, 0xFD, 0x6C, 0xF9, 0x7E, 0x3C, 0xFC, 0xF7, 0xF5, 0xE0, 0xBE, 0xE2, + 0x24, 0x81, 0x32, 0x5D, 0x81, 0x47, 0x04, 0xF8, 0xE0, 0xC2, 0xCC, 0xF4, + 0x4C, 0xA5, 0x1C, 0xCF, 0x92, 0x09, 0x84, 0x62, 0xDC, 0xE6, 0x8F, 0x47, + 0xFC, 0xB7, 0x0B, 0xFF, 0xFC, 0x1D, 0xD3, 0x22, 0xC4, 0x49, 0x62, 0xB9, + 0x58, 0x2A, 0x14, 0xE3, 0x51, 0x12, 0x71, 0x8E, 0x44, 0x9A, 0x8C, 0xF3, + 0x32, 0xA5, 0x22, 0x89, 0x42, 0x92, 0x29, 0xC5, 0x25, 0xD2, 0xFF, 0x64, + 0xE2, 0xDF, 0x2C, 0xFB, 0x03, 0x3E, 0xDF, 0x35, 0x00, 0xB0, 0x6A, 0x3E, + 0x01, 0x7B, 0x91, 0x2D, 0xA8, 0x5D, 0x63, 0x03, 0xF6, 0x4B, 0x27, 0x10, + 0x58, 0x74, 0xC0, 0xE2, 0xF7, 0x00, 0x00, 0xF2, 0xBB, 0x6F, 0xC1, 0xD4, + 0x28, 0x08, 0x03, 0x80, 0x68, 0x83, 0xE1, 0xCF, 0x77, 0xFF, 0xEF, 0x3F, + 0xFD, 0x47, 0xA0, 0x25, 0x00, 0x80, 0x66, 0x49, 0x92, 0x71, 0x00, 0x00, + 0x5E, 0x44, 0x24, 0x2E, 0x54, 0xCA, 0xB3, 0x3F, 0xC7, 0x08, 0x00, 0x00, + 0x44, 0xA0, 0x81, 0x2A, 0xB0, 0x41, 0x1B, 0xF4, 0xC1, 0x18, 0x2C, 0xC0, + 0x06, 0x1C, 0xC1, 0x05, 0xDC, 0xC1, 0x0B, 0xFC, 0x60, 0x36, 0x84, 0x42, + 0x24, 0xC4, 0xC2, 0x42, 0x10, 0x42, 0x0A, 0x64, 0x80, 0x1C, 0x72, 0x60, + 0x29, 0xAC, 0x82, 0x42, 0x28, 0x86, 0xCD, 0xB0, 0x1D, 0x2A, 0x60, 0x2F, + 0xD4, 0x40, 0x1D, 0x34, 0xC0, 0x51, 0x68, 0x86, 0x93, 0x70, 0x0E, 0x2E, + 0xC2, 0x55, 0xB8, 0x0E, 0x3D, 0x70, 0x0F, 0xFA, 0x61, 0x08, 0x9E, 0xC1, + 0x28, 0xBC, 0x81, 0x09, 0x04, 0x41, 0xC8, 0x08, 0x13, 0x61, 0x21, 0xDA, + 0x88, 0x01, 0x62, 0x8A, 0x58, 0x23, 0x8E, 0x08, 0x17, 0x99, 0x85, 0xF8, + 0x21, 0xC1, 0x48, 0x04, 0x12, 0x8B, 0x24, 0x20, 0xC9, 0x88, 0x14, 0x51, + 0x22, 0x4B, 0x91, 0x35, 0x48, 0x31, 0x52, 0x8A, 0x54, 0x20, 0x55, 0x48, + 0x1D, 0xF2, 0x3D, 0x72, 0x02, 0x39, 0x87, 0x5C, 0x46, 0xBA, 0x91, 0x3B, + 0xC8, 0x00, 0x32, 0x82, 0xFC, 0x86, 0xBC, 0x47, 0x31, 0x94, 0x81, 0xB2, + 0x51, 0x3D, 0xD4, 0x0C, 0xB5, 0x43, 0xB9, 0xA8, 0x37, 0x1A, 0x84, 0x46, + 0xA2, 0x0B, 0xD0, 0x64, 0x74, 0x31, 0x9A, 0x8F, 0x16, 0xA0, 0x9B, 0xD0, + 0x72, 0xB4, 0x1A, 0x3D, 0x8C, 0x36, 0xA1, 0xE7, 0xD0, 0xAB, 0x68, 0x0F, + 0xDA, 0x8F, 0x3E, 0x43, 0xC7, 0x30, 0xC0, 0xE8, 0x18, 0x07, 0x33, 0xC4, + 0x6C, 0x30, 0x2E, 0xC6, 0xC3, 0x42, 0xB1, 0x38, 0x2C, 0x09, 0x93, 0x63, + 0xCB, 0xB1, 0x22, 0xAC, 0x0C, 0xAB, 0xC6, 0x1A, 0xB0, 0x56, 0xAC, 0x03, + 0xBB, 0x89, 0xF5, 0x63, 0xCF, 0xB1, 0x77, 0x04, 0x12, 0x81, 0x45, 0xC0, + 0x09, 0x36, 0x04, 0x77, 0x42, 0x20, 0x61, 0x1E, 0x41, 0x48, 0x58, 0x4C, + 0x58, 0x4E, 0xD8, 0x48, 0xA8, 0x20, 0x1C, 0x24, 0x34, 0x11, 0xDA, 0x09, + 0x37, 0x09, 0x03, 0x84, 0x51, 0xC2, 0x27, 0x22, 0x93, 0xA8, 0x4B, 0xB4, + 0x26, 0xBA, 0x11, 0xF9, 0xC4, 0x18, 0x62, 0x32, 0x31, 0x87, 0x58, 0x48, + 0x2C, 0x23, 0xD6, 0x12, 0x8F, 0x13, 0x2F, 0x10, 0x7B, 0x88, 0x43, 0xC4, + 0x37, 0x24, 0x12, 0x89, 0x43, 0x32, 0x27, 0xB9, 0x90, 0x02, 0x49, 0xB1, + 0xA4, 0x54, 0xD2, 0x12, 0xD2, 0x46, 0xD2, 0x6E, 0x52, 0x23, 0xE9, 0x2C, + 0xA9, 0x9B, 0x34, 0x48, 0x1A, 0x23, 0x93, 0xC9, 0xDA, 0x64, 0x6B, 0xB2, + 0x07, 0x39, 0x94, 0x2C, 0x20, 0x2B, 0xC8, 0x85, 0xE4, 0x9D, 0xE4, 0xC3, + 0xE4, 0x33, 0xE4, 0x1B, 0xE4, 0x21, 0xF2, 0x5B, 0x0A, 0x9D, 0x62, 0x40, + 0x71, 0xA4, 0xF8, 0x53, 0xE2, 0x28, 0x52, 0xCA, 0x6A, 0x4A, 0x19, 0xE5, + 0x10, 0xE5, 0x34, 0xE5, 0x06, 0x65, 0x98, 0x32, 0x41, 0x55, 0xA3, 0x9A, + 0x52, 0xDD, 0xA8, 0xA1, 0x54, 0x11, 0x35, 0x8F, 0x5A, 0x42, 0xAD, 0xA1, + 0xB6, 0x52, 0xAF, 0x51, 0x87, 0xA8, 0x13, 0x34, 0x75, 0x9A, 0x39, 0xCD, + 0x83, 0x16, 0x49, 0x4B, 0xA5, 0xAD, 0xA2, 0x95, 0xD3, 0x1A, 0x68, 0x17, + 0x68, 0xF7, 0x69, 0xAF, 0xE8, 0x74, 0xBA, 0x11, 0xDD, 0x95, 0x1E, 0x4E, + 0x97, 0xD0, 0x57, 0xD2, 0xCB, 0xE9, 0x47, 0xE8, 0x97, 0xE8, 0x03, 0xF4, + 0x77, 0x0C, 0x0D, 0x86, 0x15, 0x83, 0xC7, 0x88, 0x67, 0x28, 0x19, 0x9B, + 0x18, 0x07, 0x18, 0x67, 0x19, 0x77, 0x18, 0xAF, 0x98, 0x4C, 0xA6, 0x19, + 0xD3, 0x8B, 0x19, 0xC7, 0x54, 0x30, 0x37, 0x31, 0xEB, 0x98, 0xE7, 0x99, + 0x0F, 0x99, 0x6F, 0x55, 0x58, 0x2A, 0xB6, 0x2A, 0x7C, 0x15, 0x91, 0xCA, + 0x0A, 0x95, 0x4A, 0x95, 0x26, 0x95, 0x1B, 0x2A, 0x2F, 0x54, 0xA9, 0xAA, + 0xA6, 0xAA, 0xDE, 0xAA, 0x0B, 0x55, 0xF3, 0x55, 0xCB, 0x54, 0x8F, 0xA9, + 0x5E, 0x53, 0x7D, 0xAE, 0x46, 0x55, 0x33, 0x53, 0xE3, 0xA9, 0x09, 0xD4, + 0x96, 0xAB, 0x55, 0xAA, 0x9D, 0x50, 0xEB, 0x53, 0x1B, 0x53, 0x67, 0xA9, + 0x3B, 0xA8, 0x87, 0xAA, 0x67, 0xA8, 0x6F, 0x54, 0x3F, 0xA4, 0x7E, 0x59, + 0xFD, 0x89, 0x06, 0x59, 0xC3, 0x4C, 0xC3, 0x4F, 0x43, 0xA4, 0x51, 0xA0, + 0xB1, 0x5F, 0xE3, 0xBC, 0xC6, 0x20, 0x0B, 0x63, 0x19, 0xB3, 0x78, 0x2C, + 0x21, 0x6B, 0x0D, 0xAB, 0x86, 0x75, 0x81, 0x35, 0xC4, 0x26, 0xB1, 0xCD, + 0xD9, 0x7C, 0x76, 0x2A, 0xBB, 0x98, 0xFD, 0x1D, 0xBB, 0x8B, 0x3D, 0xAA, + 0xA9, 0xA1, 0x39, 0x43, 0x33, 0x4A, 0x33, 0x57, 0xB3, 0x52, 0xF3, 0x94, + 0x66, 0x3F, 0x07, 0xE3, 0x98, 0x71, 0xF8, 0x9C, 0x74, 0x4E, 0x09, 0xE7, + 0x28, 0xA7, 0x97, 0xF3, 0x7E, 0x8A, 0xDE, 0x14, 0xEF, 0x29, 0xE2, 0x29, + 0x1B, 0xA6, 0x34, 0x4C, 0xB9, 0x31, 0x65, 0x5C, 0x6B, 0xAA, 0x96, 0x97, + 0x96, 0x58, 0xAB, 0x48, 0xAB, 0x51, 0xAB, 0x47, 0xEB, 0xBD, 0x36, 0xAE, + 0xED, 0xA7, 0x9D, 0xA6, 0xBD, 0x45, 0xBB, 0x59, 0xFB, 0x81, 0x0E, 0x41, + 0xC7, 0x4A, 0x27, 0x5C, 0x27, 0x47, 0x67, 0x8F, 0xCE, 0x05, 0x9D, 0xE7, + 0x53, 0xD9, 0x53, 0xDD, 0xA7, 0x0A, 0xA7, 0x16, 0x4D, 0x3D, 0x3A, 0xF5, + 0xAE, 0x2E, 0xAA, 0x6B, 0xA5, 0x1B, 0xA1, 0xBB, 0x44, 0x77, 0xBF, 0x6E, + 0xA7, 0xEE, 0x98, 0x9E, 0xBE, 0x5E, 0x80, 0x9E, 0x4C, 0x6F, 0xA7, 0xDE, + 0x79, 0xBD, 0xE7, 0xFA, 0x1C, 0x7D, 0x2F, 0xFD, 0x54, 0xFD, 0x6D, 0xFA, + 0xA7, 0xF5, 0x47, 0x0C, 0x58, 0x06, 0xB3, 0x0C, 0x24, 0x06, 0xDB, 0x0C, + 0xCE, 0x18, 0x3C, 0xC5, 0x35, 0x71, 0x6F, 0x3C, 0x1D, 0x2F, 0xC7, 0xDB, + 0xF1, 0x51, 0x43, 0x5D, 0xC3, 0x40, 0x43, 0xA5, 0x61, 0x95, 0x61, 0x97, + 0xE1, 0x84, 0x91, 0xB9, 0xD1, 0x3C, 0xA3, 0xD5, 0x46, 0x8D, 0x46, 0x0F, + 0x8C, 0x69, 0xC6, 0x5C, 0xE3, 0x24, 0xE3, 0x6D, 0xC6, 0x6D, 0xC6, 0xA3, + 0x26, 0x06, 0x26, 0x21, 0x26, 0x4B, 0x4D, 0xEA, 0x4D, 0xEE, 0x9A, 0x52, + 0x4D, 0xB9, 0xA6, 0x29, 0xA6, 0x3B, 0x4C, 0x3B, 0x4C, 0xC7, 0xCD, 0xCC, + 0xCD, 0xA2, 0xCD, 0xD6, 0x99, 0x35, 0x9B, 0x3D, 0x31, 0xD7, 0x32, 0xE7, + 0x9B, 0xE7, 0x9B, 0xD7, 0x9B, 0xDF, 0xB7, 0x60, 0x5A, 0x78, 0x5A, 0x2C, + 0xB6, 0xA8, 0xB6, 0xB8, 0x65, 0x49, 0xB2, 0xE4, 0x5A, 0xA6, 0x59, 0xEE, + 0xB6, 0xBC, 0x6E, 0x85, 0x5A, 0x39, 0x59, 0xA5, 0x58, 0x55, 0x5A, 0x5D, + 0xB3, 0x46, 0xAD, 0x9D, 0xAD, 0x25, 0xD6, 0xBB, 0xAD, 0xBB, 0xA7, 0x11, + 0xA7, 0xB9, 0x4E, 0x93, 0x4E, 0xAB, 0x9E, 0xD6, 0x67, 0xC3, 0xB0, 0xF1, + 0xB6, 0xC9, 0xB6, 0xA9, 0xB7, 0x19, 0xB0, 0xE5, 0xD8, 0x06, 0xDB, 0xAE, + 0xB6, 0x6D, 0xB6, 0x7D, 0x61, 0x67, 0x62, 0x17, 0x67, 0xB7, 0xC5, 0xAE, + 0xC3, 0xEE, 0x93, 0xBD, 0x93, 0x7D, 0xBA, 0x7D, 0x8D, 0xFD, 0x3D, 0x07, + 0x0D, 0x87, 0xD9, 0x0E, 0xAB, 0x1D, 0x5A, 0x1D, 0x7E, 0x73, 0xB4, 0x72, + 0x14, 0x3A, 0x56, 0x3A, 0xDE, 0x9A, 0xCE, 0x9C, 0xEE, 0x3F, 0x7D, 0xC5, + 0xF4, 0x96, 0xE9, 0x2F, 0x67, 0x58, 0xCF, 0x10, 0xCF, 0xD8, 0x33, 0xE3, + 0xB6, 0x13, 0xCB, 0x29, 0xC4, 0x69, 0x9D, 0x53, 0x9B, 0xD3, 0x47, 0x67, + 0x17, 0x67, 0xB9, 0x73, 0x83, 0xF3, 0x88, 0x8B, 0x89, 0x4B, 0x82, 0xCB, + 0x2E, 0x97, 0x3E, 0x2E, 0x9B, 0x1B, 0xC6, 0xDD, 0xC8, 0xBD, 0xE4, 0x4A, + 0x74, 0xF5, 0x71, 0x5D, 0xE1, 0x7A, 0xD2, 0xF5, 0x9D, 0x9B, 0xB3, 0x9B, + 0xC2, 0xED, 0xA8, 0xDB, 0xAF, 0xEE, 0x36, 0xEE, 0x69, 0xEE, 0x87, 0xDC, + 0x9F, 0xCC, 0x34, 0x9F, 0x29, 0x9E, 0x59, 0x33, 0x73, 0xD0, 0xC3, 0xC8, + 0x43, 0xE0, 0x51, 0xE5, 0xD1, 0x3F, 0x0B, 0x9F, 0x95, 0x30, 0x6B, 0xDF, + 0xAC, 0x7E, 0x4F, 0x43, 0x4F, 0x81, 0x67, 0xB5, 0xE7, 0x23, 0x2F, 0x63, + 0x2F, 0x91, 0x57, 0xAD, 0xD7, 0xB0, 0xB7, 0xA5, 0x77, 0xAA, 0xF7, 0x61, + 0xEF, 0x17, 0x3E, 0xF6, 0x3E, 0x72, 0x9F, 0xE3, 0x3E, 0xE3, 0x3C, 0x37, + 0xDE, 0x32, 0xDE, 0x59, 0x5F, 0xCC, 0x37, 0xC0, 0xB7, 0xC8, 0xB7, 0xCB, + 0x4F, 0xC3, 0x6F, 0x9E, 0x5F, 0x85, 0xDF, 0x43, 0x7F, 0x23, 0xFF, 0x64, + 0xFF, 0x7A, 0xFF, 0xD1, 0x00, 0xA7, 0x80, 0x25, 0x01, 0x67, 0x03, 0x89, + 0x81, 0x41, 0x81, 0x5B, 0x02, 0xFB, 0xF8, 0x7A, 0x7C, 0x21, 0xBF, 0x8E, + 0x3F, 0x3A, 0xDB, 0x65, 0xF6, 0xB2, 0xD9, 0xED, 0x41, 0x8C, 0xA0, 0xB9, + 0x41, 0x15, 0x41, 0x8F, 0x82, 0xAD, 0x82, 0xE5, 0xC1, 0xAD, 0x21, 0x68, + 0xC8, 0xEC, 0x90, 0xAD, 0x21, 0xF7, 0xE7, 0x98, 0xCE, 0x91, 0xCE, 0x69, + 0x0E, 0x85, 0x50, 0x7E, 0xE8, 0xD6, 0xD0, 0x07, 0x61, 0xE6, 0x61, 0x8B, + 0xC3, 0x7E, 0x0C, 0x27, 0x85, 0x87, 0x85, 0x57, 0x86, 0x3F, 0x8E, 0x70, + 0x88, 0x58, 0x1A, 0xD1, 0x31, 0x97, 0x35, 0x77, 0xD1, 0xDC, 0x43, 0x73, + 0xDF, 0x44, 0xFA, 0x44, 0x96, 0x44, 0xDE, 0x9B, 0x67, 0x31, 0x4F, 0x39, + 0xAF, 0x2D, 0x4A, 0x35, 0x2A, 0x3E, 0xAA, 0x2E, 0x6A, 0x3C, 0xDA, 0x37, + 0xBA, 0x34, 0xBA, 0x3F, 0xC6, 0x2E, 0x66, 0x59, 0xCC, 0xD5, 0x58, 0x9D, + 0x58, 0x49, 0x6C, 0x4B, 0x1C, 0x39, 0x2E, 0x2A, 0xAE, 0x36, 0x6E, 0x6C, + 0xBE, 0xDF, 0xFC, 0xED, 0xF3, 0x87, 0xE2, 0x9D, 0xE2, 0x0B, 0xE3, 0x7B, + 0x17, 0x98, 0x2F, 0xC8, 0x5D, 0x70, 0x79, 0xA1, 0xCE, 0xC2, 0xF4, 0x85, + 0xA7, 0x16, 0xA9, 0x2E, 0x12, 0x2C, 0x3A, 0x96, 0x40, 0x4C, 0x88, 0x4E, + 0x38, 0x94, 0xF0, 0x41, 0x10, 0x2A, 0xA8, 0x16, 0x8C, 0x25, 0xF2, 0x13, + 0x77, 0x25, 0x8E, 0x0A, 0x79, 0xC2, 0x1D, 0xC2, 0x67, 0x22, 0x2F, 0xD1, + 0x36, 0xD1, 0x88, 0xD8, 0x43, 0x5C, 0x2A, 0x1E, 0x4E, 0xF2, 0x48, 0x2A, + 0x4D, 0x7A, 0x92, 0xEC, 0x91, 0xBC, 0x35, 0x79, 0x24, 0xC5, 0x33, 0xA5, + 0x2C, 0xE5, 0xB9, 0x84, 0x27, 0xA9, 0x90, 0xBC, 0x4C, 0x0D, 0x4C, 0xDD, + 0x9B, 0x3A, 0x9E, 0x16, 0x9A, 0x76, 0x20, 0x6D, 0x32, 0x3D, 0x3A, 0xBD, + 0x31, 0x83, 0x92, 0x91, 0x90, 0x71, 0x42, 0xAA, 0x21, 0x4D, 0x93, 0xB6, + 0x67, 0xEA, 0x67, 0xE6, 0x66, 0x76, 0xCB, 0xAC, 0x65, 0x85, 0xB2, 0xFE, + 0xC5, 0x6E, 0x8B, 0xB7, 0x2F, 0x1E, 0x95, 0x07, 0xC9, 0x6B, 0xB3, 0x90, + 0xAC, 0x05, 0x59, 0x2D, 0x0A, 0xB6, 0x42, 0xA6, 0xE8, 0x54, 0x5A, 0x28, + 0xD7, 0x2A, 0x07, 0xB2, 0x67, 0x65, 0x57, 0x66, 0xBF, 0xCD, 0x89, 0xCA, + 0x39, 0x96, 0xAB, 0x9E, 0x2B, 0xCD, 0xED, 0xCC, 0xB3, 0xCA, 0xDB, 0x90, + 0x37, 0x9C, 0xEF, 0x9F, 0xFF, 0xED, 0x12, 0xC2, 0x12, 0xE1, 0x92, 0xB6, + 0xA5, 0x86, 0x4B, 0x57, 0x2D, 0x1D, 0x58, 0xE6, 0xBD, 0xAC, 0x6A, 0x39, + 0xB2, 0x3C, 0x71, 0x79, 0xDB, 0x0A, 0xE3, 0x15, 0x05, 0x2B, 0x86, 0x56, + 0x06, 0xAC, 0x3C, 0xB8, 0x8A, 0xB6, 0x2A, 0x6D, 0xD5, 0x4F, 0xAB, 0xED, + 0x57, 0x97, 0xAE, 0x7E, 0xBD, 0x26, 0x7A, 0x4D, 0x6B, 0x81, 0x5E, 0xC1, + 0xCA, 0x82, 0xC1, 0xB5, 0x01, 0x6B, 0xEB, 0x0B, 0x55, 0x0A, 0xE5, 0x85, + 0x7D, 0xEB, 0xDC, 0xD7, 0xED, 0x5D, 0x4F, 0x58, 0x2F, 0x59, 0xDF, 0xB5, + 0x61, 0xFA, 0x86, 0x9D, 0x1B, 0x3E, 0x15, 0x89, 0x8A, 0xAE, 0x14, 0xDB, + 0x17, 0x97, 0x15, 0x7F, 0xD8, 0x28, 0xDC, 0x78, 0xE5, 0x1B, 0x87, 0x6F, + 0xCA, 0xBF, 0x99, 0xDC, 0x94, 0xB4, 0xA9, 0xAB, 0xC4, 0xB9, 0x64, 0xCF, + 0x66, 0xD2, 0x66, 0xE9, 0xE6, 0xDE, 0x2D, 0x9E, 0x5B, 0x0E, 0x96, 0xAA, + 0x97, 0xE6, 0x97, 0x0E, 0x6E, 0x0D, 0xD9, 0xDA, 0xB4, 0x0D, 0xDF, 0x56, + 0xB4, 0xED, 0xF5, 0xF6, 0x45, 0xDB, 0x2F, 0x97, 0xCD, 0x28, 0xDB, 0xBB, + 0x83, 0xB6, 0x43, 0xB9, 0xA3, 0xBF, 0x3C, 0xB8, 0xBC, 0x65, 0xA7, 0xC9, + 0xCE, 0xCD, 0x3B, 0x3F, 0x54, 0xA4, 0x54, 0xF4, 0x54, 0xFA, 0x54, 0x36, + 0xEE, 0xD2, 0xDD, 0xB5, 0x61, 0xD7, 0xF8, 0x6E, 0xD1, 0xEE, 0x1B, 0x7B, + 0xBC, 0xF6, 0x34, 0xEC, 0xD5, 0xDB, 0x5B, 0xBC, 0xF7, 0xFD, 0x3E, 0xC9, + 0xBE, 0xDB, 0x55, 0x01, 0x55, 0x4D, 0xD5, 0x66, 0xD5, 0x65, 0xFB, 0x49, + 0xFB, 0xB3, 0xF7, 0x3F, 0xAE, 0x89, 0xAA, 0xE9, 0xF8, 0x96, 0xFB, 0x6D, + 0x5D, 0xAD, 0x4E, 0x6D, 0x71, 0xED, 0xC7, 0x03, 0xD2, 0x03, 0xFD, 0x07, + 0x23, 0x0E, 0xB6, 0xD7, 0xB9, 0xD4, 0xD5, 0x1D, 0xD2, 0x3D, 0x54, 0x52, + 0x8F, 0xD6, 0x2B, 0xEB, 0x47, 0x0E, 0xC7, 0x1F, 0xBE, 0xFE, 0x9D, 0xEF, + 0x77, 0x2D, 0x0D, 0x36, 0x0D, 0x55, 0x8D, 0x9C, 0xC6, 0xE2, 0x23, 0x70, + 0x44, 0x79, 0xE4, 0xE9, 0xF7, 0x09, 0xDF, 0xF7, 0x1E, 0x0D, 0x3A, 0xDA, + 0x76, 0x8C, 0x7B, 0xAC, 0xE1, 0x07, 0xD3, 0x1F, 0x76, 0x1D, 0x67, 0x1D, + 0x2F, 0x6A, 0x42, 0x9A, 0xF2, 0x9A, 0x46, 0x9B, 0x53, 0x9A, 0xFB, 0x5B, + 0x62, 0x5B, 0xBA, 0x4F, 0xCC, 0x3E, 0xD1, 0xD6, 0xEA, 0xDE, 0x7A, 0xFC, + 0x47, 0xDB, 0x1F, 0x0F, 0x9C, 0x34, 0x3C, 0x59, 0x79, 0x4A, 0xF3, 0x54, + 0xC9, 0x69, 0xDA, 0xE9, 0x82, 0xD3, 0x93, 0x67, 0xF2, 0xCF, 0x8C, 0x9D, + 0x95, 0x9D, 0x7D, 0x7E, 0x2E, 0xF9, 0xDC, 0x60, 0xDB, 0xA2, 0xB6, 0x7B, + 0xE7, 0x63, 0xCE, 0xDF, 0x6A, 0x0F, 0x6F, 0xEF, 0xBA, 0x10, 0x74, 0xE1, + 0xD2, 0x45, 0xFF, 0x8B, 0xE7, 0x3B, 0xBC, 0x3B, 0xCE, 0x5C, 0xF2, 0xB8, + 0x74, 0xF2, 0xB2, 0xDB, 0xE5, 0x13, 0x57, 0xB8, 0x57, 0x9A, 0xAF, 0x3A, + 0x5F, 0x6D, 0xEA, 0x74, 0xEA, 0x3C, 0xFE, 0x93, 0xD3, 0x4F, 0xC7, 0xBB, + 0x9C, 0xBB, 0x9A, 0xAE, 0xB9, 0x5C, 0x6B, 0xB9, 0xEE, 0x7A, 0xBD, 0xB5, + 0x7B, 0x66, 0xF7, 0xE9, 0x1B, 0x9E, 0x37, 0xCE, 0xDD, 0xF4, 0xBD, 0x79, + 0xF1, 0x16, 0xFF, 0xD6, 0xD5, 0x9E, 0x39, 0x3D, 0xDD, 0xBD, 0xF3, 0x7A, + 0x6F, 0xF7, 0xC5, 0xF7, 0xF5, 0xDF, 0x16, 0xDD, 0x7E, 0x72, 0x27, 0xFD, + 0xCE, 0xCB, 0xBB, 0xD9, 0x77, 0x27, 0xEE, 0xAD, 0xBC, 0x4F, 0xBC, 0x5F, + 0xF4, 0x40, 0xED, 0x41, 0xD9, 0x43, 0xDD, 0x87, 0xD5, 0x3F, 0x5B, 0xFE, + 0xDC, 0xD8, 0xEF, 0xDC, 0x7F, 0x6A, 0xC0, 0x77, 0xA0, 0xF3, 0xD1, 0xDC, + 0x47, 0xF7, 0x06, 0x85, 0x83, 0xCF, 0xFE, 0x91, 0xF5, 0x8F, 0x0F, 0x43, + 0x05, 0x8F, 0x99, 0x8F, 0xCB, 0x86, 0x0D, 0x86, 0xEB, 0x9E, 0x38, 0x3E, + 0x39, 0x39, 0xE2, 0x3F, 0x72, 0xFD, 0xE9, 0xFC, 0xA7, 0x43, 0xCF, 0x64, + 0xCF, 0x26, 0x9E, 0x17, 0xFE, 0xA2, 0xFE, 0xCB, 0xAE, 0x17, 0x16, 0x2F, + 0x7E, 0xF8, 0xD5, 0xEB, 0xD7, 0xCE, 0xD1, 0x98, 0xD1, 0xA1, 0x97, 0xF2, + 0x97, 0x93, 0xBF, 0x6D, 0x7C, 0xA5, 0xFD, 0xEA, 0xC0, 0xEB, 0x19, 0xAF, + 0xDB, 0xC6, 0xC2, 0xC6, 0x1E, 0xBE, 0xC9, 0x78, 0x33, 0x31, 0x5E, 0xF4, + 0x56, 0xFB, 0xED, 0xC1, 0x77, 0xDC, 0x77, 0x1D, 0xEF, 0xA3, 0xDF, 0x0F, + 0x4F, 0xE4, 0x7C, 0x20, 0x7F, 0x28, 0xFF, 0x68, 0xF9, 0xB1, 0xF5, 0x53, + 0xD0, 0xA7, 0xFB, 0x93, 0x19, 0x93, 0x93, 0xFF, 0x04, 0x03, 0x98, 0xF3, + 0xFC, 0x63, 0x33, 0x2D, 0xDB, 0x00, 0x00, 0x3A, 0xFD, 0x69, 0x54, 0x58, + 0x74, 0x58, 0x4D, 0x4C, 0x3A, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x78, 0x6D, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D, + 0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, + 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63, 0x7A, 0x6B, 0x63, 0x39, + 0x64, 0x22, 0x3F, 0x3E, 0x0A, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, + 0x65, 0x74, 0x61, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, + 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65, + 0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, + 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x58, 0x4D, 0x50, 0x20, + 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, + 0x38, 0x20, 0x37, 0x39, 0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, + 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D, + 0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, + 0x31, 0x39, 0x39, 0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, + 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E, 0x73, + 0x23, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, + 0x3D, 0x22, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x6D, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, + 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, + 0x6E, 0x73, 0x3A, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3D, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, + 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, + 0x30, 0x2F, 0x6D, 0x6D, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, + 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, + 0x73, 0x54, 0x79, 0x70, 0x65, 0x2F, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x23, 0x22, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, + 0x6C, 0x6E, 0x73, 0x3A, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x2F, 0x31, 0x2E, 0x30, + 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x64, 0x63, 0x3D, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x70, 0x75, 0x72, 0x6C, + 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x64, 0x63, 0x2F, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2F, 0x31, 0x2E, 0x31, 0x2F, 0x22, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, + 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x74, 0x69, 0x66, 0x66, 0x3D, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x2F, + 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, + 0x65, 0x78, 0x69, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, + 0x6D, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6F, 0x72, 0x54, + 0x6F, 0x6F, 0x6C, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, + 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, + 0x29, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6F, 0x72, 0x54, 0x6F, 0x6F, 0x6C, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, + 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, + 0x39, 0x3A, 0x33, 0x30, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, + 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, + 0x33, 0x30, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, + 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, + 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x33, 0x30, + 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, + 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x65, + 0x66, 0x63, 0x62, 0x65, 0x35, 0x33, 0x30, 0x2D, 0x35, 0x65, 0x61, 0x36, + 0x2D, 0x61, 0x32, 0x34, 0x35, 0x2D, 0x38, 0x32, 0x38, 0x35, 0x2D, 0x63, + 0x35, 0x62, 0x63, 0x64, 0x36, 0x33, 0x61, 0x62, 0x39, 0x66, 0x39, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, + 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x44, + 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x3E, 0x61, 0x64, + 0x6F, 0x62, 0x65, 0x3A, 0x64, 0x6F, 0x63, 0x69, 0x64, 0x3A, 0x70, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x65, 0x31, 0x37, 0x35, + 0x35, 0x65, 0x39, 0x63, 0x2D, 0x33, 0x35, 0x62, 0x34, 0x2D, 0x31, 0x31, + 0x65, 0x38, 0x2D, 0x39, 0x31, 0x61, 0x34, 0x2D, 0x38, 0x38, 0x34, 0x37, + 0x30, 0x37, 0x30, 0x65, 0x31, 0x35, 0x34, 0x62, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, + 0x69, 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x34, + 0x31, 0x36, 0x37, 0x34, 0x65, 0x31, 0x31, 0x2D, 0x62, 0x37, 0x39, 0x38, + 0x2D, 0x63, 0x39, 0x34, 0x38, 0x2D, 0x39, 0x30, 0x31, 0x39, 0x2D, 0x62, + 0x66, 0x31, 0x35, 0x61, 0x38, 0x31, 0x65, 0x38, 0x31, 0x61, 0x36, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, 0x69, + 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, + 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, + 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, + 0x20, 0x72, 0x64, 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x3D, 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, + 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x34, 0x31, 0x36, 0x37, 0x34, 0x65, + 0x31, 0x31, 0x2D, 0x62, 0x37, 0x39, 0x38, 0x2D, 0x63, 0x39, 0x34, 0x38, + 0x2D, 0x39, 0x30, 0x31, 0x39, 0x2D, 0x62, 0x66, 0x31, 0x35, 0x61, 0x38, + 0x31, 0x65, 0x38, 0x31, 0x61, 0x36, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, + 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, + 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, + 0x3A, 0x33, 0x30, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, + 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, + 0x74, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, + 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, + 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x20, 0x72, 0x64, + 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3D, + 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, + 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x73, 0x61, 0x76, 0x65, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, + 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, + 0x3A, 0x65, 0x66, 0x63, 0x62, 0x65, 0x35, 0x33, 0x30, 0x2D, 0x35, 0x65, + 0x61, 0x36, 0x2D, 0x61, 0x32, 0x34, 0x35, 0x2D, 0x38, 0x32, 0x38, 0x35, + 0x2D, 0x63, 0x35, 0x62, 0x63, 0x64, 0x36, 0x33, 0x61, 0x62, 0x39, 0x66, + 0x39, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, + 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, + 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, + 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x33, 0x30, 0x2B, 0x30, + 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x41, 0x64, 0x6F, + 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, + 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, + 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x64, 0x3E, 0x2F, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, + 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, + 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, 0x67, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x39, 0x30, 0x39, 0x62, 0x39, 0x65, + 0x35, 0x32, 0x2D, 0x39, 0x37, 0x62, 0x64, 0x2D, 0x34, 0x32, 0x39, 0x33, + 0x2D, 0x38, 0x30, 0x64, 0x32, 0x2D, 0x31, 0x31, 0x64, 0x65, 0x62, 0x64, + 0x36, 0x61, 0x33, 0x33, 0x65, 0x62, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, + 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, + 0x67, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, + 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, + 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, + 0x6F, 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, + 0x3E, 0x33, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x49, 0x43, 0x43, + 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, 0x73, 0x52, 0x47, 0x42, + 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, + 0x31, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x3A, 0x49, 0x43, 0x43, 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, + 0x63, 0x3A, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0x2F, 0x70, 0x6E, 0x67, 0x3C, 0x2F, 0x64, 0x63, 0x3A, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, + 0x69, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, 0x69, 0x65, 0x6E, 0x74, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, + 0x3E, 0x32, 0x3C, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, + 0x63, 0x65, 0x3E, 0x31, 0x3C, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x3A, 0x43, + 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, 0x63, 0x65, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, + 0x6D, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, 0x66, 0x3A, + 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x0A, 0x3C, 0x2F, + 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x64, + 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0xB3, 0x93, 0x52, 0x50, 0x00, 0x00, + 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x25, 0x00, 0x00, + 0x80, 0x83, 0x00, 0x00, 0xF9, 0xFF, 0x00, 0x00, 0x80, 0xE9, 0x00, 0x00, + 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, + 0x17, 0x6F, 0x92, 0x5F, 0xC5, 0x46, 0x00, 0x00, 0x05, 0xFC, 0x49, 0x44, + 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9D, 0x6B, 0x88, 0x94, 0x55, 0x18, 0xC7, + 0x7F, 0xB3, 0xAB, 0x6B, 0xA9, 0xD9, 0x62, 0xBA, 0x56, 0xBB, 0x62, 0x94, + 0x90, 0xD9, 0x05, 0xB5, 0x48, 0x4B, 0x14, 0xBB, 0x80, 0x5D, 0xB4, 0xD8, + 0xAF, 0xF5, 0xA1, 0x02, 0x23, 0xB0, 0x08, 0xA2, 0x0F, 0x51, 0x51, 0x1F, + 0xBA, 0x10, 0xA5, 0x11, 0x14, 0x51, 0x54, 0xC2, 0x16, 0x11, 0x44, 0xD1, + 0xE5, 0x43, 0x45, 0x37, 0x37, 0x8C, 0xCC, 0xB2, 0x02, 0xD3, 0xC8, 0x56, + 0xB0, 0xA2, 0xD6, 0x75, 0x6D, 0xD5, 0x35, 0x37, 0xDB, 0xD5, 0xD9, 0x99, + 0x3E, 0x3C, 0xCF, 0xA0, 0x81, 0xF3, 0x9E, 0x33, 0x7B, 0x19, 0xDF, 0x77, + 0xF6, 0xFF, 0x83, 0x61, 0x84, 0x79, 0x77, 0xDE, 0x71, 0x7E, 0xEF, 0x39, + 0xE7, 0x39, 0xCF, 0x7B, 0xCE, 0x33, 0xB9, 0x62, 0xB1, 0x88, 0xA8, 0x5D, + 0xEA, 0xF4, 0x15, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, 0x42, 0x82, 0x85, + 0x04, 0x0B, 0x09, 0x16, 0x12, 0x2C, 0xC1, 0x42, 0x82, 0x85, 0x04, 0x0B, + 0x09, 0x16, 0x12, 0x2C, 0x24, 0x58, 0x48, 0xB0, 0x04, 0x0B, 0x09, 0x16, + 0x12, 0x2C, 0x24, 0x58, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, 0x42, 0x82, + 0x25, 0x58, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, 0x42, 0x82, 0x85, 0x04, + 0x0B, 0x09, 0x96, 0x60, 0x51, 0x4B, 0x8C, 0xAB, 0xF0, 0xF8, 0x1C, 0x30, + 0x03, 0xC8, 0x03, 0x3D, 0xC3, 0x38, 0xEF, 0x49, 0xC0, 0xE9, 0xC0, 0x78, + 0xA0, 0x50, 0xE3, 0xDF, 0xF1, 0x61, 0xE0, 0x90, 0x3F, 0xFA, 0x81, 0x62, + 0x5A, 0x05, 0xCF, 0x05, 0x2E, 0x02, 0x16, 0xFA, 0x07, 0xDD, 0x08, 0x7C, + 0x07, 0x74, 0x55, 0x78, 0xCE, 0x8B, 0x81, 0x45, 0xC0, 0x7C, 0xA0, 0xA1, + 0x86, 0x05, 0xE7, 0x5C, 0xE6, 0xBF, 0xC0, 0x3E, 0xA0, 0x13, 0xD8, 0x0D, + 0xF4, 0xF9, 0xF3, 0x4E, 0x97, 0x3E, 0xAA, 0xFF, 0xFF, 0x5C, 0xE4, 0x0E, + 0xFF, 0xF9, 0xC0, 0x83, 0xC0, 0x02, 0x6F, 0x79, 0x83, 0xC0, 0x1F, 0xC0, + 0x27, 0xC0, 0x5A, 0xE0, 0xCF, 0xC8, 0xF3, 0x2D, 0x01, 0x1E, 0x00, 0xE6, + 0x01, 0xD3, 0xFC, 0x4B, 0xA8, 0x75, 0x06, 0x81, 0x01, 0xE0, 0x1F, 0xE0, + 0x6F, 0x17, 0xFE, 0x3B, 0xB0, 0xC9, 0x25, 0xFF, 0xEC, 0xCF, 0x7D, 0x27, + 0x4A, 0x70, 0x33, 0xF0, 0x1C, 0xD0, 0x7A, 0x9C, 0xD7, 0xFA, 0x81, 0x67, + 0x81, 0xFB, 0x22, 0xCE, 0x35, 0x0B, 0x68, 0x03, 0x96, 0x69, 0x64, 0x04, + 0x97, 0xBD, 0x17, 0xF8, 0xD1, 0x65, 0x6F, 0x06, 0xBE, 0x07, 0x7A, 0xAB, + 0x2D, 0xB8, 0x15, 0x78, 0x0B, 0xA8, 0x2F, 0xF3, 0xFA, 0x5E, 0xE0, 0x72, + 0xA0, 0x23, 0xF0, 0x3E, 0xB7, 0x03, 0x2F, 0xC9, 0xEB, 0x71, 0xE9, 0x05, + 0xB6, 0x03, 0x1F, 0x03, 0x9F, 0xBB, 0xE8, 0x43, 0xD5, 0x8A, 0xA2, 0xCF, + 0x4D, 0x90, 0x0B, 0x70, 0x1A, 0xB0, 0x32, 0xE2, 0x3C, 0x0B, 0xE5, 0xB1, + 0x2C, 0x8D, 0x1E, 0x97, 0xDC, 0x03, 0x3C, 0x06, 0xAC, 0x02, 0x66, 0x56, + 0x2B, 0xC8, 0x9A, 0x18, 0x78, 0xBD, 0xE8, 0x01, 0x58, 0x48, 0xF0, 0x14, + 0x3F, 0x36, 0x27, 0x9F, 0x65, 0x99, 0x02, 0x2C, 0x05, 0xE6, 0xF8, 0x77, + 0xBA, 0xCE, 0x5B, 0x73, 0x61, 0x34, 0x5B, 0xF0, 0x60, 0xE0, 0xF5, 0x82, + 0x4F, 0x05, 0x42, 0x1C, 0x91, 0xBF, 0x68, 0x9A, 0x80, 0xDB, 0x80, 0x47, + 0x81, 0x1B, 0x80, 0x09, 0xA3, 0xD5, 0x82, 0x73, 0x91, 0x57, 0xCF, 0x40, + 0xC4, 0x31, 0x05, 0x79, 0xAB, 0x88, 0x06, 0x60, 0xB9, 0x07, 0xB9, 0x53, + 0x81, 0x37, 0x3C, 0xA8, 0x1D, 0xD5, 0x44, 0x47, 0xD2, 0x85, 0x10, 0xEA, + 0xC6, 0x89, 0xE8, 0xA2, 0x4B, 0x53, 0x89, 0x5A, 0xE8, 0xC6, 0x8B, 0x1E, + 0xBB, 0x34, 0x78, 0x4F, 0x39, 0x61, 0x88, 0x2D, 0xF1, 0x02, 0xE0, 0x61, + 0x6F, 0x20, 0xAF, 0x63, 0x49, 0xA6, 0xAA, 0x0B, 0x1E, 0x29, 0x36, 0x00, + 0x1F, 0xF8, 0xE7, 0xCA, 0xD5, 0x80, 0xE0, 0x06, 0xE0, 0x14, 0x7F, 0x6E, + 0x04, 0xCE, 0x07, 0xCE, 0xF4, 0x5C, 0xC2, 0xC4, 0x0A, 0xDE, 0x6B, 0x96, + 0xE7, 0x21, 0x7A, 0x81, 0xF7, 0xB2, 0x2C, 0x78, 0x23, 0xF0, 0x8A, 0x5F, + 0xF9, 0xB5, 0x20, 0xB8, 0x0E, 0x4B, 0xC7, 0xD6, 0x7B, 0xEB, 0x3D, 0x07, + 0x38, 0x1B, 0x4B, 0xF4, 0x2C, 0x72, 0xE1, 0x93, 0x23, 0xDF, 0x6F, 0x36, + 0xF0, 0x10, 0x96, 0x11, 0xDB, 0x9C, 0x55, 0xC1, 0xF9, 0xC8, 0xF1, 0x3C, + 0xAB, 0x74, 0xFA, 0x45, 0xFC, 0xA1, 0xCB, 0xBD, 0x16, 0xB8, 0xCE, 0x23, + 0xE6, 0x98, 0x0B, 0x7A, 0x01, 0x96, 0x09, 0x5C, 0x4D, 0x64, 0x8A, 0x38, + 0x6D, 0x82, 0x27, 0x8D, 0x81, 0xE0, 0x29, 0x0F, 0xEC, 0xF1, 0xC7, 0x56, + 0x2C, 0x8B, 0x75, 0x93, 0x8B, 0x3E, 0x39, 0xE2, 0xEF, 0x57, 0x60, 0xF7, + 0x00, 0x9E, 0x8C, 0x19, 0x8F, 0x75, 0xBB, 0xF0, 0xC4, 0xD2, 0x03, 0xBC, + 0xE3, 0xE3, 0x6B, 0x1B, 0x71, 0xF9, 0xE8, 0x71, 0xC0, 0x1D, 0xC0, 0xA5, + 0x23, 0x35, 0x0F, 0xAE, 0xF6, 0xB8, 0x35, 0x16, 0xF9, 0x05, 0xCB, 0x60, + 0xBD, 0x10, 0x29, 0x79, 0x26, 0x70, 0x67, 0x4C, 0xA0, 0xA6, 0x16, 0x9C, + 0x1E, 0x76, 0x01, 0x6B, 0x3C, 0xC8, 0x8C, 0x49, 0x0A, 0xDD, 0x88, 0xDD, + 0x03, 0x90, 0xE0, 0x0C, 0xF1, 0x17, 0xF0, 0x94, 0x4F, 0x15, 0x63, 0xE2, + 0x95, 0x5B, 0x7D, 0x0A, 0x26, 0xC1, 0x19, 0xA2, 0x0B, 0x78, 0x02, 0xF8, + 0x2D, 0xE2, 0xD8, 0x95, 0xC0, 0x79, 0x12, 0x9C, 0x3D, 0xBE, 0xF5, 0xAE, + 0x3A, 0x14, 0x93, 0x4C, 0x01, 0xAE, 0x4F, 0x9A, 0x0D, 0x49, 0x70, 0x7A, + 0x69, 0x03, 0x76, 0x44, 0x1C, 0xB7, 0x3C, 0x69, 0x7A, 0x25, 0xC1, 0xE9, + 0xA5, 0x13, 0x78, 0x33, 0x62, 0xAE, 0x3B, 0x17, 0x4B, 0x65, 0x4A, 0x70, + 0x06, 0x79, 0x9B, 0xF0, 0x12, 0x9E, 0xA9, 0x58, 0x86, 0x2B, 0x27, 0xC1, + 0xD9, 0x63, 0x07, 0xB6, 0x94, 0x27, 0x14, 0x47, 0xCD, 0xA6, 0xCC, 0xAA, + 0x1B, 0x09, 0x4E, 0x37, 0x87, 0xB1, 0x3B, 0x6C, 0x21, 0x9A, 0xCA, 0xB9, + 0x94, 0xE0, 0x74, 0x53, 0x00, 0xBE, 0x21, 0xBC, 0x58, 0xA2, 0x89, 0x32, + 0xF7, 0x9A, 0x25, 0x38, 0xDD, 0x14, 0x81, 0x6E, 0xC2, 0x99, 0xAD, 0xE9, + 0x94, 0x49, 0x5B, 0x4A, 0x70, 0x36, 0x5A, 0x71, 0x28, 0x92, 0x9E, 0x84, + 0xDD, 0x77, 0x96, 0xE0, 0x0C, 0x52, 0xDA, 0x02, 0x93, 0x44, 0xBD, 0xC6, + 0xE0, 0xEC, 0x92, 0x27, 0x79, 0x5D, 0x3A, 0xDE, 0x85, 0x17, 0x24, 0x38, + 0x9B, 0x4C, 0x20, 0xBC, 0x30, 0x63, 0x3F, 0x65, 0x76, 0x42, 0x48, 0x70, + 0xBA, 0xA9, 0xC3, 0x32, 0x55, 0x21, 0xC1, 0xDD, 0xD8, 0xA6, 0x36, 0x09, + 0xCE, 0x20, 0x57, 0x11, 0x5E, 0xAF, 0xB5, 0xAF, 0x5C, 0x20, 0x26, 0xC1, + 0xE9, 0xA6, 0x11, 0xB8, 0x24, 0xE2, 0xB8, 0x4E, 0x8D, 0xC1, 0xD9, 0x64, + 0x29, 0xB6, 0xB3, 0x21, 0x89, 0x7E, 0x60, 0x8B, 0x04, 0x67, 0x8F, 0x71, + 0xD8, 0x6A, 0xCB, 0xD0, 0xBA, 0xAB, 0x2E, 0x60, 0x5B, 0xB9, 0xA9, 0x94, + 0x04, 0xA7, 0x97, 0x25, 0xC0, 0x95, 0x11, 0xC7, 0x7D, 0x4D, 0x42, 0xBD, + 0x14, 0x09, 0x4E, 0xEF, 0xD8, 0x7B, 0x37, 0xB6, 0xF7, 0x3A, 0xC4, 0xBB, + 0x24, 0x6C, 0x16, 0x90, 0xE0, 0x74, 0x72, 0x0B, 0x70, 0x4D, 0xC4, 0x71, + 0x5B, 0x81, 0xAF, 0x48, 0xC8, 0x74, 0x49, 0x70, 0xFA, 0xB8, 0x1A, 0xB8, + 0x0B, 0x2B, 0x35, 0x15, 0xE2, 0x35, 0x9F, 0x03, 0x23, 0xC1, 0xD9, 0x60, + 0x19, 0xF0, 0x08, 0x76, 0x03, 0x3F, 0xC4, 0x4F, 0xDE, 0x3D, 0x17, 0x42, + 0x91, 0x9A, 0x38, 0xF1, 0x34, 0x78, 0xCB, 0xBD, 0x1F, 0xB8, 0x2C, 0xE2, + 0xF8, 0x22, 0xF0, 0x22, 0xF0, 0x6B, 0x4C, 0x28, 0x9E, 0x26, 0xEA, 0xC7, + 0xA0, 0xDC, 0x66, 0x6C, 0x43, 0xD9, 0x2A, 0xE2, 0x92, 0x1A, 0x00, 0xEB, + 0xB1, 0xCA, 0x47, 0x85, 0xAC, 0x09, 0x1E, 0x4B, 0x75, 0x3C, 0xA6, 0xBB, + 0xD0, 0x56, 0x6C, 0x1B, 0x69, 0x4B, 0xE4, 0xDF, 0x75, 0x62, 0xBB, 0x1F, + 0xBA, 0x63, 0x27, 0xD3, 0x69, 0x62, 0x7F, 0x8D, 0x4B, 0x9D, 0xEA, 0x53, + 0xA0, 0x79, 0xC0, 0x62, 0xE0, 0x0A, 0xEC, 0x66, 0x42, 0x6C, 0x69, 0x87, + 0x3E, 0xE0, 0x69, 0xA0, 0x3D, 0xF6, 0x84, 0x69, 0x13, 0xDC, 0x02, 0x5C, + 0xE8, 0xFF, 0xAE, 0x95, 0x72, 0x4B, 0x75, 0x1E, 0x11, 0xB7, 0xB8, 0xD8, + 0xB3, 0xFC, 0x79, 0x16, 0xF1, 0xBB, 0xFB, 0xC1, 0xAA, 0x1D, 0xAD, 0xF3, + 0xC7, 0x91, 0xAC, 0x0A, 0x5E, 0x41, 0x60, 0xAF, 0x4D, 0x06, 0xA9, 0x77, + 0xC1, 0x33, 0xB0, 0xFA, 0x1C, 0x13, 0x29, 0xB3, 0xBC, 0x26, 0x81, 0x02, + 0xB6, 0x08, 0x7E, 0x2D, 0x56, 0xA4, 0x86, 0xAC, 0x0A, 0x9E, 0xE3, 0x0F, + 0x71, 0x94, 0x7E, 0x6C, 0x01, 0xFC, 0xE3, 0xC4, 0x17, 0x7D, 0x8D, 0x16, + 0x3C, 0x52, 0xDD, 0x64, 0xEE, 0x98, 0x87, 0x88, 0xA7, 0x07, 0xAB, 0x8F, + 0xF5, 0x3C, 0xE1, 0x5A, 0xA0, 0x43, 0x6E, 0xC1, 0xA1, 0xEE, 0xA4, 0x9E, + 0xB8, 0xDA, 0x1A, 0xE3, 0xE5, 0xAB, 0x22, 0x3A, 0x80, 0x97, 0x5D, 0xF0, + 0xAE, 0xA1, 0xBE, 0x49, 0x48, 0x70, 0x91, 0xF0, 0x92, 0xCD, 0x41, 0xC2, + 0x65, 0x07, 0x0A, 0x84, 0x4B, 0x22, 0x8A, 0xA3, 0x33, 0x89, 0x0D, 0xC0, + 0xAB, 0xC0, 0xA7, 0x0C, 0xB3, 0x8E, 0x74, 0x8C, 0xE0, 0xDD, 0x11, 0x82, + 0x3F, 0x8B, 0x10, 0xBC, 0x53, 0x5D, 0x74, 0x70, 0x0A, 0xB4, 0x15, 0x78, + 0x1F, 0xF8, 0x08, 0xBB, 0xC7, 0x3B, 0xEC, 0xF2, 0x8F, 0x31, 0x5D, 0xF4, + 0x36, 0xEC, 0xA6, 0xF2, 0x19, 0x09, 0xAF, 0x7F, 0x11, 0xF1, 0x3E, 0xED, + 0x58, 0x12, 0xFD, 0x54, 0xB9, 0xFC, 0xDF, 0x85, 0xBF, 0x07, 0xDB, 0x60, + 0xB6, 0xDE, 0x5B, 0xEE, 0x0F, 0xC0, 0xC1, 0x91, 0x3A, 0x41, 0xAC, 0xE0, + 0x67, 0x80, 0x7B, 0xB1, 0x32, 0xFC, 0xA5, 0x74, 0xE2, 0x11, 0xAC, 0x34, + 0xFD, 0x9A, 0xC8, 0x6E, 0x64, 0x13, 0x56, 0x39, 0x7E, 0xB5, 0x4F, 0xF8, + 0xC7, 0x22, 0xA5, 0xF2, 0xFE, 0x3D, 0x3E, 0xAE, 0x6E, 0x07, 0xBE, 0xC4, + 0xAA, 0xBE, 0x77, 0x54, 0x3A, 0x05, 0x8A, 0x8A, 0x6E, 0x23, 0x7F, 0xB3, + 0xA1, 0x11, 0xB8, 0x19, 0xFB, 0xED, 0x86, 0x19, 0xC7, 0x7C, 0xC8, 0x76, + 0xAC, 0x76, 0x62, 0x6C, 0x75, 0xBA, 0x69, 0x58, 0xE1, 0x90, 0xC5, 0x3E, + 0xE1, 0xAF, 0xE5, 0x1F, 0xE5, 0x28, 0x71, 0x18, 0x38, 0x80, 0x55, 0xC6, + 0x3F, 0xE0, 0x63, 0xEC, 0x16, 0x1F, 0xB2, 0xBA, 0xB0, 0xDF, 0xBE, 0xC8, + 0x8F, 0xD6, 0xC9, 0x63, 0x05, 0x83, 0x95, 0x09, 0x68, 0xC2, 0xEA, 0x42, + 0x94, 0x02, 0xAB, 0xCE, 0x21, 0x04, 0x4F, 0x93, 0xB1, 0x2C, 0x4E, 0xF3, + 0x18, 0x11, 0x3C, 0xE0, 0x5D, 0xEE, 0x41, 0x6C, 0x71, 0x7A, 0xE9, 0x57, + 0x58, 0xF2, 0xD5, 0x38, 0x79, 0x25, 0x82, 0x45, 0x06, 0xD1, 0x0D, 0x7F, + 0x09, 0x16, 0x12, 0x2C, 0x24, 0x58, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, + 0x42, 0x82, 0x25, 0x58, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, 0x42, 0x82, + 0x85, 0x04, 0x0B, 0x09, 0x96, 0x60, 0x21, 0xC1, 0x42, 0x82, 0x85, 0x04, + 0x0B, 0x09, 0x16, 0x12, 0x2C, 0x24, 0x58, 0x48, 0xB0, 0x04, 0x0B, 0x09, + 0x16, 0x12, 0x2C, 0x24, 0x58, 0x48, 0xB0, 0x90, 0x60, 0x21, 0xC1, 0x12, + 0x2C, 0x6A, 0x8A, 0xFF, 0x06, 0x00, 0x0E, 0x16, 0x36, 0x06, 0x65, 0x03, + 0x35, 0x24, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, + 0x60, 0x82 +}; +} +static unsigned char* rage_icon = raw::rage; +}
\ No newline at end of file diff --git a/internal_rewrite/icons/visuals.hpp b/internal_rewrite/icons/visuals.hpp new file mode 100644 index 0000000..3bd8c7b --- /dev/null +++ b/internal_rewrite/icons/visuals.hpp @@ -0,0 +1,1837 @@ +/* E:\Users\admin\Desktop\stuff\icons\visuals.png (4/1/2018 10:00:00 PM) + StartOffset: 00000000, EndOffset: 00005593, Length: 00005594 */ + +namespace icons { +constexpr static size_t visuals_size = 21908; +namespace raw { +static unsigned char visuals[21908] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, + 0x08, 0x06, 0x00, 0x00, 0x00, 0x39, 0x64, 0x36, 0xD2, 0x00, 0x00, 0x00, + 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23, 0x00, 0x00, 0x2E, + 0x23, 0x01, 0x78, 0xA5, 0x3F, 0x76, 0x00, 0x00, 0x0A, 0x4F, 0x69, 0x43, + 0x43, 0x50, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, + 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x00, + 0x00, 0x78, 0xDA, 0x9D, 0x53, 0x67, 0x54, 0x53, 0xE9, 0x16, 0x3D, 0xF7, + 0xDE, 0xF4, 0x42, 0x4B, 0x88, 0x80, 0x94, 0x4B, 0x6F, 0x52, 0x15, 0x08, + 0x20, 0x52, 0x42, 0x8B, 0x80, 0x14, 0x91, 0x26, 0x2A, 0x21, 0x09, 0x10, + 0x4A, 0x88, 0x21, 0xA1, 0xD9, 0x15, 0x51, 0xC1, 0x11, 0x45, 0x45, 0x04, + 0x1B, 0xC8, 0xA0, 0x88, 0x03, 0x8E, 0x8E, 0x80, 0x8C, 0x15, 0x51, 0x2C, + 0x0C, 0x8A, 0x0A, 0xD8, 0x07, 0xE4, 0x21, 0xA2, 0x8E, 0x83, 0xA3, 0x88, + 0x8A, 0xCA, 0xFB, 0xE1, 0x7B, 0xA3, 0x6B, 0xD6, 0xBC, 0xF7, 0xE6, 0xCD, + 0xFE, 0xB5, 0xD7, 0x3E, 0xE7, 0xAC, 0xF3, 0x9D, 0xB3, 0xCF, 0x07, 0xC0, + 0x08, 0x0C, 0x96, 0x48, 0x33, 0x51, 0x35, 0x80, 0x0C, 0xA9, 0x42, 0x1E, + 0x11, 0xE0, 0x83, 0xC7, 0xC4, 0xC6, 0xE1, 0xE4, 0x2E, 0x40, 0x81, 0x0A, + 0x24, 0x70, 0x00, 0x10, 0x08, 0xB3, 0x64, 0x21, 0x73, 0xFD, 0x23, 0x01, + 0x00, 0xF8, 0x7E, 0x3C, 0x3C, 0x2B, 0x22, 0xC0, 0x07, 0xBE, 0x00, 0x01, + 0x78, 0xD3, 0x0B, 0x08, 0x00, 0xC0, 0x4D, 0x9B, 0xC0, 0x30, 0x1C, 0x87, + 0xFF, 0x0F, 0xEA, 0x42, 0x99, 0x5C, 0x01, 0x80, 0x84, 0x01, 0xC0, 0x74, + 0x91, 0x38, 0x4B, 0x08, 0x80, 0x14, 0x00, 0x40, 0x7A, 0x8E, 0x42, 0xA6, + 0x00, 0x40, 0x46, 0x01, 0x80, 0x9D, 0x98, 0x26, 0x53, 0x00, 0xA0, 0x04, + 0x00, 0x60, 0xCB, 0x63, 0x62, 0xE3, 0x00, 0x50, 0x2D, 0x00, 0x60, 0x27, + 0x7F, 0xE6, 0xD3, 0x00, 0x80, 0x9D, 0xF8, 0x99, 0x7B, 0x01, 0x00, 0x5B, + 0x94, 0x21, 0x15, 0x01, 0xA0, 0x91, 0x00, 0x20, 0x13, 0x65, 0x88, 0x44, + 0x00, 0x68, 0x3B, 0x00, 0xAC, 0xCF, 0x56, 0x8A, 0x45, 0x00, 0x58, 0x30, + 0x00, 0x14, 0x66, 0x4B, 0xC4, 0x39, 0x00, 0xD8, 0x2D, 0x00, 0x30, 0x49, + 0x57, 0x66, 0x48, 0x00, 0xB0, 0xB7, 0x00, 0xC0, 0xCE, 0x10, 0x0B, 0xB2, + 0x00, 0x08, 0x0C, 0x00, 0x30, 0x51, 0x88, 0x85, 0x29, 0x00, 0x04, 0x7B, + 0x00, 0x60, 0xC8, 0x23, 0x23, 0x78, 0x00, 0x84, 0x99, 0x00, 0x14, 0x46, + 0xF2, 0x57, 0x3C, 0xF1, 0x2B, 0xAE, 0x10, 0xE7, 0x2A, 0x00, 0x00, 0x78, + 0x99, 0xB2, 0x3C, 0xB9, 0x24, 0x39, 0x45, 0x81, 0x5B, 0x08, 0x2D, 0x71, + 0x07, 0x57, 0x57, 0x2E, 0x1E, 0x28, 0xCE, 0x49, 0x17, 0x2B, 0x14, 0x36, + 0x61, 0x02, 0x61, 0x9A, 0x40, 0x2E, 0xC2, 0x79, 0x99, 0x19, 0x32, 0x81, + 0x34, 0x0F, 0xE0, 0xF3, 0xCC, 0x00, 0x00, 0xA0, 0x91, 0x15, 0x11, 0xE0, + 0x83, 0xF3, 0xFD, 0x78, 0xCE, 0x0E, 0xAE, 0xCE, 0xCE, 0x36, 0x8E, 0xB6, + 0x0E, 0x5F, 0x2D, 0xEA, 0xBF, 0x06, 0xFF, 0x22, 0x62, 0x62, 0xE3, 0xFE, + 0xE5, 0xCF, 0xAB, 0x70, 0x40, 0x00, 0x00, 0xE1, 0x74, 0x7E, 0xD1, 0xFE, + 0x2C, 0x2F, 0xB3, 0x1A, 0x80, 0x3B, 0x06, 0x80, 0x6D, 0xFE, 0xA2, 0x25, + 0xEE, 0x04, 0x68, 0x5E, 0x0B, 0xA0, 0x75, 0xF7, 0x8B, 0x66, 0xB2, 0x0F, + 0x40, 0xB5, 0x00, 0xA0, 0xE9, 0xDA, 0x57, 0xF3, 0x70, 0xF8, 0x7E, 0x3C, + 0x3C, 0x45, 0xA1, 0x90, 0xB9, 0xD9, 0xD9, 0xE5, 0xE4, 0xE4, 0xD8, 0x4A, + 0xC4, 0x42, 0x5B, 0x61, 0xCA, 0x57, 0x7D, 0xFE, 0x67, 0xC2, 0x5F, 0xC0, + 0x57, 0xFD, 0x6C, 0xF9, 0x7E, 0x3C, 0xFC, 0xF7, 0xF5, 0xE0, 0xBE, 0xE2, + 0x24, 0x81, 0x32, 0x5D, 0x81, 0x47, 0x04, 0xF8, 0xE0, 0xC2, 0xCC, 0xF4, + 0x4C, 0xA5, 0x1C, 0xCF, 0x92, 0x09, 0x84, 0x62, 0xDC, 0xE6, 0x8F, 0x47, + 0xFC, 0xB7, 0x0B, 0xFF, 0xFC, 0x1D, 0xD3, 0x22, 0xC4, 0x49, 0x62, 0xB9, + 0x58, 0x2A, 0x14, 0xE3, 0x51, 0x12, 0x71, 0x8E, 0x44, 0x9A, 0x8C, 0xF3, + 0x32, 0xA5, 0x22, 0x89, 0x42, 0x92, 0x29, 0xC5, 0x25, 0xD2, 0xFF, 0x64, + 0xE2, 0xDF, 0x2C, 0xFB, 0x03, 0x3E, 0xDF, 0x35, 0x00, 0xB0, 0x6A, 0x3E, + 0x01, 0x7B, 0x91, 0x2D, 0xA8, 0x5D, 0x63, 0x03, 0xF6, 0x4B, 0x27, 0x10, + 0x58, 0x74, 0xC0, 0xE2, 0xF7, 0x00, 0x00, 0xF2, 0xBB, 0x6F, 0xC1, 0xD4, + 0x28, 0x08, 0x03, 0x80, 0x68, 0x83, 0xE1, 0xCF, 0x77, 0xFF, 0xEF, 0x3F, + 0xFD, 0x47, 0xA0, 0x25, 0x00, 0x80, 0x66, 0x49, 0x92, 0x71, 0x00, 0x00, + 0x5E, 0x44, 0x24, 0x2E, 0x54, 0xCA, 0xB3, 0x3F, 0xC7, 0x08, 0x00, 0x00, + 0x44, 0xA0, 0x81, 0x2A, 0xB0, 0x41, 0x1B, 0xF4, 0xC1, 0x18, 0x2C, 0xC0, + 0x06, 0x1C, 0xC1, 0x05, 0xDC, 0xC1, 0x0B, 0xFC, 0x60, 0x36, 0x84, 0x42, + 0x24, 0xC4, 0xC2, 0x42, 0x10, 0x42, 0x0A, 0x64, 0x80, 0x1C, 0x72, 0x60, + 0x29, 0xAC, 0x82, 0x42, 0x28, 0x86, 0xCD, 0xB0, 0x1D, 0x2A, 0x60, 0x2F, + 0xD4, 0x40, 0x1D, 0x34, 0xC0, 0x51, 0x68, 0x86, 0x93, 0x70, 0x0E, 0x2E, + 0xC2, 0x55, 0xB8, 0x0E, 0x3D, 0x70, 0x0F, 0xFA, 0x61, 0x08, 0x9E, 0xC1, + 0x28, 0xBC, 0x81, 0x09, 0x04, 0x41, 0xC8, 0x08, 0x13, 0x61, 0x21, 0xDA, + 0x88, 0x01, 0x62, 0x8A, 0x58, 0x23, 0x8E, 0x08, 0x17, 0x99, 0x85, 0xF8, + 0x21, 0xC1, 0x48, 0x04, 0x12, 0x8B, 0x24, 0x20, 0xC9, 0x88, 0x14, 0x51, + 0x22, 0x4B, 0x91, 0x35, 0x48, 0x31, 0x52, 0x8A, 0x54, 0x20, 0x55, 0x48, + 0x1D, 0xF2, 0x3D, 0x72, 0x02, 0x39, 0x87, 0x5C, 0x46, 0xBA, 0x91, 0x3B, + 0xC8, 0x00, 0x32, 0x82, 0xFC, 0x86, 0xBC, 0x47, 0x31, 0x94, 0x81, 0xB2, + 0x51, 0x3D, 0xD4, 0x0C, 0xB5, 0x43, 0xB9, 0xA8, 0x37, 0x1A, 0x84, 0x46, + 0xA2, 0x0B, 0xD0, 0x64, 0x74, 0x31, 0x9A, 0x8F, 0x16, 0xA0, 0x9B, 0xD0, + 0x72, 0xB4, 0x1A, 0x3D, 0x8C, 0x36, 0xA1, 0xE7, 0xD0, 0xAB, 0x68, 0x0F, + 0xDA, 0x8F, 0x3E, 0x43, 0xC7, 0x30, 0xC0, 0xE8, 0x18, 0x07, 0x33, 0xC4, + 0x6C, 0x30, 0x2E, 0xC6, 0xC3, 0x42, 0xB1, 0x38, 0x2C, 0x09, 0x93, 0x63, + 0xCB, 0xB1, 0x22, 0xAC, 0x0C, 0xAB, 0xC6, 0x1A, 0xB0, 0x56, 0xAC, 0x03, + 0xBB, 0x89, 0xF5, 0x63, 0xCF, 0xB1, 0x77, 0x04, 0x12, 0x81, 0x45, 0xC0, + 0x09, 0x36, 0x04, 0x77, 0x42, 0x20, 0x61, 0x1E, 0x41, 0x48, 0x58, 0x4C, + 0x58, 0x4E, 0xD8, 0x48, 0xA8, 0x20, 0x1C, 0x24, 0x34, 0x11, 0xDA, 0x09, + 0x37, 0x09, 0x03, 0x84, 0x51, 0xC2, 0x27, 0x22, 0x93, 0xA8, 0x4B, 0xB4, + 0x26, 0xBA, 0x11, 0xF9, 0xC4, 0x18, 0x62, 0x32, 0x31, 0x87, 0x58, 0x48, + 0x2C, 0x23, 0xD6, 0x12, 0x8F, 0x13, 0x2F, 0x10, 0x7B, 0x88, 0x43, 0xC4, + 0x37, 0x24, 0x12, 0x89, 0x43, 0x32, 0x27, 0xB9, 0x90, 0x02, 0x49, 0xB1, + 0xA4, 0x54, 0xD2, 0x12, 0xD2, 0x46, 0xD2, 0x6E, 0x52, 0x23, 0xE9, 0x2C, + 0xA9, 0x9B, 0x34, 0x48, 0x1A, 0x23, 0x93, 0xC9, 0xDA, 0x64, 0x6B, 0xB2, + 0x07, 0x39, 0x94, 0x2C, 0x20, 0x2B, 0xC8, 0x85, 0xE4, 0x9D, 0xE4, 0xC3, + 0xE4, 0x33, 0xE4, 0x1B, 0xE4, 0x21, 0xF2, 0x5B, 0x0A, 0x9D, 0x62, 0x40, + 0x71, 0xA4, 0xF8, 0x53, 0xE2, 0x28, 0x52, 0xCA, 0x6A, 0x4A, 0x19, 0xE5, + 0x10, 0xE5, 0x34, 0xE5, 0x06, 0x65, 0x98, 0x32, 0x41, 0x55, 0xA3, 0x9A, + 0x52, 0xDD, 0xA8, 0xA1, 0x54, 0x11, 0x35, 0x8F, 0x5A, 0x42, 0xAD, 0xA1, + 0xB6, 0x52, 0xAF, 0x51, 0x87, 0xA8, 0x13, 0x34, 0x75, 0x9A, 0x39, 0xCD, + 0x83, 0x16, 0x49, 0x4B, 0xA5, 0xAD, 0xA2, 0x95, 0xD3, 0x1A, 0x68, 0x17, + 0x68, 0xF7, 0x69, 0xAF, 0xE8, 0x74, 0xBA, 0x11, 0xDD, 0x95, 0x1E, 0x4E, + 0x97, 0xD0, 0x57, 0xD2, 0xCB, 0xE9, 0x47, 0xE8, 0x97, 0xE8, 0x03, 0xF4, + 0x77, 0x0C, 0x0D, 0x86, 0x15, 0x83, 0xC7, 0x88, 0x67, 0x28, 0x19, 0x9B, + 0x18, 0x07, 0x18, 0x67, 0x19, 0x77, 0x18, 0xAF, 0x98, 0x4C, 0xA6, 0x19, + 0xD3, 0x8B, 0x19, 0xC7, 0x54, 0x30, 0x37, 0x31, 0xEB, 0x98, 0xE7, 0x99, + 0x0F, 0x99, 0x6F, 0x55, 0x58, 0x2A, 0xB6, 0x2A, 0x7C, 0x15, 0x91, 0xCA, + 0x0A, 0x95, 0x4A, 0x95, 0x26, 0x95, 0x1B, 0x2A, 0x2F, 0x54, 0xA9, 0xAA, + 0xA6, 0xAA, 0xDE, 0xAA, 0x0B, 0x55, 0xF3, 0x55, 0xCB, 0x54, 0x8F, 0xA9, + 0x5E, 0x53, 0x7D, 0xAE, 0x46, 0x55, 0x33, 0x53, 0xE3, 0xA9, 0x09, 0xD4, + 0x96, 0xAB, 0x55, 0xAA, 0x9D, 0x50, 0xEB, 0x53, 0x1B, 0x53, 0x67, 0xA9, + 0x3B, 0xA8, 0x87, 0xAA, 0x67, 0xA8, 0x6F, 0x54, 0x3F, 0xA4, 0x7E, 0x59, + 0xFD, 0x89, 0x06, 0x59, 0xC3, 0x4C, 0xC3, 0x4F, 0x43, 0xA4, 0x51, 0xA0, + 0xB1, 0x5F, 0xE3, 0xBC, 0xC6, 0x20, 0x0B, 0x63, 0x19, 0xB3, 0x78, 0x2C, + 0x21, 0x6B, 0x0D, 0xAB, 0x86, 0x75, 0x81, 0x35, 0xC4, 0x26, 0xB1, 0xCD, + 0xD9, 0x7C, 0x76, 0x2A, 0xBB, 0x98, 0xFD, 0x1D, 0xBB, 0x8B, 0x3D, 0xAA, + 0xA9, 0xA1, 0x39, 0x43, 0x33, 0x4A, 0x33, 0x57, 0xB3, 0x52, 0xF3, 0x94, + 0x66, 0x3F, 0x07, 0xE3, 0x98, 0x71, 0xF8, 0x9C, 0x74, 0x4E, 0x09, 0xE7, + 0x28, 0xA7, 0x97, 0xF3, 0x7E, 0x8A, 0xDE, 0x14, 0xEF, 0x29, 0xE2, 0x29, + 0x1B, 0xA6, 0x34, 0x4C, 0xB9, 0x31, 0x65, 0x5C, 0x6B, 0xAA, 0x96, 0x97, + 0x96, 0x58, 0xAB, 0x48, 0xAB, 0x51, 0xAB, 0x47, 0xEB, 0xBD, 0x36, 0xAE, + 0xED, 0xA7, 0x9D, 0xA6, 0xBD, 0x45, 0xBB, 0x59, 0xFB, 0x81, 0x0E, 0x41, + 0xC7, 0x4A, 0x27, 0x5C, 0x27, 0x47, 0x67, 0x8F, 0xCE, 0x05, 0x9D, 0xE7, + 0x53, 0xD9, 0x53, 0xDD, 0xA7, 0x0A, 0xA7, 0x16, 0x4D, 0x3D, 0x3A, 0xF5, + 0xAE, 0x2E, 0xAA, 0x6B, 0xA5, 0x1B, 0xA1, 0xBB, 0x44, 0x77, 0xBF, 0x6E, + 0xA7, 0xEE, 0x98, 0x9E, 0xBE, 0x5E, 0x80, 0x9E, 0x4C, 0x6F, 0xA7, 0xDE, + 0x79, 0xBD, 0xE7, 0xFA, 0x1C, 0x7D, 0x2F, 0xFD, 0x54, 0xFD, 0x6D, 0xFA, + 0xA7, 0xF5, 0x47, 0x0C, 0x58, 0x06, 0xB3, 0x0C, 0x24, 0x06, 0xDB, 0x0C, + 0xCE, 0x18, 0x3C, 0xC5, 0x35, 0x71, 0x6F, 0x3C, 0x1D, 0x2F, 0xC7, 0xDB, + 0xF1, 0x51, 0x43, 0x5D, 0xC3, 0x40, 0x43, 0xA5, 0x61, 0x95, 0x61, 0x97, + 0xE1, 0x84, 0x91, 0xB9, 0xD1, 0x3C, 0xA3, 0xD5, 0x46, 0x8D, 0x46, 0x0F, + 0x8C, 0x69, 0xC6, 0x5C, 0xE3, 0x24, 0xE3, 0x6D, 0xC6, 0x6D, 0xC6, 0xA3, + 0x26, 0x06, 0x26, 0x21, 0x26, 0x4B, 0x4D, 0xEA, 0x4D, 0xEE, 0x9A, 0x52, + 0x4D, 0xB9, 0xA6, 0x29, 0xA6, 0x3B, 0x4C, 0x3B, 0x4C, 0xC7, 0xCD, 0xCC, + 0xCD, 0xA2, 0xCD, 0xD6, 0x99, 0x35, 0x9B, 0x3D, 0x31, 0xD7, 0x32, 0xE7, + 0x9B, 0xE7, 0x9B, 0xD7, 0x9B, 0xDF, 0xB7, 0x60, 0x5A, 0x78, 0x5A, 0x2C, + 0xB6, 0xA8, 0xB6, 0xB8, 0x65, 0x49, 0xB2, 0xE4, 0x5A, 0xA6, 0x59, 0xEE, + 0xB6, 0xBC, 0x6E, 0x85, 0x5A, 0x39, 0x59, 0xA5, 0x58, 0x55, 0x5A, 0x5D, + 0xB3, 0x46, 0xAD, 0x9D, 0xAD, 0x25, 0xD6, 0xBB, 0xAD, 0xBB, 0xA7, 0x11, + 0xA7, 0xB9, 0x4E, 0x93, 0x4E, 0xAB, 0x9E, 0xD6, 0x67, 0xC3, 0xB0, 0xF1, + 0xB6, 0xC9, 0xB6, 0xA9, 0xB7, 0x19, 0xB0, 0xE5, 0xD8, 0x06, 0xDB, 0xAE, + 0xB6, 0x6D, 0xB6, 0x7D, 0x61, 0x67, 0x62, 0x17, 0x67, 0xB7, 0xC5, 0xAE, + 0xC3, 0xEE, 0x93, 0xBD, 0x93, 0x7D, 0xBA, 0x7D, 0x8D, 0xFD, 0x3D, 0x07, + 0x0D, 0x87, 0xD9, 0x0E, 0xAB, 0x1D, 0x5A, 0x1D, 0x7E, 0x73, 0xB4, 0x72, + 0x14, 0x3A, 0x56, 0x3A, 0xDE, 0x9A, 0xCE, 0x9C, 0xEE, 0x3F, 0x7D, 0xC5, + 0xF4, 0x96, 0xE9, 0x2F, 0x67, 0x58, 0xCF, 0x10, 0xCF, 0xD8, 0x33, 0xE3, + 0xB6, 0x13, 0xCB, 0x29, 0xC4, 0x69, 0x9D, 0x53, 0x9B, 0xD3, 0x47, 0x67, + 0x17, 0x67, 0xB9, 0x73, 0x83, 0xF3, 0x88, 0x8B, 0x89, 0x4B, 0x82, 0xCB, + 0x2E, 0x97, 0x3E, 0x2E, 0x9B, 0x1B, 0xC6, 0xDD, 0xC8, 0xBD, 0xE4, 0x4A, + 0x74, 0xF5, 0x71, 0x5D, 0xE1, 0x7A, 0xD2, 0xF5, 0x9D, 0x9B, 0xB3, 0x9B, + 0xC2, 0xED, 0xA8, 0xDB, 0xAF, 0xEE, 0x36, 0xEE, 0x69, 0xEE, 0x87, 0xDC, + 0x9F, 0xCC, 0x34, 0x9F, 0x29, 0x9E, 0x59, 0x33, 0x73, 0xD0, 0xC3, 0xC8, + 0x43, 0xE0, 0x51, 0xE5, 0xD1, 0x3F, 0x0B, 0x9F, 0x95, 0x30, 0x6B, 0xDF, + 0xAC, 0x7E, 0x4F, 0x43, 0x4F, 0x81, 0x67, 0xB5, 0xE7, 0x23, 0x2F, 0x63, + 0x2F, 0x91, 0x57, 0xAD, 0xD7, 0xB0, 0xB7, 0xA5, 0x77, 0xAA, 0xF7, 0x61, + 0xEF, 0x17, 0x3E, 0xF6, 0x3E, 0x72, 0x9F, 0xE3, 0x3E, 0xE3, 0x3C, 0x37, + 0xDE, 0x32, 0xDE, 0x59, 0x5F, 0xCC, 0x37, 0xC0, 0xB7, 0xC8, 0xB7, 0xCB, + 0x4F, 0xC3, 0x6F, 0x9E, 0x5F, 0x85, 0xDF, 0x43, 0x7F, 0x23, 0xFF, 0x64, + 0xFF, 0x7A, 0xFF, 0xD1, 0x00, 0xA7, 0x80, 0x25, 0x01, 0x67, 0x03, 0x89, + 0x81, 0x41, 0x81, 0x5B, 0x02, 0xFB, 0xF8, 0x7A, 0x7C, 0x21, 0xBF, 0x8E, + 0x3F, 0x3A, 0xDB, 0x65, 0xF6, 0xB2, 0xD9, 0xED, 0x41, 0x8C, 0xA0, 0xB9, + 0x41, 0x15, 0x41, 0x8F, 0x82, 0xAD, 0x82, 0xE5, 0xC1, 0xAD, 0x21, 0x68, + 0xC8, 0xEC, 0x90, 0xAD, 0x21, 0xF7, 0xE7, 0x98, 0xCE, 0x91, 0xCE, 0x69, + 0x0E, 0x85, 0x50, 0x7E, 0xE8, 0xD6, 0xD0, 0x07, 0x61, 0xE6, 0x61, 0x8B, + 0xC3, 0x7E, 0x0C, 0x27, 0x85, 0x87, 0x85, 0x57, 0x86, 0x3F, 0x8E, 0x70, + 0x88, 0x58, 0x1A, 0xD1, 0x31, 0x97, 0x35, 0x77, 0xD1, 0xDC, 0x43, 0x73, + 0xDF, 0x44, 0xFA, 0x44, 0x96, 0x44, 0xDE, 0x9B, 0x67, 0x31, 0x4F, 0x39, + 0xAF, 0x2D, 0x4A, 0x35, 0x2A, 0x3E, 0xAA, 0x2E, 0x6A, 0x3C, 0xDA, 0x37, + 0xBA, 0x34, 0xBA, 0x3F, 0xC6, 0x2E, 0x66, 0x59, 0xCC, 0xD5, 0x58, 0x9D, + 0x58, 0x49, 0x6C, 0x4B, 0x1C, 0x39, 0x2E, 0x2A, 0xAE, 0x36, 0x6E, 0x6C, + 0xBE, 0xDF, 0xFC, 0xED, 0xF3, 0x87, 0xE2, 0x9D, 0xE2, 0x0B, 0xE3, 0x7B, + 0x17, 0x98, 0x2F, 0xC8, 0x5D, 0x70, 0x79, 0xA1, 0xCE, 0xC2, 0xF4, 0x85, + 0xA7, 0x16, 0xA9, 0x2E, 0x12, 0x2C, 0x3A, 0x96, 0x40, 0x4C, 0x88, 0x4E, + 0x38, 0x94, 0xF0, 0x41, 0x10, 0x2A, 0xA8, 0x16, 0x8C, 0x25, 0xF2, 0x13, + 0x77, 0x25, 0x8E, 0x0A, 0x79, 0xC2, 0x1D, 0xC2, 0x67, 0x22, 0x2F, 0xD1, + 0x36, 0xD1, 0x88, 0xD8, 0x43, 0x5C, 0x2A, 0x1E, 0x4E, 0xF2, 0x48, 0x2A, + 0x4D, 0x7A, 0x92, 0xEC, 0x91, 0xBC, 0x35, 0x79, 0x24, 0xC5, 0x33, 0xA5, + 0x2C, 0xE5, 0xB9, 0x84, 0x27, 0xA9, 0x90, 0xBC, 0x4C, 0x0D, 0x4C, 0xDD, + 0x9B, 0x3A, 0x9E, 0x16, 0x9A, 0x76, 0x20, 0x6D, 0x32, 0x3D, 0x3A, 0xBD, + 0x31, 0x83, 0x92, 0x91, 0x90, 0x71, 0x42, 0xAA, 0x21, 0x4D, 0x93, 0xB6, + 0x67, 0xEA, 0x67, 0xE6, 0x66, 0x76, 0xCB, 0xAC, 0x65, 0x85, 0xB2, 0xFE, + 0xC5, 0x6E, 0x8B, 0xB7, 0x2F, 0x1E, 0x95, 0x07, 0xC9, 0x6B, 0xB3, 0x90, + 0xAC, 0x05, 0x59, 0x2D, 0x0A, 0xB6, 0x42, 0xA6, 0xE8, 0x54, 0x5A, 0x28, + 0xD7, 0x2A, 0x07, 0xB2, 0x67, 0x65, 0x57, 0x66, 0xBF, 0xCD, 0x89, 0xCA, + 0x39, 0x96, 0xAB, 0x9E, 0x2B, 0xCD, 0xED, 0xCC, 0xB3, 0xCA, 0xDB, 0x90, + 0x37, 0x9C, 0xEF, 0x9F, 0xFF, 0xED, 0x12, 0xC2, 0x12, 0xE1, 0x92, 0xB6, + 0xA5, 0x86, 0x4B, 0x57, 0x2D, 0x1D, 0x58, 0xE6, 0xBD, 0xAC, 0x6A, 0x39, + 0xB2, 0x3C, 0x71, 0x79, 0xDB, 0x0A, 0xE3, 0x15, 0x05, 0x2B, 0x86, 0x56, + 0x06, 0xAC, 0x3C, 0xB8, 0x8A, 0xB6, 0x2A, 0x6D, 0xD5, 0x4F, 0xAB, 0xED, + 0x57, 0x97, 0xAE, 0x7E, 0xBD, 0x26, 0x7A, 0x4D, 0x6B, 0x81, 0x5E, 0xC1, + 0xCA, 0x82, 0xC1, 0xB5, 0x01, 0x6B, 0xEB, 0x0B, 0x55, 0x0A, 0xE5, 0x85, + 0x7D, 0xEB, 0xDC, 0xD7, 0xED, 0x5D, 0x4F, 0x58, 0x2F, 0x59, 0xDF, 0xB5, + 0x61, 0xFA, 0x86, 0x9D, 0x1B, 0x3E, 0x15, 0x89, 0x8A, 0xAE, 0x14, 0xDB, + 0x17, 0x97, 0x15, 0x7F, 0xD8, 0x28, 0xDC, 0x78, 0xE5, 0x1B, 0x87, 0x6F, + 0xCA, 0xBF, 0x99, 0xDC, 0x94, 0xB4, 0xA9, 0xAB, 0xC4, 0xB9, 0x64, 0xCF, + 0x66, 0xD2, 0x66, 0xE9, 0xE6, 0xDE, 0x2D, 0x9E, 0x5B, 0x0E, 0x96, 0xAA, + 0x97, 0xE6, 0x97, 0x0E, 0x6E, 0x0D, 0xD9, 0xDA, 0xB4, 0x0D, 0xDF, 0x56, + 0xB4, 0xED, 0xF5, 0xF6, 0x45, 0xDB, 0x2F, 0x97, 0xCD, 0x28, 0xDB, 0xBB, + 0x83, 0xB6, 0x43, 0xB9, 0xA3, 0xBF, 0x3C, 0xB8, 0xBC, 0x65, 0xA7, 0xC9, + 0xCE, 0xCD, 0x3B, 0x3F, 0x54, 0xA4, 0x54, 0xF4, 0x54, 0xFA, 0x54, 0x36, + 0xEE, 0xD2, 0xDD, 0xB5, 0x61, 0xD7, 0xF8, 0x6E, 0xD1, 0xEE, 0x1B, 0x7B, + 0xBC, 0xF6, 0x34, 0xEC, 0xD5, 0xDB, 0x5B, 0xBC, 0xF7, 0xFD, 0x3E, 0xC9, + 0xBE, 0xDB, 0x55, 0x01, 0x55, 0x4D, 0xD5, 0x66, 0xD5, 0x65, 0xFB, 0x49, + 0xFB, 0xB3, 0xF7, 0x3F, 0xAE, 0x89, 0xAA, 0xE9, 0xF8, 0x96, 0xFB, 0x6D, + 0x5D, 0xAD, 0x4E, 0x6D, 0x71, 0xED, 0xC7, 0x03, 0xD2, 0x03, 0xFD, 0x07, + 0x23, 0x0E, 0xB6, 0xD7, 0xB9, 0xD4, 0xD5, 0x1D, 0xD2, 0x3D, 0x54, 0x52, + 0x8F, 0xD6, 0x2B, 0xEB, 0x47, 0x0E, 0xC7, 0x1F, 0xBE, 0xFE, 0x9D, 0xEF, + 0x77, 0x2D, 0x0D, 0x36, 0x0D, 0x55, 0x8D, 0x9C, 0xC6, 0xE2, 0x23, 0x70, + 0x44, 0x79, 0xE4, 0xE9, 0xF7, 0x09, 0xDF, 0xF7, 0x1E, 0x0D, 0x3A, 0xDA, + 0x76, 0x8C, 0x7B, 0xAC, 0xE1, 0x07, 0xD3, 0x1F, 0x76, 0x1D, 0x67, 0x1D, + 0x2F, 0x6A, 0x42, 0x9A, 0xF2, 0x9A, 0x46, 0x9B, 0x53, 0x9A, 0xFB, 0x5B, + 0x62, 0x5B, 0xBA, 0x4F, 0xCC, 0x3E, 0xD1, 0xD6, 0xEA, 0xDE, 0x7A, 0xFC, + 0x47, 0xDB, 0x1F, 0x0F, 0x9C, 0x34, 0x3C, 0x59, 0x79, 0x4A, 0xF3, 0x54, + 0xC9, 0x69, 0xDA, 0xE9, 0x82, 0xD3, 0x93, 0x67, 0xF2, 0xCF, 0x8C, 0x9D, + 0x95, 0x9D, 0x7D, 0x7E, 0x2E, 0xF9, 0xDC, 0x60, 0xDB, 0xA2, 0xB6, 0x7B, + 0xE7, 0x63, 0xCE, 0xDF, 0x6A, 0x0F, 0x6F, 0xEF, 0xBA, 0x10, 0x74, 0xE1, + 0xD2, 0x45, 0xFF, 0x8B, 0xE7, 0x3B, 0xBC, 0x3B, 0xCE, 0x5C, 0xF2, 0xB8, + 0x74, 0xF2, 0xB2, 0xDB, 0xE5, 0x13, 0x57, 0xB8, 0x57, 0x9A, 0xAF, 0x3A, + 0x5F, 0x6D, 0xEA, 0x74, 0xEA, 0x3C, 0xFE, 0x93, 0xD3, 0x4F, 0xC7, 0xBB, + 0x9C, 0xBB, 0x9A, 0xAE, 0xB9, 0x5C, 0x6B, 0xB9, 0xEE, 0x7A, 0xBD, 0xB5, + 0x7B, 0x66, 0xF7, 0xE9, 0x1B, 0x9E, 0x37, 0xCE, 0xDD, 0xF4, 0xBD, 0x79, + 0xF1, 0x16, 0xFF, 0xD6, 0xD5, 0x9E, 0x39, 0x3D, 0xDD, 0xBD, 0xF3, 0x7A, + 0x6F, 0xF7, 0xC5, 0xF7, 0xF5, 0xDF, 0x16, 0xDD, 0x7E, 0x72, 0x27, 0xFD, + 0xCE, 0xCB, 0xBB, 0xD9, 0x77, 0x27, 0xEE, 0xAD, 0xBC, 0x4F, 0xBC, 0x5F, + 0xF4, 0x40, 0xED, 0x41, 0xD9, 0x43, 0xDD, 0x87, 0xD5, 0x3F, 0x5B, 0xFE, + 0xDC, 0xD8, 0xEF, 0xDC, 0x7F, 0x6A, 0xC0, 0x77, 0xA0, 0xF3, 0xD1, 0xDC, + 0x47, 0xF7, 0x06, 0x85, 0x83, 0xCF, 0xFE, 0x91, 0xF5, 0x8F, 0x0F, 0x43, + 0x05, 0x8F, 0x99, 0x8F, 0xCB, 0x86, 0x0D, 0x86, 0xEB, 0x9E, 0x38, 0x3E, + 0x39, 0x39, 0xE2, 0x3F, 0x72, 0xFD, 0xE9, 0xFC, 0xA7, 0x43, 0xCF, 0x64, + 0xCF, 0x26, 0x9E, 0x17, 0xFE, 0xA2, 0xFE, 0xCB, 0xAE, 0x17, 0x16, 0x2F, + 0x7E, 0xF8, 0xD5, 0xEB, 0xD7, 0xCE, 0xD1, 0x98, 0xD1, 0xA1, 0x97, 0xF2, + 0x97, 0x93, 0xBF, 0x6D, 0x7C, 0xA5, 0xFD, 0xEA, 0xC0, 0xEB, 0x19, 0xAF, + 0xDB, 0xC6, 0xC2, 0xC6, 0x1E, 0xBE, 0xC9, 0x78, 0x33, 0x31, 0x5E, 0xF4, + 0x56, 0xFB, 0xED, 0xC1, 0x77, 0xDC, 0x77, 0x1D, 0xEF, 0xA3, 0xDF, 0x0F, + 0x4F, 0xE4, 0x7C, 0x20, 0x7F, 0x28, 0xFF, 0x68, 0xF9, 0xB1, 0xF5, 0x53, + 0xD0, 0xA7, 0xFB, 0x93, 0x19, 0x93, 0x93, 0xFF, 0x04, 0x03, 0x98, 0xF3, + 0xFC, 0x63, 0x33, 0x2D, 0xDB, 0x00, 0x00, 0x3A, 0xFD, 0x69, 0x54, 0x58, + 0x74, 0x58, 0x4D, 0x4C, 0x3A, 0x63, 0x6F, 0x6D, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x78, 0x6D, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, + 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D, + 0x22, 0x57, 0x35, 0x4D, 0x30, 0x4D, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, + 0x7A, 0x72, 0x65, 0x53, 0x7A, 0x4E, 0x54, 0x63, 0x7A, 0x6B, 0x63, 0x39, + 0x64, 0x22, 0x3F, 0x3E, 0x0A, 0x3C, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, + 0x65, 0x74, 0x61, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x3D, + 0x22, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x3A, 0x6E, 0x73, 0x3A, 0x6D, 0x65, + 0x74, 0x61, 0x2F, 0x22, 0x20, 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x74, 0x6B, + 0x3D, 0x22, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x58, 0x4D, 0x50, 0x20, + 0x43, 0x6F, 0x72, 0x65, 0x20, 0x35, 0x2E, 0x36, 0x2D, 0x63, 0x31, 0x33, + 0x38, 0x20, 0x37, 0x39, 0x2E, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2C, + 0x20, 0x32, 0x30, 0x31, 0x36, 0x2F, 0x30, 0x39, 0x2F, 0x31, 0x34, 0x2D, + 0x30, 0x31, 0x3A, 0x30, 0x39, 0x3A, 0x30, 0x31, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x72, 0x64, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, + 0x31, 0x39, 0x39, 0x39, 0x2F, 0x30, 0x32, 0x2F, 0x32, 0x32, 0x2D, 0x72, + 0x64, 0x66, 0x2D, 0x73, 0x79, 0x6E, 0x74, 0x61, 0x78, 0x2D, 0x6E, 0x73, + 0x23, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, + 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6F, 0x6E, 0x20, 0x72, 0x64, 0x66, 0x3A, 0x61, 0x62, 0x6F, 0x75, 0x74, + 0x3D, 0x22, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x78, 0x6D, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, + 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, + 0x6E, 0x73, 0x3A, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3D, 0x22, 0x68, 0x74, + 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, + 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, + 0x30, 0x2F, 0x6D, 0x6D, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, + 0x3A, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, + 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, + 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, + 0x73, 0x54, 0x79, 0x70, 0x65, 0x2F, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, + 0x63, 0x65, 0x45, 0x76, 0x65, 0x6E, 0x74, 0x23, 0x22, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, + 0x6C, 0x6E, 0x73, 0x3A, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, + 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x2F, 0x31, 0x2E, 0x30, + 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x64, 0x63, 0x3D, + 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x70, 0x75, 0x72, 0x6C, + 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x64, 0x63, 0x2F, 0x65, 0x6C, 0x65, 0x6D, + 0x65, 0x6E, 0x74, 0x73, 0x2F, 0x31, 0x2E, 0x31, 0x2F, 0x22, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, + 0x6D, 0x6C, 0x6E, 0x73, 0x3A, 0x74, 0x69, 0x66, 0x66, 0x3D, 0x22, 0x68, + 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, + 0x62, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x2F, + 0x31, 0x2E, 0x30, 0x2F, 0x22, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x78, 0x6D, 0x6C, 0x6E, 0x73, 0x3A, + 0x65, 0x78, 0x69, 0x66, 0x3D, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, + 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62, 0x65, 0x2E, 0x63, 0x6F, + 0x6D, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x22, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6F, 0x72, 0x54, + 0x6F, 0x6F, 0x6C, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, + 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, + 0x29, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x6F, 0x72, 0x54, 0x6F, 0x6F, 0x6C, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, + 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, + 0x39, 0x3A, 0x35, 0x38, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, + 0x78, 0x6D, 0x70, 0x3A, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, + 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, + 0x35, 0x38, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x3A, 0x4D, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x44, 0x61, + 0x74, 0x65, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x3A, 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, + 0x44, 0x61, 0x74, 0x65, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, + 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x35, 0x38, + 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x3A, + 0x4D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x44, 0x61, 0x74, 0x65, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x30, + 0x33, 0x33, 0x35, 0x64, 0x33, 0x38, 0x61, 0x2D, 0x64, 0x62, 0x31, 0x61, + 0x2D, 0x37, 0x38, 0x34, 0x31, 0x2D, 0x38, 0x38, 0x33, 0x34, 0x2D, 0x39, + 0x65, 0x36, 0x61, 0x61, 0x63, 0x37, 0x39, 0x30, 0x65, 0x64, 0x34, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x49, 0x6E, 0x73, 0x74, 0x61, + 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x44, + 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x3E, 0x61, 0x64, + 0x6F, 0x62, 0x65, 0x3A, 0x64, 0x6F, 0x63, 0x69, 0x64, 0x3A, 0x70, 0x68, + 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x66, 0x36, 0x38, 0x37, + 0x35, 0x30, 0x30, 0x66, 0x2D, 0x33, 0x35, 0x62, 0x34, 0x2D, 0x31, 0x31, + 0x65, 0x38, 0x2D, 0x39, 0x31, 0x61, 0x34, 0x2D, 0x38, 0x38, 0x34, 0x37, + 0x30, 0x37, 0x30, 0x65, 0x31, 0x35, 0x34, 0x62, 0x3C, 0x2F, 0x78, 0x6D, + 0x70, 0x4D, 0x4D, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, + 0x69, 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, + 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x30, + 0x33, 0x31, 0x65, 0x39, 0x31, 0x33, 0x65, 0x2D, 0x31, 0x30, 0x65, 0x34, + 0x2D, 0x30, 0x65, 0x34, 0x61, 0x2D, 0x38, 0x39, 0x64, 0x61, 0x2D, 0x34, + 0x32, 0x31, 0x36, 0x34, 0x33, 0x36, 0x33, 0x36, 0x63, 0x32, 0x35, 0x3C, + 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x4F, 0x72, 0x69, 0x67, 0x69, + 0x6E, 0x61, 0x6C, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x49, + 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x78, 0x6D, 0x70, 0x4D, 0x4D, 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, + 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, + 0x20, 0x72, 0x64, 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x3D, 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, + 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, + 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, + 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x69, 0x69, 0x64, 0x3A, 0x30, 0x33, 0x31, 0x65, 0x39, 0x31, + 0x33, 0x65, 0x2D, 0x31, 0x30, 0x65, 0x34, 0x2D, 0x30, 0x65, 0x34, 0x61, + 0x2D, 0x38, 0x39, 0x64, 0x61, 0x2D, 0x34, 0x32, 0x31, 0x36, 0x34, 0x33, + 0x36, 0x33, 0x36, 0x63, 0x32, 0x35, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, + 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, + 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, + 0x2D, 0x30, 0x34, 0x2D, 0x30, 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, + 0x3A, 0x35, 0x38, 0x2B, 0x30, 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, + 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, + 0x74, 0x3E, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, + 0x37, 0x20, 0x28, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, + 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x20, 0x72, 0x64, + 0x66, 0x3A, 0x70, 0x61, 0x72, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x3D, + 0x22, 0x52, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x22, 0x3E, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, + 0x3A, 0x61, 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x73, 0x61, 0x76, 0x65, + 0x64, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x61, 0x63, 0x74, + 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, + 0x63, 0x65, 0x49, 0x44, 0x3E, 0x78, 0x6D, 0x70, 0x2E, 0x69, 0x69, 0x64, + 0x3A, 0x30, 0x33, 0x33, 0x35, 0x64, 0x33, 0x38, 0x61, 0x2D, 0x64, 0x62, + 0x31, 0x61, 0x2D, 0x37, 0x38, 0x34, 0x31, 0x2D, 0x38, 0x38, 0x33, 0x34, + 0x2D, 0x39, 0x65, 0x36, 0x61, 0x61, 0x63, 0x37, 0x39, 0x30, 0x65, 0x64, + 0x34, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x69, 0x6E, 0x73, + 0x74, 0x61, 0x6E, 0x63, 0x65, 0x49, 0x44, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x77, 0x68, + 0x65, 0x6E, 0x3E, 0x32, 0x30, 0x31, 0x38, 0x2D, 0x30, 0x34, 0x2D, 0x30, + 0x31, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x39, 0x3A, 0x35, 0x38, 0x2B, 0x30, + 0x38, 0x3A, 0x30, 0x30, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, + 0x77, 0x68, 0x65, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, + 0x61, 0x72, 0x65, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3E, 0x41, 0x64, 0x6F, + 0x62, 0x65, 0x20, 0x50, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x20, 0x43, 0x43, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, 0x28, 0x57, 0x69, + 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x29, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, + 0x74, 0x3A, 0x73, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67, + 0x65, 0x6E, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, 0x68, 0x61, 0x6E, 0x67, 0x65, + 0x64, 0x3E, 0x2F, 0x3C, 0x2F, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3A, 0x63, + 0x68, 0x61, 0x6E, 0x67, 0x65, 0x64, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, + 0x64, 0x66, 0x3A, 0x53, 0x65, 0x71, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x78, 0x6D, 0x70, 0x4D, 0x4D, + 0x3A, 0x48, 0x69, 0x73, 0x74, 0x6F, 0x72, 0x79, 0x3E, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, + 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, + 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, 0x67, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x3C, 0x72, 0x64, 0x66, 0x3A, 0x6C, 0x69, 0x3E, 0x78, 0x6D, + 0x70, 0x2E, 0x64, 0x69, 0x64, 0x3A, 0x39, 0x30, 0x39, 0x62, 0x39, 0x65, + 0x35, 0x32, 0x2D, 0x39, 0x37, 0x62, 0x64, 0x2D, 0x34, 0x32, 0x39, 0x33, + 0x2D, 0x38, 0x30, 0x64, 0x32, 0x2D, 0x31, 0x31, 0x64, 0x65, 0x62, 0x64, + 0x36, 0x61, 0x33, 0x33, 0x65, 0x62, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, + 0x6C, 0x69, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x42, 0x61, + 0x67, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, + 0x44, 0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x41, 0x6E, 0x63, 0x65, + 0x73, 0x74, 0x6F, 0x72, 0x73, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, + 0x6F, 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, + 0x3E, 0x33, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, + 0x70, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x4D, 0x6F, 0x64, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x70, + 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x3A, 0x49, 0x43, 0x43, + 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, 0x73, 0x52, 0x47, 0x42, + 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2D, 0x32, 0x2E, + 0x31, 0x3C, 0x2F, 0x70, 0x68, 0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, + 0x3A, 0x49, 0x43, 0x43, 0x50, 0x72, 0x6F, 0x66, 0x69, 0x6C, 0x65, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, + 0x63, 0x3A, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x69, 0x6D, 0x61, + 0x67, 0x65, 0x2F, 0x70, 0x6E, 0x67, 0x3C, 0x2F, 0x64, 0x63, 0x3A, 0x66, + 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, + 0x69, 0x65, 0x6E, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x4F, 0x72, 0x69, 0x65, 0x6E, 0x74, + 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x58, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, + 0x65, 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x3C, + 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x59, 0x52, 0x65, 0x73, 0x6F, 0x6C, + 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x3C, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, + 0x73, 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, + 0x3E, 0x32, 0x3C, 0x2F, 0x74, 0x69, 0x66, 0x66, 0x3A, 0x52, 0x65, 0x73, + 0x6F, 0x6C, 0x75, 0x74, 0x69, 0x6F, 0x6E, 0x55, 0x6E, 0x69, 0x74, 0x3E, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, + 0x63, 0x65, 0x3E, 0x31, 0x3C, 0x2F, 0x65, 0x78, 0x69, 0x66, 0x3A, 0x43, + 0x6F, 0x6C, 0x6F, 0x72, 0x53, 0x70, 0x61, 0x63, 0x65, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, + 0x78, 0x69, 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x58, 0x44, 0x69, + 0x6D, 0x65, 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x65, 0x78, 0x69, 0x66, 0x3A, + 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, 0x6E, 0x73, + 0x69, 0x6F, 0x6E, 0x3E, 0x31, 0x32, 0x30, 0x3C, 0x2F, 0x65, 0x78, 0x69, + 0x66, 0x3A, 0x50, 0x69, 0x78, 0x65, 0x6C, 0x59, 0x44, 0x69, 0x6D, 0x65, + 0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x3C, 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x3C, + 0x2F, 0x72, 0x64, 0x66, 0x3A, 0x52, 0x44, 0x46, 0x3E, 0x0A, 0x3C, 0x2F, + 0x78, 0x3A, 0x78, 0x6D, 0x70, 0x6D, 0x65, 0x74, 0x61, 0x3E, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x3C, + 0x3F, 0x78, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20, 0x65, 0x6E, 0x64, + 0x3D, 0x22, 0x77, 0x22, 0x3F, 0x3E, 0x52, 0x1E, 0x40, 0x1C, 0x00, 0x00, + 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x25, 0x00, 0x00, + 0x80, 0x83, 0x00, 0x00, 0xF9, 0xFF, 0x00, 0x00, 0x80, 0xE9, 0x00, 0x00, + 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, + 0x17, 0x6F, 0x92, 0x5F, 0xC5, 0x46, 0x00, 0x00, 0x0F, 0xB6, 0x49, 0x44, + 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9D, 0x79, 0x94, 0x1C, 0x55, 0x15, 0xC6, + 0x7F, 0x3D, 0x7B, 0xB6, 0x21, 0x99, 0x6C, 0x10, 0x82, 0xC3, 0x12, 0x96, + 0x84, 0x18, 0x59, 0x13, 0x20, 0x91, 0x7D, 0x09, 0x04, 0x10, 0x34, 0x78, + 0x3C, 0x08, 0x02, 0xC1, 0x13, 0x8E, 0xE2, 0x71, 0x41, 0x51, 0x96, 0x28, + 0x22, 0xCA, 0x2E, 0x02, 0x46, 0x59, 0xC4, 0x05, 0x3D, 0x0A, 0x82, 0xEC, + 0x08, 0x42, 0x02, 0xB2, 0xC8, 0x2E, 0xA0, 0x01, 0x02, 0x21, 0x81, 0x24, + 0x98, 0x90, 0x90, 0x6D, 0x92, 0xC9, 0x4C, 0x66, 0xA6, 0x33, 0x33, 0xD7, + 0x3F, 0xEE, 0xED, 0x33, 0xCD, 0xD0, 0x5D, 0xFD, 0xAA, 0xA7, 0xAA, 0xBA, + 0x66, 0xA6, 0xEE, 0x39, 0x75, 0xD2, 0x67, 0x52, 0x5D, 0xFD, 0xDE, 0xFB, + 0xEA, 0xDD, 0x77, 0xEF, 0x7D, 0xDF, 0xBD, 0x2F, 0x25, 0x22, 0x24, 0xD2, + 0x77, 0xA5, 0x2C, 0x19, 0x82, 0x04, 0xE0, 0x44, 0x12, 0x80, 0x13, 0x89, + 0xAB, 0x54, 0xF4, 0x93, 0x7E, 0x6E, 0x03, 0x0C, 0x06, 0x52, 0x40, 0x03, + 0xD0, 0x9C, 0x00, 0xDC, 0x37, 0x64, 0x30, 0x30, 0x1D, 0x38, 0x1A, 0xA8, + 0x05, 0x04, 0xD8, 0x08, 0x3C, 0x08, 0x3C, 0xD3, 0x1F, 0x80, 0x4E, 0xF5, + 0x61, 0x2B, 0xBA, 0x12, 0xF8, 0x16, 0x70, 0x26, 0x50, 0x0F, 0x94, 0xDB, + 0xDF, 0xDB, 0x81, 0x45, 0xC0, 0x6D, 0x76, 0x75, 0x24, 0x00, 0xF7, 0x4E, + 0xDB, 0xE2, 0x18, 0x60, 0x2E, 0xB0, 0x93, 0xA9, 0xE6, 0x6C, 0xE9, 0x04, + 0xDE, 0x04, 0xCE, 0x05, 0x9E, 0xB3, 0x99, 0x9D, 0x18, 0x59, 0xBD, 0x48, + 0xAA, 0x80, 0x19, 0x79, 0xC0, 0xCD, 0xF4, 0x7B, 0x82, 0xA9, 0xEF, 0x3E, + 0xBD, 0x4C, 0xF5, 0x55, 0x80, 0x2B, 0x81, 0x1D, 0xF3, 0x80, 0x9B, 0x6D, + 0x7F, 0x8C, 0x49, 0x00, 0xEE, 0xBD, 0xFD, 0x72, 0x01, 0xAE, 0x3C, 0xF1, + 0x83, 0x13, 0x49, 0x00, 0x4E, 0x24, 0x01, 0x38, 0x91, 0x04, 0xE0, 0x44, + 0x12, 0x80, 0x13, 0x49, 0x00, 0x4E, 0x24, 0x01, 0x38, 0x01, 0xB8, 0x8F, + 0x48, 0x2A, 0x81, 0x37, 0xBC, 0x28, 0xCE, 0xA7, 0xD0, 0x30, 0x21, 0xC0, + 0x1B, 0xC0, 0x86, 0x64, 0xA8, 0x3F, 0x26, 0x93, 0x80, 0xA1, 0xF6, 0x79, + 0x31, 0xB0, 0xAA, 0xB7, 0x00, 0x3C, 0x08, 0xDD, 0xBD, 0x39, 0x06, 0xD8, + 0xD6, 0xFE, 0xB6, 0x04, 0x78, 0x1A, 0x78, 0x18, 0x58, 0x19, 0xD1, 0x00, + 0x0A, 0xBA, 0x6B, 0x54, 0x48, 0xCA, 0x89, 0x76, 0xA3, 0xA1, 0x1E, 0x98, + 0x89, 0x6E, 0x5F, 0x0E, 0xB3, 0xBF, 0x7D, 0x60, 0x63, 0x73, 0x27, 0xD0, + 0x1A, 0x67, 0x80, 0x6B, 0x81, 0x0B, 0x81, 0xD3, 0x81, 0x91, 0x59, 0xCF, + 0x9E, 0x08, 0x4C, 0xB5, 0xCE, 0xDD, 0x6C, 0x1D, 0x0A, 0x5B, 0xD2, 0xC0, + 0x6A, 0x87, 0xFB, 0x3E, 0x8C, 0x10, 0xE0, 0x5D, 0xD1, 0xED, 0xCB, 0x93, + 0x81, 0x11, 0x59, 0xE3, 0x33, 0x09, 0xD8, 0x1B, 0xD8, 0x0E, 0xB8, 0x0E, + 0x68, 0x0B, 0xF6, 0x55, 0x17, 0x09, 0xE2, 0xAA, 0x12, 0x91, 0xD9, 0x22, + 0xB2, 0x46, 0x72, 0x4B, 0xA7, 0x88, 0xAC, 0x12, 0x91, 0xAB, 0x45, 0xA4, + 0x3E, 0xA0, 0xDF, 0xF4, 0xBA, 0xCA, 0x45, 0x64, 0xBA, 0xFD, 0x66, 0x3E, + 0x59, 0x24, 0x22, 0x53, 0x45, 0xA4, 0x2C, 0x82, 0xF6, 0xEC, 0x26, 0x22, + 0xB7, 0x88, 0xC8, 0x3A, 0x8F, 0xF1, 0x59, 0x6A, 0xED, 0x09, 0xF4, 0xB7, + 0x83, 0x32, 0xB2, 0x06, 0x02, 0x87, 0xD8, 0xCC, 0xCD, 0x67, 0xF0, 0x8C, + 0xB6, 0xD9, 0x7D, 0x2E, 0xB0, 0x43, 0xC8, 0xB3, 0xA5, 0x03, 0x78, 0x01, + 0xB8, 0x01, 0x58, 0x9E, 0xE3, 0xFF, 0x17, 0x01, 0xBF, 0x32, 0xFB, 0xA0, + 0x33, 0xE4, 0xB6, 0xEC, 0x02, 0x7C, 0xD7, 0x54, 0xF3, 0x70, 0x8F, 0xF1, + 0xA9, 0xB7, 0xD9, 0x3D, 0x20, 0x8E, 0x2A, 0xBA, 0x3C, 0x6B, 0x4D, 0xA1, + 0x00, 0xC8, 0x67, 0xDA, 0xE7, 0x1B, 0x80, 0x15, 0x21, 0x0E, 0x6C, 0x23, + 0xF0, 0x5B, 0x60, 0x21, 0x70, 0x7C, 0xD6, 0xE0, 0x7E, 0x68, 0x6B, 0xDE, + 0xAB, 0xC0, 0xE6, 0x90, 0xC1, 0xDD, 0x19, 0xF8, 0x01, 0xF0, 0x05, 0xA0, + 0xCE, 0x61, 0x7C, 0x76, 0x01, 0x6A, 0x80, 0x96, 0xB8, 0x01, 0xDC, 0xE9, + 0x38, 0x13, 0x52, 0x36, 0xCB, 0xBF, 0x62, 0x9F, 0xAF, 0x0F, 0x11, 0x64, + 0x01, 0xD6, 0x02, 0xF3, 0x80, 0xFF, 0x02, 0xD5, 0xF6, 0xF7, 0x16, 0xE0, + 0x23, 0x5B, 0xA7, 0xC3, 0x06, 0xF7, 0x42, 0x03, 0x77, 0x98, 0xE3, 0x77, + 0x36, 0x38, 0x1A, 0x87, 0x91, 0x03, 0xBC, 0x05, 0x78, 0x05, 0x65, 0x51, + 0xB8, 0xC8, 0xA8, 0x2C, 0x90, 0xAF, 0x0B, 0xD9, 0xBA, 0x6E, 0xC9, 0x61, + 0xD8, 0x49, 0x44, 0xE0, 0xCE, 0xCC, 0x72, 0x87, 0x5C, 0xE4, 0x31, 0x1B, + 0xCB, 0xD8, 0x05, 0x3A, 0xDA, 0x80, 0xBF, 0x02, 0x2F, 0xFA, 0xF8, 0x4E, + 0x66, 0x26, 0x9F, 0x1F, 0xC1, 0x9A, 0x2C, 0xDD, 0xAE, 0xB0, 0xD7, 0xDC, + 0x39, 0xC0, 0x29, 0x3E, 0xC1, 0x7D, 0xC8, 0xEC, 0x86, 0x8E, 0x38, 0x02, + 0x9C, 0xF1, 0x77, 0x7F, 0x02, 0xBC, 0xEE, 0xE3, 0x3B, 0x23, 0x80, 0x2F, + 0x03, 0xDF, 0xF6, 0x30, 0xD0, 0x7A, 0x93, 0x8C, 0x06, 0x2E, 0x02, 0x3E, + 0x8F, 0x72, 0xB1, 0x5D, 0x65, 0x3E, 0x70, 0xB5, 0xA3, 0x6B, 0x57, 0x32, + 0x80, 0xDB, 0x81, 0xA7, 0xEC, 0xED, 0x7D, 0xCD, 0x27, 0xC8, 0xA7, 0x03, + 0x27, 0xA1, 0x64, 0xB9, 0xDE, 0x2A, 0xD5, 0xC0, 0x19, 0x45, 0x80, 0x3B, + 0x0F, 0xB8, 0xCC, 0x96, 0xB8, 0xAD, 0x71, 0x8F, 0x64, 0xB5, 0x00, 0x4F, + 0x9A, 0x9A, 0xF9, 0x29, 0xB0, 0x9F, 0x0F, 0x75, 0x7D, 0x22, 0xF0, 0x68, + 0xC0, 0x46, 0xD7, 0x00, 0xB3, 0x4A, 0xB7, 0xCD, 0x8A, 0xAC, 0xAD, 0xB6, + 0xD0, 0xE0, 0x96, 0x80, 0x0D, 0xAD, 0xED, 0x81, 0x13, 0x8A, 0x58, 0x73, + 0x33, 0xE0, 0x86, 0x62, 0xF4, 0x85, 0x11, 0x8B, 0x6E, 0x45, 0x43, 0x93, + 0x73, 0x80, 0x9F, 0x01, 0xFB, 0xFA, 0x50, 0x6F, 0x83, 0x7A, 0xF0, 0xBB, + 0xDB, 0x00, 0x7B, 0x02, 0x7B, 0xD9, 0x20, 0x6F, 0x6B, 0xCF, 0xAC, 0xB2, + 0xFF, 0xAB, 0xCD, 0x72, 0x9F, 0x36, 0xA1, 0x59, 0x0D, 0x6B, 0xCD, 0x6D, + 0x6A, 0x34, 0xAD, 0xB3, 0x90, 0xE2, 0xB3, 0x1D, 0x86, 0xD9, 0xEF, 0xB9, + 0xCA, 0xE3, 0x36, 0x09, 0x42, 0x03, 0x37, 0x2C, 0x80, 0xB3, 0x41, 0xBE, + 0xD8, 0xDE, 0xD0, 0xFD, 0x43, 0x6A, 0x4B, 0x2D, 0x30, 0x05, 0x38, 0x0A, + 0xDD, 0xDC, 0xA8, 0x37, 0x60, 0xAB, 0xED, 0xAA, 0xB2, 0x65, 0xA8, 0x2C, + 0x6B, 0x39, 0xEA, 0xCC, 0xBA, 0xDA, 0xAC, 0xAD, 0x6D, 0x36, 0xAB, 0x97, + 0x01, 0x0B, 0x6C, 0xF0, 0x17, 0x01, 0x4D, 0x3E, 0x0D, 0x39, 0xD7, 0x1D, + 0xAC, 0x47, 0x81, 0xCB, 0x81, 0x97, 0xC3, 0x76, 0xD7, 0xC2, 0xCE, 0x6C, + 0xA8, 0x01, 0xA6, 0x01, 0x97, 0xD8, 0xBF, 0x5E, 0x72, 0x37, 0x1A, 0xE5, + 0x5A, 0xEB, 0xF0, 0xDC, 0x09, 0xC0, 0x64, 0xE0, 0x38, 0xFB, 0x3C, 0xC6, + 0xD4, 0x71, 0xA5, 0x01, 0xE9, 0x77, 0xAB, 0x50, 0x0C, 0xF0, 0xB4, 0x05, + 0x3F, 0x56, 0x00, 0x6F, 0x03, 0xF7, 0x03, 0xFF, 0x04, 0xD6, 0x3B, 0x3C, + 0x63, 0x2C, 0xF0, 0x47, 0xE0, 0xB0, 0x02, 0xF7, 0xDD, 0x6F, 0x06, 0xD5, + 0xAB, 0x11, 0xF8, 0xE2, 0x10, 0x41, 0x1C, 0xB6, 0x5A, 0x44, 0x0E, 0x17, + 0x91, 0xE7, 0x3C, 0xE2, 0xC2, 0x2B, 0x44, 0xE4, 0x04, 0x8B, 0x21, 0x7B, + 0x3D, 0xAB, 0x4E, 0x44, 0x4E, 0x15, 0x91, 0x47, 0x45, 0x64, 0xB9, 0x88, + 0x34, 0x5B, 0x1C, 0x37, 0x68, 0x69, 0x17, 0x91, 0x26, 0x11, 0x79, 0x4F, + 0x44, 0xEE, 0x11, 0x91, 0x13, 0x45, 0xA4, 0xB6, 0x40, 0xDB, 0x2A, 0x45, + 0xE4, 0x0C, 0x11, 0xD9, 0xE0, 0xF1, 0xDC, 0x07, 0x44, 0x64, 0x8A, 0xC5, + 0xEE, 0xA3, 0x18, 0xFB, 0x48, 0x00, 0xCE, 0x80, 0x7C, 0xA4, 0x0D, 0x56, + 0x73, 0xB7, 0x81, 0x7C, 0x43, 0x44, 0xCE, 0x15, 0x91, 0x11, 0x1E, 0xDF, + 0x1F, 0x28, 0x22, 0x07, 0x8B, 0xC8, 0x1D, 0x16, 0x94, 0x6F, 0x09, 0x09, + 0xD8, 0x5C, 0x9B, 0x00, 0x2D, 0x22, 0xB2, 0xD8, 0x36, 0x0B, 0xF6, 0x2E, + 0xD0, 0xCF, 0x51, 0x22, 0x72, 0x81, 0x88, 0xBC, 0xDF, 0xED, 0x39, 0x8D, + 0x22, 0xF2, 0x7B, 0x11, 0x99, 0x16, 0x25, 0xB8, 0x22, 0x12, 0x69, 0xF2, + 0x59, 0x0D, 0xBA, 0x25, 0x36, 0xDD, 0x54, 0x6A, 0x95, 0xA9, 0xBE, 0x97, + 0x2C, 0x94, 0xD8, 0x98, 0x27, 0xDC, 0x39, 0x1A, 0x98, 0x05, 0x9C, 0x86, + 0xA6, 0xA3, 0x0C, 0x20, 0x7A, 0xB6, 0x86, 0xD8, 0x7A, 0xFC, 0x0E, 0xF0, + 0x6B, 0xE0, 0x01, 0x34, 0xCF, 0x38, 0x57, 0x28, 0xB6, 0xCE, 0x0C, 0xCB, + 0xC9, 0x66, 0x23, 0xB4, 0x00, 0x4B, 0xCD, 0xD7, 0x5D, 0x13, 0x89, 0x5A, + 0x8E, 0x70, 0x0D, 0xCE, 0x35, 0x00, 0x43, 0xCC, 0x00, 0x4A, 0x99, 0xDF, + 0xD7, 0xEC, 0xD1, 0xE9, 0x4F, 0x99, 0x35, 0xFE, 0x39, 0x73, 0xA5, 0x4A, + 0x4D, 0xC3, 0xE9, 0x30, 0x63, 0xEC, 0x2F, 0x16, 0x62, 0xFD, 0x28, 0xCF, + 0x7D, 0x55, 0xD6, 0xCF, 0x72, 0x7B, 0x69, 0x5B, 0xAD, 0x9F, 0x91, 0x67, + 0x31, 0xC6, 0x35, 0x7D, 0x34, 0x05, 0x7C, 0xC6, 0xC0, 0x3D, 0xD2, 0x67, + 0xE0, 0x20, 0x8A, 0xD9, 0xDC, 0x60, 0xB3, 0xF8, 0x12, 0xE0, 0x7F, 0x71, + 0x8E, 0xBE, 0xC4, 0x15, 0xE0, 0xC3, 0xCD, 0xC5, 0x3A, 0x90, 0x80, 0xF7, + 0x47, 0x03, 0x94, 0xCD, 0xC0, 0xDF, 0x81, 0xEF, 0xC7, 0x19, 0xE4, 0x38, + 0x02, 0x3C, 0x05, 0xB8, 0x02, 0xA5, 0xF9, 0x14, 0x1B, 0xBA, 0x6C, 0x44, + 0x37, 0xF3, 0xD7, 0x98, 0x8F, 0xBB, 0xD2, 0xAE, 0x32, 0x8B, 0x38, 0x8D, + 0x31, 0x9B, 0x60, 0x14, 0xB0, 0x0F, 0x5D, 0x5B, 0x89, 0x7E, 0x65, 0x8B, + 0xCD, 0xE4, 0xF3, 0xC2, 0x88, 0x23, 0xC7, 0x39, 0xD0, 0x51, 0xAC, 0x8C, + 0x02, 0xBE, 0x07, 0x1C, 0x54, 0x04, 0xB8, 0x9D, 0x16, 0x38, 0xF8, 0x17, + 0xBA, 0xF1, 0xF1, 0x1A, 0x5D, 0xFB, 0xAB, 0x2D, 0x74, 0x71, 0x9D, 0xAA, + 0xB3, 0x7C, 0xE6, 0xE1, 0x16, 0x84, 0xD9, 0x15, 0x38, 0x14, 0xE5, 0x47, + 0xF9, 0x91, 0x81, 0x16, 0x9E, 0xDC, 0x00, 0x5C, 0xE0, 0x33, 0x30, 0xD2, + 0xEF, 0x66, 0xF0, 0x60, 0xE0, 0xC7, 0xC0, 0x39, 0xF6, 0xD9, 0x8F, 0xE1, + 0xF3, 0x92, 0x05, 0x4A, 0x5E, 0x04, 0xDE, 0x33, 0xA3, 0xAD, 0x29, 0xCB, + 0x2A, 0x97, 0x1C, 0x6B, 0x3C, 0x66, 0x04, 0x0D, 0xB2, 0xD9, 0xBC, 0x87, + 0xBD, 0x58, 0x33, 0x6D, 0x56, 0xFB, 0x91, 0x8D, 0x16, 0x76, 0xFC, 0x79, + 0x02, 0x70, 0x7E, 0x99, 0x6D, 0xAA, 0xB9, 0xCE, 0xC7, 0x77, 0x96, 0xA1, + 0x4C, 0xCD, 0x79, 0x06, 0x6C, 0x33, 0xC5, 0x33, 0x22, 0xAA, 0x6C, 0x66, + 0xEF, 0x81, 0x12, 0x17, 0xCE, 0x31, 0x8D, 0xE2, 0x2A, 0xCB, 0x81, 0xAF, + 0x03, 0x8F, 0xC4, 0x0A, 0xE1, 0x28, 0x9D, 0x6E, 0x8F, 0x6B, 0x3F, 0x11, + 0x79, 0xC5, 0x67, 0x10, 0xE2, 0x31, 0x11, 0x99, 0x21, 0x22, 0x43, 0x1D, + 0x22, 0x60, 0x7E, 0xAE, 0x0A, 0x0B, 0xBA, 0x9C, 0x2E, 0x22, 0xAF, 0xFA, + 0x68, 0x4F, 0x87, 0xB5, 0x69, 0xE7, 0x98, 0x8C, 0x69, 0xA0, 0xAC, 0xCA, + 0x9E, 0x48, 0x1D, 0xF0, 0x55, 0x73, 0x8B, 0x5C, 0xE5, 0xCF, 0x28, 0xC7, + 0xF8, 0x09, 0x53, 0x8F, 0x41, 0xB2, 0x20, 0xDA, 0x81, 0x75, 0xC0, 0x7D, + 0xC0, 0x0F, 0xED, 0x37, 0x5C, 0xA4, 0xCC, 0xE2, 0xED, 0x27, 0x13, 0xA3, + 0xB4, 0x99, 0x38, 0x00, 0x7C, 0x98, 0xA9, 0xC4, 0x4A, 0xC7, 0xFB, 0x7F, + 0x63, 0x06, 0xCD, 0xBB, 0x84, 0x90, 0x09, 0x90, 0x25, 0x4D, 0xE8, 0x46, + 0xC3, 0x37, 0xD1, 0x0D, 0x02, 0x57, 0xA3, 0x6B, 0x16, 0x4A, 0x64, 0x4F, + 0x00, 0x36, 0x77, 0xE5, 0x44, 0x34, 0x84, 0xE9, 0x22, 0x77, 0x02, 0x97, + 0x9A, 0xCB, 0xD3, 0x19, 0x41, 0xFB, 0x5A, 0xD0, 0xF0, 0xE4, 0xB5, 0xC0, + 0xB3, 0x8E, 0xDF, 0xD9, 0x0D, 0x65, 0x52, 0x56, 0x25, 0x00, 0x6B, 0x20, + 0xE3, 0x68, 0xDC, 0xAA, 0xDD, 0xBC, 0x82, 0x6E, 0xB3, 0x45, 0x99, 0x6E, + 0x92, 0x71, 0xBF, 0xFE, 0x0D, 0x5C, 0x69, 0x86, 0x9C, 0x8B, 0xEB, 0x79, + 0x02, 0x9A, 0xB2, 0xD3, 0xAF, 0x01, 0x1E, 0x08, 0x1C, 0xE0, 0x68, 0xA9, + 0xAE, 0x32, 0x0B, 0x7B, 0x21, 0xA5, 0xA9, 0x4A, 0xD7, 0x86, 0x52, 0x91, + 0xAE, 0xC2, 0x8D, 0x2C, 0xBF, 0x87, 0x45, 0xE3, 0xCA, 0xFB, 0x33, 0xC0, + 0xE3, 0xD0, 0x0D, 0xFB, 0x42, 0x6D, 0x68, 0xB7, 0x35, 0xF0, 0x31, 0x82, + 0x4E, 0xCC, 0xF2, 0x27, 0xAD, 0xB6, 0x44, 0xCC, 0x77, 0xB8, 0xB7, 0xD2, + 0x6C, 0x8B, 0xD1, 0xFD, 0x19, 0xE0, 0x09, 0xB6, 0x5E, 0xB9, 0xF8, 0x97, + 0x7F, 0x20, 0x60, 0x42, 0x78, 0x91, 0xB2, 0x19, 0xB8, 0x05, 0xB7, 0x7C, + 0xE7, 0x43, 0x2D, 0x42, 0xD6, 0x2F, 0x01, 0xAE, 0x03, 0x8E, 0xC0, 0x2D, + 0x54, 0xFA, 0x28, 0xFE, 0xB8, 0xD6, 0x61, 0xCB, 0x53, 0x68, 0x29, 0x62, + 0x97, 0x25, 0x68, 0x9F, 0x52, 0x1B, 0x5B, 0xA5, 0x02, 0xB8, 0x16, 0xB7, + 0x70, 0x60, 0x0B, 0x70, 0x2F, 0x01, 0xE7, 0xEB, 0x04, 0xB0, 0x1E, 0xDF, + 0xE1, 0xE8, 0x7B, 0x1F, 0x89, 0xBF, 0xC8, 0x5C, 0x9F, 0x01, 0x78, 0x88, + 0x63, 0xC7, 0x5F, 0x44, 0xC9, 0x69, 0x71, 0xDB, 0xF2, 0x7A, 0x0D, 0xB7, + 0x44, 0xF6, 0x1D, 0xE9, 0x19, 0x15, 0xB8, 0xC7, 0x92, 0x4F, 0x45, 0x0E, + 0x46, 0xB7, 0xEB, 0x46, 0xE3, 0x56, 0xE6, 0x20, 0x65, 0xEE, 0x44, 0x33, + 0x4A, 0xBF, 0x59, 0x5C, 0xE0, 0xFE, 0x51, 0x74, 0x11, 0xD1, 0xBD, 0x64, + 0x3E, 0xBA, 0xF5, 0x17, 0x37, 0xF9, 0xD0, 0x82, 0x20, 0x3B, 0x39, 0xBC, + 0xC8, 0x43, 0x1D, 0xED, 0x91, 0x89, 0xB8, 0xD1, 0x91, 0x52, 0x74, 0xB1, + 0x40, 0x57, 0xA0, 0xF9, 0x4C, 0x2D, 0x7E, 0x00, 0x1E, 0x0F, 0x7C, 0xCD, + 0xFC, 0xD3, 0x81, 0x3E, 0x67, 0x79, 0x1A, 0xA5, 0x9B, 0x5E, 0xE5, 0xB1, + 0x4E, 0x55, 0xA0, 0x04, 0xF5, 0x1A, 0x87, 0xE7, 0x2D, 0x23, 0x9E, 0xB2, + 0x05, 0xDD, 0x9A, 0x9C, 0x55, 0xE0, 0xBE, 0x11, 0x78, 0xA7, 0x8E, 0xD6, + 0xA2, 0x74, 0xA4, 0x59, 0x36, 0xDB, 0x2B, 0x7D, 0xB4, 0xA1, 0x13, 0xE5, + 0xB4, 0x3D, 0x62, 0x46, 0xE8, 0x62, 0x17, 0x80, 0xEB, 0xD0, 0x6C, 0xBF, + 0x99, 0xA6, 0x5A, 0x8A, 0xE1, 0x17, 0x8F, 0x41, 0xF9, 0x53, 0xDF, 0xB0, + 0x41, 0xC8, 0xF5, 0x9B, 0xE3, 0x1D, 0x9E, 0xD5, 0x88, 0x46, 0x91, 0xE2, + 0x2A, 0x9B, 0x1C, 0xEE, 0x19, 0x60, 0xDA, 0x2A, 0x95, 0x43, 0x0B, 0x96, + 0xA3, 0xC5, 0x6A, 0x2E, 0x41, 0xB9, 0x67, 0xE5, 0x45, 0x8C, 0xF7, 0x18, + 0x94, 0xEC, 0x5F, 0x85, 0x6E, 0x57, 0x6E, 0x2A, 0xB4, 0x06, 0xCF, 0x30, + 0x70, 0x87, 0xD0, 0x45, 0x20, 0xF7, 0x73, 0x95, 0xA1, 0x1B, 0xEA, 0x7B, + 0xA3, 0x89, 0x58, 0x43, 0xF2, 0x34, 0xCC, 0x85, 0x41, 0xB1, 0x94, 0xDC, + 0xE5, 0x17, 0xE2, 0x22, 0x6B, 0x71, 0x4B, 0x73, 0xC9, 0x37, 0x51, 0x76, + 0x04, 0xCE, 0x32, 0x35, 0x5F, 0x59, 0xE4, 0x78, 0x67, 0x2A, 0x2B, 0x9C, + 0x46, 0x1E, 0xC2, 0x7D, 0x77, 0x80, 0x27, 0x7B, 0x80, 0xE2, 0x77, 0x6D, + 0x3F, 0xCC, 0x82, 0x19, 0xB9, 0xD6, 0x10, 0x17, 0xF7, 0x68, 0x23, 0xD1, + 0xC4, 0x9B, 0x8B, 0x95, 0x77, 0x71, 0xCB, 0x78, 0xC8, 0xB7, 0xAE, 0x8E, + 0x45, 0xF3, 0xA8, 0x82, 0x30, 0x74, 0x47, 0x03, 0x9F, 0x76, 0x01, 0x78, + 0x48, 0x80, 0x03, 0x30, 0xCC, 0xC3, 0x82, 0x74, 0x51, 0x45, 0x5B, 0x63, + 0x0E, 0x70, 0x13, 0x6E, 0x1C, 0xE7, 0x7C, 0x06, 0x6A, 0x15, 0xC1, 0x51, + 0xA6, 0x52, 0xE4, 0x21, 0x27, 0x76, 0x07, 0x38, 0xC8, 0x8A, 0x74, 0xAB, + 0xC8, 0x4D, 0x0E, 0x17, 0x47, 0x1F, 0x32, 0xEE, 0xE5, 0xF6, 0x47, 0x3A, + 0xBA, 0x40, 0xE2, 0xE1, 0x4F, 0x07, 0x49, 0x82, 0x6F, 0x71, 0x01, 0x78, + 0x81, 0xA9, 0xC6, 0x20, 0xE4, 0x31, 0x53, 0x63, 0x7E, 0x3A, 0xDD, 0xDD, + 0x02, 0x8D, 0x73, 0x42, 0xF8, 0xEE, 0xE4, 0x2F, 0x8B, 0xD4, 0x5D, 0x13, + 0xE5, 0xEA, 0xEF, 0x62, 0xE0, 0xF9, 0x80, 0xDA, 0xB2, 0x0C, 0x8D, 0xB0, + 0x15, 0x04, 0xF8, 0x49, 0xB4, 0xF4, 0x50, 0x4F, 0xCB, 0xF8, 0x3C, 0x87, + 0xD6, 0x9C, 0xD8, 0x9A, 0xC7, 0xBC, 0x77, 0x61, 0x1F, 0xEE, 0x82, 0x5B, + 0xAC, 0xBA, 0x54, 0x52, 0xED, 0xF0, 0x02, 0x8A, 0x79, 0x03, 0xB9, 0x00, + 0x5E, 0x03, 0xDC, 0x6A, 0x71, 0x83, 0x9E, 0xC8, 0x06, 0x94, 0x04, 0xF1, + 0xB2, 0x8B, 0x9B, 0xB4, 0x12, 0x2D, 0x10, 0xD6, 0x66, 0x7E, 0xF0, 0x10, + 0xC7, 0x59, 0x24, 0x59, 0xC0, 0xBD, 0x02, 0xFC, 0x0E, 0x3D, 0x78, 0x2A, + 0x97, 0x7B, 0xB0, 0x15, 0xF8, 0x8F, 0xC3, 0x33, 0x07, 0x9A, 0xFB, 0xF0, + 0x7C, 0x0C, 0x23, 0x59, 0x65, 0xB8, 0xD5, 0x14, 0x69, 0x36, 0x43, 0x2C, + 0x57, 0xFB, 0x33, 0xC5, 0xDA, 0xBE, 0x63, 0x7E, 0xF0, 0x5E, 0x16, 0x1B, + 0x70, 0x5D, 0x9A, 0xDA, 0x50, 0x2E, 0xF6, 0x9D, 0x28, 0x37, 0x3B, 0xED, + 0x02, 0x70, 0x87, 0xB9, 0x26, 0xD7, 0xA2, 0x34, 0xD4, 0xC1, 0x8E, 0xCE, + 0x77, 0xCA, 0xBE, 0xDB, 0x6C, 0xEE, 0xCD, 0x46, 0x8F, 0x75, 0x56, 0x4C, + 0x3D, 0x35, 0x51, 0x98, 0x1E, 0xBB, 0xBB, 0x0D, 0x66, 0xDC, 0x8E, 0x9F, + 0xDB, 0x06, 0xAD, 0xEC, 0xE7, 0xE2, 0x09, 0xAC, 0x2D, 0xF0, 0x02, 0x3C, + 0x63, 0xC1, 0xA1, 0x7A, 0xFC, 0x25, 0xD6, 0xA5, 0xED, 0xD9, 0xCB, 0xBC, + 0xD6, 0xF2, 0x8A, 0x3C, 0x2A, 0xB4, 0x81, 0xE2, 0x43, 0x84, 0x2E, 0x60, + 0x34, 0x98, 0x6A, 0x29, 0x04, 0xF0, 0x74, 0xE0, 0x97, 0x76, 0x6F, 0x9C, + 0x66, 0xF1, 0x48, 0x0A, 0x27, 0xB4, 0x67, 0x82, 0x21, 0x8D, 0x0E, 0xE3, + 0xB5, 0x1A, 0xB7, 0xC4, 0x77, 0xDF, 0xE3, 0x5D, 0x56, 0xE0, 0x8B, 0xC5, + 0x5C, 0x2E, 0xD2, 0xE8, 0xD8, 0xA1, 0x3D, 0xD1, 0x54, 0x96, 0xB8, 0xA9, + 0xE8, 0xA9, 0xB8, 0x31, 0x51, 0xDE, 0x72, 0x8C, 0x78, 0x85, 0x36, 0xDE, + 0xA5, 0xDA, 0x4D, 0x5A, 0x8F, 0x06, 0xEB, 0x5D, 0xA2, 0x40, 0xA7, 0x50, + 0xE2, 0x1D, 0x99, 0x6E, 0x52, 0x0B, 0x7C, 0xC9, 0x71, 0xE9, 0x9A, 0x4F, + 0x89, 0x8B, 0xA1, 0x97, 0x0A, 0xE0, 0x26, 0x33, 0x30, 0x5C, 0x76, 0xA9, + 0x0E, 0x45, 0xC9, 0x79, 0x71, 0x91, 0x63, 0xD1, 0x88, 0x9F, 0x8B, 0x96, + 0x5A, 0x5A, 0xEA, 0x60, 0x4D, 0x29, 0x29, 0x3B, 0x0B, 0x51, 0xB6, 0x62, + 0x21, 0x19, 0x0B, 0x9C, 0x6A, 0x56, 0x75, 0xA9, 0x65, 0x04, 0x1A, 0x63, + 0x1F, 0xEA, 0x70, 0xEF, 0xB3, 0xC4, 0x60, 0x37, 0xAC, 0x94, 0x00, 0xBF, + 0x6F, 0xC1, 0x90, 0x42, 0x52, 0x81, 0x72, 0xA7, 0xCF, 0xC2, 0xDF, 0x76, + 0x5A, 0xD0, 0x52, 0x85, 0x56, 0x01, 0x3A, 0xD8, 0xF1, 0xFE, 0x7F, 0x58, + 0x1F, 0xFB, 0x2D, 0xC0, 0x69, 0xBA, 0x52, 0x3D, 0x0B, 0xC9, 0x70, 0x34, + 0xB1, 0xAB, 0x94, 0xAA, 0xFA, 0x38, 0x7B, 0xC9, 0x5C, 0xEC, 0x81, 0x97, + 0x6C, 0xFD, 0xED, 0xEC, 0xCF, 0x00, 0x63, 0xD1, 0x97, 0x27, 0x1C, 0xAD, + 0xE4, 0xF1, 0x68, 0xA1, 0xCF, 0x09, 0x25, 0x68, 0xE7, 0x01, 0x68, 0x39, + 0x89, 0x7A, 0xC7, 0xFB, 0x9F, 0x26, 0x9A, 0xB3, 0x29, 0x62, 0x0F, 0x70, + 0x03, 0x70, 0x8F, 0xE3, 0x60, 0xA4, 0x50, 0x12, 0xDB, 0x15, 0x44, 0x97, + 0x35, 0x90, 0x32, 0x37, 0xED, 0x7A, 0xDC, 0x4B, 0x32, 0xBE, 0x00, 0xDC, + 0x45, 0x3C, 0x68, 0xBE, 0xB1, 0x48, 0x3E, 0x7B, 0x0E, 0xF8, 0x1B, 0xEE, + 0xC7, 0xE0, 0xCC, 0x40, 0x13, 0xAD, 0xA7, 0x52, 0x7C, 0xE9, 0x05, 0x17, + 0xA9, 0xB6, 0x40, 0xCB, 0x5C, 0x03, 0xD9, 0x45, 0x5A, 0x81, 0x3F, 0xA1, + 0x44, 0xC1, 0x58, 0x48, 0x5C, 0x12, 0xC0, 0x77, 0x45, 0x03, 0xE6, 0x87, + 0x38, 0xDE, 0xDF, 0x81, 0x86, 0xF7, 0x6E, 0x45, 0x29, 0xAC, 0xEB, 0x02, + 0x6E, 0xCF, 0x76, 0x68, 0xB1, 0xF2, 0xD9, 0x68, 0xF5, 0x76, 0x57, 0xB9, + 0x0F, 0x4D, 0x1C, 0x5F, 0x9B, 0x00, 0xFC, 0x49, 0x39, 0x19, 0x0D, 0x4B, + 0x6E, 0xEF, 0xE3, 0x3B, 0x1B, 0xD1, 0x60, 0xFB, 0xFD, 0xB6, 0x9E, 0x37, + 0x04, 0xE0, 0x06, 0x4D, 0x45, 0xB3, 0x03, 0x67, 0xE2, 0xAF, 0xC2, 0xCF, + 0x22, 0x94, 0x87, 0x36, 0x9F, 0x18, 0x49, 0x9C, 0x00, 0xAE, 0x46, 0x09, + 0x7F, 0x17, 0xE1, 0xBF, 0x74, 0xD2, 0x5B, 0x68, 0x64, 0xEC, 0x61, 0xFB, + 0xBC, 0x12, 0xF7, 0xF0, 0x66, 0x39, 0xBA, 0x6B, 0x35, 0xC9, 0xD4, 0xFF, + 0x11, 0x3E, 0x67, 0x6D, 0xE6, 0x45, 0x3B, 0xCF, 0xD4, 0x73, 0x7B, 0x02, + 0x70, 0x7E, 0x19, 0x83, 0xB2, 0x03, 0x4F, 0x2B, 0xC2, 0xE7, 0x15, 0x94, + 0x60, 0xF0, 0x8E, 0x59, 0xE6, 0xEF, 0xA2, 0x61, 0xC2, 0x15, 0xE8, 0xFE, + 0x76, 0x47, 0x96, 0xDD, 0xB1, 0x3D, 0xBA, 0x23, 0x34, 0xD4, 0x0C, 0xB6, + 0x23, 0xD1, 0xBD, 0xE7, 0x1D, 0x8B, 0x68, 0x73, 0x0B, 0x9A, 0x5A, 0x7A, + 0x15, 0xA5, 0x4D, 0x8E, 0xEB, 0x15, 0x00, 0x63, 0x6E, 0xD0, 0x1C, 0x34, + 0xDE, 0x5B, 0x6C, 0x29, 0x84, 0xCC, 0x2E, 0x4E, 0x93, 0x01, 0x9D, 0x39, + 0x46, 0x27, 0x65, 0x9A, 0x62, 0x77, 0x5B, 0x67, 0xAB, 0x51, 0xEE, 0xD8, + 0xE0, 0x1E, 0xB4, 0xF7, 0x66, 0xB4, 0x18, 0xDA, 0x66, 0x62, 0x28, 0x71, + 0xAD, 0x74, 0x37, 0xC9, 0x54, 0xF5, 0xC9, 0x04, 0x43, 0xDB, 0xC9, 0x14, + 0x00, 0xCF, 0x50, 0x7B, 0x83, 0xA8, 0xA1, 0x91, 0x06, 0x6E, 0x37, 0x8B, + 0x7E, 0x11, 0x31, 0x95, 0x38, 0xD7, 0xAA, 0x9C, 0x48, 0xD7, 0x91, 0x70, + 0x83, 0x62, 0xD6, 0xBE, 0xF5, 0xC0, 0x4D, 0xE8, 0xE9, 0x6D, 0x0D, 0xC4, + 0x8F, 0x90, 0x50, 0x52, 0x80, 0x33, 0x2C, 0x91, 0x32, 0x9B, 0x05, 0x69, + 0x8F, 0xB5, 0x6B, 0x9C, 0xA9, 0xEA, 0xD9, 0x84, 0x7F, 0xB6, 0x92, 0xAB, + 0x7B, 0xB6, 0xC4, 0xD4, 0xF2, 0x4D, 0x1E, 0xED, 0xAE, 0x44, 0x37, 0x47, + 0xAA, 0x50, 0x8A, 0x52, 0x3B, 0x25, 0xAA, 0x82, 0x17, 0x25, 0xC0, 0x83, + 0xD0, 0xD2, 0x06, 0xA7, 0xD2, 0xC5, 0xE6, 0x6F, 0x40, 0xCF, 0x47, 0x98, + 0x67, 0xBE, 0x63, 0xAE, 0xD8, 0x6D, 0x15, 0xBA, 0x27, 0x3C, 0xCB, 0xFC, + 0xE4, 0x52, 0xD1, 0x69, 0x5B, 0xAC, 0x9D, 0xB7, 0x03, 0x0F, 0xE6, 0xB1, + 0x96, 0x53, 0x68, 0x52, 0xDD, 0xF1, 0x28, 0xF1, 0xBF, 0xD6, 0x5E, 0xE0, + 0x85, 0x28, 0x05, 0x6A, 0x09, 0xC5, 0x1F, 0xFA, 0x51, 0x9C, 0x44, 0x58, + 0xF1, 0xFD, 0x14, 0x2B, 0xEB, 0x9F, 0xEE, 0x56, 0x40, 0xEC, 0x03, 0x11, + 0xB9, 0x52, 0x44, 0xB6, 0xF3, 0xF8, 0x7E, 0x99, 0x88, 0x8C, 0x17, 0x91, + 0xEB, 0xAD, 0xE2, 0x7B, 0x5A, 0xA2, 0x93, 0x56, 0x11, 0x59, 0x28, 0x22, + 0x97, 0x89, 0xC8, 0x4E, 0x05, 0x8E, 0xA3, 0x1D, 0x2B, 0x22, 0x73, 0x45, + 0x64, 0x7D, 0xB7, 0x67, 0x6C, 0x16, 0x91, 0xF9, 0x56, 0xB8, 0xAD, 0x3A, + 0xCA, 0x42, 0x68, 0x51, 0x82, 0xFB, 0xBA, 0xC7, 0x20, 0xAE, 0x11, 0x91, + 0xB3, 0x1D, 0xCE, 0xF2, 0x1D, 0x64, 0xE7, 0x27, 0xDC, 0x6A, 0xE7, 0x29, + 0xB4, 0xDA, 0xB1, 0x00, 0x61, 0x9C, 0xD9, 0xD0, 0x2C, 0x22, 0x6F, 0x8B, + 0xC8, 0x8D, 0x22, 0x72, 0x8C, 0x1D, 0x2B, 0x40, 0x81, 0x97, 0xF0, 0xFC, + 0x6E, 0x47, 0x16, 0x74, 0x97, 0x67, 0x44, 0xE4, 0x58, 0x11, 0xA9, 0x89, + 0x0A, 0xE0, 0xB0, 0xAB, 0xCD, 0x0E, 0xB0, 0xA8, 0xD0, 0x45, 0x78, 0x67, + 0x14, 0x8E, 0x34, 0x35, 0xFC, 0x38, 0xDE, 0xB5, 0x97, 0x9B, 0x4D, 0x3D, + 0x3E, 0x85, 0x16, 0x0E, 0x3D, 0xCC, 0xFE, 0xDD, 0xDD, 0x96, 0x80, 0xEA, + 0x22, 0x55, 0x78, 0x86, 0xF6, 0xDB, 0x6A, 0x6B, 0xE5, 0x02, 0x8B, 0x8C, + 0x3D, 0x89, 0xD2, 0x80, 0x5D, 0x5C, 0xA0, 0x9D, 0xAD, 0xAF, 0x5E, 0xC4, + 0x84, 0xCF, 0x5A, 0x1B, 0x2B, 0x89, 0xA8, 0xA8, 0x4C, 0x98, 0x00, 0xD7, + 0x58, 0x87, 0xE7, 0x18, 0x00, 0x85, 0xA4, 0x0E, 0x77, 0xD6, 0x46, 0x23, + 0xBA, 0xA1, 0xFE, 0x84, 0xAD, 0xEB, 0x93, 0x51, 0x82, 0xDE, 0x34, 0x0B, + 0x37, 0xD6, 0xD0, 0x55, 0x45, 0xB6, 0xDC, 0xC3, 0x60, 0xDA, 0x62, 0x57, + 0xE6, 0xC8, 0xD9, 0x67, 0x2D, 0x12, 0xF6, 0x32, 0x5A, 0x13, 0xCB, 0x4F, + 0x54, 0x2A, 0x13, 0x38, 0x29, 0x24, 0x93, 0xD1, 0x12, 0x89, 0x62, 0x20, + 0xA7, 0x7B, 0x23, 0xC0, 0x35, 0xE8, 0x19, 0x7E, 0x17, 0x3B, 0x82, 0x4B, + 0x91, 0xBE, 0xE9, 0x56, 0xB4, 0xF0, 0xF7, 0x1B, 0x66, 0x8C, 0x4D, 0xB0, + 0x41, 0x1E, 0x63, 0xE1, 0xC7, 0xDD, 0xD0, 0xCC, 0xBB, 0x4E, 0xBA, 0x76, + 0xCE, 0x3A, 0xEC, 0xF3, 0x6A, 0xF3, 0x5F, 0x97, 0xD3, 0x75, 0xFA, 0xD9, + 0xC2, 0x1E, 0x86, 0x1A, 0x5D, 0xFB, 0xB0, 0x5F, 0x37, 0x90, 0xB7, 0xF6, + 0x26, 0x80, 0x33, 0x6A, 0xF9, 0x47, 0xB8, 0x97, 0x11, 0x12, 0x94, 0xA0, + 0xD6, 0x13, 0x06, 0x62, 0x9A, 0x4F, 0x66, 0x4C, 0xD4, 0x9A, 0x5B, 0xD6, + 0x91, 0x35, 0x93, 0x33, 0x00, 0x6F, 0x0E, 0xD8, 0x75, 0x59, 0x83, 0x72, + 0xB0, 0x5C, 0xD3, 0x6D, 0xF6, 0x47, 0xEB, 0x63, 0x57, 0xA1, 0x59, 0xFA, + 0xAD, 0xBD, 0x01, 0xE0, 0x01, 0xC0, 0x17, 0x4D, 0x2D, 0x8F, 0xF3, 0xF1, + 0xBD, 0x95, 0xE8, 0x49, 0x26, 0xEB, 0x03, 0x6E, 0x4F, 0x23, 0xD1, 0xD5, + 0xF8, 0x58, 0x81, 0xEE, 0x6C, 0x4D, 0xC1, 0xFD, 0x10, 0x91, 0x7D, 0x6D, + 0xAC, 0x52, 0xE8, 0xF9, 0x0F, 0x81, 0x83, 0x5C, 0x16, 0xF0, 0xCB, 0x32, + 0xB3, 0x08, 0x70, 0x3F, 0x42, 0xF3, 0xA1, 0xE6, 0x11, 0xEF, 0x7C, 0x60, + 0x17, 0x2D, 0x74, 0x2F, 0x70, 0x1B, 0xFE, 0xD8, 0x1C, 0x7B, 0x9B, 0x11, + 0x3A, 0x9D, 0x30, 0x98, 0xA3, 0x01, 0x9A, 0xE4, 0x07, 0x99, 0xBF, 0xE8, + 0xE7, 0x54, 0xB1, 0x95, 0x76, 0x52, 0x58, 0x6D, 0x9C, 0x8A, 0x68, 0xF7, + 0xF0, 0xAA, 0x13, 0x91, 0x6B, 0xEC, 0xB4, 0x33, 0x3F, 0xF2, 0xBC, 0x88, + 0x8C, 0x8B, 0x6B, 0x41, 0xF0, 0xC1, 0xE6, 0xE6, 0x8C, 0xF7, 0xF1, 0xB6, + 0x7F, 0x08, 0xDC, 0x68, 0xB3, 0x37, 0x0A, 0x35, 0x5A, 0x1E, 0x51, 0x14, + 0x6C, 0x03, 0x7A, 0xB2, 0xE8, 0x2D, 0xF8, 0xDB, 0x61, 0x3A, 0x10, 0xDD, + 0x8B, 0x2E, 0x8B, 0xA3, 0x8A, 0xAE, 0xF2, 0x61, 0x2D, 0x67, 0x83, 0x7B, + 0x33, 0xE1, 0x6E, 0xB3, 0x95, 0x9B, 0x45, 0x3F, 0x1A, 0xAD, 0xAC, 0xB7, + 0x17, 0x4A, 0xC1, 0x0D, 0x3B, 0xB1, 0xBC, 0x01, 0xDD, 0x23, 0xBE, 0xD9, + 0xA7, 0x21, 0x37, 0x8D, 0x80, 0x37, 0x56, 0x82, 0xAC, 0x11, 0xE1, 0xE2, + 0x5E, 0x74, 0x1A, 0xB8, 0x37, 0xD8, 0x5A, 0xB5, 0x29, 0xC4, 0x41, 0xAE, + 0xB0, 0x98, 0xF7, 0xA1, 0x68, 0xAE, 0xF3, 0x78, 0x7B, 0xB9, 0x16, 0xA0, + 0xDC, 0xA9, 0xC7, 0x43, 0xD6, 0x1C, 0xEB, 0x51, 0x06, 0x68, 0x07, 0x5A, + 0x77, 0xCC, 0xC5, 0xF0, 0xAA, 0x0E, 0xDA, 0xF0, 0x0D, 0xEA, 0x61, 0x69, + 0xEB, 0x50, 0xA7, 0x87, 0x56, 0xC8, 0x54, 0x66, 0x9B, 0x6B, 0xE0, 0x6E, + 0x0C, 0x79, 0x16, 0x0D, 0x43, 0xCB, 0xF1, 0x9F, 0xCD, 0xC7, 0x29, 0x40, + 0x13, 0xD1, 0xFC, 0xA2, 0x4B, 0xAD, 0x1D, 0xCD, 0x21, 0xCF, 0xE4, 0x6B, + 0xEC, 0xC5, 0x9A, 0x8D, 0x77, 0xC9, 0x87, 0x0E, 0x34, 0xDB, 0x3F, 0xD8, + 0xF6, 0x04, 0xB4, 0x98, 0x97, 0x89, 0xC8, 0x49, 0x76, 0x0E, 0x70, 0x67, + 0x9E, 0x13, 0x49, 0x96, 0x8A, 0xC8, 0x79, 0x22, 0xB2, 0x4D, 0x04, 0x86, + 0x4E, 0xCA, 0xCE, 0xF2, 0xF5, 0x32, 0x74, 0x96, 0x59, 0x9B, 0x53, 0x11, + 0x19, 0x5E, 0x97, 0x8B, 0xC8, 0x3A, 0x8F, 0xF1, 0x79, 0x53, 0x44, 0x26, + 0xC5, 0xD5, 0xC8, 0xEA, 0xB4, 0xF8, 0xF0, 0x6D, 0x36, 0x4B, 0x5B, 0x2D, + 0x3A, 0xB3, 0xD5, 0x3E, 0x2F, 0x41, 0xC9, 0xE3, 0x61, 0xAB, 0xE5, 0x6C, + 0x7F, 0xFC, 0x28, 0xBC, 0xCB, 0x42, 0xD5, 0xA3, 0x5C, 0xAC, 0x28, 0xF2, + 0x9D, 0x36, 0xD8, 0x4C, 0x9E, 0x8B, 0xC6, 0xDA, 0xBB, 0x8F, 0xCF, 0xFB, + 0x28, 0x17, 0x6D, 0x41, 0x9C, 0x03, 0x1D, 0x9B, 0x50, 0xDA, 0xEB, 0x5B, + 0x68, 0xB2, 0xD8, 0xF0, 0x2C, 0x3F, 0xF7, 0x2E, 0x34, 0x0F, 0x29, 0x2A, + 0xDE, 0x52, 0x05, 0x6E, 0xD5, 0x6C, 0x6B, 0x89, 0x8E, 0xFC, 0xDF, 0x80, + 0x1E, 0x49, 0xBB, 0xC0, 0xE2, 0x05, 0x43, 0xCD, 0x76, 0x59, 0x8D, 0x72, + 0xBB, 0x1F, 0x8F, 0x7B, 0x24, 0x4B, 0x6C, 0x1D, 0xBE, 0xDB, 0x82, 0x16, + 0x99, 0x7A, 0x13, 0x4D, 0x44, 0x5F, 0x31, 0x36, 0xE5, 0xA3, 0x6F, 0x51, + 0x9E, 0x71, 0xD4, 0x68, 0xC1, 0x90, 0x27, 0x2D, 0xA8, 0x21, 0x16, 0x14, + 0xD9, 0x14, 0xE6, 0x9B, 0x1E, 0x86, 0x6C, 0x8C, 0xC0, 0x88, 0x72, 0x79, + 0xE1, 0xE2, 0x2A, 0x91, 0x8D, 0x4F, 0x19, 0x7D, 0x57, 0xA4, 0x97, 0xBF, + 0x04, 0x09, 0xC0, 0x89, 0x24, 0x00, 0x27, 0x00, 0x27, 0x43, 0x90, 0x00, + 0x9C, 0x48, 0x02, 0x70, 0x22, 0x09, 0xC0, 0x89, 0x24, 0x00, 0x07, 0x2C, + 0xA9, 0x80, 0xEE, 0x49, 0x00, 0x8E, 0xA1, 0x74, 0xE2, 0x56, 0xF3, 0x3A, + 0x9D, 0x00, 0xDC, 0x3B, 0x25, 0x8D, 0xD2, 0x61, 0xBD, 0xF6, 0xA8, 0xDB, + 0xF0, 0xCF, 0x7D, 0x4E, 0x00, 0x8E, 0x89, 0xB4, 0xA3, 0xB5, 0x32, 0xDE, + 0xCE, 0x03, 0x60, 0x1A, 0xCD, 0x58, 0xB8, 0xAF, 0xAF, 0x03, 0x5C, 0xD1, + 0x47, 0xFB, 0xD5, 0x81, 0x12, 0xCA, 0x87, 0xA1, 0xB5, 0x33, 0x76, 0xA0, + 0x8B, 0x8F, 0x95, 0x21, 0xCB, 0xFF, 0x02, 0x25, 0xBE, 0xF7, 0xE9, 0x70, + 0x65, 0x5C, 0x13, 0xC0, 0x83, 0xD4, 0x50, 0x87, 0xA3, 0x95, 0xEA, 0x86, + 0xD3, 0xC5, 0x07, 0x7B, 0x88, 0x18, 0x67, 0xE5, 0x27, 0x00, 0xF7, 0xCC, + 0xAA, 0xEE, 0x37, 0x1D, 0xEE, 0xCB, 0x2A, 0x3A, 0x97, 0xF4, 0x2B, 0x60, + 0xFB, 0x83, 0x1F, 0x9C, 0x48, 0x02, 0x70, 0xDF, 0x97, 0xFF, 0x0F, 0x00, + 0xAE, 0x7B, 0xCD, 0x15, 0x78, 0xF2, 0x40, 0xF8, 0x00, 0x00, 0x00, 0x00, + 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 +}; +} +static unsigned char* visuals_icon = raw::visuals; +}
\ No newline at end of file diff --git a/internal_rewrite/identity.cpp b/internal_rewrite/identity.cpp new file mode 100644 index 0000000..d17bb29 --- /dev/null +++ b/internal_rewrite/identity.cpp @@ -0,0 +1,110 @@ +#include "identity.hpp"
+#include "settings.hpp"
+#include "interface.hpp"
+#include "pattern.hpp"
+
+#include "context.hpp"
+
+namespace features
+{
+ void c_identity::clantag_changer( ) {
+ static auto fn_offset = pattern::first_code_match( g_csgo.m_engine.dll( ), xors( "53 56 57 8B DA 8B F9 FF 15" ) );
+ static auto fn = reinterpret_cast< void( __fastcall* )( const char*, const char* ) >( fn_offset );
+ static bool was_enabled = false;
+
+ if ( !g_settings.misc.clantag_changer( ) ) {
+ if ( was_enabled ) {
+ fn( "", " " );
+ static cvar_t* cl_clanid = g_csgo.m_cvar( )->FindVar( xors( "cl_clanid" ) );
+ auto backup_val = cl_clanid->get_int( );
+ cl_clanid->set_value( 0 );
+ cl_clanid->set_value( backup_val );
+ was_enabled = false;
+ }
+
+ return;
+ }
+
+ static const std::string moneybot_string = xors( "moneybot " );
+ static std::string clantag_str = moneybot_string;
+
+ static auto next_settime = g_csgo.m_globals->m_curtime;
+ auto curtime = g_csgo.m_globals->m_curtime;
+
+ if( !was_enabled || std::abs( curtime - next_settime ) > 1.f ) {
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+
+ if( nci ) {
+ auto tick = TIME_TO_TICKS( g_ctx.pred_time( ) + nci->GetLatency( 0 ) );
+ clantag_str = moneybot_string;
+ if( tick % 15 )
+ return;
+
+ next_settime = curtime;
+ }
+ }
+
+ was_enabled = true;
+
+ if ( curtime > next_settime ) {
+ const int length = clantag_str.length( );
+ clantag_str.insert( 0, 1, clantag_str[ length - 2 ] );
+ clantag_str.erase( length - 1, 1 );
+
+ std::string set = clantag_str;
+ set.resize( 15 );
+ set[ 14 ] = '$';
+
+ auto is_full = set.find( xors( "moneybot" ) ) != std::string::npos;
+
+ next_settime = curtime + ( is_full ? 0.85f : 0.4f );
+ fn( set.c_str( ), set.c_str( ) );
+ }
+ }
+
+ void c_identity::name_changer( ) {
+ static auto cvar = g_csgo.m_cvar( )->FindVar( xors( "name" ) );
+ auto set_name = [ ]( const char* name ) {
+ *( int* )( uintptr_t( &cvar->m_change_callback ) + 0xc ) = 0;
+ cvar->set_value( name );
+ };
+
+ static bool activated = false;
+ static char original_name[ 100 ]{ };
+
+ if( !g_settings.misc.name_changer ) {
+ if( activated ) {
+ set_name( original_name );
+ }
+
+ activated = false;
+ return;
+ }
+
+ if( !activated ) {
+ strcpy( original_name, cvar->get_string( ) );
+ if( g_settings.misc.name_changer == 1 ) {
+ char new_name[ 128 ];
+ memset( new_name, '$', sizeof( new_name ) );
+ set_name( new_name );
+ }
+ if( g_settings.misc.name_changer == 2 ) {
+ set_name( xors( "moneybot.cc" ) );
+ }
+ if( g_settings.misc.name_changer == 101 ) {
+ set_name( "\n\xAD\xAD\xAD" );
+ }
+ }
+ else if( g_settings.misc.name_changer == 101 ) {
+ char new_name[ 15 ];
+ for( size_t i{ }; i < 15; ++i ) {
+ auto is_upper = !( math::random_number( 0, 256 ) & 1 );
+ new_name[ i ] = is_upper ? math::random_number( 65, 90 ) : math::random_number( 97, 122 );
+ }
+
+ set_name( new_name );
+ }
+
+ activated = true;
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/identity.hpp b/internal_rewrite/identity.hpp new file mode 100644 index 0000000..aecba35 --- /dev/null +++ b/internal_rewrite/identity.hpp @@ -0,0 +1,16 @@ +#pragma once +#include "sdk.hpp" + +namespace features +{ + class c_identity { + private: + void clantag_changer( ); + void name_changer( ); + public: + void operator()( ) { + clantag_changer( ); + name_changer( ); + } + }; +}
\ No newline at end of file diff --git a/internal_rewrite/iface_dllmain_impl.hpp b/internal_rewrite/iface_dllmain_impl.hpp new file mode 100644 index 0000000..f8209ec --- /dev/null +++ b/internal_rewrite/iface_dllmain_impl.hpp @@ -0,0 +1,82 @@ +#pragma once + +namespace factory +{ + namespace interfaces + { + class c_interface_manager { + struct reg { + char m_key; + uintptr_t m_ptr; + uintptr_t m_module; + char m_module_name[ 64 ]; + char m_name[ 64 ]; + }; + + size_t m_count; + reg* m_regs; + + void decrypt_str( char* buf, size_t size, char key ) { + for( size_t i{ }; i < size; ++i ) { + buf[ i ] ^= key; + } + } + + public: + void init( uintptr_t iface_addr ) { + m_count = *( size_t* )( iface_addr ); + m_regs = ( reg* )( iface_addr + 4 ); + } + + template < typename t = void* > + t find_interface( const std::string& module_, std::string name ) { + if( !::isdigit( name[ name.length( ) - 1 ] ) ) + name += '0'; + + char name_buf[ 64 ]; + char module_buf[ 64 ]; + + for( size_t i{ }; i < m_count; ++i ) { + auto& reg = m_regs[ i ]; + + memcpy( name_buf, reg.m_name, 64 ); + memcpy( module_buf, reg.m_module_name, 64 ); + + decrypt_str( name_buf, 64, reg.m_key ); + decrypt_str( module_buf, 64, reg.m_key ); + + if( !module_.compare( module_buf ) && strstr( name_buf, name.c_str( ) ) ) { + return ( t )( reg.m_ptr ); + } + } + + return t{ }; + } + + template < typename t = void* > + t find_interface( std::string name ) { + if( !::isdigit( name[ name.length( ) - 1 ] ) ) + name += '0'; + + char name_buf[ 64 ]; + char module_buf[ 64 ]; + + for( size_t i{ }; i < m_count; ++i ) { + auto& reg = m_regs[ i ]; + + memcpy( name_buf, reg.m_name, 64 ); + memcpy( module_buf, reg.m_module_name, 64 ); + + decrypt_str( name_buf, 64, reg.m_key ); + decrypt_str( module_buf, 64, reg.m_key ); + + if( strstr( name_buf, name.c_str( ) ) ) { + return ( t )( reg.m_ptr ); + } + } + + return t{ }; + } + }; + } +}
\ No newline at end of file diff --git a/internal_rewrite/in_prediction.cpp b/internal_rewrite/in_prediction.cpp new file mode 100644 index 0000000..1044ca3 --- /dev/null +++ b/internal_rewrite/in_prediction.cpp @@ -0,0 +1,33 @@ +#include "mem.hpp"
+#include "hooks.hpp"
+#include "context.hpp"
+
+#undef max
+
+bool __fastcall hooks::in_prediction( void* ecx_, void* edx_ ) {
+ static auto in_prediction_o = g_csgo.m_prediction->get_old_function< decltype( &hooks::in_prediction ) >( 14 );
+ static auto ret_address = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "84 C0 75 08 57 8B CE E8 ? ? ? ? 8B 06" ) );
+
+ if( g_ctx.m_local && ret_address && g_settings.rage.enabled( ) ) {
+ stack_t stack( get_baseptr( ) );
+ int local_team = g_ctx.m_local->m_iTeamNum( );
+
+ if( stack.return_address( ) == ret_address ) {
+ for( size_t i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || !ent->is_valid( ) || ent == g_ctx.m_local || !ent->has_valid_anim( ) )
+ continue;
+
+ if( ent->m_iTeamNum( ) != local_team || g_settings.rage.friendlies ) {
+ //printf( "model bone counter: %d %d\n", ent->m_iMostRecentModelBoneCounter( ), c_base_player::g_iModelBoneCounter( ) );
+ ent->m_iMostRecentModelBoneCounter( ) = c_base_player::g_iModelBoneCounter( );
+ ent->m_flLastBoneSetupTime( ) = g_csgo.m_globals->m_curtime;
+ }
+ }
+ }
+ }
+
+ return in_prediction_o( ecx_, 0 );
+}
\ No newline at end of file diff --git a/internal_rewrite/input_system.cpp b/internal_rewrite/input_system.cpp new file mode 100644 index 0000000..6040cca --- /dev/null +++ b/internal_rewrite/input_system.cpp @@ -0,0 +1,527 @@ +#include <Windows.h> + +#include "input_system.hpp" +#include "util.hpp" + +util::c_input_manager g_input; + +NAMESPACE_REGION( util ) + +const char* const key_names_short[] = { + "unk", + "m1", + "m2", + "can", + "m3", + "m4", + "m5", + "unk", + "back", + "tab", + "unk", + "unk", + "clr", + "ret", + "unk", + "unk", + "shift", + "ctrl", + "alt", + "pause", + "caps", + "kana", + "unk", + "junja", + "final", + "kanji", + "unk", + "esc", + "convert", + "nonconvert", + "accept", + "modechange", + " ", + "prior", + "next", + "end", + "home", + "left", + "up", + "right", + "down", + "slct", + "prnt", + "execute", + "snapshot", + "ins", + "del", + "help", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "lwin", + "rwin", + "apps", + "unk", + "unk", + "num0", + "num1", + "num2", + "num3", + "num4", + "num5", + "num6", + "num7", + "num8", + "num9", + "*", + "+", + "sep", + "-", + ",", + "/", + "f1", + "f2", + "f3", + "f4", + "f5", + "f6", + "f7", + "f8", + "f9", + "f10", + "f11", + "f12", + "f13", + "f14", + "f15", + "f16", + "f17", + "f18", + "f19", + "f20", + "f21", + "f22", + "f23", + "f24", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "numlock", + "scroll", + "oem_nec_equal", + "oem_fj_masshou", + "oem_fj_touroku", + "oem_fj_loya", + "oem_fj_roya", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "unk", + "lshift", + "rshift", + "lctrl", + "rctrl", + "lalt", + "ralt", +}; + +const char* const key_names[] = { + "unknown", + "mouse_1", + "mouse_2", + "cancel", + "mouse_3", + "mouse_4", + "mouse_5", + "unknown", + "back", + "tab", + "unknown", + "unknown", + "clear", + "return", + "unknown", + "unknown", + "shift", + "control", + "alt", + "pause", + "capital", + "kana", + "unknown", + "junja", + "final", + "kanji", + "unknown", + "escape", + "convert", + "nonconvert", + "accept", + "modechange", + "space", + "prior", + "next", + "end", + "home", + "left", + "up", + "right", + "down", + "select", + "print", + "execute", + "snapshot", + "insert", + "delete", + "help", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "lwin", + "rwin", + "apps", + "unknown", + "unknown", + "numpad0", + "numpad1", + "numpad2", + "numpad3", + "numpad4", + "numpad5", + "numpad6", + "numpad7", + "numpad8", + "numpad9", + "multiply", + "add", + "separator", + "subtract", + "decimal", + "divide", + "f1", + "f2", + "f3", + "f4", + "f5", + "f6", + "f7", + "f8", + "f9", + "f10", + "f11", + "f12", + "f13", + "f14", + "f15", + "f16", + "f17", + "f18", + "f19", + "f20", + "f21", + "f22", + "f23", + "f24", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "numlock", + "scroll", + "oem_nec_equal", + "oem_fj_masshou", + "oem_fj_touroku", + "oem_fj_loya", + "oem_fj_roya", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "unknown", + "lshift", + "rshift", + "lcontrol", + "rcontrol", + "lmenu", + "rmenu", +}; + +void c_input_manager::capture_mouse_move( ulong_t lparam ) { + m_mouse_pos[ 0 ] = LOWORD( lparam ); + m_mouse_pos[ 1 ] = HIWORD( lparam ); +} + +void c_input_manager::clear_keys( ) { + memset( m_pressed_keys, 0, sizeof( m_pressed_keys ) ); +} + +bool c_input_manager::register_key_press( int key_event, int key ) +{ + switch ( key_event ) { + case KEYDOWN: { + if ( is_valid_key( key ) ) + m_pressed_keys[ key ] = true; + return true; + } + case KEYUP: { + if ( is_valid_key( key ) ) + m_pressed_keys[ key ] = false; + return true; + } + case SYSKEYDOWN: { //WTF IS THIS STUPID SHIT, WHY IS ALT LITERALLY THE ONLY FUCKING KEY UNDER SYSKEYDOWN OUT OF ALL THE MODIFIER KEYS? + if ( key == KEYS_ALT ) + m_pressed_keys[ key ] = true; + break; + } + case SYSKEYUP: { + if ( key == KEYS_ALT ) + m_pressed_keys[ key ] = false; + break; + } + case LBUTTONDOWN: + m_pressed_keys[ KEYS_MOUSE1 ] = true; + return true; + case LBUTTONUP: + m_pressed_keys[ KEYS_MOUSE1 ] = false; + return true; + case RBUTTONDOWN: + m_pressed_keys[ KEYS_MOUSE2 ] = true; + return true; + case RBUTTONUP: + m_pressed_keys[ KEYS_MOUSE2 ] = false; + return true; + case MBUTTONDOWN: + m_pressed_keys[ KEYS_MOUSE3 ] = true; + return true; + case MBUTTONUP: + m_pressed_keys[ KEYS_MOUSE3 ] = false; + return true; + case XBUTTONDOWN: { + bool pressed_xbutton = static_cast<bool>( HIWORD( key ) - 1 ); //should result in mouse4 as false, and mouse5 as true + m_pressed_keys[ pressed_xbutton ? KEYS_MOUSE5 : KEYS_MOUSE4 ] = true; + return true; + } + case XBUTTONUP: { + bool pressed_xbutton = static_cast<bool>( HIWORD( key ) - 1 ); //should result in mouse4 as false, and mouse5 as true + m_pressed_keys[ pressed_xbutton ? KEYS_MOUSE5 : KEYS_MOUSE4 ] = false; + return true; + } + case MOUSEWHEEL: { + short scroll_input = ( short )HIWORD( key ); + m_scroll_wheel_state = scroll_input > 0 ? 1 : -1; + return true; + } + } + + return key_event == 0x200 || key_event == 0x203 || key_event == 0x206 || key_event == 0x209; //gotta block WM_MOUSEFIST | WM_LBUTTONDBLCLK | WM_RBUTTONDBLCLK | WM_MBUTTONDBLCLK +} + +bool c_input_manager::is_key_pressed( int key ) { + auto k = key; + return is_valid_key( k ) && m_pressed_keys[ k ]; +} + +const char* c_input_manager::get_key_name( int key ) { + if ( !is_valid_key( key ) || key > KEYS_MAX ) + return key_names[ KEYS_NONE ]; + + return key_names[ key ]; +} + +const char* c_input_manager::get_short_name( int key ) { + return key_names_short[ is_valid_key( key ) ? key : KEYS_NONE ]; +} + +VirtualKeys_t c_input_manager::is_any_key_pressed( ) { + for ( size_t i{ }; i < KEYS_MAX; ++i ) { + if ( m_pressed_keys[ i ] ) { + return VirtualKeys_t( i ); + } + } + + return KEYS_NONE; +} + +int c_input_manager::get_scroll_state( ) { + int current_state = m_scroll_wheel_state; + m_scroll_wheel_state = 0; + return current_state; +} + +char c_input_manager::get_pressed_char( int* out ) { + size_t pressed_character{ }; + for ( size_t i{ }; i < KEYS_MAX; ++i ) { + if ( is_key_pressed( VirtualKeys_t( i ) ) ) { + if ( ( i >= KEYS_A && i <= KEYS_Z ) + || ( i >= KEYS_N0 && i <= KEYS_N9 ) ) { + pressed_character = i; + } + } + } + + if ( pressed_character ) { + if ( out ) { + *out = int( pressed_character ); + } + + if ( is_key_pressed( KEYS_SHIFT ) ) { + if ( pressed_character >= KEYS_A + && pressed_character <= KEYS_Z ) + return char( pressed_character ); + + //gay way to shift it to symbols + if ( pressed_character >= KEYS_N0 + && pressed_character <= KEYS_N9 ) { + switch ( pressed_character ) { + case KEYS_N0: + return ')'; + case KEYS_N1: + return '!'; + case KEYS_N2: + return '@'; + case KEYS_N3: + return '#'; + case KEYS_N4: + return '$'; + case KEYS_N5: + return '%'; + case KEYS_N6: + return '^'; + case KEYS_N7: + return '&'; + case KEYS_N8: + return '*'; + case KEYS_N9: + return '('; + } + } + } + else { + if ( pressed_character >= KEYS_A + && pressed_character <= KEYS_Z ) + return char( ::tolower( pressed_character ) ); + + if ( pressed_character >= KEYS_N0 + && pressed_character <= KEYS_N9 ) + return char( pressed_character ); + } + } + else if ( is_key_pressed( KEYS_SPACE ) ) { + if ( out ) + *out = KEYS_SPACE; + + return ' '; + } + else if ( is_key_pressed( KEYS_BACK ) ) { + if ( out ) + *out = KEYS_BACK; + + return 0; + } + + if ( out ) + *out = KEYS_NONE; + + return 0; +} + +END_REGION
\ No newline at end of file diff --git a/internal_rewrite/input_system.hpp b/internal_rewrite/input_system.hpp new file mode 100644 index 0000000..338c493 --- /dev/null +++ b/internal_rewrite/input_system.hpp @@ -0,0 +1,186 @@ +#pragma once +#include "util.hpp" + +enum VirtualKeyEvents_t { + KEYDOWN = 0x0100, + KEYUP = 0x0101, + SYSKEYDOWN = 0x104, + SYSKEYUP = 0x105, + LBUTTONDOWN = 0x0201, + LBUTTONUP = 0x0202, + RBUTTONDOWN = 0x0204, + RBUTTONUP = 0x0205, + MBUTTONDOWN = 0x0207, + MBUTTONUP = 0x0208, + MOUSEWHEEL = 0x020A, + XBUTTONDOWN = 0x020B, + XBUTTONUP = 0x020C, +}; + +enum VirtualKeys_t { + KEYS_NONE = 0, + KEYS_MOUSE1 = 0X01, + KEYS_MOUSE2 = 0X02, + KEYS_CANCEL = 0X03, + KEYS_MOUSE3 = 0X04, + KEYS_MOUSE4 = 0X05, + KEYS_MOUSE5 = 0X06, + KEYS_BACK = 0X08, + KEYS_TAB = 0X09, + KEYS_CLEAR = 0X0C, + KEYS_RETURN = 0X0D, + KEYS_SHIFT = 0X10, + KEYS_CONTROL = 0X11, + KEYS_ALT = 0X12, + KEYS_PAUSE = 0X13, + KEYS_CAPSLOCK = 0X14, + KEYS_ESCAPE = 0X1B, + KEYS_CONVERT = 0X1C, + KEYS_NONCONVERT = 0X1D, + KEYS_ACCEPT = 0X1E, + KEYS_MODECHANGE = 0X1F, + KEYS_SPACE = 0X20, + KEYS_PRIOR = 0X21, + KEYS_NEXT = 0X22, + KEYS_END = 0X23, + KEYS_HOME = 0X24, + KEYS_LEFT = 0X25, + KEYS_UP = 0X26, + KEYS_RIGHT = 0X27, + KEYS_DOWN = 0X28, + KEYS_SELECT = 0X29, + KEYS_PRINT = 0X2A, + KEYS_EXECUTE = 0X2B, + KEYS_SNAPSHOT = 0X2C, + KEYS_INSERT = 0X2D, + KEYS_DELETE = 0X2E, + KEYS_HELP = 0X2F, + KEYS_N0 = 0X30, + KEYS_N1 = 0X31, + KEYS_N2 = 0X32, + KEYS_N3 = 0X33, + KEYS_N4 = 0X34, + KEYS_N5 = 0X35, + KEYS_N6 = 0X36, + KEYS_N7 = 0X37, + KEYS_N8 = 0X38, + KEYS_N9 = 0X39, + KEYS_A = 0X41, + KEYS_B = 0X42, + KEYS_C = 0X43, + KEYS_D = 0X44, + KEYS_E = 0X45, + KEYS_F = 0X46, + KEYS_G = 0X47, + KEYS_H = 0X48, + KEYS_I = 0X49, + KEYS_J = 0X4A, + KEYS_K = 0X4B, + KEYS_L = 0X4C, + KEYS_M = 0X4D, + KEYS_N = 0X4E, + KEYS_O = 0X4F, + KEYS_P = 0X50, + KEYS_Q = 0X51, + KEYS_R = 0X52, + KEYS_S = 0X53, + KEYS_T = 0X54, + KEYS_U = 0X55, + KEYS_V = 0X56, + KEYS_W = 0X57, + KEYS_X = 0X58, + KEYS_Y = 0X59, + KEYS_Z = 0X5A, + KEYS_LEFTWINDOWS = 0X5B, + KEYS_RIGHTWINDOWS = 0X5C, + KEYS_APPLICATION = 0X5D, + KEYS_NUMPAD0 = 0X60, + KEYS_NUMPAD1 = 0X61, + KEYS_NUMPAD2 = 0X62, + KEYS_NUMPAD3 = 0X63, + KEYS_NUMPAD4 = 0X64, + KEYS_NUMPAD5 = 0X65, + KEYS_NUMPAD6 = 0X66, + KEYS_NUMPAD7 = 0X67, + KEYS_NUMPAD8 = 0X68, + KEYS_NUMPAD9 = 0X69, + KEYS_MULTIPLY = 0X6A, + KEYS_ADD = 0X6B, + KEYS_SEPARATOR = 0X6C, + KEYS_SUBTRACT = 0X6D, + KEYS_DECIMAL = 0X6E, + KEYS_DIVIDE = 0X6F, + KEYS_F1 = 0X70, + KEYS_F2 = 0X71, + KEYS_F3 = 0X72, + KEYS_F4 = 0X73, + KEYS_F5 = 0X74, + KEYS_F6 = 0X75, + KEYS_F7 = 0X76, + KEYS_F8 = 0X77, + KEYS_F9 = 0X78, + KEYS_F10 = 0X79, + KEYS_F11 = 0X7A, + KEYS_F12 = 0X7B, + KEYS_NUMLOCK = 0X90, + KEYS_SCROLLLOCK = 0X91, + KEYS_LEFTSHIFT = 0XA0, + KEYS_RIGHTSHIFT = 0XA1, + KEYS_LEFTCONTROL = 0XA2, + KEYS_RIGHTCONTROL = 0XA3, + KEYS_LEFTMENU = 0XA4, + KEYS_RIGHTMENU = 0XA5, + KEYS_PERIOD = 0xBE, + KEYS_MAX = 0XA6, + KEYS_LAST = 0xfe +}; + +namespace util +{ + class c_input_manager { + public: + bool m_pressed_keys[ KEYS_LAST ]{ }; + int m_mouse_pos[ 2 ]{ }; + int m_scroll_wheel_state{ }; + + + c_input_manager( ) { + memset( m_pressed_keys, 0, KEYS_LAST ); + } + + void capture_mouse_move( ulong_t lparam ); + + //resets all keys so unpressed + void clear_keys( ); + + //registers a key press from wndproc + bool register_key_press( int key_event, int key ); + + //checks if the key is pressed + bool is_key_pressed( int key ); + + //returns the first found key pressed, or KEY_NONE if none are + VirtualKeys_t is_any_key_pressed( ); + + //returns the last scroll state and resets it to 0 + int get_scroll_state( ); + + //returns the key's name + const char* get_key_name( int key ); + const char* get_short_name( int key ); + + //returns the first found currently pressed key + char get_pressed_char( int* pressed_key = nullptr ); + + //check if a key is valid + inline bool is_valid_key( int key ) { return key > KEYS_NONE && key < KEYS_LAST; } + + //get cursor pos + inline void get_cursor_pos( int& x, int& y ) { + x = m_mouse_pos[ 0 ]; + y = m_mouse_pos[ 1 ]; + } + }; +} + +extern util::c_input_manager g_input;
\ No newline at end of file diff --git a/internal_rewrite/interface.cpp b/internal_rewrite/interface.cpp new file mode 100644 index 0000000..351b1ea --- /dev/null +++ b/internal_rewrite/interface.cpp @@ -0,0 +1,244 @@ +#include <thread>
+
+#include "interface.hpp"
+#include "console.hpp"
+#include "hooks.hpp"
+#include "renderer.hpp"
+#include "pattern.hpp"
+#include "hooks.hpp"
+#include "base_cheat.hpp"
+#include "settings.hpp"
+#include "context.hpp"
+
+using namespace factory;
+
+interfaces::c_interface_manager g_factory;
+factory::c_csgo g_csgo;
+
+bool factory::create_interfaces( c_csgo* instance ) {
+
+ instance->create( &instance->m_chl, xors( "VClient" ) );
+ instance->create( &instance->m_surface, xors( "VGUI_Surface" ) );
+ instance->create( &instance->m_panel, xors( "VGUI_Panel" ) );
+ instance->create( &instance->m_engine, xors( "VEngineClient" ) );
+ instance->create( &instance->m_entlist, xors( "VClientEntityList" ) );
+ instance->create( &instance->m_prediction, xors( "VClientPrediction" ) );
+ instance->create( &instance->m_cvar, xors( "VEngineCvar" ) );
+ instance->create( &instance->m_game_movement, xors( "GameMovement" ) );
+ instance->create( &instance->m_model_info, xors( "VModelInfoClient" ) );
+ instance->create( &instance->m_trace, xors( "EngineTraceClient" ) );
+ instance->create( &instance->m_model_render, xors( "VEngineModel" ) );
+ instance->create( &instance->m_mat_system, xors( "VMaterialSystem" ) );
+ instance->create( &instance->m_render_view, xors( "VEngineRenderView" ) );
+ instance->create( &instance->m_phys_props, xors( "VPhysicsSurfaceProps" ) );
+ instance->create( &instance->m_engine_sound, xors( "IEngineSoundClient" ) );
+ instance->create( &instance->m_event_mgr, xors( "GAMEEVENTSMANAGER002" ) );
+ instance->create( &instance->m_string_table, xors( "VEngineClientStringTable" ) );
+ instance->create( &instance->m_partition, xors( "SpatialPartition" ) );
+ instance->create( &instance->m_clientleaf, xors( "ClientLeafSystem002" ) );
+ instance->create( &instance->m_mdl_cache, xors( "MDLCache" ) );
+ instance->create( &instance->m_engine_vgui, xors( "VEngineVGui" ) );
+ instance->create( &instance->m_input_sys, xors( "InputSystemVersion" ) );
+
+ auto d3d_device = pattern::first_code_match( GetModuleHandleA( xors( "shaderapidx9.dll" ) ),
+ xors( "A1 ?? ?? ?? ?? 50 8B 08 FF 51 0C" ) ) + 0x1;
+
+ auto move_helper = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "8B 0D ?? ?? ?? ?? 8B 46 08 68" ) ) + 0x2;
+
+ auto beam_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "B9 ? ? ? ? A1 ? ? ? ? FF 10 A1 ? ? ? ? B9" ), 0x1 );
+
+ auto mm_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "89 4C 24 10 8B 0D ? ? ? ? 53" ), 0x6 );
+
+ instance->create( &instance->m_d3d, **reinterpret_cast< uintptr_t** >( d3d_device ) );
+ instance->create( &instance->m_move_helper, **reinterpret_cast< uintptr_t** >( move_helper ) );
+ instance->create( &instance->m_beams, *reinterpret_cast< uintptr_t* >( beam_ptr ) );
+ //instance->create( &instance->m_mm, **reinterpret_cast< uintptr_t** >( mm_ptr ) );
+
+ instance->m_steam_pipe_handle = ( ( SteamPipeHandle( __cdecl* )( ) )GetProcAddress( GetModuleHandleA( xors( "steam_api.dll" ) ), xors( "SteamAPI_GetHSteamPipe" ) ) )( );
+ instance->m_steam_user_handle = ( ( SteamUserHandle( __cdecl* )( ) )GetProcAddress( GetModuleHandleA( xors( "steam_api.dll" ) ), xors( "SteamAPI_GetHSteamUser" ) ) )( );
+
+ uintptr_t steam_client_ptr = ( ( uintptr_t ( __cdecl* )( void ) )GetProcAddress( GetModuleHandleA( xors( "steam_api.dll" ) ), xors( "SteamClient" ) ) )( );
+ instance->create( &instance->m_steam_client, steam_client_ptr );
+
+ uintptr_t steam_friends_ptr = ( uintptr_t )instance->m_steam_client( )->GetISteamFriends( instance->m_steam_user_handle, instance->m_steam_pipe_handle, "SteamFriends015" );
+ instance->create( &instance->m_steam_friends, steam_friends_ptr );
+
+
+ auto kv_fn = ( void*( __cdecl* )( ) )( GetProcAddress(
+ GetModuleHandleA( xors( "vstdlib.dll" ) ),
+ xors( "KeyValuesSystem" ) ) );
+
+ instance->m_keyvalues = ( IKeyValuesSystem* )kv_fn( );
+
+ instance->m_alloc = *( IMemAlloc** )GetProcAddress(
+ GetModuleHandleA( xors( "tier0.dll" ) ),
+ xors( "g_pMemAlloc" ) );
+
+ uintptr_t* globals = **reinterpret_cast< uintptr_t*** >(
+ instance->m_chl->get_old_function( 0 ) + 0x1b );
+ instance->m_globals = reinterpret_cast< global_vars_t* >( globals );
+
+ uintptr_t* client_mode = **reinterpret_cast< uintptr_t*** >(
+ instance->m_chl->get_old_function( 10 ) + 0x5 );
+ instance->create( &instance->m_clientmode, uintptr_t( client_mode ) );
+
+ uintptr_t input = *reinterpret_cast< uintptr_t* >(
+ instance->m_chl->get_old_function( 16 ) + 0x1 );
+ instance->create( &instance->m_input, input );
+
+ uintptr_t** global_state = pattern::first_code_match< uintptr_t** >( instance->m_engine.dll( ),
+ xors( "B9 ? ? ? ? 56 FF 50 14 8B 34 85" ), 0x1 );
+ instance->m_global_state = reinterpret_cast< CGlobalState* >( *global_state );
+
+ auto clientstate = instance->m_global_state->get_client_state( );
+ if( clientstate && clientstate->m_netchannel )
+ instance->create( &instance->m_net_channel, ( uintptr_t )clientstate->m_netchannel );
+
+ uintptr_t var_ptr = ( uintptr_t )instance->m_cvar( )->FindVar( xors( "weapon_debug_spread_show" ) );
+ instance->create( &instance->m_debug_show_spread, var_ptr );
+
+ uintptr_t cl_interpolate = ( uintptr_t )( instance->m_cvar( )->FindVar( xors( "cl_interpolate" ) ) );
+ instance->create( &instance->m_interpolate, cl_interpolate );
+
+ uintptr_t net_showfragments = ( uintptr_t )( instance->m_cvar( )->FindVar( xors( "net_showfragments" ) ) );
+ instance->create( &instance->m_netshowfragments, net_showfragments );
+
+ instance->listeners.bullet_impact.init( );
+ instance->listeners.player_hurt.init( );
+ instance->listeners.round_start.init( );
+ instance->listeners.molotov_detonate.init( );
+ instance->listeners.weapon_fire.init( );
+ instance->listeners.player_death.init( );
+
+ return true;
+}
+
+
+con_fn clear_fn{ fnv( "clear" ), [ ]( const char*, const char* ) { g_con->m_logs.clear( ); }, "" };
+con_fn enable_logs_fn{ fnv( "log_enable" ),
+ [ ]( const char* a, const char* ) {
+ g_settings.menu.logs_enable ^= 1;
+ g_con->log( g_settings.menu.logs_enable ? xors( "logs enabled" ) : xors( "logs disabled" ) );
+ },
+ ""
+};
+
+con_fn fnv_fn{ fnv( "fnv" ),
+ [ ]( const char* a, const char* ) {
+ auto print = hash::fnv1a( a );
+ g_con->log( "%08x", print );
+ },
+ "%S"
+};
+
+con_fn sum_fn{ fnv( "sum" ),
+ [ ]( const char* a, const char* syntax ) {
+ auto arg_1 = con_fn::get_arg< int >( a, 0, syntax );
+ auto arg_2 = con_fn::get_arg< int >( a, 1, syntax );
+ g_con->log( "%d + %d = %d", arg_1, arg_2, arg_1 + arg_2 );
+ },
+ "%D %D"
+};
+
+con_fn dump_cfg{ fnv( "dump_cfg" ),
+ [ ]( const char* , const char* ) {
+ for( auto& it : data::holder_.get_nodes( ) ) {
+ auto setting = static_cast< ISetting* >( it );
+ g_con->log( "%08x: %s", setting->get_hash( ), setting->get_string( ).c_str( ) );
+ }
+ },
+ ""
+};
+
+con_fn retard_fn{ fnv( "retard" ),
+ [ ]( const char*, const char* ) {
+ g_con->log( "snuze" );
+ },
+ ""
+};
+
+con_fn unload_fn{ fnv( "unload" ),
+ [ ]( const char*, const char* ) {
+ g_csgo.m_panic = true;
+ ExitProcess( 0 );
+ },
+ ""
+};
+
+
+/*con_fn alias_fn{ fnv( "alias" ),
+ [ ]( const char* a, const char* b ) {
+ auto var_type = std::string( b );
+ if( var_type.length( ) > 1 ) {
+ g_con->log( xors( "unknown var type: %s" ), var_type.c_str( ) );
+ return;
+ }
+
+ switch( b[ 0 ] ) {
+ case TYPE_STRING: {
+ std::shared_ptr< con_alias< const char* > >( fnv( ) )
+ }
+ }
+ },
+ "%S %S"
+};*/
+
+void factory::c_csgo::initialize( ) {
+ m_panic = true;
+ g_con->create( );
+ auto now = std::chrono::high_resolution_clock::now( );
+ g_con->print( xors( "hello\n" ) );
+ //hi
+
+
+ factory::create_interfaces( &g_csgo );
+ g_fonts.initialize( );
+
+ g_netvars.init( );
+ g_settings.load( );
+ g_con->register_fn( &clear_fn );
+ g_con->register_fn( &enable_logs_fn );
+ g_con->register_fn( &fnv_fn );
+ g_con->register_fn( &sum_fn );
+ g_con->register_fn( &dump_cfg );
+ g_con->register_fn( &retard_fn );
+ g_con->register_fn( &unload_fn );
+
+ hooks::commit( &g_csgo );
+
+ g_cheat.m_chams.m_materials.initialize_materials( );
+
+ util::calculate_spread_runtime( );
+
+ auto after = std::chrono::high_resolution_clock::now( );
+ std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
+
+ std::chrono::duration< float > delta = after - now;
+
+ g_con->log( xors( "cheat initialized\n" ) );
+ g_con->log( xors( "time taken: %f\n" ), delta.count( ) );
+
+ m_panic = false;
+}
+
+void factory::c_csgo::uninitialize( ) {
+ m_panic = true;
+ g_con->destroy( );
+
+ //restore wndproc
+ if ( hooks::window_procedure_o ) {
+ SetWindowLongA( m_hwnd, GWLP_WNDPROC, ( long )hooks::window_procedure_o );
+ }
+
+ //unreference materials
+ g_cheat.m_chams.m_materials.destroy_materials( );
+
+ //restore all interfaces
+ restore( );
+
+ Sleep( 100 );
+
+ //free the library
+ FreeLibraryAndExitThread( g_dll, 0 );
+}
diff --git a/internal_rewrite/interface.hpp b/internal_rewrite/interface.hpp new file mode 100644 index 0000000..7cabe6a --- /dev/null +++ b/internal_rewrite/interface.hpp @@ -0,0 +1,184 @@ +#pragma once
+#include <thread>
+
+#include "factory.hpp"
+#include "sdk.hpp"
+#include "listener.hpp"
+
+NAMESPACE_REGION( factory )
+
+struct IDirect3DDevice9;
+
+//interface holder
+template < typename t >
+class c_interface_base {
+ friend class c_csgo;
+public:
+ t* operator( )( ) {
+ return m_interface;
+ }
+
+ //calls a virtual
+ template< size_t index, typename ret = void,
+ class... Args >
+ ret call( Args... args ) {
+ return util::get_vfunc< ret( __thiscall* )( void*, Args... ) >
+ ( m_interface, index )( m_interface, args... );
+ }
+
+ //also calls a virtual but you supply the typedef instead of return type
+ template< typename def, size_t index, class... Args >
+ auto call( Args... args ) {
+ return util::get_vfunc< def >
+ ( m_interface, index )( m_interface, args... );
+ }
+
+ //allows you to cast the interface
+ template< typename t0 = t* >
+ t0 get( ) {
+ return ( t0 )m_interface;
+ }
+
+ void operator( )( t* ptr ) {
+ m_interface = ptr;
+ m_hook.reset( );
+ m_hook = std::make_shared< hooks::c_vmt >( static_cast< void* >( ptr ) );
+
+ /*find the module the interface is located in
+ i know i could just pass the pointer but traps are gay*/
+ MEMORY_BASIC_INFORMATION info;
+ VirtualQuery( ptr, &info, sizeof( MEMORY_BASIC_INFORMATION ) );
+
+ m_dll = static_cast< HMODULE >( info.AllocationBase );
+ }
+
+ void operator( )( void* ptr ) {
+ operator( )( static_cast< t* >( ptr ) );
+ }
+
+ decltype( auto ) operator->( ) {
+ return m_hook;
+ }
+
+ template< typename t2 = decltype( m_dll ) >
+ t2 dll( ) {
+ return ( t2 )m_dll;
+ }
+
+protected:
+ t* m_interface;
+ HMODULE m_dll;
+ std::shared_ptr< hooks::c_vmt > m_hook;
+};
+
+//declare your interfaces here
+class c_csgo {
+public:
+ c_interface_base< IBaseClientDLL > m_chl;
+ c_interface_base< ISurface > m_surface;
+ c_interface_base< IPanel > m_panel;
+ c_interface_base< IClientMode > m_clientmode;
+ c_interface_base< IVEngineClient > m_engine;
+ c_interface_base< IClientEntityList > m_entlist;
+ c_interface_base< IDirect3DDevice9 > m_d3d;
+ c_interface_base< IPrediction > m_prediction;
+ c_interface_base< ICSGameMovement > m_game_movement;
+ c_interface_base< IMoveHelper > m_move_helper;
+ c_interface_base< IVModelInfoClient > m_model_info;
+ c_interface_base< IVModelRender > m_model_render;
+ c_interface_base< IMaterialSystem > m_mat_system;
+ c_interface_base< IEngineTrace > m_trace;
+ c_interface_base< IPhysicsSurfaceProps > m_phys_props;
+ c_interface_base< IVRenderView > m_render_view;
+ c_interface_base< ICVar > m_cvar;
+ c_interface_base< IGameEventManager2 > m_event_mgr;
+ c_interface_base< CHudChat > m_hud_chat;
+ c_interface_base< uintptr_t > m_engine_sound;
+ c_interface_base< INetChannel > m_net_channel;
+ c_interface_base< cvar_t > m_debug_show_spread;
+ c_interface_base< cvar_t > m_interpolate;
+ c_interface_base< cvar_t > m_netshowfragments;
+ c_interface_base< ISteamClient > m_steam_client;
+ c_interface_base< ISteamFriends > m_steam_friends;
+ c_interface_base< IViewRenderBeams > m_beams;
+ //c_interface_base< CMatchFramework > m_mm;
+ c_interface_base< uintptr_t > m_input_sys;
+ c_interface_base< CStringTable > m_string_table;
+ c_interface_base< CInput > m_input;
+ c_interface_base< uintptr_t > m_partition;
+ c_interface_base< uintptr_t > m_clientleaf;
+ c_interface_base< uintptr_t > m_mdl_cache;
+ c_interface_base< uintptr_t > m_engine_vgui;
+ c_interface_base< c_base_player > m_local;
+ SteamUserHandle m_steam_user_handle;
+ SteamPipeHandle m_steam_pipe_handle;
+ IKeyValuesSystem* m_keyvalues;
+ global_vars_t* m_globals;
+ CGlobalState* m_global_state;
+ IMemAlloc* m_alloc;
+ float m_frametime;
+ std::thread::id m_main_thread;
+ std::thread::id m_d3d_thread;
+
+
+ HWND m_hwnd{ };
+ bool m_panic{ };
+
+ struct {
+ generic_listener_t player_death { xors( "player_death" ), &listeners::player_death };
+ generic_listener_t bullet_impact{ xors( "bullet_impact" ), &listeners::bullet_impact };
+ generic_listener_t player_hurt{ xors( "player_hurt" ), &listeners::player_hurt };
+ generic_listener_t round_start{ xors( "round_start" ), &listeners::round_start };
+ generic_listener_t molotov_detonate{ xors( "molotov_detonate" ), &listeners::molotov_detonate };
+ generic_listener_t weapon_fire{ xors( "weapon_fire" ), &listeners::weapon_fire };
+ } listeners;
+public:
+ //find the interface inside of the module
+ void create( void* iface, const std::string& name, const std::string& mod ) {
+ auto* interface_ = static_cast< c_interface_base< uintptr_t >* >( iface );
+ auto ptr = g_factory.find_interface( mod, name );
+ if( !ptr )
+ return;
+
+ ( *interface_ )( ptr );
+ m_container.push_back( interface_ );
+ }
+
+ void create( void* iface, uintptr_t pointer ) {
+ auto interface_ = static_cast< c_interface_base< uintptr_t >* >( iface );
+
+ //msvc is retarded
+ ( *interface_ )( ( void* )pointer );
+ m_container.push_back( interface_ );
+ }
+
+ void create( void* iface, const std::string& name ) {
+ auto* interface_ = static_cast< c_interface_base< uintptr_t >* >( iface );
+ auto ptr = g_factory.find_interface( name );
+ if( !ptr )
+ return;
+
+ ( *interface_ )( ptr );
+ m_container.push_back( interface_ );
+ }
+
+ void __cdecl initialize( );
+ void __cdecl uninitialize( );
+
+private:
+ //restore the vmts to their original
+ void restore( ) {
+ for ( const auto& it : m_container ) {
+ it->m_hook->restore( );
+ }
+ }
+
+private:
+ std::vector< c_interface_base< uintptr_t >* > m_container;
+};
+
+bool create_interfaces( c_csgo* instance );
+
+END_REGION
+
+extern factory::c_csgo g_csgo;
\ No newline at end of file diff --git a/internal_rewrite/internal_rewrite.vcxproj b/internal_rewrite/internal_rewrite.vcxproj new file mode 100644 index 0000000..8a582d1 --- /dev/null +++ b/internal_rewrite/internal_rewrite.vcxproj @@ -0,0 +1,481 @@ +<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Online|Win32">
+ <Configuration>Online</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Online|x64">
+ <Configuration>Online</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="optimize_test|Win32">
+ <Configuration>optimize_test</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="optimize_test|x64">
+ <Configuration>optimize_test</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <VCProjectVersion>15.0</VCProjectVersion>
+ <ProjectGuid>{140DEC51-B0E7-4289-BB6F-79686422318E}</ProjectGuid>
+ <RootNamespace>internal_rewrite</RootNamespace>
+ <WindowsTargetPlatformVersion>10.0.17134.0</WindowsTargetPlatformVersion>
+ <ProjectName>moneybot</ProjectName>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Online|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Online|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="Shared">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Online|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Online|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <IncludePath>$(ProjectDir)\protobuf_src;C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ <OutDir>$(SolutionDir)\bin</OutDir>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|Win32'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ <OutDir>$(SolutionDir)\bin</OutDir>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Online|Win32'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ <OutDir>$(SolutionDir)\online</OutDir>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ <OutDir>$(SolutionDir)\bin</OutDir>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|x64'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Online|x64'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+ <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level2</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest /Zc:threadSafeInit- %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_DEBUG;_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS;_SCL_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+ <MultiProcessorCompilation>true</MultiProcessorCompilation>
+ <MinimalRebuild>false</MinimalRebuild>
+ <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <PrecompiledHeaderFile>precompiled.hpp</PrecompiledHeaderFile>
+ </ClCompile>
+ <Link>
+ <AssemblyDebug>false</AssemblyDebug>
+ <AdditionalOptions>/FAs %(AdditionalOptions)</AdditionalOptions>
+ <GenerateDebugInformation>DebugFastLink</GenerateDebugInformation>
+ <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+ <FullProgramDatabaseFile>false</FullProgramDatabaseFile>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|Win32'">
+ <ClCompile>
+ <WarningLevel>Level2</WarningLevel>
+ <Optimization>Full</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest /Zc:threadSafeInit- %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG;_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS</PreprocessorDefinitions>
+ <MultiProcessorCompilation>true</MultiProcessorCompilation>
+ <MinimalRebuild>false</MinimalRebuild>
+ <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <FloatingPointModel>Fast</FloatingPointModel>
+ <StringPooling>true</StringPooling>
+ <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+ <UndefinePreprocessorDefinitions>_DEBUG</UndefinePreprocessorDefinitions>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <PrecompiledHeaderFile>precompiled.hpp</PrecompiledHeaderFile>
+ </ClCompile>
+ <Link>
+ <AssemblyDebug>false</AssemblyDebug>
+ <AdditionalOptions>/FAs %(AdditionalOptions)</AdditionalOptions>
+ <GenerateDebugInformation>DebugFastLink</GenerateDebugInformation>
+ <FullProgramDatabaseFile>false</FullProgramDatabaseFile>
+ <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG</PreprocessorDefinitions>
+ </ClCompile>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='optimize_test|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG</PreprocessorDefinitions>
+ </ClCompile>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Full</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest /Zc:threadSafeInit- %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+ <StringPooling>true</StringPooling>
+ <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+ <FloatingPointModel>Precise</FloatingPointModel>
+ <CompileAs>CompileAsCpp</CompileAs>
+ <RuntimeTypeInfo>false</RuntimeTypeInfo>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <PrecompiledHeaderFile>precompiled.hpp</PrecompiledHeaderFile>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Online|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <PrecompiledHeaderFile>precompiled.hpp</PrecompiledHeaderFile>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Online|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalOptions>/std:c++latest %(AdditionalOptions)</AdditionalOptions>
+ <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClCompile Include="autowall.cpp" />
+ <ClCompile Include="base_cheat.cpp" />
+ <ClCompile Include="begin_lock.cpp" />
+ <ClCompile Include="chams.cpp" />
+ <ClCompile Include="console.cpp" />
+ <ClCompile Include="context.cpp" />
+ <ClCompile Include="c_base_player.cpp" />
+ <ClCompile Include="c_base_weapon.cpp" />
+ <ClCompile Include="d3d.cpp" />
+ <ClCompile Include="d3d_sprite.cpp" />
+ <ClCompile Include="debug_show_spread.cpp" />
+ <ClCompile Include="directx.cpp" />
+ <ClCompile Include="do_post_screen_space_effects.cpp" />
+ <ClCompile Include="draw_model_execute.cpp" />
+ <ClCompile Include="draw_small_entities.cpp" />
+ <ClCompile Include="emit_sound.cpp" />
+ <ClCompile Include="end_lock.cpp" />
+ <ClCompile Include="extra.cpp" />
+ <ClCompile Include="factory.cpp" />
+ <ClCompile Include="fire_event_clientside.cpp" />
+ <ClCompile Include="frame_stage_notify.cpp" />
+ <ClCompile Include="get_screen_size.cpp" />
+ <ClCompile Include="get_viewmodel_fov.cpp" />
+ <ClCompile Include="create_move.cpp" />
+ <ClCompile Include="hooks.cpp" />
+ <ClCompile Include="hud_process_input.cpp" />
+ <ClCompile Include="identity.cpp" />
+ <ClCompile Include="input_system.cpp" />
+ <ClCompile Include="interface.cpp" />
+ <ClCompile Include="interpolate.cpp" />
+ <ClCompile Include="is_connected.cpp" />
+ <ClCompile Include="is_paused.cpp" />
+ <ClCompile Include="KeyValues.cpp" />
+ <ClCompile Include="lag_mgr.cpp" />
+ <ClCompile Include="legitbot.cpp" />
+ <ClCompile Include="legitbot_lagcomp.cpp" />
+ <ClCompile Include="listener.cpp" />
+ <ClCompile Include="lock_cursor.cpp" />
+ <ClCompile Include="materialsystem_config.cpp" />
+ <ClCompile Include="math.cpp" />
+ <ClCompile Include="movement.cpp" />
+ <ClCompile Include="movement_recorder.cpp" />
+ <ClCompile Include="netvars.cpp" />
+ <ClCompile Include="net_showfragments.cpp" />
+ <ClCompile Include="on_screen_size_changed.cpp" />
+ <ClCompile Include="override_mouse_input.cpp" />
+ <ClCompile Include="override_view.cpp" />
+ <ClCompile Include="paint_traverse.cpp" />
+ <ClCompile Include="player_manager.cpp" />
+ <ClCompile Include="play_sound.cpp" />
+ <ClCompile Include="prediction.cpp" />
+ <ClCompile Include="proxies.cpp" />
+ <ClCompile Include="ragebot.cpp" />
+ <ClCompile Include="ragebot_antiaim.cpp" />
+ <ClCompile Include="ragebot_lagcomp.cpp" />
+ <ClCompile Include="ragebot_resolver.cpp" />
+ <ClCompile Include="renderer.cpp" />
+ <ClCompile Include="run_command.cpp" />
+ <ClCompile Include="scene_end.cpp" />
+ <ClCompile Include="send_datagram.cpp" />
+ <ClCompile Include="shut_down.cpp" />
+ <ClCompile Include="simple_settings.cpp" />
+ <ClCompile Include="simulate.cpp" />
+ <ClCompile Include="skins.cpp" />
+ <ClCompile Include="Source.cpp" />
+ <ClCompile Include="is_hltv.cpp" />
+ <ClCompile Include="in_prediction.cpp" />
+ <ClCompile Include="suppress_lists.cpp" />
+ <ClCompile Include="traceray.cpp" />
+ <ClCompile Include="ui_itemlist_def.h" />
+ <ClCompile Include="ui_text_input.cpp" />
+ <ClCompile Include="update_clientside_animation.cpp" />
+ <ClCompile Include="util.cpp" />
+ <ClCompile Include="Valve\checksum_crc.cpp" />
+ <ClCompile Include="visual_draw.cpp" />
+ <ClCompile Include="visual_player.cpp" />
+ <ClCompile Include="visual_local.cpp" />
+ <ClCompile Include="visual_world.cpp" />
+ <ClCompile Include="window_procedure.cpp" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="autowall.hpp" />
+ <ClInclude Include="base_cheat.hpp" />
+ <ClInclude Include="bf_write.hpp" />
+ <ClInclude Include="chams.hpp" />
+ <ClInclude Include="CHLClient.hpp" />
+ <ClInclude Include="CInput.hpp" />
+ <ClInclude Include="ClientClass.hpp" />
+ <ClInclude Include="color.hpp" />
+ <ClInclude Include="console.hpp" />
+ <ClInclude Include="context.hpp" />
+ <ClInclude Include="con_alias.hpp" />
+ <ClInclude Include="con_fn.hpp" />
+ <ClInclude Include="CUtlVector.hpp" />
+ <ClInclude Include="c_base_player.hpp" />
+ <ClInclude Include="c_base_weapon.hpp" />
+ <ClInclude Include="d3d.hpp" />
+ <ClInclude Include="d3d_sprite.hpp" />
+ <ClInclude Include="extra.hpp" />
+ <ClInclude Include="factory.hpp" />
+ <ClInclude Include="fnv.hpp" />
+ <ClInclude Include="GlobalVars_t.hpp" />
+ <ClInclude Include="hooks.hpp" />
+ <ClInclude Include="IAppSystem.hpp" />
+ <ClInclude Include="IClientEntityList.hpp" />
+ <ClInclude Include="IClientMode.hpp" />
+ <ClInclude Include="icons.hpp" />
+ <ClInclude Include="icons\config.hpp" />
+ <ClInclude Include="icons\legit.hpp" />
+ <ClInclude Include="icons\misc.hpp" />
+ <ClInclude Include="icons\rage.hpp" />
+ <ClInclude Include="icons\visuals.hpp" />
+ <ClInclude Include="ICvar.hpp" />
+ <ClInclude Include="identity.hpp" />
+ <ClInclude Include="IEngineTrace.hpp" />
+ <ClInclude Include="iface_dllmain_impl.hpp" />
+ <ClInclude Include="IGameEventManager.hpp" />
+ <ClInclude Include="IMaterialSystem.hpp" />
+ <ClInclude Include="IMemAlloc.hpp" />
+ <ClInclude Include="input_system.hpp" />
+ <ClInclude Include="interface.hpp" />
+ <ClInclude Include="IPhysicsSurfaceProps.hpp" />
+ <ClInclude Include="IPrediction.hpp" />
+ <ClInclude Include="ISteamClient.hpp" />
+ <ClInclude Include="ISurface.hpp" />
+ <ClInclude Include="IPanel.hpp" />
+ <ClInclude Include="IVEngineClient.hpp" />
+ <ClInclude Include="IVModelInfoClient.hpp" />
+ <ClInclude Include="IVRenderView.hpp" />
+ <ClInclude Include="KeyValues.hpp" />
+ <ClInclude Include="lag_mgr.hpp" />
+ <ClInclude Include="legitbot.hpp" />
+ <ClInclude Include="listener.hpp" />
+ <ClInclude Include="match_framework.h" />
+ <ClInclude Include="math.hpp" />
+ <ClInclude Include="movement.hpp" />
+ <ClInclude Include="movement_recorder.hpp" />
+ <ClInclude Include="netvars.hpp" />
+ <ClInclude Include="netvar_proxy.hpp" />
+ <ClInclude Include="pattern.hpp" />
+ <ClInclude Include="player_manager.hpp" />
+ <ClInclude Include="prediction.hpp" />
+ <ClInclude Include="ragebot.hpp" />
+ <ClInclude Include="renderer.hpp" />
+ <ClInclude Include="sdk.hpp" />
+ <ClInclude Include="settings.hpp" />
+ <ClInclude Include="simple_settings.hpp" />
+ <ClInclude Include="mem.hpp" />
+ <ClInclude Include="skins.hpp" />
+ <ClInclude Include="strings.hpp" />
+ <ClInclude Include="ui.h" />
+ <ClInclude Include="ui_base_item.h" />
+ <ClInclude Include="ui_button.h" />
+ <ClInclude Include="ui_checkbox.h" />
+ <ClInclude Include="ui_color_picker.h" />
+ <ClInclude Include="ui_draw.h" />
+ <ClInclude Include="ui_dropdown.h" />
+ <ClInclude Include="ui_dropdown_item.h" />
+ <ClInclude Include="ui_form.h" />
+ <ClInclude Include="ui_itemlist.h" />
+ <ClInclude Include="ui_key_picker.h" />
+ <ClInclude Include="ui_label.h" />
+ <ClInclude Include="ui_menu.h" />
+ <ClInclude Include="ui_render.h" />
+ <ClInclude Include="ui_slider.h" />
+ <ClInclude Include="ui_tab_manager.h" />
+ <ClInclude Include="ui_text_input.h" />
+ <ClInclude Include="util.hpp" />
+ <ClInclude Include="Valve\checksum_crc.h" />
+ <ClInclude Include="Valve\dt_common.h" />
+ <ClInclude Include="Valve\dt_recv.h" />
+ <ClInclude Include="vector.hpp" />
+ <ClInclude Include="visual.hpp" />
+ <ClInclude Include="vmt.hpp" />
+ <ClInclude Include="x86.hpp" />
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file diff --git a/internal_rewrite/internal_rewrite.vcxproj.filters b/internal_rewrite/internal_rewrite.vcxproj.filters new file mode 100644 index 0000000..4a2a246 --- /dev/null +++ b/internal_rewrite/internal_rewrite.vcxproj.filters @@ -0,0 +1,559 @@ +<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="factory">
+ <UniqueIdentifier>{111ce6db-2b60-4a90-b3a8-f418abb6e441}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="sdk">
+ <UniqueIdentifier>{46408dc1-0b1f-43a7-b32d-4b3f1a4e3393}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="protection">
+ <UniqueIdentifier>{e3e56c63-e162-43dc-af43-e40c4b463299}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="features">
+ <UniqueIdentifier>{037f8374-e510-46a1-b5e3-f418537a7e61}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="utility">
+ <UniqueIdentifier>{c1fd811f-a868-4a60-9bf4-1c81c22c61ce}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="context">
+ <UniqueIdentifier>{de79d40e-dbca-46ba-ac40-4adcd316d638}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="sdk\valve">
+ <UniqueIdentifier>{5b0550fa-f13e-4b35-83a2-2b8ae64dc7ee}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="ui">
+ <UniqueIdentifier>{1e1c2f2b-1cb9-4040-8a0f-f03ecfb56522}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="resource">
+ <UniqueIdentifier>{3a5a53ed-6526-48c1-ade4-05eaefe13c86}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="hooks">
+ <UniqueIdentifier>{8bc3e769-d369-4e50-ad7d-20b9c4d6680b}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="hooks\hookers">
+ <UniqueIdentifier>{37890891-fcc3-4432-9cdf-e586bded2aa1}</UniqueIdentifier>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="Source.cpp" />
+ <ClCompile Include="interface.cpp">
+ <Filter>factory</Filter>
+ </ClCompile>
+ <ClCompile Include="context.cpp">
+ <Filter>context</Filter>
+ </ClCompile>
+ <ClCompile Include="hooks.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="paint_traverse.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="renderer.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="factory.cpp">
+ <Filter>factory</Filter>
+ </ClCompile>
+ <ClCompile Include="netvars.cpp">
+ <Filter>factory</Filter>
+ </ClCompile>
+ <ClCompile Include="window_procedure.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="input_system.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="d3d.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="directx.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="simple_settings.cpp">
+ <Filter>context</Filter>
+ </ClCompile>
+ <ClCompile Include="frame_stage_notify.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="base_cheat.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="run_command.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="movement.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="prediction.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="override_mouse_input.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="legitbot.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="c_base_player.cpp">
+ <Filter>sdk</Filter>
+ </ClCompile>
+ <ClCompile Include="c_base_weapon.cpp">
+ <Filter>sdk</Filter>
+ </ClCompile>
+ <ClCompile Include="chams.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="KeyValues.cpp">
+ <Filter>sdk</Filter>
+ </ClCompile>
+ <ClCompile Include="scene_end.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="draw_model_execute.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="util.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="legitbot_lagcomp.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="is_hltv.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="ragebot.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="autowall.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="ragebot_lagcomp.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="get_viewmodel_fov.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="get_screen_size.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="identity.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="lag_mgr.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="ragebot_antiaim.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="extra.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="override_view.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="emit_sound.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="ragebot_resolver.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="proxies.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="listener.cpp">
+ <Filter>hooks\hookers</Filter>
+ </ClCompile>
+ <ClCompile Include="movement_recorder.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="player_manager.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="visual_local.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="visual_player.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="math.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="in_prediction.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="d3d_sprite.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="visual_world.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="send_datagram.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="is_paused.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="do_post_screen_space_effects.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="on_screen_size_changed.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="console.cpp">
+ <Filter>utility</Filter>
+ </ClCompile>
+ <ClCompile Include="play_sound.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="debug_show_spread.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="is_connected.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="hud_process_input.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="skins.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="materialsystem_config.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="shut_down.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="Valve\checksum_crc.cpp">
+ <Filter>sdk\valve</Filter>
+ </ClCompile>
+ <ClCompile Include="visual_draw.cpp">
+ <Filter>features</Filter>
+ </ClCompile>
+ <ClCompile Include="ui_text_input.cpp">
+ <Filter>ui</Filter>
+ </ClCompile>
+ <ClCompile Include="ui_itemlist_def.h">
+ <Filter>ui</Filter>
+ </ClCompile>
+ <ClCompile Include="fire_event_clientside.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="suppress_lists.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="draw_small_entities.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="end_lock.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="simulate.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="begin_lock.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="create_move.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="update_clientside_animation.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="interpolate.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="lock_cursor.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="traceray.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ <ClCompile Include="net_showfragments.cpp">
+ <Filter>hooks</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="factory.hpp">
+ <Filter>factory</Filter>
+ </ClInclude>
+ <ClInclude Include="interface.hpp">
+ <Filter>factory</Filter>
+ </ClInclude>
+ <ClInclude Include="sdk.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="vector.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="util.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="console.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="context.hpp">
+ <Filter>context</Filter>
+ </ClInclude>
+ <ClInclude Include="IClientMode.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="CHLClient.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="base_cheat.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="renderer.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="hooks.hpp">
+ <Filter>hooks</Filter>
+ </ClInclude>
+ <ClInclude Include="IAppSystem.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="ISurface.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="pattern.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="color.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="x86.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="IPanel.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="IVEngineClient.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="IClientEntityList.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="c_base_player.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="netvars.hpp">
+ <Filter>factory</Filter>
+ </ClInclude>
+ <ClInclude Include="ClientClass.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="Valve\dt_common.h">
+ <Filter>sdk\valve</Filter>
+ </ClInclude>
+ <ClInclude Include="Valve\dt_recv.h">
+ <Filter>sdk\valve</Filter>
+ </ClInclude>
+ <ClInclude Include="GlobalVars_t.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="input_system.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_draw.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="d3d.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_base_item.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_menu.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_render.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_form.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_checkbox.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="simple_settings.hpp">
+ <Filter>context</Filter>
+ </ClInclude>
+ <ClInclude Include="settings.hpp">
+ <Filter>context</Filter>
+ </ClInclude>
+ <ClInclude Include="strings.hpp">
+ <Filter>protection</Filter>
+ </ClInclude>
+ <ClInclude Include="fnv.hpp">
+ <Filter>protection</Filter>
+ </ClInclude>
+ <ClInclude Include="IPrediction.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="movement.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="vmt.hpp">
+ <Filter>hooks\hookers</Filter>
+ </ClInclude>
+ <ClInclude Include="netvar_proxy.hpp">
+ <Filter>hooks\hookers</Filter>
+ </ClInclude>
+ <ClInclude Include="prediction.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_tab_manager.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_slider.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_dropdown.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_dropdown_item.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_key_picker.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_text_input.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_button.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="legitbot.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="IVModelInfoClient.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="ICvar.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="c_base_weapon.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="IMaterialSystem.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="IEngineTrace.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="chams.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="visual.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="IVRenderView.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="KeyValues.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_color_picker.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="math.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="ragebot.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="autowall.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="IPhysicsSurfaceProps.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="CUtlVector.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="identity.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="lag_mgr.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="IMemAlloc.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="extra.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="CInput.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="IGameEventManager.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="listener.hpp">
+ <Filter>hooks\hookers</Filter>
+ </ClInclude>
+ <ClInclude Include="movement_recorder.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_label.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="player_manager.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="d3d_sprite.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="icons\config.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="icons\legit.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="icons\misc.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="icons\rage.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="icons\visuals.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="icons.hpp">
+ <Filter>resource</Filter>
+ </ClInclude>
+ <ClInclude Include="mem.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="con_fn.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="con_alias.hpp">
+ <Filter>utility</Filter>
+ </ClInclude>
+ <ClInclude Include="bf_write.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="skins.hpp">
+ <Filter>features</Filter>
+ </ClInclude>
+ <ClInclude Include="iface_dllmain_impl.hpp">
+ <Filter>factory</Filter>
+ </ClInclude>
+ <ClInclude Include="ISteamClient.hpp">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ <ClInclude Include="Valve\checksum_crc.h">
+ <Filter>sdk\valve</Filter>
+ </ClInclude>
+ <ClInclude Include="ui_itemlist.h">
+ <Filter>ui</Filter>
+ </ClInclude>
+ <ClInclude Include="match_framework.h">
+ <Filter>sdk</Filter>
+ </ClInclude>
+ </ItemGroup>
+</Project>
\ No newline at end of file diff --git a/internal_rewrite/interpolate.cpp b/internal_rewrite/interpolate.cpp new file mode 100644 index 0000000..51a5c08 --- /dev/null +++ b/internal_rewrite/interpolate.cpp @@ -0,0 +1,20 @@ +#include "hooks.hpp" +#include "interface.hpp" +#include "mem.hpp" +#include "base_cheat.hpp" +#include "util.hpp" +#include "context.hpp" + +int __fastcall hooks::cl_interpolate_get_int( void* ecx_, void* edx_ ) { + static auto old_fn = g_csgo.m_interpolate->get_old_function< decltype( &hooks::cl_interpolate_get_int ) >( 13 ); + static auto interpolate_entities = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 EC 1C 8B 0D ? ? ? ? 53" ), 0x72 ); + + stack_t stack( get_baseptr( ) ); + + if( stack.return_address( ) == interpolate_entities ) { + //if( g_settings.rage.enabled( ) && g_ctx.m_local && g_ctx.m_local->is_valid( ) ) + //return 0; + } + + return old_fn( ecx_, 0 ); +}
\ No newline at end of file diff --git a/internal_rewrite/is_connected.cpp b/internal_rewrite/is_connected.cpp new file mode 100644 index 0000000..159d036 --- /dev/null +++ b/internal_rewrite/is_connected.cpp @@ -0,0 +1,14 @@ +#include "mem.hpp" +#include "hooks.hpp" + +bool __fastcall hooks::is_connected( void* ecx_, void* edx_ ) { + static auto inventory = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "84 C0 75 04 B0 01 5F" ) ); + static auto is_connected_o = g_csgo.m_engine->get_old_function< decltype( &is_connected ) >( 27 ); + stack_t stack( get_baseptr( ) ); + + if( stack.return_address( ) == inventory && g_settings.misc.unlock_inventory( ) ) + return false; + + + return is_connected_o( ecx_, 0 ); +}
\ No newline at end of file diff --git a/internal_rewrite/is_hltv.cpp b/internal_rewrite/is_hltv.cpp new file mode 100644 index 0000000..60b24f8 --- /dev/null +++ b/internal_rewrite/is_hltv.cpp @@ -0,0 +1,31 @@ +#include "hooks.hpp" +#include "pattern.hpp" +#include "mem.hpp" + +bool __fastcall hooks::is_hltv( void* ecx, uintptr_t pvs_ent ) { + static auto is_hltv_o = g_csgo.m_engine->get_old_function< decltype( &hooks::is_hltv ) >( 93 ); + static auto pvs_retaddr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "84 C0 0F 85 ? ? ? ? A1 ? ? ? ? 8B B7" ) ); + + if ( !g_csgo.m_panic && pvs_retaddr ) { + stack_t stack( get_baseptr( ) ); + auto return_address = stack.return_address( ); + + if ( return_address == pvs_retaddr ) { + if ( pvs_ent && reinterpret_cast< c_base_player* >( pvs_ent )->is_valid( ) ) { + *( int* )( pvs_ent + 0xa24 ) = -1; + *( int* )( pvs_ent + 0xa2c ) = *( int* )( pvs_ent + 0xa28 ); + *( int* )( pvs_ent + 0xa28 ) = 0; + return true; + } + } + } + + return is_hltv_o( ecx, pvs_ent ); +} + +bool __declspec( naked ) __fastcall hooks::is_hltv_proxy( void*, void* ) { + __asm { + mov edx, edi; + jmp is_hltv; + } +}
\ No newline at end of file diff --git a/internal_rewrite/is_paused.cpp b/internal_rewrite/is_paused.cpp new file mode 100644 index 0000000..9cb0ef8 --- /dev/null +++ b/internal_rewrite/is_paused.cpp @@ -0,0 +1,16 @@ +#include "mem.hpp" +#include "hooks.hpp" + +bool __fastcall hooks::is_paused( void* ecx_, void* edx_ ) { + static auto interpolation_addr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "84 C0 74 07 C6 05 ? ? ? ? ? 8B 0D" ) ); + static auto is_paused_o = g_csgo.m_engine->get_old_function< decltype( &is_paused ) >( 90 ); + + stack_t stack( get_baseptr( ) ); + uintptr_t return_address = stack.return_address( ); + + if( g_settings.rage.enabled && return_address == interpolation_addr ) { + return true; + } + + return is_paused_o( ecx_, 0 ); +}
\ No newline at end of file diff --git a/internal_rewrite/lag_mgr.cpp b/internal_rewrite/lag_mgr.cpp new file mode 100644 index 0000000..72ad8c4 --- /dev/null +++ b/internal_rewrite/lag_mgr.cpp @@ -0,0 +1,145 @@ +#include "lag_mgr.hpp" +#include "c_base_player.hpp" +#include "context.hpp" +#include "interface.hpp" +#include "base_cheat.hpp" + +namespace features +{ + void c_lagmgr::on_antiaim( ) { + if( m_sent_ticks ) { + *m_sendpacket = false; + } + } + + bool c_lagmgr::predict_position( ) { + vec3_t local_pos = g_ctx.m_local->get_eye_pos( ); + + auto i = util::get_closest_player( ); + auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i ); + + if( !ent || !ent->is_valid( ) ) + return true; + + auto wep = ent->get_weapon( ); + if( !wep ) { + return true; + } + + float dmg_begin = g_cheat.m_autowall.run( ent, g_ctx.m_local, local_pos, false ); + bool is_visible = dmg_begin > 10.f; + + if( !is_visible ) { + vec3_t position = local_pos; + + vec3_t velocity_ang = math::vector_angles( vec3_t( ), g_ctx.m_local->m_vecVelocity( ) ); + vec3_t velocity_dir = math::angle_vectors( velocity_ang ); + + position += velocity_dir * 15.f; + + float dmg = g_cheat.m_autowall.run( ent, g_ctx.m_local, position, false ); + + if( dmg > 25.f ) + return false; + } + + return true; + } + + void c_lagmgr::fakelag( ) { + //2017 sucked + //i hope 2018 goes better + + if( !g_settings.rage.fakelag.mode( ) || + !g_settings.rage.fakelag.ticks( ) ) { + m_breaking_lc = false; + return; + } + + static float last_rand = 0.f; + + auto& settings = g_settings.rage.fakelag; + + auto weapon = g_ctx.m_local->get_weapon( ); + + if( g_ctx.m_local->m_vecVelocity( ).length( ) < 0.1f || + g_cheat.m_ragebot.m_antiaim->is_fakewalking( ) ) { + return; + } + + vec3_t delta = g_ctx.m_last_origin - g_ctx.m_local->m_vecOrigin( ); + int max_ticks = g_settings.rage.fakelag.ticks( ); + if( settings.fluctuate ) + max_ticks *= last_rand; + + max_ticks = math::min( max_ticks, 14 ); + + bool force_send = m_held_ticks > max_ticks; + if( settings.mode == 1 ) { + if( delta.length2dsqr( ) > 4096.f ) { + force_send = get_choked( ) > 3; + } + } + + if( settings.mode == 2 ) { + static bool broken_lc = false; + bool should_send = false; + + if( broken_lc ) { + should_send = math::random_number( 0, 100 ) % 2; + if( get_choked( ) > 1 ) + broken_lc = false; + } + + if( should_send ) + force_send = true; + else if( delta.length2dsqr( ) > 4096.f ) { + force_send = get_choked( ) > 3; + broken_lc = true; + } + } + + bool send = false; + static bool was_onground{ }; + + if( !settings.in_move ) { + send = true; + } + + if( settings.on_peek ) { + static int choke_ticks = 0; + bool predicted = predict_position( ); + if( !predicted ) + choke_ticks = settings.ticks; + + if( choke_ticks ) { + send = !choke_ticks--; + } + } + + if( settings.in_air && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + send = false; + } + + if( settings.avoid_ground ) { + if( !was_onground && g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) { + send = false; + } + } + + was_onground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND; + + if( ( m_cmd->m_buttons & IN_ATTACK ) && g_ctx.m_local->can_attack( ) && + !settings.in_attack ) { + if( !weapon->is_grenade( ) || ( weapon->is_grenade( ) && weapon->m_fThrowTime( ) < TICK_INTERVAL( ) ) ) { + send = true; + } + } + + *m_sendpacket = ( send || force_send ) && !get_sent( ); + if( *m_sendpacket ) { + m_breaking_lc = delta.length2dsqr( ) > 4096.f; + last_rand = ( 1.f + math::random_number( -settings.fluctuate, settings.fluctuate( ) ) * 0.01f ); + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/lag_mgr.hpp b/internal_rewrite/lag_mgr.hpp new file mode 100644 index 0000000..21360dd --- /dev/null +++ b/internal_rewrite/lag_mgr.hpp @@ -0,0 +1,71 @@ +#pragma once +#include "sdk.hpp" +#include "settings.hpp" +#include "console.hpp" + +namespace features +{ + class c_lagmgr { + public: + void operator()( user_cmd_t* cmd, byte* sendpacket ) { + if( !sendpacket ) return; + if( !cmd ) return; + + m_cmd = cmd; + m_sendpacket = sendpacket; + + if( g_settings.rage.anti_aim( ) ) { + on_antiaim( ); + } + + //let fakelag override whatever happened in antiaim + //this also means we will call stuff like fakewalk etc + //after this + fakelag( ); + } + + void on_cmove_end( ) { + if( !m_sendpacket ) return; + + if( *m_sendpacket ) { + ++m_sent_ticks; + m_held_ticks = 0; + } + else { + ++m_held_ticks; + m_sent_ticks = 0; + } + } + + void set_state( bool state ) { + *m_sendpacket = state; + } + + int get_choked( ) const { + return m_held_ticks; + } + + int get_sent( ) const { + return m_sent_ticks; + } + + bool get_state( ) const { + return m_sendpacket ? !!*m_sendpacket : true; + } + + bool is_breaking_lc( ) const { + return m_breaking_lc; + } + + private: + void on_antiaim( ); + bool predict_position( ); + void fakelag( ); + + user_cmd_t* m_cmd{ }; + byte* m_sendpacket{ }; + int m_sent_ticks{ }; + int m_held_ticks{ }; + bool m_breaking_lc{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/legitbot.cpp b/internal_rewrite/legitbot.cpp new file mode 100644 index 0000000..c3c0010 --- /dev/null +++ b/internal_rewrite/legitbot.cpp @@ -0,0 +1,331 @@ +#include "interface.hpp"
+#include "input_system.hpp"
+#include "context.hpp"
+#include "legitbot.hpp"
+#include "settings.hpp"
+#include "math.hpp"
+
+namespace features
+{
+ int c_legitbot::get_aim_target( float fov ) {
+ float best_fov = fov ? fov : g_settings.legit.active->m_fov;
+ int target{ -1 };
+ vec3_t aim_angle{ };
+ vec3_t cur_angle{ };
+ vec3_t local_pos{ };
+ vec3_t aim_pos{ };
+
+ g_csgo.m_engine( )->GetViewAngles( cur_angle );
+ local_pos = g_ctx.m_local->get_eye_pos( );
+
+ for ( int i{ 1 }; i <= g_csgo.m_globals->m_maxclients; ++i ) {
+ auto entity = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if ( !entity ) continue;
+ if ( entity == g_ctx.m_local ) continue;
+ if ( !entity->is_valid( ) ) continue;
+ int team = entity->m_iTeamNum( );
+ if ( team == g_ctx.m_local->m_iTeamNum( )
+ && !g_settings.legit.friendlies( ) ) {
+ continue;
+ }
+
+ bool visible = entity->is_visible( 0 );
+ if( !visible && g_settings.legit.backtracking_target( ) ) {
+ auto record = m_lagcomp.find_best_record( i );
+ if( record ) {
+ visible = util::trace_ray( local_pos, record->m_position,
+ g_ctx.m_local->ce( ), entity->ce( ) );
+ }
+ }
+
+ if ( !visible ) {
+ continue;
+ }
+
+ aim_angle = math::vector_angles( local_pos, entity->get_hitbox_pos( 0 ) );
+ aim_angle.clamp( );
+
+ float fov = ( cur_angle - aim_angle ).clamp( ).length2d( );
+ if( fov < best_fov ) {
+ best_fov = fov;
+ target = i;
+ }
+ }
+
+ return target;
+ }
+
+ void c_legitbot::assist( c_base_player* target, float* x, float* y ) {
+ vec3_t aim_ang;
+ vec3_t move_ang;
+ vec3_t view_ang;
+ vec3_t enemy_pos;
+ vec3_t local_pos;
+ vec3_t view_delta;
+ vec3_t delta;
+ vec2_t pixels;
+
+ local_pos = g_ctx.m_local->get_eye_pos( );
+ enemy_pos = target->get_hitbox_pos( 0 );
+
+ aim_ang = math::vector_angles( local_pos, enemy_pos );
+ aim_ang -= g_ctx.m_local->m_aimPunchAngle( ) * 2.f * g_settings.legit.active->m_rcs;
+
+ move_ang = pixels_to_angle( vec2_t( *x, *y ) );
+ g_csgo.m_engine( )->GetViewAngles( view_ang );
+
+ view_delta = ( aim_ang - view_ang ).clamp( );
+
+ move_ang *= g_settings.legit.active->m_assist_strength;
+ float delta_y = std::abs( move_ang.y );
+ float delta_x = std::abs( move_ang.x );
+
+ delta.x = std::clamp( view_delta.x, -delta_x, delta_x );
+ delta.y = std::clamp( view_delta.y, -delta_y, delta_y );
+
+ pixels = angle_to_pixels( delta );
+ *x += pixels.x; *y += pixels.y;
+ }
+
+ void c_legitbot::triggerbot( user_cmd_t* cmd ) {
+ static float time_at = 0.f;
+
+ if( !g_settings.legit.triggerbot( ) )
+ return;
+
+ if( !g_input.is_key_pressed( ( VirtualKeys_t )g_settings.legit.trigger_key( ) ) && !time_at ) // sometimes people will let go of their triggerbot key too quickly and will cause them to not shoot.
+ return;
+
+ vec3_t viewangles{ };
+ vec3_t forward{ };
+ g_csgo.m_engine( )->GetViewAngles( viewangles );
+
+ auto wep = g_ctx.m_local->get_weapon( );
+ if( !wep ) return;
+ if( wep->is_knife( ) ) return;
+
+ auto wpn_info = wep->get_wpn_info( );
+ if( !wpn_info ) return;
+
+ const float length = wpn_info->range;
+ const float current_time = TICKS_TO_TIME( g_csgo.m_globals->m_tickcount );
+
+ if( time_at && abs( current_time - time_at ) > 0.3f ) {
+ time_at = 0.f; // delta too big
+ }
+
+ if( length > 1.0f ) {
+ if( !time_at ) {
+ viewangles += g_ctx.m_local->m_aimPunchAngle( ) * 2.f;
+
+ forward = math::angle_vectors( viewangles );
+ forward *= length;
+
+ vec3_t src = g_ctx.m_local->get_eye_pos( );
+ vec3_t dst = src + forward;
+
+ CTraceFilter filter{ };
+ CGameTrace tr{ };
+ Ray_t ray{ };
+
+ filter.pSkip = g_ctx.m_local;
+ ray.Init( src, dst );
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &tr );
+
+ if( tr.m_pEnt ) {
+ auto ent = tr.m_pEnt->as< c_base_player >( );
+ if( ent->is_valid( ) ) {
+ if( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) || g_settings.legit.friendlies ) {
+ time_at = current_time;
+ }
+ }
+ }
+ }
+
+ if( time_at ) {
+ if( ( current_time - time_at ) >= g_settings.legit.trigger_delay( ) ) {
+ cmd->m_buttons |= IN_ATTACK;
+ time_at = 0.f;
+ }
+ }
+ }
+ }
+
+ void c_legitbot::sample_angle_data( const vec3_t& cur_angles ) {
+ auto time = g_csgo.m_globals->m_curtime;
+
+ if ( !m_aiming ) {
+ m_angle_samples.push_front( { cur_angles, time } );
+ }
+
+ while ( m_angle_samples.size( ) > g_settings.legit.sample_size( ) ) {
+ m_angle_samples.pop_back( );
+ }
+ }
+
+ float c_legitbot::get_avg_delta( ) {
+ if ( m_angle_samples.empty( ) )
+ return 0.f;
+
+ float avg_delta{ };
+
+ for ( auto& it : m_angle_samples ) {
+ static vec3_t last_angle = it.m_viewangles;
+
+ //doing this implements nonsticky aswell
+ //once you already are at the target
+ //after lets say a flick
+ //it will reduce the aim speed
+ //making it not "stick" to the bone
+ //as we dont store records when aiming
+ float time_delta = g_csgo.m_globals->m_curtime - it.m_time;
+ float delta_diff = m_deltatime / ( time_delta * 2.f );
+
+ vec3_t angle_delta = ( last_angle - it.m_viewangles ).clamp( );
+ float delta_length = angle_delta.length( ) * delta_diff;
+
+ avg_delta += delta_length;
+ last_angle = it.m_viewangles;
+ }
+
+ //scale the delta down
+ return avg_delta / float( g_settings.legit.sample_size( ) );
+ }
+
+ vec2_t c_legitbot::angle_to_pixels( const vec3_t& angle ) {
+ static auto m_yaw = g_csgo.m_cvar( )->FindVar( xors( "m_yaw" ) );
+ static auto m_pitch = g_csgo.m_cvar( )->FindVar( xors( "m_pitch" ) );
+
+ float x = angle.x / m_pitch->get_float( );
+ float y = angle.y / m_yaw->get_float( );
+
+ return vec2_t( -y, x );
+ }
+
+ vec3_t c_legitbot::pixels_to_angle( const vec2_t& pixel ) {
+ static auto m_yaw = g_csgo.m_cvar( )->FindVar( xors( "m_yaw" ) );
+ static auto m_pitch = g_csgo.m_cvar( )->FindVar( xors( "m_pitch" ) );
+
+ float x = pixel.x * m_pitch->get_float( );
+ float y = pixel.y * m_yaw->get_float( );
+
+ return vec3_t( -y, x, 0.f ).clamp( );
+ }
+
+ bool c_legitbot::update_settings( ) {
+ if ( !g_ctx.run_frame( ) ) return false;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if ( !weapon ) return false;
+
+ if ( weapon->is_grenade( ) || weapon->is_knife( ) ) {
+ return false;
+ }
+
+ if ( weapon->is_rifle( ) ) {
+ g_settings.legit.active = &g_settings.legit.rifles;
+ }
+ else if ( weapon->is_sniper( ) ) {
+ g_settings.legit.active = &g_settings.legit.snipers;
+ }
+ else if ( weapon->is_pistol( ) ) {
+ g_settings.legit.active = &g_settings.legit.pistols;
+ }
+ else {
+ g_settings.legit.active = &g_settings.legit.general;
+ }
+
+ return true;
+ }
+
+ void c_legitbot::aim_at_target( c_base_player* target, float* x, float* y ) {
+ vec3_t aim_ang;
+ vec3_t cur_ang;
+ vec3_t delta;
+ vec2_t pixels;
+ vec2_t mouse;
+
+ g_csgo.m_engine( )->GetViewAngles( cur_ang );
+
+ if ( g_settings.legit.backtracking( ) && m_lagcomp.find_best_record( target->ce( )->GetIndex( ) ) ) {
+ aim_ang = math::vector_angles( g_ctx.m_local->get_eye_pos( ),
+ m_lagcomp.get_backtracked_position( target->ce( )->GetIndex( ) ) ).clamp( );
+ }
+ else {
+ aim_ang = math::vector_angles( g_ctx.m_local->get_eye_pos( ),
+ target->get_hitbox_pos( 0 ) ).clamp( );
+ }
+
+ aim_ang -= g_ctx.m_local->m_aimPunchAngle( ) * 2.f * ( g_settings.legit.active->m_rcs / 100.f );
+
+ delta = ( aim_ang - cur_ang ).clamp( );
+ float delta_length = delta.length( );
+
+ if ( delta_length ) {
+ float final_time = delta_length / ( g_settings.legit.active->m_speed( ) / 100.f );
+ m_curtime += m_deltatime;
+
+ if ( m_curtime > final_time ) {
+ m_curtime = final_time;
+ }
+
+ float aim_progress = m_curtime / final_time;
+ delta *= aim_progress;
+ aim_ang = delta;
+
+ pixels = angle_to_pixels( delta );
+ *x += pixels.x;
+ *y += pixels.y;
+ }
+ }
+
+ void c_legitbot::aimbot( float* x, float* y ) {
+ if ( !g_settings.legit.enabled( ) ) return;
+ if ( !update_settings( ) ) return;
+
+ m_aiming = false;
+ static float old_time = g_csgo.m_globals->m_curtime;
+ float time = g_csgo.m_globals->m_curtime;
+
+ m_deltatime = time - old_time;
+ if ( g_settings.legit.dynamic_smoothing( ) ) {
+ float avg_delta = get_avg_delta( ) * g_settings.legit.smooth_factor( );
+ if ( avg_delta > m_deltatime ) {
+ m_deltatime = avg_delta;
+ }
+ }
+
+ old_time = time;
+
+ bool in_attack = false;
+ if ( g_settings.legit.activation_type == 0 )
+ in_attack = true;
+ if ( g_settings.legit.activation_type == 1
+ && g_input.is_key_pressed( ( VirtualKeys_t )g_settings.legit.key( ) ) ) {
+ in_attack = true;
+ }
+ if( g_settings.legit.trigger_magnet
+ && g_settings.legit.triggerbot
+ && g_input.is_key_pressed( g_settings.legit.trigger_key ) ) {
+ in_attack = true;
+ }
+
+ int target_index = get_aim_target( );
+ auto target = g_csgo.m_entlist( )->GetClientEntity< >( target_index );
+
+ if ( target_index != -1 ) {
+ if( in_attack ) {
+ m_aiming = true;
+ aim_at_target( target, x, y );
+ }
+ if( g_settings.legit.assist ) {
+ assist( target, x, y );
+ }
+ }
+ else {
+ m_curtime = 0;
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/legitbot.hpp b/internal_rewrite/legitbot.hpp new file mode 100644 index 0000000..f543fd4 --- /dev/null +++ b/internal_rewrite/legitbot.hpp @@ -0,0 +1,75 @@ +#pragma once +#include <deque> +#include <chrono> + +#include "sdk.hpp" + +namespace features +{ + class c_legitbot { + public: + void operator()( float* x, float* y ) { + aimbot( x, y ); + } + + //call once per tick + void sample_angle_data( const vec3_t& angle ); + void triggerbot( user_cmd_t* cmd ); + private: + struct aim_record_t { + vec3_t m_viewangles; + float m_time; + }; + + struct lag_record_t { + int m_tickcount{ }; + vec3_t m_position{ }; + matrix3x4 m_matrix[ 128 ]{ }; + + bool is_valid( ); + }; + + class c_lagcomp { + public: + friend class c_legitbot; + using lag_deque_t = std::deque< lag_record_t >; + + lag_record_t* find_best_record( int ent_index ); + vec3_t get_backtracked_position( int ent_index ); + auto& get_records( int ent_index ) { + return m_data[ ent_index ]; + } + + void store( ); + void operator()( user_cmd_t* cmd ); + + private: + bool backtrack_entity( int ent_index ); + bool can_backtrack_entity( int ent_index ); + void store_player( int ent_index ); + + lag_deque_t m_data[ 65 ]; + user_cmd_t* m_cmd; + }; + + vec2_t angle_to_pixels( const vec3_t& angle ); + vec3_t pixels_to_angle( const vec2_t& pixel ); + void aimbot( float* x, float* y ); + void assist( c_base_player* player, float* x, float* y ); + void aim_at_target( c_base_player*, float*, float* ); + + bool update_settings( ); + float get_avg_delta( ); + int get_aim_target( float fov = 0.f ); + + private: + float m_deltatime{ }; + float m_curtime{ }; + bool m_aiming{ }; + + std::deque< aim_record_t > m_angle_samples; + + public: + c_lagcomp m_lagcomp; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/legitbot_lagcomp.cpp b/internal_rewrite/legitbot_lagcomp.cpp new file mode 100644 index 0000000..c80bcbd --- /dev/null +++ b/internal_rewrite/legitbot_lagcomp.cpp @@ -0,0 +1,155 @@ +#include "legitbot.hpp" +#include "interface.hpp" +#include "context.hpp" +#include "settings.hpp" +#include "math.hpp" +#include "base_cheat.hpp" +#include "input_system.hpp" +#include "d3d.hpp" + +namespace features +{ + bool c_legitbot::lag_record_t::is_valid( ) { + return util::is_tick_valid( m_tickcount ); + } + + void c_legitbot::c_lagcomp::store_player( int ent_index ) { + auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index ); + vec3_t pos = ent->get_hitbox_pos( 0 ); + int tickcount = TIME_TO_TICKS( ent->m_flSimulationTime( ) ); + + lag_record_t new_record; + if ( ent->ce( )->SetupBones( new_record.m_matrix, 128, 0x100, 0.f ) ) { + new_record.m_position = pos; + new_record.m_tickcount = tickcount; + + m_data[ ent_index ].push_front( new_record ); + } + + while ( !m_data[ ent_index ].empty( ) && + ( m_data[ ent_index ].size( ) > TIME_TO_TICKS( 1.0f ) ) ) { + m_data[ ent_index ].pop_back( ); + } + } + + bool c_legitbot::c_lagcomp::can_backtrack_entity( int ent_index ) { + if ( m_data[ ent_index ].empty( ) ) { + return false; + } + + for( auto& it : m_data[ ent_index ] ) { + if( it.is_valid( ) ) return true; + } + + return false; + } + + c_legitbot::lag_record_t* c_legitbot::c_lagcomp::find_best_record( int ent_index ) { + c_legitbot::lag_record_t* best_record = nullptr; + float best_fov{ g_settings.legit.backtracking_fov( ) }; + vec3_t cur_angle; + vec3_t aim_angle; + vec3_t aim_pos; + vec3_t cur_pos; + int cur_tick; + + if( m_data[ ent_index ].empty( ) ) { + return nullptr; + } + + if( g_settings.misc.net_fakelag( ) && g_settings.misc.net_fakeping_active ) { + best_fov = 360.f; + } + + g_csgo.m_engine( )->GetViewAngles( cur_angle ); + cur_pos = g_ctx.m_local->get_eye_pos( ); + cur_tick = g_csgo.m_globals->m_tickcount; + + for( auto& it : m_data[ ent_index ] ) { + int delta = std::abs( cur_tick - it.m_tickcount ); + + if( !( g_settings.misc.net_fakelag( ) && g_settings.misc.net_fakeping_active ) ) { + auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); + if( nci ) { + float max_latency = g_settings.legit.backtracking_time + nci->GetLatency( 0 ); + if( delta > TIME_TO_TICKS( max_latency ) ) + continue; + } + } + + if( !it.is_valid( ) ) + continue; + + aim_pos = it.m_position; + aim_angle = math::vector_angles( cur_pos, aim_pos ).clamp( ); + + float fov = ( cur_angle - aim_angle ).clamp( ).length2d( ); + if ( fov < best_fov ) { + best_fov = fov; + best_record = ⁢ + } + } + + return best_record; + } + + vec3_t c_legitbot::c_lagcomp::get_backtracked_position( int ent_index ) { + if( !m_data[ ent_index ].size( ) ) return vec3_t( ); + auto lag_record = find_best_record( ent_index ); + + vec3_t last_position{ }; + for( auto& it : util::reverse_iterator( m_data[ ent_index ] ) ) { + if( it.is_valid( ) ) last_position = it.m_position; break; + } + + return lag_record ? lag_record->m_position : last_position; + } + + void c_legitbot::c_lagcomp::store( ) { + for ( int i = 1; i < 65; ++i ) { + auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i ); + + if ( ent && ent->is_valid( ) && ent != g_ctx.m_local ) { + store_player( i ); + } + else { + m_data[ i ].clear( ); + } + } + } + + bool c_legitbot::c_lagcomp::backtrack_entity( int ent_index ) { + if ( !m_cmd ) return false; + + if ( !can_backtrack_entity( ent_index ) ) return false; + + auto best_record = find_best_record( ent_index ); + + if ( best_record ) { + m_cmd->m_tick_count = best_record->m_tickcount; + return true; + } + + return false; + } + + void c_legitbot::c_lagcomp::operator()( user_cmd_t* cmd ) { + if ( !g_settings.legit.enabled( ) || !g_settings.legit.backtracking( ) ) + return; + + m_cmd = cmd; + store( ); + + auto target = g_cheat.m_legitbot.get_aim_target( g_settings.legit.backtracking_fov( ) ); + bool active = false; + + if ( g_settings.legit.activation_type( ) == 0 ) + active = true; + if ( g_input.is_key_pressed( ( VirtualKeys_t )g_settings.legit.key( ) ) ) + active = true; + + if ( active && target != -1 ) { + backtrack_entity( target ); + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/level_init_pre_entity.cpp b/internal_rewrite/level_init_pre_entity.cpp new file mode 100644 index 0000000..c4d8c38 --- /dev/null +++ b/internal_rewrite/level_init_pre_entity.cpp @@ -0,0 +1,18 @@ +#include "hooks.hpp" +#include "chams.hpp" +#include "base_cheat.hpp" + +void __fastcall hooks::level_init_pre_entity( void* ecx_, void* edx_, const char* map_name ) { + static auto original_fn = g_csgo.m_chl->get_old_function< decltype( &level_init_pre_entity ) >( 5 ); + + bool has_level_initialized = **( bool** )( ( uintptr_t )original_fn + 8 ); + + // obviously source engine is perfect + // "HACK: Bogus, but the logic is too complicated in the engine" + + if( !has_level_initialized ) { + //g_cheat.m_chams.m_materials.initialize_materials( ); + } + + return original_fn( ecx_, edx_, map_name ); +}
\ No newline at end of file diff --git a/internal_rewrite/listener.cpp b/internal_rewrite/listener.cpp new file mode 100644 index 0000000..a28dde8 --- /dev/null +++ b/internal_rewrite/listener.cpp @@ -0,0 +1,238 @@ +#include "listener.hpp"
+#include "interface.hpp"
+#include "base_cheat.hpp"
+#include "context.hpp"
+
+#undef PlaySound
+
+generic_listener_t::generic_listener_t( const char* name, void( *function )( IGameEvent* ) ) :
+ m_function( function ), m_name( name ) { }
+
+generic_listener_t::~generic_listener_t( ) {
+ if( m_registered )
+ g_csgo.m_event_mgr( )->RemoveListener( this );
+
+}
+
+void generic_listener_t::init( ) {
+ g_csgo.m_event_mgr( )->AddListener( this, m_name, false );
+ m_registered = true;
+}
+
+namespace listeners
+{
+ void weapon_fire( IGameEvent* e ) {
+ if( !g_csgo.m_panic && e ) {
+ int userid = e->GetInt( xors( "userid" ) );
+ if( g_csgo.m_engine( )->GetPlayerForUserID( userid ) == g_csgo.m_engine( )->GetLocalPlayer( ) ) {
+ auto wep = e->GetString( xors( "weapon" ) );
+
+ if( !strstr( wep, xors( "knife" ) ) && !strstr( wep, xors( "taser" ) ) && !strstr( wep, xors( "molotov" ) ) && !strstr( wep, xors( "grenade" ) ) && !strstr( wep, xors( "flashbang" ) ) ) {
+ g_ctx.m_last_shot_ack++;
+ g_ctx.m_last_shot_ack %= 128;
+
+ auto m_last_shot = g_ctx.m_last_shot_ack;
+ auto m_shot_data = g_ctx.m_shot_data;
+
+ auto& shot = g_ctx.m_shot_data[ g_ctx.m_last_shot_ack ];
+ if( shot.m_enemy_index && shot.m_resolver_state ) {
+ //g_cheat.m_ragebot.m_resolver->increment_shots( shot.m_enemy_index );
+ }
+ }
+ }
+ }
+ }
+
+ void bullet_impact( IGameEvent* e ) {
+ if( !g_csgo.m_panic && e ) {
+ static float last_time = g_csgo.m_globals->m_curtime;
+ float x = e->GetFloat( xors( "x" ) );
+ float y = e->GetFloat( xors( "y" ) );
+ float z = e->GetFloat( xors( "z" ) );
+ int user_id = e->GetInt( xors( "userid" ) );
+ int player_id = g_csgo.m_engine( )->GetPlayerForUserID( user_id );
+
+ vec3_t impact{ x, y, z };
+ if( player_id == g_csgo.m_engine( )->GetLocalPlayer( ) ) {
+ g_cheat.m_visuals.store_shot( impact, true );
+
+ if( g_ctx.m_last_shot_ack > g_ctx.m_last_shot ) {
+ g_ctx.reset_shot_queue( );
+ }
+
+ auto& shot = g_ctx.m_shot_data[ g_ctx.m_last_shot_ack ];
+
+ if( shot.m_enemy_index && !shot.m_handled ) {
+ vec3_t ang = math::vector_angles( shot.m_local_pos, impact );
+ vec3_t dir = math::angle_vectors( ang );
+ //csgo is gay
+ dir *= 8192.f;
+
+ vec3_t pos = shot.m_local_pos;
+
+ bool intersect = util::intersects_hitbox( pos, dir, shot.m_hitbox.min * 1.05f, shot.m_hitbox.max * 1.05f, shot.m_hitbox.radius * 1.05f );
+
+ if( !intersect ) {
+ if( shot.m_enemy_index ) {
+ g_cheat.m_ragebot.m_resolver->on_missed_spread( shot.m_enemy_index, g_ctx.m_last_shot_ack );
+ shot.m_missed = true;
+ }
+ }
+ else {
+ if( shot.m_resolver_state ) {
+ //g_cheat.m_ragebot.m_resolver->increment_shots( shot.m_enemy_index );
+ }
+
+ shot.m_missed = false;
+ }
+ shot.m_handled = true;
+ }
+ }
+
+ if( g_settings.visuals.bullet_tracers( ) && last_time != g_csgo.m_globals->m_curtime ) {
+ g_cheat.m_visuals.store_tracer( player_id, vec3_t( x, y, z ) );
+ }
+
+ last_time = g_csgo.m_globals->m_curtime;
+ }
+ }
+
+ void player_hurt( IGameEvent* e ) {
+ if( !g_csgo.m_panic && e ) {
+
+ int user_id = e->GetInt( xors( "userid" ) );
+ int attacker = e->GetInt( xors( "attacker" ) );
+ int hitgroup = e->GetInt( xors( "hitgroup" ) );
+ int dmg = e->GetInt( xors( "dmg_health" ) );
+ int hp = e->GetInt( xors( "health" ) );
+ int attacker_id = g_csgo.m_engine( )->GetPlayerForUserID( attacker );
+ int player_id = g_csgo.m_engine( )->GetPlayerForUserID( user_id );
+
+ g_cheat.m_visuals.store_ent_dmg( attacker_id, player_id, dmg );
+ if( attacker_id == g_csgo.m_engine( )->GetLocalPlayer( ) && user_id != attacker_id ) {
+ g_cheat.m_visuals.store_hit( );
+
+ auto& shot = g_ctx.m_shot_data[ g_ctx.m_last_shot_ack % 128 ];
+
+ if( shot.m_hitgroup == hitgroup && shot.m_resolver_state && !shot.m_missed && hitgroup != HITGROUP_GENERIC ) {
+ g_cheat.m_ragebot.m_resolver->listener( player_id, g_ctx.m_last_shot_ack );
+ }
+
+ if( shot.m_enemy_index && hitgroup != HITGROUP_GENERIC ) {
+ shot.m_hit = hitgroup;
+ shot.m_handled = true;
+ shot.m_logged = false;
+ shot.m_damage = dmg;
+ }
+ else if( g_settings.misc.log_hits( ) ) {
+ char print_str[ 100 ];
+ sprintf_s( print_str, "[\3moneybot\1] hit player in %s for %d", util::hitgroup_to_string( hitgroup ).c_str( ), dmg );
+
+ g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, print_str );
+ g_con->game_console_print( "%s\n", print_str );
+ }
+
+ if( shot.m_enemy_index && !shot.m_missed ) {
+ //g_cheat.m_visuals.store_shot( shot.m_enemy_pos, true );
+ }
+ }
+ }
+ }
+
+ void round_start( IGameEvent* e ) {
+ g_cheat.m_visuals.on_round_start( );
+
+ if( g_ctx.run_frame( ) ) {
+ switch( g_settings.misc.autobuy.main_weapon ) {
+ case 1:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy g3sg1" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy scar20" ) );
+ break;
+ case 2:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy ssg08" ) );
+ break;
+ case 3:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy awp" ) );
+ break;
+ case 4:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy ak47" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy m4a1" ) );
+ break;
+ case 5:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy ssg556" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy aug" ) );
+ break;
+ case 6:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy mac10" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy mp9" ) );
+ break;
+ }
+
+ switch( g_settings.misc.autobuy.secondary_weapon ) {
+ case 1:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy deagle" ) );
+ break;
+ case 2:
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy elite" ) );
+ break;
+ }
+
+ if( g_ctx.m_local->m_iAccount( ) > 1000 ) {
+ if( g_settings.misc.autobuy.armor( ) ) {
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy vest" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy vesthelm" ) );
+ }
+
+ if( g_settings.misc.autobuy.zeus( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy taser 34" ) );
+
+
+ if( g_settings.misc.autobuy.defuser( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy defuser" ) );
+
+
+ if( g_settings.misc.autobuy.molly( ) ) {
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy molotov" ) );
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy incgrenade" ) );
+ }
+
+ if( g_settings.misc.autobuy.smoke( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy smokegrenade" ) );
+
+
+ if( g_settings.misc.autobuy.grenade( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy hegrenade" ) );
+
+
+ if( g_settings.misc.autobuy.flash( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy flashbang" ) );
+
+
+ if( g_settings.misc.autobuy.decoy( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy decoy" ) );
+
+
+ if( g_settings.misc.autobuy.flash( ) )
+ g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "buy flashbang" ) );
+ }
+ }
+ }
+
+ void molotov_detonate( IGameEvent* e ) {
+ //1 line pro
+ float x = e->GetFloat( xors( "x" ) );
+ float y = e->GetFloat( xors( "y" ) );
+ float z = e->GetFloat( xors( "z" ) );
+ if( !( x && y && z ) )
+ return;
+
+ vec3_t pos{ x, y, z };
+ auto thrower = g_csgo.m_engine( )->GetPlayerForUserID( e->GetInt( xors( "userid" ) ) );
+ g_cheat.m_visuals.store_firegrenades( thrower, pos );
+
+ }
+
+ void player_death( IGameEvent *evt ) {
+ g_cheat.m_extra.money_talk( evt );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/listener.hpp b/internal_rewrite/listener.hpp new file mode 100644 index 0000000..5e18879 --- /dev/null +++ b/internal_rewrite/listener.hpp @@ -0,0 +1,29 @@ +#pragma once +#include "sdk.hpp" + +struct generic_listener_t : public IGameEventListener2 { + generic_listener_t( const char* event_name, + void( *function )( IGameEvent* ) ); + + generic_listener_t( ) = default; + + ~generic_listener_t( ); + + void init( ); + + void FireGameEvent( IGameEvent* event ) override { m_function( event ); } + int GetEventDebugID( ) override { return 0x2a; } +private: + void( *m_function )( IGameEvent* ); + const char* m_name{ }; + bool m_registered{ }; +}; + +namespace listeners { + extern void bullet_impact( IGameEvent* e ); + extern void player_hurt( IGameEvent* e ); + extern void round_start( IGameEvent* e ); + extern void molotov_detonate( IGameEvent* e ); + extern void weapon_fire( IGameEvent* e ); + extern void player_death( IGameEvent *e ); +}
\ No newline at end of file diff --git a/internal_rewrite/lock_cursor.cpp b/internal_rewrite/lock_cursor.cpp new file mode 100644 index 0000000..1d4d0e2 --- /dev/null +++ b/internal_rewrite/lock_cursor.cpp @@ -0,0 +1,12 @@ +#include "hooks.hpp"
+
+void __fastcall hooks::lock_cursor( void* ecx_, void* edx_ ) {
+ static auto lock_cursor_o = g_csgo.m_surface->get_old_function< decltype( &lock_cursor ) >( 67 );
+
+ if( g_settings.menu.open || g_con->m_open ) {
+ g_csgo.m_surface( )->UnlockCursor( );
+ return;
+ }
+
+ lock_cursor_o( ecx_, 0 );
+}
\ No newline at end of file diff --git a/internal_rewrite/match_framework.h b/internal_rewrite/match_framework.h new file mode 100644 index 0000000..f63efb1 --- /dev/null +++ b/internal_rewrite/match_framework.h @@ -0,0 +1,23 @@ +#pragma once
+#pragma once
+#include "util.hpp"
+#include "KeyValues.hpp"
+
+class CMatchSessionOnlineHost {
+public:
+ KeyValues* GetSessionSettings( ) {
+ using fn = KeyValues* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 1 )( this );
+ }
+ void UpdateSessionSettings( KeyValues* packet ) {
+ util::get_vfunc< 2, void >( this, packet );
+ }
+};
+
+class CMatchFramework {
+public:
+ CMatchSessionOnlineHost* GetMatchSession( ) {
+ using fn = CMatchSessionOnlineHost* ( __thiscall* )( void* );
+ return util::get_vfunc< fn >( this, 13 )( this );
+ }
+};
diff --git a/internal_rewrite/materialsystem_config.cpp b/internal_rewrite/materialsystem_config.cpp new file mode 100644 index 0000000..d3dc44a --- /dev/null +++ b/internal_rewrite/materialsystem_config.cpp @@ -0,0 +1,10 @@ +#include "hooks.hpp" +#include "settings.hpp" + +bool __fastcall hooks::material_system( void* ecx, void* edx, IMaterialSystem_Config_t* config, bool forceupdate ) { + static auto original_fn = g_csgo.m_mat_system->get_old_function< decltype( &hooks::material_system ) >( 21 ); + + config->m_fullbright = g_settings.visuals.fullbright( ); + + return original_fn( ecx, edx, config, forceupdate ); +} diff --git a/internal_rewrite/math.cpp b/internal_rewrite/math.cpp new file mode 100644 index 0000000..79389a9 --- /dev/null +++ b/internal_rewrite/math.cpp @@ -0,0 +1,301 @@ +#include <xmmintrin.h> +#include "math.hpp" +#include "interface.hpp" + +using _m128 = __m128; + +namespace math +{ + uint32_t md5_pseudorandom( uint32_t seed ) { + using fn = uint32_t( __thiscall * )( uint32_t seed ); + + static auto func = pattern::first_code_match< fn >( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 70 6A 58" ) ); + if( !func ) { + return 0; + } + + return func( seed ); + } + + static const __declspec( align( 16 ) ) uint32_t g_simd_component_mask[ 4 ][ 4 ] = { + { INT_MAX, 0, 0, 0 }, + { 0, INT_MAX, 0, 0 }, + { 0, 0, INT_MAX, 0 }, + { 0, 0, 0, INT_MAX } + }; + + void concat_transforms( const matrix3x4& in, const matrix3x4& in2, matrix3x4& out ) { + //SSE concat transforms - turbo mode engaged + + _m128 last_mask = *( _m128* )( &g_simd_component_mask[ 3 ] ); + _m128 row_a0 = _mm_loadu_ps( in[ 0 ] ); + _m128 row_a1 = _mm_loadu_ps( in[ 1 ] ); + _m128 row_a2 = _mm_loadu_ps( in[ 2 ] ); + + _m128 row_b0 = _mm_loadu_ps( in2[ 0 ] ); + _m128 row_b1 = _mm_loadu_ps( in2[ 1 ] ); + _m128 row_b2 = _mm_loadu_ps( in2[ 2 ] ); + + _m128 a0 = _mm_shuffle_ps( row_a0, row_a0, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + _m128 a1 = _mm_shuffle_ps( row_a0, row_a0, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + _m128 a2 = _mm_shuffle_ps( row_a0, row_a0, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + + _m128 mul00 = _mm_mul_ps( a0, row_b0 ); + _m128 mul01 = _mm_mul_ps( a1, row_b1 ); + _m128 mul02 = _mm_mul_ps( a2, row_b2 ); + _m128 out0 = _mm_add_ps( mul00, _mm_add_ps( mul01, mul02 ) ); + + a0 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + a1 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + a2 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + + _m128 mul10 = _mm_mul_ps( a0, row_b0 ); + _m128 mul11 = _mm_mul_ps( a1, row_b1 ); + _m128 mul12 = _mm_mul_ps( a2, row_b2 ); + _m128 out1 = _mm_add_ps( mul10, _mm_add_ps( mul11, mul12 ) ); + + a0 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 0, 0, 0, 0 ) ); + a1 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 1, 1, 1, 1 ) ); + a2 = _mm_shuffle_ps( row_a2, row_a2, _MM_SHUFFLE( 2, 2, 2, 2 ) ); + + _m128 mul20 = _mm_mul_ps( a0, row_b0 ); + _m128 mul21 = _mm_mul_ps( a0, row_b1 ); + _m128 mul22 = _mm_mul_ps( a0, row_b2 ); + _m128 out2 = _mm_add_ps( mul20, _mm_add_ps( mul21, mul22 ) ); + + a0 = _mm_and_ps( row_a0, last_mask ); + a1 = _mm_and_ps( row_a1, last_mask ); + a2 = _mm_and_ps( row_a2, last_mask ); + + out0 = _mm_add_ps( out0, a0 ); + out1 = _mm_add_ps( out1, a1 ); + out2 = _mm_add_ps( out2, a2 ); + + *( _m128* )( out[ 0 ] ) = out0; + *( _m128* )( out[ 1 ] ) = out1; + *( _m128* )( out[ 2 ] ) = out2; + } + + void math::set_matrix_position( vec3_t pos, matrix3x4& matrix ) { + for( size_t i{ }; i < 3; ++i ) { + matrix[ i ][ 3 ] = pos[ i ]; + } + } + + vec3_t math::get_matrix_position( const matrix3x4& src ) { + return vec3_t( src[ 0 ][ 3 ], src[ 1 ][ 3 ], src[ 2 ][ 3 ] ); + } + + void angle_matrix( vec3_t angles, matrix3x4& matrix ) { + float sr, sp, sy, cr, cp, cy; + + sp = sinf( angles.x * M_PIRAD ); + cp = cosf( angles.x * M_PIRAD ); + sy = sinf( angles.y * M_PIRAD ); + cy = cosf( angles.y * M_PIRAD ); + sr = sinf( angles.z * M_PIRAD ); + cr = cosf( angles.z * M_PIRAD ); + + matrix[ 0 ][ 0 ] = cp * cy; + matrix[ 1 ][ 0 ] = cp * sy; + matrix[ 2 ][ 0 ] = -sp; + + float crcy = cr * cy; + float crsy = cr * sy; + float srcy = sr * cy; + float srsy = sr * sy; + matrix[ 0 ][ 1 ] = sp * srcy - crsy; + matrix[ 1 ][ 1 ] = sp * srsy + crcy; + matrix[ 2 ][ 1 ] = sr * cp; + + matrix[ 0 ][ 2 ] = ( sp*crcy + srsy ); + matrix[ 1 ][ 2 ] = ( sp*crsy - srcy ); + matrix[ 2 ][ 2 ] = cr * cp; + + matrix[ 0 ][ 3 ] = 0.f; + matrix[ 1 ][ 3 ] = 0.f; + matrix[ 2 ][ 3 ] = 0.f; + } + + void angle_imatrix( vec3_t angles, matrix3x4& matrix ) { + float sr, sp, sy, cr, cp, cy; + + sp = sinf( angles.x * M_PIRAD ); + cp = cosf( angles.x * M_PIRAD ); + sy = sinf( angles.y * M_PIRAD ); + cy = cosf( angles.y * M_PIRAD ); + sr = sinf( angles.z * M_PIRAD ); + cr = cosf( angles.z * M_PIRAD ); + + matrix[ 0 ][ 0 ] = cp * cy; + matrix[ 0 ][ 1 ] = cp * sy; + matrix[ 0 ][ 2 ] = -sp; + matrix[ 1 ][ 0 ] = sr * sp*cy + cr * -sy; + matrix[ 1 ][ 1 ] = sr * sp*sy + cr * cy; + matrix[ 1 ][ 2 ] = sr * cp; + matrix[ 2 ][ 0 ] = ( cr*sp*cy + -sr * -sy ); + matrix[ 2 ][ 1 ] = ( cr*sp*sy + -sr * cy ); + matrix[ 2 ][ 2 ] = cr * cp; + matrix[ 0 ][ 3 ] = 0.f; + matrix[ 1 ][ 3 ] = 0.f; + matrix[ 2 ][ 3 ] = 0.f; + } + + void angle_matrix( vec3_t angles, matrix3x4& matrix, vec3_t origin ) { + angle_matrix( angles, matrix ); + set_matrix_position( origin, matrix ); + } + + vec3_t matrix_angles( const matrix3x4& matrix ) { + //thx strackoverflow + vec3_t angles; + float forward[ 3 ]; + float left[ 3 ]; + float up[ 3 ]; + + forward[ 0 ] = matrix[ 0 ][ 0 ]; + forward[ 1 ] = matrix[ 1 ][ 0 ]; + forward[ 2 ] = matrix[ 2 ][ 0 ]; + left[ 0 ] = matrix[ 0 ][ 1 ]; + left[ 1 ] = matrix[ 1 ][ 1 ]; + left[ 2 ] = matrix[ 2 ][ 1 ]; + up[ 2 ] = matrix[ 2 ][ 2 ]; + + float xy_dist = sqrtf( forward[ 0 ] * forward[ 0 ] + forward[ 1 ] * forward[ 1 ] ); + + if( xy_dist > 0.001f ) { + angles.y = RAD2DEG( atan2f( forward[ 1 ], forward[ 0 ] ) ); + angles.x = RAD2DEG( atan2f( -forward[ 2 ], xy_dist ) ); + angles.z = RAD2DEG( atan2f( left[ 2 ], up[ 2 ] ) ); + } + else { + angles.y = RAD2DEG( atan2f( -left[ 0 ], left[ 1 ] ) ); + angles.x = RAD2DEG( atan2f( -forward[ 2 ], xy_dist ) ); + + angles.z = 0; + } + + return angles; + } + + void rotate_matrix( vec3_t angles, vec3_t origin, float degrees, matrix3x4& matrix ) { + angles.y += degrees; + angles.clamp( ); + + vec3_t rotated( 0, degrees, 0 ); + matrix3x4 rotated_matrix; + angle_matrix( rotated, rotated_matrix ); + + vec3_t delta = get_matrix_position( matrix ) - origin; + vec3_t out = vector_transform( delta, rotated_matrix ); + + matrix3x4 bone_rotation, matrix_out; + memcpy( &bone_rotation, &matrix, sizeof( matrix3x4 ) ); + + set_matrix_position( vec3_t( ), bone_rotation ); + concat_transforms( rotated_matrix, bone_rotation, matrix_out ); + auto angles_out = matrix_angles( matrix_out ); + angle_matrix( angles_out, matrix, out ); + } + + float approach_angle( float to, float from, float speed ) { + float delta = std::remainderf( to - from, 360.f ); + + if( delta > speed ) + from += speed; + else if( delta < -speed ) + from -= speed; + else from = to; + + return std::clamp( from, -180.f, 180.f ); + } + + float snap_yaw( float value ) { + //this is actually what the code looks like in the game btw + float sign = 1.0f; + if( value < 0.0f ) { + sign = -1.0f; + value = -value; + } + + if( value < 23.0f ) + value = 0.0f; + else if( value < 67.0f ) + value = 45.0f; + else if( value < 113.0f ) + value = 90.0f; + else if( value < 157 ) + value = 135.0f; + else + value = 180.0f; + + return ( value * sign ); + } + + float __vectorcall dist_segment_to_segment( vec3_t s1, vec3_t s2, vec3_t k1, vec3_t k2 ) { + vec3_t u = s2 - s1; + vec3_t v = k2 - k1; + vec3_t w = s1 - k1; + float a = u.dot( u ); + float b = u.dot( v ); + float c = v.dot( v ); + float d = u.dot( w ); + float e = v.dot( w ); + float D = a*c - b*b; + float sc, sN, sD = D; + float tc, tN, tD = D; + + if( D < SMALL_NUM ) { + sN = 0.0f; + sD = 1.0f; + tN = e; + tD = c; + } + else { + sN = ( b*e - c*d ); + tN = ( a*e - b*d ); + if( sN < 0.0f ) { + sN = 0.0f; + tN = e; + tD = c; + } + else if( sN > sD ) { + sN = sD; + tN = e + b; + tD = c; + } + } + + if( tN < 0.0f ) { + tN = 0.0; + + if( -d < 0.0f ) + sN = 0.0; + else if( -d > a ) + sN = sD; + else { + sN = -d; + sD = a; + } + } + else if( tN > tD ) { + tN = tD; + + if( ( -d + b ) < 0.0f ) + sN = 0; + else if( ( -d + b ) > a ) + sN = sD; + else { + sN = ( -d + b ); + sD = a; + } + } + + sc = ( abs( sN ) < SMALL_NUM ? 0.0f : sN / sD ); + tc = ( abs( tN ) < SMALL_NUM ? 0.0f : tN / tD ); + + vec3_t dP = w + ( u * sc ) - ( v * tc ); + + return dP.length(); + } +}
\ No newline at end of file diff --git a/internal_rewrite/math.hpp b/internal_rewrite/math.hpp new file mode 100644 index 0000000..b965600 --- /dev/null +++ b/internal_rewrite/math.hpp @@ -0,0 +1,164 @@ +#pragma once +#include <random> +#include "util.hpp" +#include "pattern.hpp" +#include "sdk.hpp" + +static constexpr long double M_PI = 3.14159265358979323846f; +static constexpr long double M_RADPI = 57.295779513082f; +static constexpr long double M_PIRAD = 0.01745329251f; +static constexpr float SMALL_NUM = 0.00000001f; +static constexpr float M_PI_F = ( ( float )( M_PI ) ); +__forceinline float RAD2DEG( float x ) { return( ( float )( x ) * ( float )( 180.f / M_PI_F ) ); } +__forceinline float DEG2RAD( float x ) { return( ( float )( x ) * ( float )( M_PI_F / 180.f ) ); } + +namespace { + //make a random generator and seed it with a p random number + static std::random_device rd; + static std::mt19937 gen( rd( ) ); +} + +NAMESPACE_REGION( math ) + +#undef min +#undef max + +template < typename t > +t min( const t& t1, const t& t2 ) { + return t1 < t2 ? t1 : t2; +} + +template < typename t, typename... ts_ > +t min( const t& t1, const t& t2, ts_&&... ts ) { + return t1 < t2 ? + min( t1, std::forward< ts_ >( ts )... ) : + min( t2, std::forward< ts_ >( ts )... ); +} + +template < typename t > +t max( const t& t1, const t& t2 ) { + return t1 > t2 ? t1 : t2; +} + +template < typename t, typename... ts_ > +t max( const t& t1, const t& t2, ts_&&... ts ) { + return t1 > t2 ? + max( t1, std::forward< ts_ >( ts )... ) : + max( t2, std::forward< ts_ >( ts )... ); +} + +template < typename t > +t lerp( const t& t1, const t& t2, float progress ) { + return t1 + ( t2 - t1 ) * progress; +} + +// todo - dex; make 2 random generator funcs here, this one only works for floats normally + +template < typename t > +__forceinline t random_number( t min, t max ) { + if constexpr( !std::is_integral_v< t > ) { + std::uniform_real_distribution< t > dist( min, max ); + return dist( gen ); + } + else { + std::uniform_int_distribution< t > dist( min, max ); + return dist( gen ); + } +} + +__forceinline vec3_t get_rotated_pos( vec3_t start, float rotation, float distance ) { + float rad = DEG2RAD( rotation ); + start.x += cos( rad ) * distance; + start.y += sin( rad ) * distance; + + return start; +} + +__forceinline vec3_t vector_angles( const vec3_t& start, const vec3_t& end ) { + vec3_t delta = end - start; + + float magnitude = sqrtf( delta.x * delta.x + delta.y * delta.y ); + float pitch = atan2f( -delta.z, magnitude ) * M_RADPI; + float yaw = atan2f( delta.y, delta.x ) * M_RADPI; + + vec3_t angle( pitch, yaw, 0.0f ); + return angle.clamp( ); +} + + +__forceinline vec3_t vector_angles( const vec3_t& v ) { + float magnitude = sqrtf( v.x * v.x + v.y * v.y ); + float pitch = atan2f( -v.z, magnitude ) * M_RADPI; + float yaw = atan2f( v.y, v.x ) * M_RADPI; + + vec3_t angle( pitch, yaw, 0.0f ); + return angle; +} + +__forceinline vec3_t angle_vectors( const vec3_t& angles ) { + float sp, sy, cp, cy; + sp = sinf( angles.x * M_PIRAD ); + cp = cosf( angles.x * M_PIRAD ); + sy = sinf( angles.y * M_PIRAD ); + cy = cosf( angles.y * M_PIRAD ); + + return vec3_t{ cp * cy, cp * sy, -sp }; +} + +__forceinline void angle_vectors( const vec3_t& angles, vec3_t* forward, vec3_t* right, vec3_t* up ) { + float sr, sp, sy, cr, cp, cy; + + sp = sinf( angles.x * M_PIRAD ); + cp = cosf( angles.x * M_PIRAD ); + sy = sinf( angles.y * M_PIRAD ); + cy = cosf( angles.y * M_PIRAD ); + sr = sinf( angles.z * M_PIRAD ); + cr = cosf( angles.z * M_PIRAD ); + + if ( forward ) { + forward->x = cp * cy; + forward->y = cp * sy; + forward->z = -sp; + } + + if ( right ) { + right->x = -1 * sr * sp * cy + -1 * cr * -sy; + right->y = -1 * sr * sp * sy + -1 * cr * cy; + right->z = -1 * sr * cp; + } + + if ( up ) { + up->x = cr * sp * cy + -sr * -sy; + up->y = cr * sp * sy + -sr * cy; + up->z = cr * cp; + } +} + +__forceinline float find_closest_step( float angle, float step ) { + int steps = ( int )( angle / step + 0.5f ); + + return steps * step; +} + +__forceinline vec3_t vector_transform( const vec3_t& in, const matrix3x4& matrix ) { + vec3_t out; + for ( int i{ }; i < 3; i++ ) + out[ i ] = in.dot( ( const vec3_t& )matrix[ i ] ) + matrix[ i ][ 3 ]; + + return out; +} + +extern void concat_transforms( const matrix3x4& in, const matrix3x4& in2, matrix3x4& out ); +extern void rotate_matrix( vec3_t angles, vec3_t origin, float degrees, matrix3x4& matrix ); +extern void set_matrix_position( vec3_t pos, matrix3x4& src ); +extern vec3_t get_matrix_position( const matrix3x4& pos ); +extern vec3_t matrix_angles( const matrix3x4& matrix ); +extern void angle_matrix( vec3_t angles, matrix3x4& matrix, vec3_t origin ); +extern void angle_imatrix( vec3_t angles, matrix3x4& matrix ); +extern void angle_matrix( vec3_t angles, matrix3x4& matrix ); +extern float approach_angle( float to, float from, float speed ); +extern float snap_yaw( float value ); +extern uint32_t md5_pseudorandom( uint32_t seed ); +extern float __vectorcall dist_segment_to_segment( vec3_t s1, vec3_t s2, vec3_t k1, vec3_t k2 ); + +END_REGION
\ No newline at end of file diff --git a/internal_rewrite/mem.hpp b/internal_rewrite/mem.hpp new file mode 100644 index 0000000..37db3ad --- /dev/null +++ b/internal_rewrite/mem.hpp @@ -0,0 +1,66 @@ +#pragma once +#include <intrin.h> +#include "util.hpp" + +#define get_baseptr( ) ( ( uintptr_t )( _AddressOfReturnAddress( ) ) - sizeof( uintptr_t ) ) + +class stack_t { + uintptr_t m_ptr; + +public: + __forceinline stack_t( ) : m_ptr( get_baseptr( ) ) { } + + __forceinline stack_t( uintptr_t ptr ) : m_ptr( ptr ) { } + + template < typename t = uintptr_t > + __forceinline t get( ) { + return ( t )m_ptr; + } + + template < typename t = uintptr_t > + __forceinline t return_address( ) { + return *( t* )( m_ptr + sizeof( void* ) ); + } + + template < typename t = uintptr_t > + __forceinline t address_of_return_address( ) { + return ( t )( m_ptr + sizeof( uintptr_t ) ); + } + + __forceinline stack_t& next( ) { + return *( stack_t* )( m_ptr ); + } + + template < typename t = uintptr_t > + __forceinline t local( size_t at ) { + return ( t )( m_ptr - at ); + } + + template < typename t = uintptr_t > + __forceinline t arg( size_t at ) { + return ( t )( m_ptr + at ); + } +}; + +namespace util { + template < typename t = uint8_t > + __forceinline t* memcpy( t* dst, t* src, size_t size = sizeof( t ) ) { + __movsb( + ( uint8_t* )dst, + ( uint8_t* )src, + size + ); + + return dst; + } + + __forceinline void* memset( uint8_t* dst, uint8_t val, size_t size ) { + __stosb( + dst, + val, + size + ); + + return dst; + } +}
\ No newline at end of file diff --git a/internal_rewrite/movement.cpp b/internal_rewrite/movement.cpp new file mode 100644 index 0000000..e62dfda --- /dev/null +++ b/internal_rewrite/movement.cpp @@ -0,0 +1,318 @@ +#include "movement.hpp"
+#include "interface.hpp"
+#include "settings.hpp"
+#include "context.hpp"
+
+#include <algorithm>
+#include "base_cheat.hpp"
+#include "input_system.hpp"
+#include "renderer.hpp"
+
+NAMESPACE_REGION( features )
+
+float get_ideal_strafe_step( float speed ) {
+ static auto* sv_airaccelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_airaccelerate" ) );
+ float airaccel = std::min< float >( sv_airaccelerate->get_float( ), 30.f );
+
+ float step = std::atan2( airaccel, speed ) * M_RADPI;
+
+ //tickcount correction
+ float tickcount = 1.0f / g_csgo.m_globals->m_interval_per_tick;
+ step *= ( 64.f / tickcount );
+
+ return step;
+}
+
+void rotate_movement( user_cmd_t* cmd, float rotation ) {
+ rotation = rotation * M_PIRAD;
+
+ float cos_rot = cos( rotation );
+ float sin_rot = sin( rotation );
+
+ float new_forwardmove = ( cos_rot * cmd->m_forwardmove ) - ( sin_rot * cmd->m_sidemove );
+ float new_sidemove = ( sin_rot * cmd->m_forwardmove ) + ( cos_rot * cmd->m_sidemove );
+
+ cmd->m_forwardmove = new_forwardmove;
+ cmd->m_sidemove = new_sidemove;
+}
+
+void c_movement::bhop( ) {
+ if ( !g_settings.misc.bunny_hop )
+ return;
+
+ if ( g_ctx.m_local->m_nMoveType( ) == MOVETYPE_LADDER ||
+ g_ctx.m_local->m_nMoveType( ) == MOVETYPE_NOCLIP )
+ return;
+
+ //jump like you nohat
+ if ( m_ucmd->m_buttons & IN_JUMP && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) {
+ m_ucmd->m_buttons &= ~IN_JUMP;
+ }
+}
+
+void c_movement::auto_strafer( ) {
+ if( !g_settings.misc.auto_strafe )
+ return;
+
+ vec3_t velocity = g_ctx.m_local->m_vecVelocity( );
+ float speed = velocity.length2d( );
+ auto cmd = g_ctx.get_last_cmd( );
+
+ auto on_ground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND;
+ if( cmd && ( m_ucmd->m_buttons & IN_JUMP ) && ( speed > 1.0f || g_settings.misc.air_duck( ) ) && !on_ground ) {
+ if( !cmd->m_forwardmove && !cmd->m_sidemove ) {
+ if( !cmd->m_mousedx ) {
+ vec3_t velocity_dir = math::vector_angles( vec3_t( ), velocity );
+ float yaw = g_csgo.m_engine( )->GetViewAngles( ).y;
+
+ static auto* sv_airaccelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_airaccelerate" ) );
+ float airaccel = std::min< float >( sv_airaccelerate->get_float( ), 30.f );
+
+ float ideal_rotation = std::clamp( RAD2DEG( std::atan2f( airaccel, speed ) ), 0.f, 45.f );
+ if( ( cmd->m_cmd_nr % 2 ) )
+ ideal_rotation *= -1;
+
+ cmd->m_sidemove = ( cmd->m_cmd_nr % 2 ) ? 450.f : -450.f;
+ cmd->m_forwardmove = 0;
+
+ rotate_movement( cmd, std::remainderf( ideal_rotation, 360.f ) );
+ }
+ else {
+ cmd->m_sidemove = m_ucmd->m_mousedx < 0.f ? -450.f : 450.f;
+ }
+ }
+ }
+}
+
+
+void c_movement::edge_jump( ) {
+ if ( !g_settings.misc.edge_jump )
+ return;
+
+ if ( !g_input.is_key_pressed( ( VirtualKeys_t )g_settings.misc.edge_jump_key( ) ) )
+ return;
+
+ //needs key check here so its not always on
+ //what??
+ bool pre_onground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND;
+ bool post_onground = g_cheat.m_prediction.get_predicted_flags( ) & FL_ONGROUND;
+
+ if ( pre_onground && !post_onground ) {
+ m_ucmd->m_buttons |= IN_JUMP;
+ }
+}
+
+void c_movement::air_duck( ) {
+ if( !g_settings.misc.air_duck )
+ return;
+
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ m_ucmd->m_buttons |= IN_DUCK;
+}
+
+void c_movement::auto_jumpbug( ) {
+ if ( !g_settings.misc.auto_jumpbug( ) )
+ return;
+
+ if ( !g_input.is_key_pressed( ( VirtualKeys_t )g_settings.misc.auto_jumpbug_key( ) ) )
+ return;
+
+ static bool jumped = false;
+ static bool jump_next = false;
+
+ vec3_t origin = g_ctx.m_local->m_vecOrigin( );
+ origin += g_ctx.m_local->m_vecVelocity( ) * TICK_INTERVAL( );
+
+ Ray_t ray;
+ ray.Init( origin, origin + vec3_t( 0.f, 0.f, 4.f ) );
+
+ CTraceFilter f;
+ f.pSkip = g_ctx.m_local;
+
+ CGameTrace tr;
+ g_csgo.m_trace( )->TraceRay( ray, MASK_PLAYERSOLID, &f, &tr );
+
+ bool unduck = tr.fraction != 1.0f;
+
+ if( unduck ) {
+ m_ucmd->m_buttons &= ~IN_DUCK;
+ m_ucmd->m_buttons |= IN_JUMP;
+ }
+ else {
+ m_ucmd->m_buttons |= IN_DUCK;
+ m_ucmd->m_buttons &= ~IN_JUMP;
+ }
+}
+
+void c_movement::jump_stats( ) {
+ if( !g_settings.misc.show_jump_stats ) return;
+
+ static auto sv_airaccelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_airaccelerate" ) );
+ static bool was_onground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND;
+ static vec3_t last_origin{ };
+ static float ground_vel{ };
+ static float last_jump_max_speed{ };
+ static float last_height{ };
+ static float last_dist{ };
+
+ const float lj_threshold = sv_airaccelerate->get_float( ) < 15.f ? 190.f : 240.f;
+
+ bool on_ground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND;
+ bool ducking = g_ctx.m_local->m_fFlags( ) & FL_DUCKING;
+
+ char jump_string[ 250 ] = { };
+
+ if( on_ground ) {
+ int vertical = 0;
+
+ if( !was_onground ) {
+ vec3_t cur_origin = g_ctx.m_local->m_vecOrigin( );
+ last_dist = cur_origin.dist_to( last_origin );
+
+ if( std::abs( cur_origin.z - last_origin.z ) >= ( ducking ? 10.f : 5.f ) ) {
+ vertical = cur_origin.z > last_origin.z ? 1 : -1;
+ }
+
+ if( ground_vel > 200.f && last_jump_max_speed > 260.f && std::abs( last_height ) > 20.f ) {
+ if( vertical ) {
+ strenc::w_sprintf_s( jump_string, 250, xors( "[\3JUMP STAT\1] pre: %0.2f | max vel: %0.2f | height: %0.2f | duck: %d | \2%s\n" ),
+ ground_vel, last_jump_max_speed, last_height, ducking, vertical == 1 ? xors( "vertical" ) : xors( "dropjump" ) );
+ }
+ else {
+ bool is_lj = last_dist > lj_threshold;
+ strenc::w_sprintf_s( jump_string, 250, xors( "[\3JUMP STAT\1]: pre: %0.2f | max vel: %0.2f | height: %0.2f | duck: %d | dist: %c%0.2f\n" ),
+ ground_vel, last_jump_max_speed, last_height, ducking, is_lj ? 4 : 1, last_dist );
+ }
+
+ g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, jump_string );
+ }
+ }
+ last_origin = g_ctx.m_local->m_vecOrigin( );
+ last_jump_max_speed = 0.f;
+ last_height = 0.f;
+ ground_vel = g_ctx.m_local->m_vecVelocity( ).length2d( );
+
+ was_onground = true;
+ }
+ else {
+ was_onground = false;
+ float vel = g_ctx.m_local->m_vecVelocity( ).length2d( );
+ if( vel > last_jump_max_speed ) {
+ last_jump_max_speed = vel;
+ }
+ float delta = g_ctx.m_local->m_vecOrigin( ).z - last_origin.z;
+ if( std::abs( delta ) > std::abs( last_height ) ) {
+ last_height = delta;
+ }
+ }
+}
+
+//fuck hardcode
+const vec3_t mins( -26.f, -26.f, 0 );
+const vec3_t maxs( 26.f, 26.f, 44.f );
+
+constexpr int TRACE_STEP_MAX = 45;
+bool trace_ideal_step( float step, float speed, vec3_t velocity, vec3_t start_pos ) {
+ vec3_t direction = math::vector_angles( vec3_t( ), velocity );
+ float wish_step = direction.y + step;
+
+ vec3_t origin = start_pos;
+
+ vec3_t start = origin;
+ vec3_t trace_step = math::angle_vectors( vec3_t( 0, wish_step, 0 ) ) * velocity.length2d( ) * TICK_INTERVAL( );
+
+ vec3_t pos = start + trace_step;
+
+ CGameTrace tr;
+ CTraceFilter filter;
+ filter.pSkip = g_ctx.m_local;
+
+ for( size_t i{ }; i <= 1 / TICK_INTERVAL( ); ++i ) {
+ start = pos;
+ trace_step = math::angle_vectors( vec3_t( 0, wish_step += step, 0 ) ) * velocity.length2d( ) * TICK_INTERVAL( );
+ pos += trace_step;
+
+ Ray_t ray;
+ ray.Init( start, pos, mins, maxs );
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SOLID, &filter, &tr );
+
+ if( !tr.DidHit( ) ) {
+ if( i == TRACE_STEP_MAX ) {
+ return true;
+ }
+ continue;
+ }
+
+ break;
+ }
+
+ return false;
+}
+
+float c_movement::get_best_strafe_angle( ) {
+ vec3_t velocity = g_ctx.m_local->m_vecVelocity( );
+ float ideal_step = get_ideal_strafe_step( velocity.length2d( ) ) * 0.8f;
+
+ float step = ideal_step;
+ vec3_t start = g_ctx.m_local->m_vecOrigin( );
+
+ for( size_t i{ }; i < 9; ++i ) {
+ if( trace_ideal_step( step, velocity.length2d( ), velocity, start ) ) {
+ vec3_t direction = math::vector_angles( vec3_t( ), velocity );
+ return direction.y + step;
+ }
+
+ step -= step * 0.2f;
+ }
+
+ step = ideal_step;
+ for( size_t i{ }; i < velocity.length2d( ) * 0.015f; ++i ) {
+ step += step * 0.2f;
+ if( trace_ideal_step( step, velocity.length2d( ), velocity, start ) ) {
+ vec3_t direction = math::vector_angles( vec3_t( ), velocity );
+ return direction.y + step;
+ }
+ }
+
+ return math::vector_angles( vec3_t( ), velocity ).y;
+}
+
+void c_movement::circle_strafe( ) {
+ if( g_settings.misc.circle_strafe ) {
+ if( g_ctx.m_local->m_nMoveType( ) == MOVETYPE_LADDER || g_ctx.m_local->m_nMoveType( ) == MOVETYPE_NOCLIP )
+ return;
+
+ static bool can_finish = true;
+ auto cmd = g_ctx.get_last_cmd( );
+ if( g_input.is_key_pressed( g_settings.misc.circle_strafe_key ) || !can_finish ) {
+ m_ucmd->m_buttons |= IN_JUMP;
+ cmd->m_forwardmove = 450.f;
+
+ float speed = g_ctx.m_local->m_vecVelocity( ).length2d( );
+ if( speed > 1.f ) {
+ can_finish = false;
+ float angle = get_best_strafe_angle( );
+
+ float delta = std::remainderf( m_ucmd->m_viewangles.y - angle, 360.f );
+
+ cmd->m_forwardmove = 5850.f / speed;
+ cmd->m_sidemove = -450.f;
+ rotate_movement( cmd, delta );
+
+ vec3_t current_view;
+ g_csgo.m_engine( )->GetViewAngles( current_view );
+ float view_delta = std::remainderf( current_view.y - angle, 360.f );
+
+ if( std::fabs( view_delta ) < 10.0f || speed < 250.f ) {
+ can_finish = true;
+ }
+ }
+ else {
+ can_finish = true;
+ }
+ }
+ }
+}
+
+END_REGION
\ No newline at end of file diff --git a/internal_rewrite/movement.hpp b/internal_rewrite/movement.hpp new file mode 100644 index 0000000..0c0b1a6 --- /dev/null +++ b/internal_rewrite/movement.hpp @@ -0,0 +1,39 @@ +#pragma once
+#include "util.hpp"
+
+//forward declarations
+class user_cmd_t;
+
+NAMESPACE_REGION( features )
+
+class c_movement {
+ user_cmd_t* m_ucmd{ };
+ bool m_direction{ };
+
+ void bhop( );
+ void auto_strafer( );
+
+ void edge_jump( );
+ void auto_jumpbug( );
+ void jump_stats( );
+
+ bool get_best_direction( float ideal_step, float left, float right, float weight );
+ float get_best_strafe_step( float speed, vec3_t direction );
+ float get_best_strafe_angle( );
+ void circle_strafe( );
+ void air_duck( );
+
+public:
+ void operator()( user_cmd_t* ucmd ) {
+ m_ucmd = ucmd;
+ auto_strafer( );
+ circle_strafe( );
+ bhop( );
+ edge_jump( );
+ auto_jumpbug( );
+ jump_stats( );
+ air_duck( );
+ }
+};
+
+END_REGION
\ No newline at end of file diff --git a/internal_rewrite/movement_recorder.cpp b/internal_rewrite/movement_recorder.cpp new file mode 100644 index 0000000..6e9245c --- /dev/null +++ b/internal_rewrite/movement_recorder.cpp @@ -0,0 +1,79 @@ +#include "movement_recorder.hpp" +#include "input_system.hpp" +#include "settings.hpp" +#include "interface.hpp" + +namespace features +{ + void c_move_recorder::operator()( user_cmd_t* cmd ) { + if( !g_settings.misc.recorder_enable ) + return; + + if( g_input.is_key_pressed( g_settings.misc.recording_start_key( ) ) ) + start_recording( ); + + if( g_input.is_key_pressed( g_settings.misc.recording_stop_key( ) ) ) + stop_recording( ); + + if( m_recording ) { + record_cmd( cmd ); + } + + if( m_playing ) { + if( m_move_data.empty( ) ) { + m_playing = false; + } + else if( ++m_record_index >= m_move_data.size( ) ) { + m_playing = false; + } + else { + auto& old_cmd = m_move_data.at( m_record_index ); + + if( g_settings.misc.recording_show_angles == 1 && ( old_cmd.m_buttons & IN_ATTACK ) || + g_settings.misc.recording_show_angles == 2 ) { + g_csgo.m_engine( )->SetViewAngles( old_cmd.m_viewangles ); + } + + cmd->m_buttons = old_cmd.m_buttons; + cmd->m_aimdirection = old_cmd.m_aimdirection; + cmd->m_forwardmove = old_cmd.m_forwardmove; + cmd->m_impulse = old_cmd.m_impulse; + cmd->m_mousedx = old_cmd.m_mousedx; + cmd->m_mousedy = old_cmd.m_mousedy; + cmd->m_sidemove = old_cmd.m_sidemove; + cmd->m_upmove = old_cmd.m_upmove; + cmd->m_viewangles = old_cmd.m_viewangles; + cmd->m_weaponselect = old_cmd.m_weaponselect; + cmd->m_weaponsubtype = old_cmd.m_weaponsubtype; + } + } + else { + m_record_index = 0; + } + } + + void c_move_recorder::record_cmd( user_cmd_t* cmd ) { + m_move_data.push_back( *cmd ); + } + + void c_move_recorder::start_recording( ) { + m_recording = true; + } + + void c_move_recorder::stop_recording( ) { + m_recording = false; + } + + void c_move_recorder::play_back( ) { + m_recording = false; + m_playing = true; + } + + void c_move_recorder::stop_playback( ) { + m_playing = false; + } + + void c_move_recorder::clear_recording( ) { + m_move_data.clear( ); + } +}
\ No newline at end of file diff --git a/internal_rewrite/movement_recorder.hpp b/internal_rewrite/movement_recorder.hpp new file mode 100644 index 0000000..03bcf8c --- /dev/null +++ b/internal_rewrite/movement_recorder.hpp @@ -0,0 +1,29 @@ +#pragma once +#include "sdk.hpp" +#include "vector.hpp" + +namespace features +{ + class c_move_recorder { + public: + void play_back( ); + void stop_playback( ); + void clear_recording( ); + + bool is_recording( ) const { return m_recording; } + bool is_playing( ) const { return m_playing; } + int get_record_count( ) const { return m_move_data.size( ); } + auto get_current_record( ) const { return m_record_index; } + + void operator()( user_cmd_t* ); + private: + void record_cmd( user_cmd_t* cmd ); + void start_recording( ); + void stop_recording( ); + + bool m_recording = false; + bool m_playing = false; + size_t m_record_index = 0; + std::vector< user_cmd_t > m_move_data; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/net_showfragments.cpp b/internal_rewrite/net_showfragments.cpp new file mode 100644 index 0000000..60ddbc9 --- /dev/null +++ b/internal_rewrite/net_showfragments.cpp @@ -0,0 +1,50 @@ +#include "hooks.hpp"
+#include "mem.hpp"
+#include "context.hpp"
+
+// Index 13 is GetBool, GetInt and GetFloat are inlined by default.
+int __fastcall hooks::net_showfragments_get_int( void* ecx_, void* edx_ ) {
+ static auto old_fn = g_csgo.m_netshowfragments->get_old_function< decltype( &net_showfragments_get_int ) >( 13 );
+
+ static auto ret_checkreceivinglist = pattern::first_code_match( g_csgo.m_engine.dll( ), xors( "FF 50 34 8B 1D ? ? ? ? 85 C0 74 16 FF B6" ), 0x3 );
+ static auto ret_readsubchanneldata = pattern::first_code_match( g_csgo.m_engine.dll( ), xors( "FF 50 34 85 C0 74 12 53 FF 75 0C" ), 0x3 );
+
+ static auto last_fragment = 0;
+ static auto last_time = 0.f;
+
+ stack_t stack( get_baseptr( ) );
+ auto cl = g_csgo.m_global_state->get_client_state( );
+ auto nc = cl->m_netchannel;
+
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+
+ if ( nci && ( ( g_settings.misc.net_fakeping_amount( ) && g_settings.misc.net_fakeping_active ) || nci->GetLatency( 1 ) > 0.06f ) && g_ctx.m_local ) {
+ if ( stack.return_address( ) == ret_readsubchanneldata ) {
+ auto e = ( uint32_t* ) ( nc );
+ auto data = &e [ 0x54 ];
+
+ auto fragment = data [ 0x43 ];
+
+ if ( fragment == last_fragment ) {
+ float delta = GetTickCount( ) * 0.001f - last_time;
+
+ if ( delta <= std::max( nci->GetLatency( 1 ), 0.3f ) ) {
+ ( ( uint32_t* ) data ) [ 0x42 ] = 0;
+ last_time = GetTickCount( ) * 0.001f;
+ }
+ }
+ }
+
+ if ( stack.return_address( ) == ret_checkreceivinglist ) {
+ auto e = ( uint32_t* ) ( nc );
+ auto data = &e [ 0x54 ];
+
+ auto fragment = data [ 0x43 ];
+
+ last_fragment = fragment;
+ last_time = GetTickCount( ) * 0.001f;
+ }
+ }
+
+ return old_fn( ecx_, 0 );
+}
\ No newline at end of file diff --git a/internal_rewrite/netvar_proxy.hpp b/internal_rewrite/netvar_proxy.hpp new file mode 100644 index 0000000..9e039ae --- /dev/null +++ b/internal_rewrite/netvar_proxy.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "Valve/dt_recv.h" + +//dont leave things out of namespaces +namespace hooks +{ + class c_netvar_proxy { + public: + c_netvar_proxy( RecvProp* target_property, RecvVarProxyFn new_proxy ) { + m_target = target_property; + m_original = target_property->m_ProxyFn; + m_target->m_ProxyFn = new_proxy; + } + + c_netvar_proxy( ) = default; + + void init( RecvProp* target, RecvVarProxyFn new_proxy ) { + m_target = target; + m_original = target->m_ProxyFn; + m_target->m_ProxyFn = new_proxy; + } + + ~c_netvar_proxy( ) { + if( !m_target ) return; + m_target->m_ProxyFn = m_original; + } + + RecvVarProxyFn get_old_function( ) const { + return m_original; + } + + private: + //overcomplicated... + RecvProp* m_target; + RecvVarProxyFn m_original; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/netvars.cpp b/internal_rewrite/netvars.cpp new file mode 100644 index 0000000..eb2d8fd --- /dev/null +++ b/internal_rewrite/netvars.cpp @@ -0,0 +1,93 @@ +#include "netvars.hpp" +#include "interface.hpp" + +factory::c_netvars g_netvars; + +NAMESPACE_REGION( factory ) + +void c_netvars::init( ) { + for ( auto client_class = g_csgo.m_chl( )->GetAllClasses( ); + !!client_class; + client_class = client_class->m_next + ) { + auto table = client_class->m_rt_table; + m_tables.push_back( table ); + } +} + +RecvTable* c_netvars::get_table( hash_t hash ) const { + if ( m_tables.empty( ) ) return nullptr; + + for ( auto& table : m_tables ) { + if ( !table ) continue; + + if ( hash == hash::fnv1a( table->m_pNetTableName ) ) { + return table; + } + } + + return nullptr; +} + +//iterating this too much results in a stack overflow, so thats cool +RecvProp* c_netvars::get_prop( hash_t data, hash_t name ) const { + RecvProp* prop{ }; + RecvTable* child{ }; + + auto table = get_table( data ); + if( !table ) return nullptr; + + for( int i{ }; i < table->m_nProps; ++i ) { + prop = &table->m_pProps[ i ]; + child = prop->GetDataTable( ); + + if( child && child->m_nProps ) { + auto tmp = get_prop( hash::fnv1a( child->m_pNetTableName ), name ); + if( tmp ) return tmp; + } + + if( name != hash::fnv1a( prop->m_pVarName ) ) + continue; + + return prop; + } + + return nullptr; +} + +std::ptrdiff_t c_netvars::get_entry( hash_t name, RecvTable* table ) const { + std::ptrdiff_t ret{ }; + RecvProp* prop; + RecvTable* child; + + for ( int i{ }; i < table->m_nProps; ++i ) { + prop = &table->m_pProps[ i ]; + child = prop->GetDataTable( ); + + if ( child && child->m_nProps ) { + auto tmp = get_entry( name, child ); + if ( tmp ) ret += prop->GetOffset( ) + tmp; + } + + if ( name != hash::fnv1a( prop->m_pVarName ) ) + continue; + + return prop->GetOffset( ) + ret; + } + + return ret; +} + +std::ptrdiff_t c_netvars::get_netvar( hash_t data, hash_t name ) const { + std::ptrdiff_t ret{ }; + auto table = get_table( data ); + if ( !table ) return 0; + + ret = get_entry( name, table ); +#ifdef DEBUG + printf( "%s:\t\t 0x%05x\n", name.c_str( ), ret ); +#endif + return ret; +} + +END_REGION
\ No newline at end of file diff --git a/internal_rewrite/netvars.hpp b/internal_rewrite/netvars.hpp new file mode 100644 index 0000000..ca50ed9 --- /dev/null +++ b/internal_rewrite/netvars.hpp @@ -0,0 +1,44 @@ +#pragma once +#include <vector> + +#include "Valve\dt_recv.h" +#include "util.hpp" +#include "fnv.hpp" + +class RecvTable; + +#define NETVAR( funcname, name, table, extra, type ) \ +__forceinline auto& funcname( ) { \ + static std::ptrdiff_t offset = g_netvars.get_netvar( fnv( table ), fnv( name ) ); \ + return get< type >( offset + extra ); \ +} + +#define PNETVAR( funcname, name, table, extra, type ) \ +__forceinline type* funcname( ) { \ + static std::ptrdiff_t offset = g_netvars.get_netvar( fnv( table ), fnv( name ) ); \ + return reinterpret_cast< type* >( uintptr_t( this ) + offset + extra ); \ +} + +#define OFFSET( funcname, offset, type ) \ +__forceinline auto& funcname( ) { \ + return get< type >( offset ); \ +} + +NAMESPACE_REGION( factory ) + +class c_netvars { +public: + void init( ); + //search through the netvar list + std::ptrdiff_t get_netvar( hash_t table, hash_t hash ) const; + RecvProp* get_prop( hash_t table, hash_t name ) const; +public: + std::ptrdiff_t get_entry( hash_t hash, RecvTable* table ) const; + RecvTable* get_table( hash_t hash ) const; +private: + std::vector< RecvTable* > m_tables; +}; + +END_REGION + +extern factory::c_netvars g_netvars;
\ No newline at end of file diff --git a/internal_rewrite/on_screen_size_changed.cpp b/internal_rewrite/on_screen_size_changed.cpp new file mode 100644 index 0000000..62a5102 --- /dev/null +++ b/internal_rewrite/on_screen_size_changed.cpp @@ -0,0 +1,9 @@ +#include "hooks.hpp" + +void __fastcall hooks::on_screen_size_changed( void* ecx_, void* edx_, int old_w, int old_h ) { + static auto old_fn = g_csgo.m_surface->get_old_function< decltype( &on_screen_size_changed ) >( 116 ); + + old_fn( ecx_, nullptr, old_w, old_h ); + + g_fonts.initialize( ); +}
\ No newline at end of file diff --git a/internal_rewrite/override_mouse_input.cpp b/internal_rewrite/override_mouse_input.cpp new file mode 100644 index 0000000..47d3b49 --- /dev/null +++ b/internal_rewrite/override_mouse_input.cpp @@ -0,0 +1,14 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::override_mouse_input( void* ecx_, void* edx_, float* x, float* y ) { + static auto omi_o = g_csgo.m_clientmode->get_old_function< decltype( &hooks::override_mouse_input ) >( 23 ); + omi_o( ecx_, edx_, x, y ); + + if( g_csgo.m_panic ) return; + + if( g_ctx.run_frame( ) && g_ctx.m_local->is_alive( ) ) { + g_cheat.m_legitbot( x, y ); + } +}
\ No newline at end of file diff --git a/internal_rewrite/override_view.cpp b/internal_rewrite/override_view.cpp new file mode 100644 index 0000000..c379c27 --- /dev/null +++ b/internal_rewrite/override_view.cpp @@ -0,0 +1,17 @@ +#include "base_cheat.hpp" +#include "context.hpp" +#include "hooks.hpp" +#include "settings.hpp" +void __fastcall hooks::override_view( void* ecx_, void* edx_, CViewSetup* setup ) { + static auto override_view_o = g_csgo.m_clientmode->get_old_function< decltype( &hooks::override_view ) >( 18 ); + if( g_csgo.m_panic ) { + return override_view_o( ecx_, nullptr, setup ); + } + + g_ctx.m_fov = setup->m_flFov; + if ( g_ctx.run_frame( ) && g_ctx.m_local->is_valid( ) && ( !g_ctx.m_local->m_bIsScoped( ) || g_settings.misc.no_zoom( ) )) { + setup->m_flFov = g_settings.misc.fov_changer( ); + } + g_cheat.m_extra.thirdperson( ); + override_view_o( ecx_, nullptr, setup ); +}
\ No newline at end of file diff --git a/internal_rewrite/paint_traverse.cpp b/internal_rewrite/paint_traverse.cpp new file mode 100644 index 0000000..7664f9a --- /dev/null +++ b/internal_rewrite/paint_traverse.cpp @@ -0,0 +1,63 @@ +#include "hooks.hpp" +#include "renderer.hpp" +#include "context.hpp" +#include "console.hpp" +#include "base_cheat.hpp" +#include "math.hpp" +#include "settings.hpp" + +void __fastcall hooks::paint_traverse( void* ecx_, void* edx_, unsigned int panel, bool force_repaint, bool allowforce ) { + static auto paint_traverse_o = g_csgo.m_panel->get_old_function< decltype( &hooks::paint_traverse ) >( 41 ); + if( g_csgo.m_panic ) return paint_traverse_o( ecx_, 0, panel, force_repaint, allowforce ); + + g_csgo.m_main_thread = std::this_thread::get_id( ); + + if( g_settings.legit.enabled ) { + g_settings.rage.enabled( ) = false; + } + + static uint32_t mat_system_top_panel{ }; + if( !mat_system_top_panel ) { + auto panel_name = g_csgo.m_panel( )->GetName( panel ); + auto panel_hash = hash::fnv1a( panel_name ); + if( fnv( "MatSystemTopPanel" ) == panel_hash ) { + mat_system_top_panel = panel; + } + } + + static uint32_t hud_zoom{ }; + if( !hud_zoom ) { + auto panel_name = g_csgo.m_panel( )->GetName( panel ); + auto panel_hash = hash::fnv1a( panel_name ); + if( fnv( "HudZoom" ) == panel_hash ) { + hud_zoom = panel; + } + } + + if( panel && panel == hud_zoom && g_settings.misc.no_scope + && g_ctx.m_local && g_ctx.m_local->is_valid( ) ) { + return; + } + + if( panel && panel == mat_system_top_panel ) { + //render your epic 2008 hake esp here + g_renderer.draw_box( 0, 0, 1, 1, clr_t( 0, 0, 0, 1 ) ); + if( !g_settings.misc.hide_from_obs ) + g_cheat.m_visuals( ); + + /*auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); + if( nci ) { + float desired_in_latency = g_settings.misc.net_fakeping_amount * 0.001f; + float latency = nci->GetLatency( 1 ); + + float delta = latency - desired_in_latency; + + g_renderer.draw_string( g_fonts.f_12, 20, 400, clr_t( 255, 255, 255 ), "latency: %f", latency ); + //g_renderer.draw_string( g_fonts.f_12, 20, ) + g_renderer.draw_string( g_fonts.f_12, 20, 410, clr_t( 255, 255, 255 ), "delta: %f", delta ); + }*/ + } + + g_csgo.m_prediction( )->SetLocalViewAngles( g_ctx.m_last_fakeangle ); + return paint_traverse_o( ecx_, 0, panel, force_repaint, allowforce ); +}
\ No newline at end of file diff --git a/internal_rewrite/pattern.hpp b/internal_rewrite/pattern.hpp new file mode 100644 index 0000000..8b4e17e --- /dev/null +++ b/internal_rewrite/pattern.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include <Windows.h> +#include <stdio.h> +#include <Psapi.h> +#include <vector> +#include <iostream> +#include <string> +#include <sstream> +#include <algorithm> +#include <iterator> + +#pragma warning ( disable : 4018 ) + +namespace pattern +{ + inline bool bin_match( uint8_t* code, uint8_t* pattern, size_t size ) { + for( size_t j = 0; j < size; j++ ) { + if( pattern[ j ] && code[ j ] != pattern[ j ] ) { + return false; + } + } + return true; + } + + template< typename t = uintptr_t > static t first_match( uintptr_t start, std::string sig, size_t len, std::ptrdiff_t offset = 0 ) { + std::istringstream iss( sig ); + std::vector< std::string > tokens{ std::istream_iterator< std::string >{ iss }, std::istream_iterator< std::string >{} }; + std::vector< uint8_t > sig_bytes; + + for( const auto& hex_byte : tokens ) { + sig_bytes.push_back( static_cast< uint8_t >( std::strtoul( hex_byte.c_str( ), nullptr, 16 ) ) ); + } + + if( sig_bytes.empty( ) || sig_bytes.size( ) < 2 ) { + return t{ }; + } + + auto sig_data = sig_bytes.data( ); + auto sig_size = sig_bytes.size( ); + + for( size_t i{ }; i < len; i++ ) { + uint8_t* code_ptr = reinterpret_cast< uint8_t* >( start + i ); + + if( bin_match( code_ptr, sig_data, sig_size ) ) { + return( ( t )( start + i + offset ) ); + } + } + + return t{ }; + } + + //ultimately the function you want to call to sigscan ( ida style ) + template< typename t = uintptr_t > static t first_code_match( HMODULE start, std::string sig, std::ptrdiff_t offset = 0 ) { + auto dos_hdr = reinterpret_cast< PIMAGE_DOS_HEADER >( start ); + + if( !dos_hdr ) return t{ }; + + //DOS header, verifies if module is valid + if( dos_hdr->e_magic != 0x5a4d ) { + return t{ }; + } + + auto nt_hdrs = reinterpret_cast< PIMAGE_NT_HEADERS >( reinterpret_cast< uintptr_t >( dos_hdr ) + dos_hdr->e_lfanew ); + + return first_match< t >( reinterpret_cast< uintptr_t >( dos_hdr ) + nt_hdrs->OptionalHeader.BaseOfCode, sig, nt_hdrs->OptionalHeader.SizeOfCode, offset ); + } +};
\ No newline at end of file diff --git a/internal_rewrite/play_sound.cpp b/internal_rewrite/play_sound.cpp new file mode 100644 index 0000000..e090690 --- /dev/null +++ b/internal_rewrite/play_sound.cpp @@ -0,0 +1,27 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +void __fastcall hooks::play_sound( void* ecx_, void*, const char* file ) { + static auto play_sound_o = g_csgo.m_surface->get_old_function< decltype( &play_sound ) >( 82 ); + static auto is_ready = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "55 8B EC 83 E4 F8 83 EC 08 56 8B 35 00 00 00 00 57 83 BE" ), 0 ); + static bool was_played = false; + static float played_tick = 0.f; + + play_sound_o( ecx_, 0, file ); + + if( !g_settings.misc.auto_accept || g_csgo.m_engine( )->IsInGame( ) ) { + was_played = false; + return; + } + + if( strstr( file, xors( "competitive_accept_beep.wav" ) ) && !was_played ) { + was_played = true; + played_tick = GetTickCount( ) * 0.001f + g_settings.misc.auto_accept_delay; + g_cheat.m_extra.server_information( ); + g_cheat.m_visuals.reset_local_dmg( ); + } + + if( was_played && GetTickCount( ) * 0.001f > played_tick ) { + reinterpret_cast< void( __cdecl* )( ) >( is_ready )( ); + was_played = false; + } +}
\ No newline at end of file diff --git a/internal_rewrite/player_manager.cpp b/internal_rewrite/player_manager.cpp new file mode 100644 index 0000000..f76b363 --- /dev/null +++ b/internal_rewrite/player_manager.cpp @@ -0,0 +1,44 @@ +#include "player_manager.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +namespace features +{ + void c_player_record::update( int ent_index ) { + auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index ); + if( !ent ) { clear( ); return; } + + if( ent != m_ent || ent->m_flSimulationTime( ) > g_csgo.m_globals->m_curtime + 1.f ) + clear( ); + + m_ent = ent; + if( !ent->is_valid( ) ) + return; + + update_simtime( ); + update_antiaim( ); + + update_cheater( ); + } + + bool c_player_manager::is_cheater( int ent_index ) { +#ifdef _DEBUG + static con_var< bool > dbg_nocheater{ &data::holder_, fnv( "dbg_nocheater" ) }; + if( dbg_nocheater( ) ) + return true; +#endif + + return m_players[ ent_index ].is_cheater( ); + } + + void c_player_manager::frame_stage_notify( ) { + if( !g_ctx.m_local ) return; + + for( int i{ 1 }; i < 65; ++i ) { + if( i == g_csgo.m_engine( )->GetLocalPlayer( ) ) + continue; + + m_players[ i ].update( i ); + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/player_manager.hpp b/internal_rewrite/player_manager.hpp new file mode 100644 index 0000000..440ddf3 --- /dev/null +++ b/internal_rewrite/player_manager.hpp @@ -0,0 +1,68 @@ +#pragma once
+#include "sdk.hpp"
+
+namespace features
+{
+ constexpr int CHEATER_SIMTIME_THRESHOLD = 10;
+ constexpr int CHEATER_AA_THRESHOLD = 50;
+ constexpr int CHEATER_MAX_DETECTIONS = 200;
+
+ class c_player_record {
+ float m_last_simtime;
+ int m_simtime_detections;
+ int m_aa_detections;
+ bool m_is_cheater;
+
+ c_base_player* m_ent;
+
+ void clear( ) {
+ m_last_simtime = { };
+ m_simtime_detections = { };
+ m_aa_detections = { };
+ m_is_cheater = { };
+ m_ent = { };
+ }
+
+ void update_simtime( ) {
+ if( !m_ent ) return;
+
+ if( m_ent->m_flSimulationTime( ) == m_last_simtime ) {
+ m_simtime_detections += 2;
+ }
+ else if( m_simtime_detections > 0 ) {
+ m_simtime_detections--;
+ }
+ m_last_simtime = m_ent->m_flSimulationTime( );
+ }
+
+ void update_antiaim( ) {
+ if( !m_ent ) return;
+
+ auto pitch = m_ent->m_angEyeAngles( ).x;
+ if( pitch > 75.f && m_aa_detections < CHEATER_MAX_DETECTIONS ) {
+ m_aa_detections++;
+ }
+ else if( m_aa_detections > 0 ) {
+ m_aa_detections--;
+ }
+ }
+
+ void update_cheater( ) {
+ m_is_cheater = ( m_simtime_detections > CHEATER_SIMTIME_THRESHOLD
+ || m_aa_detections > CHEATER_AA_THRESHOLD )
+ && m_simtime_detections;
+ }
+
+ public:
+ c_player_record( ) { clear( ); }
+ bool is_cheater( ) const { return m_is_cheater; }
+ void update( int ent_index );
+ };
+
+ class c_player_manager {
+ std::array< c_player_record, 65 > m_players;
+ public:
+ void frame_stage_notify( );
+ bool is_cheater( int ent_index );
+ };
+}
\ No newline at end of file diff --git a/internal_rewrite/prediction.cpp b/internal_rewrite/prediction.cpp new file mode 100644 index 0000000..1d643de --- /dev/null +++ b/internal_rewrite/prediction.cpp @@ -0,0 +1,841 @@ +#include "prediction.hpp"
+#include "hooks.hpp"
+#include "context.hpp"
+
+NAMESPACE_REGION( features )
+
+void c_prediction::player_data_t::update( int ent_index ) {
+ auto player = g_csgo.m_entlist( )->GetClientEntity( ent_index );
+ if( !player || !player->is_valid( ) || player == g_ctx.m_local ) {
+ m_valid = false;
+ return;
+ }
+
+ float simtime = player->m_flSimulationTime( );
+
+ if( std::abs( simtime - m_simtime ) ) {
+ float delta = std::abs( m_simtime - simtime );
+ if( !m_valid ) {
+ m_old_velocity = player->m_vecVelocity( );
+ }
+ else {
+ m_last_choke = TIME_TO_TICKS( delta );
+ m_old_velocity = m_velocity;
+ m_breaking_lc = player->m_vecOrigin( ).dist_to( m_position ) > 64;
+ }
+
+ m_velocity = player->get_animdata( ).m_last_velocity;
+ m_position = player->m_vecOrigin( );
+
+ m_valid = true;
+
+ if( m_breaking_lc )
+ m_records.push_front( { m_velocity, m_last_choke } );
+ }
+
+ m_simtime = simtime;
+
+ while( m_records.size( ) > 32 )
+ m_records.pop_back( );
+}
+
+void c_prediction::frame_stage_notify( ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ m_players[ i ].update( i );
+ }
+}
+
+int c_prediction::get_predicted_choke( int idx ) {
+ auto& data = m_players[ idx ];
+
+ int adaptive_dtc = 0;
+ int static_dtc = 0;
+ int min_choke = 16;
+ int max_choke = 0;
+
+ if( !data.m_records.empty( ) ) {
+ int prev_choke = data.m_last_choke;
+ float last_dist = 0.f;
+ for( auto& it : data.m_records ) {
+ if( it.m_tick == prev_choke )
+ static_dtc++;
+
+ float speed = it.m_velocity.length2d( );
+ float dist = speed * it.m_tick * TICK_INTERVAL( );
+
+ if( dist > 62.f && std::abs( last_dist - dist ) < 12.f )
+ adaptive_dtc++;
+
+ prev_choke = it.m_tick;
+ last_dist = dist;
+ min_choke = math::min( it.m_tick, min_choke );
+ max_choke = math::max( it.m_tick, max_choke );
+ }
+ }
+
+ if( adaptive_dtc > 10 ) {
+ return TIME_TO_TICKS( 64.f / data.m_velocity.length2d( ) ) + 1;
+ }
+ else if( static_dtc > 16 || data.m_records.empty( ) ) {
+ return data.m_last_choke;
+ }
+
+ float factor = math::random_number( 0.f, 1.f );
+ return ( 1.0f - factor ) * min_choke + factor * max_choke;
+}
+
+vec3_t c_prediction::aimware_extrapolate( c_base_player* ent, vec3_t origin, vec3_t& velocity ) {
+ static auto sv_jump_impulse = g_csgo.m_cvar( )->FindVar( xors( "sv_jump_impulse" ) );
+ static auto sv_gravity = g_csgo.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+
+ auto min = ent->m_vecMins( );
+ auto max = ent->m_vecMaxs( );
+
+ auto start = origin;
+ auto end = start + velocity * TICK_INTERVAL( );
+
+ CTraceFilter f;
+ CGameTrace tr;
+ Ray_t ray;
+
+ ray.Init( start, end, min, max );
+ f.pSkip = ent;
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_PLAYERSOLID, &f, &tr );
+
+ if( tr.fraction != 1.f ) {
+ for( int i{ }; i < 2; ++i ) {
+ velocity -= tr.plane.normal * velocity.dot( tr.plane.normal );
+
+ auto dot = velocity.dot( tr.plane.normal );
+ if( dot < 0.f ) {
+ velocity -= dot * tr.plane.normal;
+ }
+
+ end = tr.endpos + ( velocity * TICK_INTERVAL( ) * ( 1.f - tr.fraction ) );
+ ray.Init( tr.endpos, end, min, max );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_PLAYERSOLID, &f, &tr );
+
+ if( tr.fraction == 1.f )
+ break;
+ }
+ }
+
+ end = tr.endpos;
+ end.z -= 2.f;
+
+ ray.Init( tr.endpos, end, min, max );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_PLAYERSOLID, &f, &tr );
+
+ if( tr.fraction != 1.f && tr.plane.normal.z > 0.7f ) {
+ velocity.z = sv_jump_impulse->get_float( );
+ }
+ else {
+ velocity.z -= sv_gravity->get_float( ) * TICK_INTERVAL( );
+ }
+
+ return tr.endpos;
+}
+
+vec3_t c_prediction::full_walk_move( c_base_player* player, int ticks ) {
+ auto index = player->ce( )->GetIndex( );
+ auto data = get_player_data( index );
+ vec3_t origin = data.m_position;
+ vec3_t velocity = data.m_velocity;
+ vec3_t old_velocity = data.m_velocity;
+ vec3_t acceleration;
+
+ bool is_on_ground = player->m_fFlags( ) & FL_ONGROUND;
+
+ m_player = data;
+
+ if( !data.m_valid )
+ return origin;
+
+ float velocity_dir = RAD2DEG( atan2( velocity.y, velocity.x ) );
+ float angle_dir = velocity_dir - RAD2DEG( atan2( data.m_old_velocity.y, data.m_old_velocity.x ) );
+
+ angle_dir *= TICKS_TO_TIME( data.m_last_choke );
+
+ if( velocity_dir <= 180.f ) {
+ if( velocity_dir < -180.f )
+ velocity_dir += 360.f;
+ }
+ else {
+ velocity_dir -= 360.f;
+ }
+
+ float length = velocity.length2d( );
+
+ for( int i{ }; i < ticks; ++i ) {
+ float extrapolated_dir = velocity_dir + angle_dir;
+
+ velocity.x = cos( DEG2RAD( extrapolated_dir ) ) * length;
+ velocity.y = sin( DEG2RAD( extrapolated_dir ) ) * length; // hey.... fix please In Fucking Correct
+
+ start_gravity( player, origin, velocity );
+
+ if( is_on_ground ) {
+ check_jump_button( player, origin, velocity ); // Won't jump all the time
+ }
+
+ if( is_on_ground ) {
+ //velocity.z = 0.f; go to hell
+ friction( player, origin, velocity );
+ }
+
+ check_velocity( player, origin, velocity );
+
+ // fuck walking
+ if( !is_on_ground ) {
+ air_move( player, origin, velocity, old_velocity, acceleration );
+ }
+
+ try_player_move( player, origin, velocity );
+
+ is_on_ground = categorize_position( player, origin, velocity );
+
+ check_velocity( player, origin, velocity );
+
+ finish_gravity( player, origin, velocity );
+
+ if( is_on_ground ) {
+ velocity.z = 0.f;
+ }
+
+ old_velocity = velocity;
+
+ velocity_dir = extrapolated_dir;
+ }
+
+ return origin;
+}
+
+void c_prediction::check_jump_button( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ static auto sv_jump_impulse = g_csgo.m_cvar( )->FindVar( xors( "sv_jump_impulse" ) );
+ float ground_factor = 1.f;
+ vec3_t ground_point = origin;
+
+ ground_point.z -= 2.f;
+
+ CGameTrace pm;
+ trace_player_bbox( player, origin, ground_point, &pm );
+
+ if( pm.m_pEnt ) {
+ auto surface_data = g_csgo.m_phys_props( )->GetSurfaceData( pm.surface.surfaceProps );
+ if( surface_data ) {
+ ground_factor = surface_data->game.jumpfactor;
+ }
+ }
+
+
+ if( !ground_factor ) {
+ ground_factor = 1.f;
+ }
+
+ //if( player->m_fFlags( ) & FL_DUCKING ) {
+ //velocity.z += ground_factor * sv_jump_impulse->get_float( ); // how they do it in csgo
+ //}
+ //else {
+ velocity.z = ground_factor * sv_jump_impulse->get_float( );
+ //}
+
+ finish_gravity( player, origin, velocity );
+
+}
+
+void c_prediction::start_gravity( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ static auto sv_gravity = g_csgo.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+
+ float m_flGravity = player->m_flGravity( );
+
+ //if( !m_flGravity ) {
+ m_flGravity = 1.f;
+ //}
+
+ velocity.z -= ( m_flGravity * sv_gravity->get_float( ) * 0.5f * TICK_INTERVAL( ) );
+
+ check_velocity( player, origin, velocity );
+}
+
+void c_prediction::finish_gravity( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ static auto sv_gravity = g_csgo.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+
+ float m_flGravity = player->m_flGravity( );
+ //if( !m_flGravity ) {
+ m_flGravity = 1.f;
+ //}
+
+ velocity.z -= ( m_flGravity * sv_gravity->get_float( ) * 0.5f * TICK_INTERVAL( ) );
+
+ check_velocity( player, origin, velocity );
+}
+
+void c_prediction::friction( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ static auto sv_friction = g_csgo.m_cvar( )->FindVar( xors( "sv_friction" ) );
+ static auto sv_stopspeed = g_csgo.m_cvar( )->FindVar( xors( "sv_stopspeed" ) );
+ const float m_surfaceFriction = player->m_surfaceFriction( );
+
+ float speed = velocity.length( );
+
+ if( speed < 0.1f )
+ return;
+
+ float friction = sv_friction->get_float( ) * m_surfaceFriction;
+ float control = ( speed < sv_stopspeed->get_float( ) ) ? sv_stopspeed->get_float( ) : speed;
+ float drop = control * friction * TICK_INTERVAL( );
+
+ float newspeed = speed - drop;
+ if( newspeed < 0.f )
+ newspeed = 0.f;
+
+ if( newspeed != speed ) {
+ newspeed /= speed;
+ velocity *= newspeed;
+ }
+}
+
+void c_prediction::air_move( c_base_player* player, vec3_t& origin, vec3_t& velocity, vec3_t& old_velocity, vec3_t& acceleration ) {
+ vec3_t wishvel;
+ vec3_t wishdir;
+ float wishspeed;
+ vec3_t forward, right, up;
+
+ //fmove = m_player.m_movement.x;
+ //smove = m_player.m_movement.y;
+ //
+ //math::angle_vectors( m_player.m_angles, &forward, &right, &up );
+ //
+ //forward.z = right.z = 0.f;
+ //
+ //forward.normalize_vector( );
+ //right.normalize_vector( );
+ //
+ //for( int i{ }; i < 2; ++i ) {
+ // wishvel[ i ] = forward[ i ] * fmove + right[ i ] * smove;
+ //}
+
+
+ wishvel = velocity;
+
+ wishvel[ 2 ] = 0.f;
+
+ wishdir = wishvel;
+ wishdir.normalize_vector( );
+
+ wishspeed = acceleration.length( ); // probably wrong
+
+ air_accelerate( player, origin, old_velocity, wishdir, wishspeed );
+}
+
+void c_prediction::air_accelerate( c_base_player* player, vec3_t& origin, vec3_t& velocity, vec3_t& wishdir, float wishspeed ) {
+ static auto sv_airaccelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_airaccelerate" ) );
+
+ float wishspd = wishspeed;
+
+ if( wishspd > 30.f )
+ wishspd = 30.f;
+
+ float currentspeed = velocity.dot( wishdir );
+
+ float addspeed = wishspd - currentspeed;
+
+ if( addspeed <= 0 )
+ return;
+
+ float accelspeed = sv_airaccelerate->get_float( ) * wishspeed * TICK_INTERVAL( );
+
+ if( accelspeed > addspeed )
+ accelspeed = addspeed;
+
+ for( int i{ }; i < 2; ++i ) {
+ velocity[ i ] += accelspeed * wishdir[ i ];
+ }
+}
+
+void c_prediction::try_player_move( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ CGameTrace pm;
+ vec3_t end_pos = origin + velocity * TICK_INTERVAL( );
+
+ trace_player_bbox( player, origin, end_pos, &pm );
+
+ if( pm.fraction != 1.f ) {
+ end_pos = pm.endpos;
+ }
+
+ origin = end_pos;
+}
+
+
+
+//there are supposed to be some ladder checks etc here, but we're really only supposed to be doing this when people are breaking lag comp etc
+//also ugly code, please fix :(
+bool c_prediction::categorize_position( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ constexpr float NON_JUMP_VELOCITY = 140.f;
+ vec3_t ground_point = origin;
+ bool is_moving_up_rapidally = velocity.z > NON_JUMP_VELOCITY;
+ CGameTrace pm;
+
+ ground_point.z -= 2.f;
+
+ if( is_moving_up_rapidally ) {
+ return false;
+ }
+ else {
+ trace_player_bbox( player, origin, ground_point, &pm );
+ if( !pm.m_pEnt || pm.plane.normal.z < 0.7 ) {
+ try_touch_ground_in_quadrants( player, origin, ground_point, &pm );
+ if( !pm.m_pEnt || pm.plane.normal.z < 0.7 ) {
+ return false;
+ }
+ else {
+ return true;
+ }
+ }
+ else {
+ return true;
+ }
+ }
+
+ return true;
+}
+
+
+void c_prediction::check_velocity( c_base_player* player, vec3_t& origin, vec3_t& velocity ) {
+ static auto sv_max_velocity = g_csgo.m_cvar( )->FindVar( xors( "sv_maxvelocity" ) );
+ const float max_velocity = sv_max_velocity->get_float( );
+
+ for( int i{ }; i < 3; ++i ) {
+ if( !std::isfinite( velocity[ i ] ) ) {
+ velocity[ i ] = 0.f;
+ }
+
+ if( !std::isfinite( origin[ i ] ) ) {
+ origin[ i ] = 0.f;
+ }
+
+ velocity[ i ] = std::clamp( velocity[ i ], -max_velocity, max_velocity );
+ }
+}
+
+
+
+// https://github.com/ValveSoftware/source-sdk-2013/blob/master/mp/src/game/shared/gamemovement.cpp#L2025
+vec3_t c_prediction::extrapolate_player( c_base_player* player, int ticks ) {
+ static auto sv_gravity = g_csgo.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+ static auto sv_jump_impulse = g_csgo.m_cvar( )->FindVar( xors( "sv_jump_impulse" ) );
+
+ auto index = player->ce( )->GetIndex( );
+ auto data = get_player_data( index );
+
+ vec3_t& m_vecBaseVelocity = player->get< vec3_t >( 0x11C );
+
+ vec3_t predicted( data.m_position );
+ vec3_t velocity( data.m_velocity );
+ vec3_t acceleration{ };
+
+ if( !data.m_valid )
+ return predicted;
+
+ float velocity_dir = RAD2DEG( atan2( velocity.y, velocity.x ) );
+ float angle_dir = velocity_dir - RAD2DEG( atan2( data.m_old_velocity.y, data.m_old_velocity.x ) );
+
+ angle_dir *= TICKS_TO_TIME( data.m_last_choke );
+
+ if( velocity_dir <= 180.f ) {
+ if( velocity_dir < -180.f )
+ velocity_dir += 360.f;
+ }
+ else {
+ velocity_dir -= 360.f;
+ }
+
+ float length = velocity.length2d( );
+
+ float dir = velocity_dir;
+
+ for( int i = 0; i < ticks; ++i ) {
+ float extrapolated_dir = velocity_dir + angle_dir;
+
+ velocity.x = cos( DEG2RAD( extrapolated_dir ) ) * length;
+ velocity.y = sin( DEG2RAD( extrapolated_dir ) ) * length;
+
+ predicted = aimware_extrapolate( player, predicted, velocity );
+
+ velocity_dir = extrapolated_dir;
+ }
+
+ return predicted;
+}
+
+void c_prediction::trace_player_bbox( c_base_player* player, const vec3_t& start, const vec3_t& end, CGameTrace* pm ) {
+ Ray_t ray;
+ ray.Init( start, end, player->m_vecMins( ), player->m_vecMaxs( ) );
+
+ CTraceFilter filter;
+ filter.pSkip = player;
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SOLID & ~CONTENTS_MONSTER, &filter, pm );
+}
+
+void c_prediction::try_touch_ground( c_base_player* player, const vec3_t& start, const vec3_t& end, const vec3_t& mins, const vec3_t& maxs, CGameTrace* pm ) {
+ Ray_t ray;
+ ray.Init( start, end, mins, maxs );
+
+ CTraceFilter filter;
+ filter.pSkip = player;
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SOLID & ~CONTENTS_MONSTER, &filter, pm );
+}
+
+void c_prediction::try_touch_ground_in_quadrants( c_base_player* player, const vec3_t& start, const vec3_t& end, CGameTrace* pm ) {
+ vec3_t mins, maxs;
+
+ vec3_t mins_src = player->m_vecMins( );
+ vec3_t maxs_src = player->m_vecMaxs( );
+
+ float fraction = pm->fraction;
+ vec3_t end_pos = pm->endpos;
+
+ mins = mins_src;
+ maxs = vec3_t( std::min( 0.f, maxs_src.x ), std::min( 0.f, maxs_src.y ), maxs_src.z );
+
+ try_touch_ground( player, start, end, mins, maxs, pm );
+ if( pm->m_pEnt && pm->plane.normal.z >= 0.7 ) {
+ pm->fraction = fraction;
+ pm->endpos = end_pos;
+ return;
+ }
+
+ mins = vec3_t( std::max( 0.f, mins_src.x ), std::max( 0.f, mins_src.y ), mins_src.z );
+ maxs = maxs_src;
+
+ try_touch_ground( player, start, end, mins, maxs, pm );
+ if( pm->m_pEnt && pm->plane.normal.z >= 0.7 ) {
+ pm->fraction = fraction;
+ pm->endpos = end_pos;
+ return;
+ }
+
+ mins = vec3_t( mins_src.x, std::max( 0.f, mins_src.y ), mins_src.z );
+ maxs = vec3_t( std::min( 0.f, maxs_src.x ), maxs_src.y, maxs_src.z );
+
+ try_touch_ground( player, start, end, mins, maxs, pm );
+ if( pm->m_pEnt && pm->plane.normal.z >= 0.7 ) {
+ pm->fraction = fraction;
+ pm->endpos = end_pos;
+ return;
+ }
+
+ mins = vec3_t( std::max( 0.f, mins_src.x ), mins_src.y, mins_src.z );
+ maxs = vec3_t( maxs_src.x, std::min( 0.f, maxs_src.y ), maxs_src.z );
+
+ try_touch_ground( player, start, end, mins, maxs, pm );
+ if( pm->m_pEnt && pm->plane.normal.z >= 0.7 ) {
+ pm->fraction = fraction;
+ pm->endpos = end_pos;
+ return;
+ }
+
+ pm->fraction = fraction;
+ pm->endpos = end_pos;
+}
+
+// This is extremely gay, don't use it.
+// void c_prediction::local_pred( user_cmd_t* ucmd ) {
+// if( !ucmd || !g_ctx.m_local || !g_ctx.m_local->is_alive( ) )
+// return;
+//
+// static uintptr_t run_command_address = g_csgo.m_prediction->get_old_function< uintptr_t >( 19 );
+//
+// CMoveData move_data{ };
+// IClientEntity* local_ent = g_ctx.m_local->ce( );
+//
+// //backup data
+// int old_buttons = ucmd->m_buttons;
+// float old_curtime = g_csgo.m_globals->m_curtime;
+// float old_frame_time = g_csgo.m_globals->m_frametime;
+// int old_tickbase = g_ctx.m_local->m_nTickBase( );
+// int old_flags = g_ctx.m_local->m_fFlags( );
+// MoveType_t old_move_type = g_ctx.m_local->m_nMoveType( );
+// vec3_t old_velocity = g_ctx.m_local->m_vecVelocity( );
+//
+// //set globals
+// g_csgo.m_globals->m_curtime = g_csgo.m_globals->m_interval_per_tick * old_tickbase;
+// g_csgo.m_globals->m_frametime = g_csgo.m_globals->m_interval_per_tick;
+//
+// //random seed is already being calculated and set in createmove
+// **( uintptr_t** )( run_command_address + 0x3E ) = ucmd->m_random_seed; //prediction seed
+// **( uintptr_t** )( run_command_address + 0x54 ) = uintptr_t( g_ctx.m_local ); //prediction player
+//
+// //start prediction
+// g_csgo.m_move_helper( )->SetHost( local_ent );
+// g_csgo.m_game_movement( )->StartTrackPredictionErrors( local_ent );
+//
+// //run prediction
+// g_csgo.m_prediction( )->SetupMove( local_ent, ucmd, g_csgo.m_move_helper( ), &move_data );
+// g_csgo.m_game_movement( )->ProcessMovement( local_ent, &move_data );
+// g_csgo.m_prediction( )->FinishMove( local_ent, ucmd, &move_data );
+//
+// //finish prediction
+// g_csgo.m_game_movement( )->FinishTrackPredictionErrors( local_ent );
+// g_csgo.m_move_helper( )->SetHost( nullptr );
+//
+// **( uintptr_t** )( run_command_address + 0x3E ) = 0xffffffff;
+// **( uintptr_t*** )( run_command_address + 0x54 ) = nullptr;
+//
+// //good to have, can be used for edge jump and such
+// m_predicted_flags = g_ctx.m_local->m_fFlags( );
+//
+// //restore
+// ucmd->m_buttons = old_buttons;
+// g_csgo.m_globals->m_curtime = old_curtime;
+// g_csgo.m_globals->m_frametime = old_frame_time;
+// g_ctx.m_local->m_nTickBase( ) = old_tickbase;
+// g_ctx.m_local->m_fFlags( ) = old_flags;
+// g_ctx.m_local->m_nMoveType( ) = old_move_type;
+// g_ctx.m_local->m_vecVelocity( ) = old_velocity;
+// }
+
+void c_prediction::pre_run_command( ) {
+ // The game does not advance the tickbase if the engine is paused.
+ if ( g_csgo.m_prediction( )->m_bEnginePaused )
+ return;
+
+ auto *cl = g_csgo.m_global_state->get_client_state( );
+
+ // Ideally, you should only be doing this if the last stage is
+ // FRAME_NET_UPDATE_END.
+
+ if ( cl && cl->m_delta_tick >= 0 ) {
+ // This should fix the issues when bunny-hopping on a low frame-rate.
+ g_csgo.m_prediction( )->Update(
+ cl->m_delta_tick,
+ cl->m_delta_tick > 0,
+ cl->m_last_acknowledged_cmd,
+ cl->m_lastoutgoingcommand + cl->m_chokedcommands
+ );
+ }
+}
+
+// This code got nasty after a while, imo. You can clean it up if you care enough.
+void c_prediction::run_command( user_cmd_t *ucmd ) {
+ CMoveData movedata{ };
+
+ if ( !ucmd || !g_csgo.m_engine( )->IsConnected( ) || !g_csgo.m_engine( )->IsInGame( ) || !g_csgo.m_move_helper.get( ) )
+ return;
+
+ // Time saver.
+ auto *player = g_ctx.m_local;
+ auto *player_ce = player->ce( );
+
+ if ( !player || !player_ce )
+ return;
+
+ // Set random seed and player.
+ if ( !m_prediction_seed || !m_prediction_player ) {
+ m_prediction_seed = *reinterpret_cast< int * >( g_csgo.m_prediction->get_old_function< uint32_t >( 19 ) + 0x30 );
+ m_prediction_player = *reinterpret_cast< int * >( g_csgo.m_prediction->get_old_function< uint32_t >( 19 ) + 0x3E );
+ }
+
+ *reinterpret_cast< int * >( m_prediction_seed ) = ucmd ? ucmd->m_random_seed : -1;
+ *reinterpret_cast< uint32_t * >( m_prediction_player ) = uint32_t( player );
+
+ // Copy user command to m_pCurrentCommand and m_pPlayerCommand.
+ *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0x3314 ) = uint32_t( ucmd );
+ *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0x326C ) = uint32_t( ucmd );
+
+ // Store entity variables that will get updated.
+ auto old_flags = player->m_fFlags( );
+ auto old_move = player->m_nMoveType( );
+ auto old_tickbase = player->m_nTickBase( );
+
+ m_velocity = player->m_vecVelocity( );
+
+ // Store globals prior to prediction.
+ m_old_time = g_csgo.m_globals->m_curtime;
+ m_old_frametime = g_csgo.m_globals->m_frametime;
+ m_old_tickcount = g_csgo.m_globals->m_tickcount;
+
+ // Set up globals.
+ g_csgo.m_globals->m_curtime = old_tickbase * TICK_INTERVAL( );
+ g_csgo.m_globals->m_frametime = TICK_INTERVAL( );
+ g_csgo.m_globals->m_tickcount = old_tickbase;
+
+ // This is in order to avoid double footsteps
+ // NOTE: This is being a meme in Moneybot for some reason, not sure why.
+ // Worked perfectly fine in my cheat.
+ bool old_predicted = g_csgo.m_prediction( )->m_bIsFirstTimePredicted;
+ bool old_prediction = g_csgo.m_prediction( )->m_bInPrediction;
+
+ g_csgo.m_prediction( )->m_bIsFirstTimePredicted = false;
+ g_csgo.m_prediction( )->m_bInPrediction = true;
+
+ // Handle frame-time as the engine would.
+ if ( g_csgo.m_prediction( )->m_bEnginePaused )
+ g_csgo.m_globals->m_frametime = 0.0f;
+
+ ucmd->m_buttons |= *( uint32_t * ) ( ( uint32_t ) player + 0x3310 ); // unk01
+
+ g_csgo.m_game_movement( )->StartTrackPredictionErrors( player_ce );
+
+ if ( ucmd->m_impulse )
+ *( uint32_t * ) ( ( uint32_t ) player + 0x31EC ) = ucmd->m_impulse;
+
+ // CPrediction::UpdateButtonState
+ {
+ /*
+ v16 = ucmd->m_fButtons;
+ v17 = v16 ^ *(_DWORD *)(player + 0x31E8);
+ *(_DWORD *)(player + 0x31DC) = *(_DWORD *)(player + 0x31E8);
+ *(_DWORD *)(player + 0x31E8) = v16;
+ *(_DWORD *)(player + 0x31E0) = v16 & v17;
+ v18 = gpGlobals;
+ *(_DWORD *)(player + 0x31E4) = v17 & ~v16;
+ */
+
+ auto original_buttons = ucmd->m_buttons;
+
+ auto *m_afButtonBackup = reinterpret_cast< int * >( uint32_t( player ) + 0x31E8 );
+ auto unk03 = original_buttons ^ *m_afButtonBackup;
+
+ *reinterpret_cast< int * >( uint32_t( player ) + 0x31DC ) = *m_afButtonBackup; // m_afButtonLast
+ *reinterpret_cast< int * >( uint32_t( player ) + 0x31E8 ) = original_buttons; // m_afButtonBackup (??)
+ *reinterpret_cast< int * >( uint32_t( player ) + 0x31E0 ) = original_buttons & unk03; // m_afButtonPressed
+ *reinterpret_cast< int * >( uint32_t( player ) + 0x31E4 ) = unk03 & ~original_buttons;// m_afButtonReleased
+ }
+
+ // NOTE: The IDA generated call is WRONG, check the assembly!
+ // The function only uses the lower bits of the double, though. Valve code.....
+
+ // using fnCheckMovingGround = void( __thiscall * )( void *, se::C_BaseEntity *, double );
+ // Memory::Virtual< fnCheckMovingGround >( this, 16 )( this, player, frametime );
+
+ // This might not be needed, tbh.
+ /*
+ (*(void (__stdcall **)(int, _DWORD, _DWORD))(*(_DWORD *)prediction->pad00 + 72))(
+ player,
+ COERCE_UNSIGNED_INT64(v18->frametime),
+ COERCE_UNSIGNED_INT64(v18->frametime) >> 32);
+ */
+
+ g_csgo.m_prediction( )->CheckMovingGround( player_ce, g_csgo.m_globals->m_frametime );
+
+ // CPrediction::RunPreThink
+ {
+ player->set_local_view_angles( &ucmd->m_viewangles );
+
+ if ( player->run_physics_think( 0 ) )
+ player->pre_think( );
+ }
+
+ // CPrediction::RunThink
+ {
+ auto *next_think = reinterpret_cast< int * >( uint32_t( player ) + 0xF8 );
+
+ if ( *next_think > 0 && *next_think <= player->m_nTickBase( ) )
+ {
+ *next_think = -1;
+
+ // sub_1017E880
+ /*
+ v2 = (int)this;
+ v3 = this[57];
+ result = (this[57] >> 22) & 1;
+ if ( result )
+ {
+ if ( a2 )
+ {
+ this[57] = v3 & 0xFFBFFFFF;
+ return result;
+ }
+ }
+ else if ( a2 )
+ {
+ return result;
+ }
+ if ( result )
+ return result;
+ result = sub_1017E840();
+ if ( !result )
+ *(_DWORD *)(v2 + 228) = v3 | 0x400000;
+ return result;
+ */
+
+ auto v3 = *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0xE4 ); // m_iEFlags
+ auto v4 = v3 & 0x400000;
+
+ // Referenced in sub_1017E840.
+ /*
+ v3 = *(_DWORD *)(this + 0x2B8);
+ v4 = 0;
+ if ( v3 <= 0 )
+ return 0;
+ */
+ auto v5 = *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0x2B8 );
+
+ if ( !v4 && !v5 )
+ *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0xE4 ) = v3 | 0x400000;
+
+ player->think( );
+ }
+ }
+
+ g_csgo.m_move_helper( )->SetHost( player_ce );
+
+ g_csgo.m_prediction( )->SetupMove( player_ce, ucmd, g_csgo.m_move_helper( ), &movedata );
+ g_csgo.m_game_movement( )->ProcessMovement( player_ce, &movedata );
+ g_csgo.m_prediction( )->FinishMove( player_ce, ucmd, &movedata );
+
+ // CPrediction::RunPostThink
+ {
+ g_csgo.m_move_helper( )->ProcessImpacts( );
+
+ // Calling C_BasePlayer::PostThink will cause C_BasePlayer::ItemPostFrame
+ // to be called, resulting in all of our timers being fucked up.
+
+ // player->PostThink( );
+ }
+
+ // Restore prediction flags.
+ g_csgo.m_prediction( )->m_bIsFirstTimePredicted = old_predicted;
+ g_csgo.m_prediction( )->m_bInPrediction = old_prediction;
+
+ // Important: restore the old tick-base.
+ player->m_nTickBase( ) = old_tickbase;
+ player->m_fFlags( ) = old_flags;
+ player->m_nMoveType( ) = old_move;
+
+ // IMLAZY:
+ // I'd rather just restore this instead of fixing it everywhere in the cheat.
+ player->m_vecVelocity( ) = m_velocity;
+}
+
+void c_prediction::post_run_command( ) {
+ // Time saver.
+ auto *player = g_ctx.m_local;
+ auto *player_ce = player->ce( );
+
+ if ( !player || !player_ce )
+ return;
+
+ g_csgo.m_game_movement( )->FinishTrackPredictionErrors( player_ce );
+ g_csgo.m_move_helper( )->SetHost( nullptr );
+
+ // CPrediction::FinishCommand
+ {
+ // Restore globals.
+ g_csgo.m_globals->m_curtime = m_old_time;
+ g_csgo.m_globals->m_frametime = m_old_frametime;
+ g_csgo.m_globals->m_tickcount = m_old_tickcount;
+
+ // Invalidate seed, player.
+ *reinterpret_cast< int * >( m_prediction_seed ) = int( -1 );
+ *reinterpret_cast< int * >( m_prediction_player ) = 0;
+ *reinterpret_cast< uint32_t * >( uint32_t( player ) + 0x3314 ) = 0;
+ }
+
+ g_csgo.m_game_movement( )->Reset( );
+}
+
+END_REGION
diff --git a/internal_rewrite/prediction.hpp b/internal_rewrite/prediction.hpp new file mode 100644 index 0000000..914b97f --- /dev/null +++ b/internal_rewrite/prediction.hpp @@ -0,0 +1,97 @@ +#pragma once
+#include "vector.hpp"
+#include "util.hpp"
+
+#include <array>
+#include <deque>
+
+class user_cmd_t;
+class c_base_player;
+
+NAMESPACE_REGION( features )
+
+class c_prediction
+{
+ user_cmd_t* m_ucmd{ };
+ int m_predicted_flags{ };
+ + float m_old_time; + float m_old_frametime; + int m_old_tickcount; + + int m_prediction_seed; + int m_prediction_player;
+
+ struct player_data_t {
+ struct lag_velocity_record_t {
+ vec3_t m_velocity;
+ int m_tick;
+ };
+
+ void update( int ent_index );
+
+ float m_simtime{ };
+ int m_last_choke{ };
+ vec3_t m_angles{ };
+ vec3_t m_velocity{ };
+ vec3_t m_old_velocity{ };
+ vec3_t m_position{ };
+ vec3_t m_movement{ };
+ bool m_valid{ };
+ bool m_breaking_lc{ };
+
+ std::deque< lag_velocity_record_t > m_records{ };
+ };
+
+ std::array< player_data_t, 65 > m_players;
+
+ void run( user_cmd_t* ucmd );
+public:
+ // You should be using the un-predicted velocity for fake-walk.
+ vec3_t m_velocity{ };
+
+ // void local_pred( user_cmd_t* );
+
+ void pre_run_command( );
+ void run_command( user_cmd_t *cmd );
+ void post_run_command( );
+
+ int get_predicted_flags( ) const {
+ return m_predicted_flags;
+ }
+
+ bool is_breaking_lc( int ent ) const {
+ return m_players[ ent ].m_breaking_lc;
+ }
+
+ inline player_data_t get_player_data( int ent_index ) {
+ return m_players[ ent_index ];
+ }
+
+ player_data_t m_player;
+
+ //gamemovement functions
+ vec3_t full_walk_move( c_base_player*, int );
+ void check_jump_button( c_base_player*, vec3_t&, vec3_t& );
+ void start_gravity( c_base_player*, vec3_t&, vec3_t& );
+ void finish_gravity( c_base_player*, vec3_t&, vec3_t& );
+ void friction( c_base_player*, vec3_t&, vec3_t& );
+ void air_move( c_base_player*, vec3_t&, vec3_t&, vec3_t&, vec3_t& );
+ void air_accelerate( c_base_player*, vec3_t&, vec3_t&, vec3_t&, float );
+ // void walk_move( c_base_player*, vec3_t&, vec3_t& );
+ bool categorize_position( c_base_player*, vec3_t&, vec3_t& );
+ void check_velocity( c_base_player*, vec3_t&, vec3_t& );
+ void try_player_move( c_base_player*, vec3_t&, vec3_t& );
+
+ void frame_stage_notify( );
+ vec3_t aimware_extrapolate( c_base_player* ent, vec3_t origin, vec3_t& velocity );
+ void predict_player( c_base_player* player );
+ int get_predicted_choke( int );
+ vec3_t extrapolate_player( c_base_player*, int );
+ void trace_player_bbox( c_base_player*, const vec3_t& start, const vec3_t& end, CGameTrace* pm );
+ void try_touch_ground( c_base_player*, const vec3_t& start, const vec3_t& end, const vec3_t& mins, const vec3_t& maxs, CGameTrace* pm );
+ void try_touch_ground_in_quadrants( c_base_player*, const vec3_t& start, const vec3_t& end, CGameTrace* pm );
+
+};
+
+END_REGION
diff --git a/internal_rewrite/proxies.cpp b/internal_rewrite/proxies.cpp new file mode 100644 index 0000000..13466b4 --- /dev/null +++ b/internal_rewrite/proxies.cpp @@ -0,0 +1,103 @@ +#include "hooks.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+
+void __cdecl hooks::lby_proxy_fn( const CRecvProxyData* proxy_data_const, void* entity, void* output ) {
+ lby_proxy.get_old_function( )( proxy_data_const, entity, output );
+
+ if( !g_csgo.m_panic ) {
+ auto player = ( c_base_player* )( entity );
+ if( player && player == g_ctx.m_local ) {
+ g_cheat.m_ragebot.m_antiaim->on_lby_proxy( );
+ }
+ }
+}
+
+void __cdecl hooks::last_shot_proxy_fn( const CRecvProxyData* proxy_data_const, void* entity, void* output ) {
+ last_shot_proxy.get_old_function( )( proxy_data_const, entity, output );
+ if( !g_csgo.m_panic && proxy_data_const && g_settings.rage.enabled( ) && g_settings.rage.resolver( ) ) {
+ auto wep = ( c_base_weapon* )( entity );
+ if( wep && !wep->is_knife( ) && !wep->is_grenade( ) ) {
+ auto owner = g_csgo.m_entlist( )->GetClientEntityFromHandle( wep->m_hOwner( ) );
+ if( owner && owner->is_valid( ) && owner != g_ctx.m_local && g_ctx.m_local->is_valid( ) && owner->has_valid_anim( ) ) {
+ if( owner->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && !g_settings.rage.friendlies )
+ return;
+
+ static float last_time = 0.f;
+ float time = wep->m_fLastShotTime( );
+
+ if( !time )
+ return;
+
+ float anim_time = owner->m_flOldSimulationTime( ) + TICK_INTERVAL( );
+ auto record = g_cheat.m_ragebot.m_lagcomp->get_newest_record( owner->ce( )->GetIndex( ) );
+ float& last_update = g_cheat.m_ragebot.m_lagcomp->get_last_updated_simtime( owner->ce( )->GetIndex( ) );
+
+ if( time == owner->m_flSimulationTime( ) && owner->has_valid_anim( ) && owner->m_flSimulationTime( ) != last_update ) {
+ last_update = owner->m_flSimulationTime( );
+
+ vec3_t local_pos = g_ctx.m_local->m_vecOrigin( );
+ vec3_t enemy_pos = owner->m_vecOrigin( );
+ vec3_t ang = math::vector_angles( enemy_pos, local_pos );
+
+ owner->m_angEyeAngles( ).y = ang.y;
+ owner->fix_animations( );
+
+ features::c_ragebot::lag_record_t record( owner );
+ record.m_shot = true;
+
+ g_cheat.m_ragebot.m_lagcomp->store_record( owner->ce( )->GetIndex( ), RECORD_NORMAL, record );
+ last_time = time;
+ }
+ else if( owner->has_valid_anim( ) && time != last_time ) {
+ auto lby_records = g_cheat.m_ragebot.m_lagcomp->get_records( owner->ce( )->GetIndex( ), RECORD_LBY );
+ auto sim_records = g_cheat.m_ragebot.m_lagcomp->get_records( owner->ce( )->GetIndex( ), RECORD_NORMAL );
+
+ features::c_ragebot::lag_record_t* prev_record = nullptr;
+ float min_delta = FLT_MAX;
+
+ if( lby_records->size( ) ) {
+ for( auto& it : *lby_records ) {
+ float delta = std::abs( it.m_flSimulationTime - time );
+ if( delta > TICKS_TO_TIME( 15 ) )
+ break;
+
+ if( delta < g_csgo.m_globals->m_interval_per_tick )
+ break;
+
+ if( delta < min_delta ) {
+ prev_record = ⁢
+ min_delta = delta;
+ }
+ }
+ }
+
+ if( sim_records->size( ) ) {
+ for( auto& it : *sim_records ) {
+ if( it.m_shot )
+ continue;
+
+ float delta = std::abs( it.m_flSimulationTime - time );
+ if( delta > TICKS_TO_TIME( 15 ) )
+ break;
+
+ if( delta < g_csgo.m_globals->m_interval_per_tick )
+ break;
+
+ if( delta < min_delta ) {
+ prev_record = ⁢
+ min_delta = delta;
+ }
+ }
+ }
+
+ if( prev_record && !prev_record->m_shot ) {
+ owner->m_angEyeAngles( ).x = prev_record->m_vecAngles.x;
+ }
+
+ last_time = time;
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ragebot.cpp b/internal_rewrite/ragebot.cpp new file mode 100644 index 0000000..7d0f3d3 --- /dev/null +++ b/internal_rewrite/ragebot.cpp @@ -0,0 +1,1033 @@ +#include "ragebot.hpp"
+#include "interface.hpp"
+#include "settings.hpp"
+#include "context.hpp"
+#include "math.hpp"
+#include "base_cheat.hpp"
+#include "input_system.hpp"
+
+namespace features
+{
+ c_ragebot::c_ragebot( ) :
+ m_antiaim( std::make_shared< c_antiaim >( ) ),
+ m_lagcomp( std::make_shared< c_lagcomp >( ) ),
+ m_resolver( std::make_shared< c_resolver >( ) ) { }
+
+ void c_ragebot::operator()( user_cmd_t* cmd ) {
+ if( !cmd ) return;
+ m_cmd = cmd;
+
+ m_antiaim->run( cmd );
+ run( );
+ m_antiaim->fix_movement( );
+ }
+
+ vec3_t head_scale( c_base_player* ent, vec3_t pos ) {
+
+ // broke, crashes the hack
+ //not what it is
+ //return pos;
+
+ vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
+ CTraceFilterOneEntity filter;
+ Ray_t ray;
+ CGameTrace trace;
+
+ filter.ent = ent;
+
+ float height{ };
+ float highest_dmg{ };
+ float max_height{ };
+
+ const float max = 6.5f * g_settings.rage.active->m_hitbox_scale;
+
+ for( float i = 0.f; i < max; i += 0.25f ) {
+ vec3_t end = pos;
+ end.z += i;
+
+ ray.Init( eye_pos, end );
+ g_csgo.m_trace( )->TraceRay( ray, 0x46004003, &filter, &trace );
+
+ if( trace.m_pEnt == ent->ce( ) ) {
+ max_height = i;
+ if( trace.hitgroup == HITGROUP_HEAD && !height ) {
+ height = i;
+ }
+ }
+ }
+
+ if( height < 0.5f ) {
+ pos.z += height;
+ return pos;
+ }
+
+ pos.z += ( height + max_height ) * 0.5f;
+ return pos;
+ }
+
+ int c_ragebot::get_min_dmg( c_base_player* ent ) {
+ int hp = ent->m_iHealth( );
+ int dmg = g_settings.rage.active->m_damage( );
+ int scale = g_settings.rage.active->m_damage_scale( );
+ return std::min< int >( ( int )( hp * scale * 0.01f ) + dmg, 100 );
+ }
+
+ vec3_t c_ragebot::multipoint( c_base_player* ent, int hitbox, float* out_dmg ) {
+ auto should_multipoint = [ ]( int hitbox, bool moving ) -> bool {
+ switch( hitbox ) {
+ case HITBOX_HEAD:
+ case HITBOX_PELVIS:
+ return g_settings.rage.multipoint >= 1;
+ case HITBOX_BODY:
+ case HITBOX_UPPER_CHEST:
+ case HITBOX_THORAX:
+ if( util::is_low_fps( ) && g_settings.rage.preserve_fps )
+ return false;
+ return g_settings.rage.multipoint >= 2;
+ case HITBOX_LEFT_THIGH:
+ case HITBOX_RIGHT_THIGH:
+ if( util::is_low_fps( ) && g_settings.rage.preserve_fps )
+ return false;
+ return g_settings.rage.multipoint >= 3 && !moving;
+ default:
+ return false;
+ }
+ };
+
+ bool moving = ent->m_vecVelocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( );
+
+ vec3_t pos = ent->get_hitbox_pos( hitbox );
+ if( hitbox == HITBOX_HEAD )
+ pos = head_scale( ent, pos );
+
+ float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pos );
+ if( dmg > get_min_dmg( ent ) ) {
+ *out_dmg = dmg;
+ return pos;
+ }
+
+ if( should_multipoint( hitbox, moving ) ) {
+ const auto model = ent->ce( )->GetModel( );
+ if( !model ) return vec3_t{ };
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !hdr ) return vec3_t{ };
+
+ matrix3x4 bone_matrix[ 128 ];
+ if( !ent->ce( )->SetupBones( bone_matrix, 128, 0x100, g_csgo.m_globals->m_curtime ) ) {
+ return vec3_t{ };
+ }
+
+ auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) );
+ if( !set ) return vec3_t{ };
+
+ //literally 20000 iq, the best multipoint
+ //im an actual fucking retard jesus christ
+ auto box = set->pHitbox( hitbox );
+ if( !box ) return vec3_t{ };
+
+ vec3_t center = ( box->bbmax + box->bbmin ) * 0.5f;
+
+ float dist = box->m_flRadius;
+
+ if( box->m_flRadius == -1.f )
+ dist = center.dist_to( box->bbmin ) * 0.85f;
+ vec3_t min_dir = math::angle_vectors( math::vector_angles( center, box->bbmin ) );
+ vec3_t min = center + min_dir * dist * g_settings.rage.active->m_hitbox_scale * 1.1f;
+
+ if( box->m_flRadius == -1.f )
+ dist = center.dist_to( box->bbmax ) * 0.85f;
+ vec3_t max_dir = math::angle_vectors( math::vector_angles( center, box->bbmax ) );
+ vec3_t max = center + max_dir * dist * g_settings.rage.active->m_hitbox_scale * 1.1f;
+
+ //float radius = box->m_flRadius * 1.1f * g_settings.rage.active->m_hitbox_scale;
+ //min -= vec3_t( radius, radius, radius );
+ //max += vec3_t( radius, radius, radius );
+
+ static int point_index[ 65 ][ HITBOX_MAX ];
+
+ std::array< vec3_t, 8 > points = {
+ vec3_t{ min.x, min.y, min.z },
+ vec3_t{ min.x, max.y, min.z },
+ vec3_t{ max.x, max.y, min.z },
+ vec3_t{ max.x, min.y, min.z },
+ vec3_t{ max.x, max.y, max.z },
+ vec3_t{ min.x, max.y, max.z },
+ vec3_t{ min.x, min.y, max.z },
+ vec3_t{ max.x, min.y, max.z }
+ };
+
+ vec3_t lt{ },
+ rt{ },
+ lb{ },
+ rb{ };
+
+ vec3_t lt_ang{ FLT_MAX, FLT_MAX, 0.f },
+ rt_ang{ FLT_MAX, -FLT_MAX, 0.f },
+ lb_ang{ -FLT_MAX, FLT_MAX, 0.f },
+ rb_ang{ -FLT_MAX, -FLT_MAX, 0.f };
+
+ vec3_t transformed_center = math::vector_transform( vec3_t( min + max ) * 0.5f, bone_matrix[ box->bone ] );
+ vec3_t center_ang = math::vector_angles( g_ctx.m_local->get_eye_pos( ), transformed_center );
+
+ float min_dmg = get_min_dmg( ent );
+
+ auto& point_idx = point_index[ ent->ce( )->GetIndex( ) ][ hitbox ];
+
+ int count = std::max< int >( ( int )( g_csgo.m_globals->m_frametime / TICK_INTERVAL( ) ), 1 );
+
+ for( int i{ }; i < std::min( count, 9 ); ++i ) {
+ point_idx %= points.size( );
+
+ vec3_t point = points[ point_idx ];
+
+ vec3_t trans_point = math::vector_transform( point, bone_matrix[ box->bone ] );
+ CTraceFilterOneEntity filter;
+ CGameTrace trace;
+ Ray_t ray;
+
+ filter.ent = ent;
+ ray.Init( g_ctx.m_local->get_eye_pos( ), trans_point );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &trace );
+
+ if( trace.m_pEnt == ent->ce( ) ) {
+ float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, trans_point );
+ if( dmg > min_dmg ) {
+ *out_dmg = dmg;
+ return trans_point;
+ }
+ else {
+ point_idx++;
+ }
+ }
+ else {
+ point_idx++;
+ }
+ }
+ }
+
+ return ent->get_hitbox_pos( hitbox );
+ }
+
+ int c_ragebot::hitscan( c_base_player* ent, bool baim, vec3_t& out_pos, float& out_dmg ) {
+ auto should_histcan = []( int hitbox, bool moving ) -> bool {
+ switch ( hitbox ) {
+ case HITBOX_HEAD:
+ case HITBOX_NECK:
+ return g_settings.rage.hitscan.head;
+ case HITBOX_PELVIS:
+ case HITBOX_BODY:
+ case HITBOX_CHEST:
+ return g_settings.rage.hitscan.stomach;
+ case HITBOX_UPPER_CHEST:
+ case HITBOX_THORAX:
+ return g_settings.rage.hitscan.chest;
+ case HITBOX_RIGHT_HAND:
+ case HITBOX_LEFT_HAND:
+ if( moving && g_settings.rage.ignore_limbs_moving )
+ return false;
+
+ if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
+ return false;
+
+ return g_settings.rage.hitscan.arms;
+ case HITBOX_RIGHT_THIGH:
+ case HITBOX_LEFT_THIGH:
+ case HITBOX_LEFT_CALF:
+ case HITBOX_RIGHT_CALF:
+ if( moving && g_settings.rage.ignore_limbs_moving )
+ return false;
+
+ if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
+ return false;
+
+ return g_settings.rage.hitscan.legs;
+
+ case HITBOX_RIGHT_FOOT:
+ case HITBOX_LEFT_FOOT:
+ if( moving )
+ return false;
+
+ if( g_settings.rage.preserve_fps && util::is_low_fps( ) )
+ return false;
+
+ return g_settings.rage.hitscan.feet;
+ default:
+ return false;
+ }
+ };
+
+ constexpr std::array< std::pair< PlayerHitboxes_t, int >, 15 > hitbox_order = {
+ std::make_pair( HITBOX_HEAD, 4 ),
+ std::make_pair( HITBOX_NECK, 4 ),
+
+ std::make_pair( HITBOX_PELVIS, 3 ),
+ std::make_pair( HITBOX_BODY, 3 ),
+ std::make_pair( HITBOX_THORAX, 3 ),
+ std::make_pair( HITBOX_CHEST, 3 ),
+ std::make_pair( HITBOX_UPPER_CHEST, 3 ),
+
+ std::make_pair( HITBOX_RIGHT_HAND, 2 ),
+ std::make_pair( HITBOX_LEFT_HAND, 2 ),
+
+ std::make_pair( HITBOX_RIGHT_THIGH, 2 ),
+ std::make_pair( HITBOX_LEFT_THIGH, 2 ),
+
+ std::make_pair( HITBOX_RIGHT_CALF, 1 ),
+ std::make_pair( HITBOX_LEFT_CALF , 1 ),
+
+ std::make_pair( HITBOX_RIGHT_FOOT, 0 ),
+ std::make_pair( HITBOX_LEFT_FOOT, 0 ),
+ };
+
+ bool moving = ent->m_vecVelocity( ).length( ) > 0.1f && !ent->is_fakewalking( );
+ float min_dmg = get_min_dmg( ent );
+
+ if ( g_settings.rage.hitbox != -1 ) {
+ float dmg{ };
+ vec3_t pos = multipoint( ent, g_settings.rage.hitbox, &dmg );
+
+ if( dmg > min_dmg && pos ) {
+ out_dmg = dmg;
+ out_pos = pos;
+ return g_settings.rage.hitbox;
+ }
+
+ return -1;
+ }
+
+ struct hitbox_t {
+ float dmg;
+ int hitbox;
+ int priority;
+ vec3_t position;
+ };
+
+ std::vector< hitbox_t > hitboxes;
+
+ for( size_t i{ }; i < hitbox_order.size( ); ++i ) {
+ auto hitbox = hitbox_order[ i ];
+ if( !should_histcan( hitbox.first, moving ) ) {
+ continue;
+ }
+
+ float dmg{ };
+ vec3_t pos = multipoint( ent, hitbox.first, &dmg );
+
+ if( pos )
+ hitboxes.push_back( { dmg, hitbox.first, hitbox.second, pos } );
+ }
+
+ std::sort( hitboxes.begin( ), hitboxes.end( ), [ &ent, &baim ]( hitbox_t& a, hitbox_t& b ) -> bool {
+ int hp = ent->m_iHealth( );
+
+ bool a_head = !( a.hitbox == HITBOX_HEAD || a.hitbox == HITBOX_NECK );
+ bool b_head = !( b.hitbox == HITBOX_HEAD || b.hitbox == HITBOX_NECK );
+
+ if( a.dmg != b.dmg && g_settings.rage.active->m_baim_lethal ) {
+ if( a.dmg > ( float )( hp + 10 ) && ( float )( b.dmg > hp + 10 ) ) {
+ if( a_head != b_head ) {
+ return a_head > b_head;
+ }
+ }
+ }
+
+ if( a_head != b_head && baim )
+ return a_head > b_head;
+
+ if( a.priority != b.priority ) {
+ return a.priority > b.priority;
+ }
+
+ if( a.dmg != b.dmg ) {
+ return a.dmg > b.dmg;
+ }
+
+ return a.hitbox > b.hitbox;
+ } );
+
+ for( auto& it : hitboxes ) {
+ if( it.dmg > min_dmg ) {
+ out_dmg = it.dmg;
+ out_pos = it.position;
+
+ return it.hitbox;
+ }
+ }
+
+ return -1;
+ }
+
+ void c_ragebot::update_settings( ) {
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon ) return;
+ int weapon_id = weapon->m_iItemDefinitionIndex( );
+
+ switch ( weapon_id ) {
+ case WEAPON_DEAGLE:
+ case WEAPON_R8REVOLVER:
+ g_settings.rage.active = &g_settings.rage.heavy_pistols;
+ break;
+ case WEAPON_AWP:
+ case WEAPON_SSG08:
+ g_settings.rage.active = &g_settings.rage.snipers;
+ break;
+ case WEAPON_G3SG1:
+ case WEAPON_SCAR20:
+ g_settings.rage.active = &g_settings.rage.auto_snipers;
+ break;
+ default:
+ g_settings.rage.active = &g_settings.rage.general;
+ break;
+ }
+ }
+
+ bool c_ragebot::should_baim_entity( c_base_player* ent, bool backtracked ) {
+ int index = ent->ce( )->GetIndex( );
+
+ auto weap = g_ctx.m_local->get_weapon( );
+ if( weap->m_iItemDefinitionIndex( ) == WEAPON_TASER )
+ return true;
+
+ if( !g_cheat.m_player_mgr.is_cheater( index ) )
+ return false;
+
+ int min_hp = g_settings.rage.active->m_baim_health;
+ int min_shots = g_settings.rage.active->m_baim_shots;
+
+ if( m_resolver->get_shots( index ) >= min_shots )
+ return true;
+
+ if( ent->m_iHealth( ) <= min_hp )
+ return true;
+
+ if( !( ent->m_fFlags( ) & FL_ONGROUND ) && g_settings.rage.active->m_baim_air )
+ return true;
+
+ if( !backtracked && g_settings.rage.active->m_baim_fake )
+ return true;
+
+ return false;
+ }
+
+ void quick_stop( user_cmd_t* cmd ) {
+ if( g_cheat.m_ragebot.m_antiaim->is_fakewalking( ) )
+ return;
+
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ return;
+
+ vec3_t vel = g_ctx.m_local->m_vecVelocity( );
+ float speed = vel.length2d( );
+
+ if( speed < 1.f ) {
+ g_ctx.get_last_cmd( )->m_forwardmove = 0.f;
+ g_ctx.get_last_cmd( )->m_sidemove = 0.f;
+ return;
+ }
+
+ static auto sv_accelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_accelerate" ) );
+ float accel = sv_accelerate->get_float( );
+ float max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed;
+ if( g_ctx.m_local->get_weapon( )->is_sniper( ) && g_ctx.m_local->m_bIsScoped( ) ) {
+ max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed_alt;
+ }
+
+ if( g_ctx.m_local->m_fFlags( ) & FL_DUCKING ) {
+ max_speed /= 3.f;
+ accel /= 3.f;
+ }
+
+ float surf_friction = 1.f;
+ float max_accelspeed = accel * g_csgo.m_globals->m_interval_per_tick * max_speed * surf_friction;
+
+ float wishspeed{ };
+
+ if( speed - max_accelspeed <= -1.f ) {
+ wishspeed = max_accelspeed / ( speed / ( accel * g_csgo.m_globals->m_interval_per_tick ) );
+ }
+ else {
+ wishspeed = max_accelspeed;
+ }
+
+ vec3_t ndir = math::vector_angles( vel * -1.f );
+ ndir.y = cmd->m_viewangles.y - ndir.y;
+ ndir = math::angle_vectors( ndir );
+
+ g_ctx.get_last_cmd( )->m_forwardmove = ndir.x * wishspeed;
+ g_ctx.get_last_cmd( )->m_sidemove = ndir.y * wishspeed;
+ }
+
+ std::array< int, 65 > c_ragebot::get_sorted_targets( ) {
+ typedef struct {
+ int index;
+ float dist;
+ float fov;
+ bool moving;
+ int hp;
+ float simtime;
+ } target;
+
+ std::array< target, 65 > targets{ };
+ std::array< int, 65 > ret{ };
+
+ vec3_t local_pos = g_ctx.m_local->get_eye_pos( );
+ vec3_t cur_ang, dir_vec;
+ g_csgo.m_engine( )->GetViewAngles( cur_ang );
+
+ dir_vec = math::angle_vectors( cur_ang );
+
+ for( size_t i{ }; i < 65; ++i ) {
+ auto& cur_target = targets.at( i );
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+ cur_target.index = i;
+
+ if( !ent || ent == g_ctx.m_local || !ent->is_valid( ) )
+ continue;
+
+ if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) &&
+ !g_settings.rage.friendlies( ) )
+ continue;
+
+ if( !ent->has_valid_anim( ) )
+ continue;
+
+ auto pos = ent->m_vecOrigin( );
+ pos.z += 30.f; //eh
+
+ auto dir = ( pos - local_pos );
+ dir.normalize_vector( );
+
+ float fov = dir_vec.fov_to( dir ) * M_RADPI; // epic fov fix by friendly....
+
+ cur_target.fov = fov;
+ cur_target.dist = pos.dist_to( local_pos );
+ cur_target.hp = ent->m_iHealth( );
+ cur_target.moving = ent->m_vecVelocity( ).length2d( ) > 0.1f
+ && !ent->is_fakewalking( )
+ && ( ent->m_fFlags( ) & FL_ONGROUND );
+ cur_target.simtime = ent->m_flSimulationTime( );
+ }
+
+ auto sort_fn = [ ]( const target& a, const target& b ) {
+ if( g_settings.rage.prefer_low_hp ) {
+ if( a.hp != b.hp )
+ return a.hp < b.hp;
+ }
+
+ if( g_settings.rage.prefer_moving ) {
+ if( a.moving != b.moving )
+ return a.moving > b.moving;
+ }
+
+ if( g_settings.rage.selection_type == 0 ) {
+ if( a.fov != b.fov )
+ return a.fov < b.fov;
+ }
+ else if( g_settings.rage.selection_type == 1 ) {
+ if( a.dist != b.dist )
+ return a.dist < b.dist;
+ }
+ else if( g_settings.rage.selection_type == 2 ) {
+ if( a.simtime != b.simtime )
+ return a.simtime > b.simtime;
+ }
+
+ return a.index > b.index;
+ };
+
+ std::sort( targets.begin( ), targets.end( ), sort_fn );
+ for( size_t i{ }; i < 65; ++i ) {
+ if( targets[ i ].fov < g_settings.rage.fov ) {
+ ret[ i ] = targets[ i ].index;
+ }
+ }
+
+ return ret;
+ }
+
+ bool c_ragebot::can_hit_without_ping( int entity ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( entity );
+
+ if( !ent )
+ return false;
+
+ int min_dmg = get_min_dmg( ent );
+ auto check_records = [ &ent, &min_dmg ]( std::deque< lag_record_t >* records ) {
+ auto& front = records->front( );
+ vec3_t pred_pos = front.m_vecPelvisPos;
+
+ float dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pred_pos, false );
+ if( dmg > min_dmg )
+ return true;
+
+ pred_pos = front.m_vecHeadPos;
+ dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, pred_pos, false );
+ if( dmg > min_dmg )
+ return true;
+
+ return false;
+ };
+
+ auto lby_records = m_lagcomp->get_records( entity, RECORD_LBY );
+ auto sim_records = m_lagcomp->get_records( entity, RECORD_NORMAL );
+
+ if( lby_records->size( ) ) {
+ if( check_records( lby_records ) )
+ return true;
+ }
+
+ if( sim_records->size( ) ) {
+ if( check_records( sim_records ) )
+ return true;
+ }
+
+ return false;
+ }
+
+ int c_ragebot::knifebot( ) {
+ auto aim_pos = g_ctx.m_local->get_eye_pos( );
+
+ float dist = FLT_MAX;
+ int ideal_ent = 0;
+ int ideal_tick = 0;
+ int hp = 0;
+ vec3_t pos;
+
+ for( size_t i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+
+ if( !ent || !ent->is_valid( ) || ent == g_ctx.m_local || !ent->has_valid_anim( ) || ent->m_bGunGameImmunity( ) )
+ continue;
+
+ auto newest_record = m_lagcomp->get_newest_valid_record( i );
+ if( !newest_record )
+ continue;
+
+ if( newest_record->m_vecPelvisPos.dist_to( aim_pos ) < dist ) {
+ hp = ent->m_iHealth( );
+ ideal_ent = i;
+ ideal_tick = newest_record->m_tickcount;
+ pos = newest_record->m_vecPelvisPos;
+
+ dist = pos.dist_to( aim_pos );
+ }
+ }
+
+ if( ideal_ent && dist < 80.f ) {
+ int attack = 0;
+
+ if( dist < 70.f )
+ attack = IN_ATTACK2;
+ else if( hp < 35 )
+ attack = IN_ATTACK;
+ else
+ return -1;
+
+ vec3_t ang = math::vector_angles( aim_pos, pos );
+ float fov = ang.dist_to( g_csgo.m_engine( )->GetViewAngles( ) );
+
+ if( fov < g_settings.rage.fov ) {
+ m_cmd->m_viewangles = math::vector_angles( aim_pos, pos );
+ m_cmd->m_tick_count = ideal_tick;
+ m_cmd->m_buttons |= attack;
+
+ return ideal_ent;
+ }
+ else {
+ return -1;
+ }
+ }
+
+ return -1;
+ }
+
+ c_ragebot::aim_target_t c_ragebot::find_best_target( ) {
+ aim_target_t ret{ -1, m_cmd->m_tick_count, -1, vec3_t{ }, vec3_t{ }, vec3_t{ }, 0.f, 0 };
+ vec3_t aim_angle{ };
+ vec3_t local_pos{ };
+ vec3_t aim_pos{ };
+ auto weapon_info = g_ctx.m_local->get_weapon( )->get_wpn_info( );
+ bool is_zeus = g_ctx.m_local->get_weapon( )->m_iItemDefinitionIndex( ) == WEAPON_TASER;
+ int damage = weapon_info->damage;
+
+ local_pos = g_ctx.m_local->get_eye_pos( );
+
+ auto players = get_sorted_targets( );
+ auto data = players.data( );
+
+ for( size_t i{ }; i < players.size( ); ++i ) {
+ auto& it = data[ i ];
+
+ auto entity = g_csgo.m_entlist( )->GetClientEntity< >( it );
+ if( !entity || !entity->is_valid( ) || entity == g_ctx.m_local ) continue;
+ if( entity->m_bGunGameImmunity( ) ) continue;
+ if( !entity->has_valid_anim( ) ) continue;
+
+ bool baim = false;
+ bool should_baim = true;
+ bool backtracked = false;
+ bool restore = false;
+ float hit_damage = 0.f;
+ vec3_t extrapolate{ };
+
+ lag_record_t original_record( entity );
+ lag_record_t* backtracked_record{ };
+
+ int tick_count = m_cmd->m_tick_count;
+ float lerp = util::get_lerptime( );
+ auto record_type = m_lagcomp->can_backtrack_entity( it );
+ if( !g_settings.rage.resolver( ) ) {
+ if( !util::is_tick_valid( entity->m_flSimulationTime( ) + lerp ) ) {
+ int new_tickcount = m_lagcomp->backtrack_entity( it,
+ record_type, &backtracked_record );
+
+ if( new_tickcount != -1 ) {
+ restore = true;
+ tick_count = new_tickcount;
+ }
+ else if( g_settings.misc.net_fakelag == 4 && can_hit_without_ping( it ) ) {
+ m_can_fakeping = false;
+ }
+ }
+ }
+ else {
+ int new_tickcount = m_lagcomp->backtrack_entity( it, record_type, &backtracked_record );
+ if( new_tickcount != -1 ) {
+ tick_count = new_tickcount;
+ should_baim = record_type != RECORD_LBY;
+ backtracked = record_type == RECORD_LBY;
+ restore = true;
+ }
+ else {
+ if( g_settings.misc.net_fakelag == 4 ) {
+ //if( can_hit_without_ping( it ) )
+ // m_can_fakeping = false;
+ }
+
+ lag_record_t* last_simtime_record = m_lagcomp->get_newest_valid_record( it );
+ if( last_simtime_record ) {
+ //ENSURE THE MOST ACCURATE DATA
+ entity->m_vecVelocity( ) = entity->get_animdata( ).m_last_velocity;
+
+ auto velocity = entity->m_vecVelocity( );
+ auto min_vel = 64 / TICK_INTERVAL( ) / 14;
+
+ //IS HE A SLOW BOI OR A FAST NIGGER
+ if( g_settings.rage.fakelag_resolver( ) && velocity.length2d( ) > min_vel - 10.f ) {
+ auto new_record = *last_simtime_record;
+
+ //FUCK FAKE PINGERS WE IN THIS BITCH
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); //GOD FUCKING KNOWS WHY
+ float latency = nci->GetLatency( 0 ) + g_csgo.m_globals->m_frametime;
+
+ auto pred_choke = g_cheat.m_prediction.get_predicted_choke( it );
+ auto latency_ticks = TIME_TO_TICKS( latency );
+
+ float time_since_update = g_ctx.pred_time( ) + latency - entity->m_flSimulationTime( );
+
+ //NIGGA UPDATED ALREADY FUCK ADAPTIVE
+ if( TIME_TO_TICKS( time_since_update ) > pred_choke && pred_choke > 0 ) {
+ if( g_settings.rage.fakelag_resolver( ) == 1 )
+ continue;
+
+ else if( latency_ticks > 0 ) {
+ int update_count = TIME_TO_TICKS( time_since_update ) / pred_choke;
+
+ vec3_t extrapolated_origin = g_cheat.m_prediction.full_walk_move( entity, update_count * pred_choke );
+ new_record.m_vecRenderOrigin = extrapolated_origin;
+ new_record.m_tickcount += update_count * pred_choke;
+ }
+ }
+
+ //if( !new_record.is_valid( ) )
+ // continue;
+
+ int shots = m_resolver->get_shots( i );
+ bool recalc = shots != last_simtime_record->m_shots;
+
+ new_record.restore( true, recalc );
+ tick_count = new_record.m_tickcount;
+ backtracked_record = last_simtime_record;
+ restore = true;
+ }
+ else {
+ int shots = m_resolver->get_shots( i );
+ bool recalc = shots != last_simtime_record->m_shots;
+
+ last_simtime_record->restore( recalc, recalc );
+ tick_count = last_simtime_record->m_tickcount;
+ backtracked_record = last_simtime_record;
+ restore = true;
+ }
+ }
+ else {
+ //fake ping, just wait for an update
+ continue;
+ }
+ }
+ }
+
+ baim = should_baim_entity( entity, !should_baim );
+
+ auto restore_player = [ &original_record, &restore, &entity, this ]( ) {
+ original_record.restore( true );
+ //entity->m_flLastBoneSetupTime( ) = std::numeric_limits< float >::quiet_NaN( );
+ };
+
+ int hitbox = hitscan( entity, baim, aim_pos, hit_damage );
+ if( hitbox == -1 ) {
+ restore_player( );
+ continue;
+ }
+
+ if( aim_pos.dist_to( local_pos ) > 150.f && is_zeus ) {
+ restore_player( );
+ continue;
+ }
+
+ aim_angle = math::vector_angles( local_pos, aim_pos ).clamp( );
+
+ if( !util::hitchance( it, aim_angle,
+ g_settings.rage.active->m_hitchance ) ) {
+ if( g_settings.rage.active->m_auto_stop( ) )
+ quick_stop( m_cmd );
+
+ if( g_settings.rage.auto_scope( ) && g_ctx.m_local->get_weapon( )->is_sniper( ) ) {
+ if( !g_ctx.m_local->m_bIsScoped( ) ) {
+ m_cmd->m_buttons |= IN_ATTACK2;
+ }
+ }
+
+ restore_player( );
+ continue;
+ }
+
+ ret.m_ent_index = it;
+ ret.m_position = aim_pos;
+ ret.m_tick_count = tick_count;
+ ret.m_hitbox = hitbox;
+ ret.m_backtracked = backtracked;
+ ret.m_min = entity->get_hitbox_mins( hitbox );
+ ret.m_max = entity->get_hitbox_maxs( hitbox );
+ ret.m_radius = entity->get_hitbox_radius( hitbox );
+
+ memcpy( m_shot_matrix, entity->m_CachedBoneData( ).GetElements( ), sizeof( matrix3x4 ) * entity->m_CachedBoneData( ).GetSize( ) );
+
+ m_shot_target = it;
+
+ restore_player( );
+
+ break;
+ }
+
+ return ret;
+ }
+
+ void c_ragebot::set_angles( const vec3_t& angles ) {
+ auto weapon = g_ctx.m_local->get_weapon( );
+
+ // TODO: Implement the get_spread_direction here I guess.
+ if( g_settings.rage.compensate_spread ) {
+ int seed = m_cmd->m_random_seed;
+
+ weapon->update_accuracy_penalty( );
+
+ float inaccuracy = weapon->get_inaccuracy( );
+ float spread = weapon->get_spread( );
+
+ util::set_random_seed( ( seed & 0xff ) + 1 );
+
+ float rand_a = util::get_random_float( 0.0f, 1.0f );
+ float pi_rand_a = util::get_random_float( 0.f, 2.f * M_PI );
+ float rand_b = util::get_random_float( 0.f, 1.0f );
+ float pi_rand_b = util::get_random_float( 0.f, 2.f * M_PI );
+
+ float spread_x = cos( pi_rand_a ) * ( rand_a * inaccuracy ) + cos( pi_rand_b ) * ( rand_b * spread );
+ float spread_y = sin( pi_rand_a ) * ( rand_a * inaccuracy ) + sin( pi_rand_b ) * ( rand_b * spread );
+
+ vec3_t forward, right, up;
+ math::angle_vectors( angles, &forward, &right, &up );
+
+ vec3_t spread_dir = forward + ( right * -spread_x ) + ( up * -spread_y );
+ spread_dir.normalize_vector( );
+
+ vec3_t comp = math::vector_angles( vec3_t( ), spread_dir );
+
+ m_cmd->m_viewangles = comp;
+ m_cmd->m_random_seed = seed;
+ }
+
+ if( g_settings.rage.silent == 2 ) {
+ g_cheat.m_lagmgr.set_state( weapon->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER );
+ m_send_next = weapon->m_iItemDefinitionIndex( ) != WEAPON_R8REVOLVER;
+ }
+
+ if( g_settings.rage.silent == 1 && !m_antiaim->is_fakewalking( ) ) {
+ if( weapon->m_iItemDefinitionIndex( ) != WEAPON_R8REVOLVER )
+ g_cheat.m_lagmgr.set_state( !g_cheat.m_lagmgr.get_sent( ) );
+ }
+
+ m_cmd->m_viewangles = angles;
+ if( !g_settings.rage.silent( ) ) {
+ g_csgo.m_engine( )->SetViewAngles( m_cmd->m_viewangles );
+ }
+ }
+
+ void c_ragebot::aim_at_target( const aim_target_t& target ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( target.m_ent_index );
+ if( !ent )
+ return;
+
+ if( g_ctx.m_local->get_weapon( )->m_iItemDefinitionIndex( ) != WEAPON_R8REVOLVER ) {
+ if( g_settings.rage.active->m_delay_type == 2 ) {
+ static auto time_to_fire = 0.f;
+ const float delay = float( g_settings.rage.active->m_delay( ) ) * 0.001f;
+ const float time = g_ctx.pred_time( );
+
+ float delta = time_to_fire - time;
+
+ if( delta > delay ) {
+ time_to_fire = time + delay;
+ }
+
+ if( delta < 0.f ) {
+ time_to_fire = time + delay;
+ delta = delay;
+ }
+
+ if( delta > g_csgo.m_globals->m_interval_per_tick ) {
+ return;
+ }
+ }
+ if( g_settings.rage.active->m_delay_type == 3 ) {
+ static float time_to_fire = 0.f;
+ const float time = g_ctx.pred_time( );
+
+ float delta = time_to_fire - time;
+
+ vec3_t velocity = ent->m_vecVelocity( );
+ float speed = velocity.length2d( );
+ if( speed > g_ctx.m_local->m_vecVelocity( ).length2d( ) && speed > 100.f ) {
+ vec3_t head_pos = ent->get_hitbox_pos( 0 );
+ vec3_t origin = ent->m_vecOrigin( );
+ origin.z = head_pos.z = 0.f;
+
+ float dist = origin.dist_to( head_pos ); //1 / 64
+ auto delay = dist / speed + 0.015625f;
+
+ if( delta > delay )
+ time_to_fire = time + delay;
+
+ if( delta < 0.f ) {
+ time_to_fire = time + delay;
+ delta = delay;
+ }
+
+ if( delta > g_csgo.m_globals->m_interval_per_tick )
+ return;
+ }
+ }
+ }
+
+ m_cmd->m_buttons |= IN_ATTACK;
+ m_cmd->m_buttons &= ~IN_USE;
+
+ vec3_t position = target.m_position;
+ m_cmd->m_tick_count = target.m_tick_count;
+
+ auto angle = math::vector_angles(
+ g_ctx.m_local->get_eye_pos( ),
+ target.m_position );
+
+ static auto weapon_recoil_scale = g_csgo.m_cvar( )->FindVar( xors( "weapon_recoil_scale" ) );
+ angle -= g_ctx.m_local->m_aimPunchAngle( ) * weapon_recoil_scale->get_float( );
+
+ g_cheat.m_visuals.store_shot( target.m_position );
+
+ if( !target.m_backtracked && g_cheat.m_player_mgr.is_cheater( target.m_ent_index ) ) {
+ m_resolver->aimbot(
+ target.m_ent_index,
+ target.m_hitbox, angle,
+ target.m_position,
+ target.m_min,
+ target.m_max,
+ target.m_radius );
+ }
+ else {
+ context::shot_data_t new_shot{ };
+ new_shot.m_angle = angle;
+ new_shot.m_enemy_index = target.m_ent_index;
+
+ new_shot.m_hitbox.max = target.m_min;
+ new_shot.m_hitbox.min = target.m_max;
+ new_shot.m_hitbox.radius = target.m_radius;
+ new_shot.m_hitgroup = target.m_hitbox;
+
+ new_shot.m_enemy_pos = target.m_position;
+
+ g_ctx.m_last_shot++;
+ g_ctx.m_last_shot %= 128;
+
+ g_ctx.m_shot_data[ g_ctx.m_last_shot ] = new_shot;
+ g_ctx.m_has_incremented_shots = true;
+ }
+
+ set_angles( angle.clamp( ) );
+ }
+
+ void c_ragebot::run( ) {
+ if( !g_settings.rage.enabled( ) || !g_ctx.run_frame( ) || !g_ctx.m_local->is_valid( ) ) {
+ m_target = -1;
+ return;
+ }
+
+ update_settings( );
+
+ if( m_send_next ) {
+ if( !g_cheat.m_lagmgr.get_sent( ) && !m_antiaim->is_fakewalking( ) )
+ g_cheat.m_lagmgr.set_state( true );
+
+ m_send_next = false;
+ }
+
+ auto wep = g_ctx.m_local->get_weapon( );
+ if( !wep ) {
+ m_target = -1;
+ return;
+ }
+
+ bool in_attack = false;
+
+ if( !g_ctx.m_local->can_attack( ) )
+ return;
+
+ m_can_fakeping = true;
+
+ if ( g_settings.rage.activation_type == 0 ) in_attack = true;
+ else in_attack = g_input.is_key_pressed(
+ ( VirtualKeys_t )g_settings.rage.aimkey( ) );
+
+ if( !in_attack ) {
+ m_target = -1;
+ return;
+ }
+
+ if( wep->is_knife( ) ) {
+ m_target = knifebot( );
+ return;
+ }
+
+ if( !wep->m_iClip1( ) || wep->is_grenade( ) ) {
+ m_target = -1;
+ return;
+ }
+
+ auto target = find_best_target( );
+ if ( target.m_ent_index != -1 ) {
+ aim_at_target( target );
+ }
+
+ m_target = target.m_ent_index;
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ragebot.hpp b/internal_rewrite/ragebot.hpp new file mode 100644 index 0000000..4b5676f --- /dev/null +++ b/internal_rewrite/ragebot.hpp @@ -0,0 +1,340 @@ +#pragma once
+#include <deque>
+#include <memory>
+
+#include "sdk.hpp"
+#include "console.hpp"
+
+struct CCSGOPlayerAnimState;
+
+enum RecordType_t {
+ RECORD_NONE,
+ RECORD_LBY,
+ RECORD_NORMAL,
+};
+
+enum HitscanTypes_t {
+ HITSCAN_OFF,
+ HITSCAN_HEAD_BODY,
+ HITSCAN_HEAD_BODY_ARMS,
+ HITSCAN_LIMBS,
+};
+
+enum BreakerState_t {
+ BS_OFF,
+ BS_MOVING,
+ BS_WAS_MOVING,
+ BS_BREAKING,
+};
+
+struct lby_update_t {
+ int m_tickbase;
+ BreakerState_t m_state;
+};
+
+namespace features
+{
+ class c_ragebot {
+ public:
+ c_ragebot( );
+
+ class c_lagcomp;
+ struct lag_record_t;
+ struct render_record_t;
+ class c_antiaim;
+ class c_lby_breaker;
+ class c_resolver;
+
+ std::shared_ptr< c_resolver > m_resolver;
+ std::shared_ptr< c_lagcomp > m_lagcomp;
+ std::shared_ptr< c_antiaim > m_antiaim;
+ private:
+ struct aim_target_t {
+ int m_ent_index;
+ int m_tick_count;
+ int m_hitbox;
+ vec3_t m_position;
+ vec3_t m_min;
+ vec3_t m_max;
+ float m_radius;
+ bool m_backtracked;
+ };
+ user_cmd_t* m_cmd;
+ int m_target;
+ bool m_send_next;
+ matrix3x4 m_shot_matrix[ 128 ];
+ int m_shot_target;
+ bool m_can_fakeping;
+
+ void run( );
+
+ std::array< int, 65 > get_sorted_targets( );
+ aim_target_t find_best_target( );
+ int hitscan( c_base_player* ent, bool baim, vec3_t& out_pos, float& out_dmg );
+ void set_angles( const vec3_t& viewangles );
+ bool should_baim_entity( c_base_player* ent, bool backtracked = false );
+ void aim_at_target( const aim_target_t& target );
+ bool can_hit_without_ping( int entity );
+ vec3_t multipoint( c_base_player* ent, int hitbox, float* out_dmg );
+ int knifebot( );
+
+ void update_settings( );
+ public:
+ int get_min_dmg( c_base_player* ent );
+ bool can_fakeping( ) const { return m_can_fakeping; }
+ auto get_shot_target( ) const { return m_shot_target; }
+ auto get_shot_matrix( ) const { return m_shot_matrix; }
+ int get_target( ) const { return m_target; }
+ void operator()( user_cmd_t* cmd );
+ };
+
+ class c_ragebot::c_lby_breaker {
+ friend class c_antiaim;
+ private:
+ std::array< lby_update_t, 64 > m_lby_updates;
+ void update_animstate( );
+
+ float m_next_update{ };
+ public:
+ int get_next_update( ) const;
+ void on_lby_proxy( );
+ void override_angles( float* angle, float original, float offset, bool freestanding = false );
+ };
+
+ class c_ragebot::c_antiaim {
+ private:
+ c_lby_breaker m_breaker;
+ user_cmd_t* m_cmd;
+ bool m_is_edging{ };
+ bool m_is_fakewalking{ };
+ bool m_direction{ };
+
+ void run( );
+
+ float get_yaw( bool fake, float original, bool no_jitter = false );
+ float get_pitch( );
+
+ bool run_freestanding( int player = -1 );
+ bool run_edge_dtc( );
+ void run_fakewalk( );
+
+ public:
+ bool is_fakewalking( ) const { return m_is_fakewalking; }
+ bool is_edging( ) const { return m_is_edging; }
+ float get_yaw( bool no_jitter = false );
+
+ void on_runcommand( ) {
+ m_breaker.update_animstate( );
+ }
+ void on_lby_proxy( ) {
+ m_breaker.on_lby_proxy( );
+ }
+ auto get_next_update( ) {
+ return m_breaker.get_next_update( );
+ }
+
+
+ void fix_movement( );
+ void run( user_cmd_t* cmd ) {
+ m_cmd = cmd;
+ run( );
+ }
+ };
+
+ struct c_ragebot::lag_record_t {
+ c_base_player* m_ent{ };
+
+ int m_tickcount{ };
+ float m_flSimulationTime{ };
+ float m_flOldSimulationTime{ };
+ bool m_balanceadjust{ };
+ bool m_shot{ };
+ int m_choked{ };
+
+ float m_flCycle{ };
+ float m_flLowerBodyYawTarget{ };
+ float m_flDuckAmount{ };
+ float m_flDuckSpeed{ };
+ float m_animDuck{ };
+ int m_fFlags{ };
+
+ vec3_t m_animVelocity{ };
+ vec3_t m_prevVelocity{ };
+
+ bool m_sim_record{ };
+ int m_shots{ };
+
+ C_AnimationLayer m_AnimLayers[ 13 ]{ };
+ float m_PoseParameters[ 24 ]{ };
+
+ vec3_t m_vecOrigin{ }, m_vecAngles{ };
+ vec3_t m_vecRenderOrigin{ }, m_vecRenderAngles{ };
+
+ vec3_t m_vecMins{ }, m_vecMaxs{ };
+ vec3_t m_vecHeadPos{ };
+ vec3_t m_vecPelvisPos{ };
+
+ CCSGOPlayerAnimState m_state{ };
+ matrix3x4 m_matrix[ 128 ]{ };
+
+ bool is_valid( );
+
+ lag_record_t( ) : m_tickcount( -1 ), m_valid( false ) { }
+ lag_record_t( c_base_player* ent );
+
+ bool restore( bool recalculate = false, bool reanimate = false );
+
+ bool m_valid{ };
+ };
+
+ struct c_ragebot::render_record_t {
+ matrix3x4 m_matrix[ 128 ]{ };
+ vec3_t m_origin{ };
+ float m_simtime{ };
+ float m_globaltime{ };
+ float m_validtime{ };
+ };
+
+ class c_ragebot::c_lagcomp {
+ public:
+ using lag_deque_t = std::deque< lag_record_t >;
+ using anim_array_t = C_AnimationLayer[ 13 ];
+ using render_deque_t = std::deque< render_record_t >;
+
+
+ lag_record_t* find_best_record( int ent_index );
+ vec3_t get_backtracked_position( int ent_index );
+ lag_deque_t* get_records( int ent_index, RecordType_t type ) {
+ switch( type ) {
+ case RECORD_LBY:
+ return &m_data_lby[ ent_index ];
+ case RECORD_NORMAL:
+ return &m_data_normal[ ent_index ];
+ }
+
+ return nullptr;
+ }
+
+ void store_record( int ent_index, RecordType_t type, const lag_record_t& record ) {
+ auto records = get_records( ent_index, type );
+ if( records ) {
+ records->push_front( record );
+ }
+ }
+
+ void fsn_net_update_start( );
+ void fsn_render_start( );
+ void restore_animations( );
+ void store_visuals( );
+ void invalidate_bone_caches( );
+
+ lag_record_t* get_newest_record( int ent_index );
+ lag_record_t* get_newest_valid_record( int ent_index );
+
+ bool get_render_record( int ent_index, matrix3x4* out );
+
+ void operator()( user_cmd_t* cmd );
+
+ int backtrack_entity( int ent_index, RecordType_t type, lag_record_t** out_record = nullptr );
+ RecordType_t can_backtrack_entity( int ent_index );
+ float get_flick_time( int ent_index ) {
+ return m_flick_time[ ent_index ];
+ }
+
+ float& get_last_updated_simtime( int ent_index ) {
+ return m_last_simtime[ ent_index ];
+ }
+
+ private:
+ float m_last_simtime[ 65 ]{ };
+ float m_flick_time[ 65 ]{ };
+ bool m_first_update[ 65 ]{ };
+ lag_deque_t m_data_lby[ 65 ];
+ lag_deque_t m_data_normal[ 65 ];
+ render_deque_t m_data_render[ 65 ];
+ user_cmd_t* m_cmd;
+ };
+
+ enum BreakingState_t {
+ BREAKING_NONE,
+ BREAKING,
+ BREAKING_LAST,
+ };
+
+ enum OverrideDir_t {
+ OVERRIDE_NONE,
+ OVERRIDE_CENTER,
+ OVERRIDE_LEFT,
+ OVERRIDE_RIGHT,
+ OVERRIDE_LAST
+ };
+
+ class c_ragebot::c_resolver {
+ public:
+ void aimbot( int ent_index, int hitbox, vec3_t angle, vec3_t position, vec3_t min, vec3_t max, float radius );
+ void listener( int ent_index, int shots );
+ void frame_stage_notify( );
+ std::vector< float > get_shot_vec( int ent );
+ float get_shot_yaw( int shots, int ent );
+
+ void force_yaw( c_base_player*, float );
+
+ void brute_force( c_base_player* );
+ int manual_override( c_base_player* );
+ void force_lby( c_base_player* );
+ void on_missed_spread( int ent_index, int shots );
+ int try_freestanding( c_base_player* );
+ void update_player( int i );
+
+ __forceinline bool is_breaking_lby( int ent_index ) {
+ return !!m_data[ ent_index ].m_breaking;
+ }
+
+ __forceinline int get_breaking_state( int ent_index ) {
+ return m_data[ ent_index ].m_breaking;
+ }
+
+ void increment_shots( int ent_index );
+
+ __forceinline int get_shots( int ent_index ) {
+ auto& data = m_data[ ent_index ];
+
+ return data.m_missed_shots;
+ }
+
+ __forceinline bool& yaw_change( int ent_index ) {
+ return m_data[ ent_index ].m_angle_change;
+ }
+
+ protected:
+
+ struct resolve_log_t {
+ //todo: deque to log hits etc
+ void update( int ent_index );
+ void reset( );
+
+ bool m_logged{ };
+ float m_logged_lby{ };
+ int m_breaking{ };
+ float m_last_lby{ };
+ float m_last_moving_lby{ };
+ float m_last_update{ };
+ int m_shots{ };
+ bool m_was_invalid{ };
+ bool m_has_valid_lby{ };
+ int m_last_freestanding{ };
+ int m_overriding{ };
+ int m_missed_shots{ };
+ int m_logged_shots{ };
+ bool m_angle_change{ };
+ vec3_t m_last_pos{ };
+ };
+
+ struct resolve_data_t : public resolve_log_t {
+ std::array< resolve_log_t, 150 > m_snapshot;
+ };
+
+ std::array< resolve_data_t, 65 > m_data;
+ };
+
+}
\ No newline at end of file diff --git a/internal_rewrite/ragebot_antiaim.cpp b/internal_rewrite/ragebot_antiaim.cpp new file mode 100644 index 0000000..8ace9a1 --- /dev/null +++ b/internal_rewrite/ragebot_antiaim.cpp @@ -0,0 +1,793 @@ +#include "ragebot.hpp"
+#include "base_cheat.hpp"
+#include "context.hpp"
+#include "math.hpp"
+#include "input_system.hpp"
+
+namespace features
+{
+ //don't ask
+ /*vec3_t func( vec3_t a1, float a3, float a4, float a5, float a6, float a7, float a8, float a9 ) {
+ int v8; // ebp@0
+ float v9; // xmm6@1
+ float v10; // xmm7_4@1
+ float v11; // xmm2@1
+ float v12; // xmm5@1
+ float v13; // xmm4_4@1
+ float v14 = 0.f; // xmm3_4@1
+ float v15; // xmm1_4@2
+ vec3_t v16; // xmm0@2
+ float v17; // eax@2
+ vec3_t v18; // ecx@2
+ float v20; // xmm1_4@4
+ float v21 = 0.f; // eax@4
+ vec3_t v22; // ecx@4
+ float v23; // eax@5
+ float v24; // [sp-10h] [bp-1Ch]@1
+ vec3_t v25;
+ int v28; // [sp+0h] [bp-Ch]@1
+ int v29; // [sp+4h] [bp-8h]@1
+
+ v12 = a4;
+ v9 = a3;
+ v11 = a5;
+ v10 = a7;
+ v11 = a5 - a8;
+ v12 = a4 - a7;
+
+ v13 = a6 - a9;
+ v24 = a6 - a9;
+
+ v14 = sqrt( v12 * v12 + v11 * v11 + v13 * v13 );
+
+ if( v14 <= v9 ) {
+ if( -v9 <= v14 ) {
+ a1.x = a4;
+ a1.y = a5;
+ a1.z = a6;
+ return a1;
+ }
+ else {
+ vec3_t v25 = { v11, v12, v24 };
+ v20 = 1.0f / ( v12 * v12 + v11 * v11 + v13 * v13 + FLT_EPSILON );
+
+ a7 = v10 - v20 * v12 * v9;
+ a8 = a8 - v25.y * v20 * v9;
+
+ a9 = a9 - v25.z * v20 * v9;
+ v12 = a9;
+
+ v22.x = a7;
+ v22.y = a8;
+ v22.z = a9;
+
+ return v22;
+ }
+ }
+ else {
+ vec3_t v25 = { v11, v12, v24 };
+
+ v15 = 1.0f / ( v12 * v12 + v11 * v11 + v13 * v13 + FLT_EPSILON );
+
+ a7 = v15 * v12 * v9 + v10;
+ a8 = v12 * v15 * v9 + a8;
+
+ v16.x = a7;
+ v16.y = a8;
+
+ a9 = v25.z * v15 * v9 + a9;
+
+ v18.x = a7;
+ v18.y = a8;
+ v18.z = a9;
+
+ return v18;
+ }
+ }*/
+
+
+ void c_ragebot::c_lby_breaker::update_animstate( ) {
+ auto cl = g_csgo.m_global_state->get_client_state( );
+ if( !cl )
+ return;
+
+ if( g_cheat.m_lagmgr.get_choked( ) )
+ return;
+
+ bool moving = g_ctx.m_local->get_animstate( )->m_velocity >= 0.1f && g_ctx.m_local->get_animstate( )->m_bOnGround;
+ float time = g_ctx.pred_time( );
+
+ if( moving ) {
+ m_next_update = time + 0.22f;
+ }
+ else if( time > m_next_update ) {
+ m_next_update = time + 1.1f;
+ }
+
+ if( g_ctx.m_tickbase > 0 ) {
+ //auto& cur_update = m_lby_updates[ g_ctx.m_tickbase % 64 ];
+ //cur_update.m_tickbase = g_ctx.m_tickbase;
+ //cur_update.m_state = m_state;
+ }
+ }
+
+ void c_ragebot::c_lby_breaker::on_lby_proxy( ) {
+ float oldsimtime_1tickfuture = g_ctx.m_local->m_flOldSimulationTime( ) + TICK_INTERVAL( );
+ int oldsimtime_ticks = TIME_TO_TICKS( oldsimtime_1tickfuture );
+
+ float latency = g_csgo.m_engine( )->GetNetChannelInfo( )->GetLatency( 0 ) + g_csgo.m_globals->m_interval_per_tick;
+ for( auto& it : m_lby_updates ) {
+ if( it.m_tickbase == oldsimtime_ticks ) {
+ //if( it.m_state == BS_BREAKING )
+ //m_next_update = oldsimtime_1tickfuture + 1.1f - latency;
+ break;
+
+ }
+ }
+ }
+
+ int c_ragebot::c_lby_breaker::get_next_update( ) const {
+ auto current_tick = TIME_TO_TICKS( g_ctx.pred_time( ) );
+ auto update_tick = TIME_TO_TICKS( m_next_update );
+
+ return update_tick - current_tick;
+ }
+
+ void c_ragebot::c_lby_breaker::override_angles( float* angles, float original, float offset, bool freestanding ) {
+ static bool was_breaking = false;
+ static float last_angle = 0.f;
+ const float angle = original;
+ int update_ticks = get_next_update( );
+
+ if( g_cheat.m_lagmgr.get_state( ) )
+ return;
+
+ if( g_cheat.m_lagmgr.get_choked( ) )
+ return;
+
+ //yep
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ return;
+
+ bool breaking = g_ctx.m_local->get_animstate( )->m_velocity < 0.1f;
+ float break_angle = angle + offset;
+
+ float lby = g_ctx.m_local->m_flLowerBodyYawTarget( );
+ float real = angle;
+ float delta = std::remainderf( lby - real, 360.f );
+
+ if( std::abs( delta ) < 37.f && breaking ) {
+ if( update_ticks < -TIME_TO_TICKS( 1.f ) ) {
+ *angles = break_angle;
+ return;
+ }
+ }
+
+ if( freestanding && g_settings.rage.lby_avoid_updates && was_breaking ) {
+ if( std::abs( std::remainderf( original - last_angle, 360.f ) ) > 50.f
+ && update_ticks < 1 ) {
+ break_angle = last_angle;
+ offset = std::remainderf( original - last_angle, 360.f );
+ }
+ }
+
+ if( std::abs( offset ) < 105 ) {
+ int min_tick = g_cheat.m_ragebot.m_antiaim->is_fakewalking( ) ? g_settings.rage.fakewalk_ticks( ) + 1 : 3;
+ if( update_ticks < min_tick && update_ticks >= 2 ) {
+ *angles = break_angle + ( offset < 0 ? 105 : -105 );
+ //g_ctx.m_thirdperson_angle.y = *angles;
+ return;
+ }
+ }
+
+ if( breaking && update_ticks < 3 ) {
+ *angles = break_angle;
+ if( !freestanding ) {
+ last_angle = break_angle;
+ was_breaking = true;
+ }
+ }
+
+ //g_ctx.m_thirdperson_angle.y = *angles;
+ }
+
+ void c_ragebot::c_antiaim::fix_movement( ) {
+ if( !g_settings.rage.anti_aim && !g_settings.rage.enabled )
+ return;
+
+ float pitch = std::remainderf( m_cmd->m_viewangles.x, 360.f );
+ bool fix_forward_move = ( pitch < -90.f || pitch > 90.f );
+
+ auto last_cmd = g_ctx.get_last_cmd( );
+ auto old_yaw = last_cmd->m_viewangles.y;
+ auto cur_yaw = m_cmd->m_viewangles.y;
+
+ float yaw_delta = cur_yaw - old_yaw;
+
+ float f1 = old_yaw < 0.f ? old_yaw + 360.f : old_yaw;
+ float f2 = cur_yaw < 0.f ? cur_yaw + 360.f : cur_yaw;
+
+ if( f2 < f1 )
+ yaw_delta = abs( f2 - f1 );
+ else
+ yaw_delta = 360.f - abs( f1 - f2 );
+ yaw_delta = 360.f - yaw_delta;
+
+ m_cmd->m_forwardmove = cos( yaw_delta * M_PIRAD ) * last_cmd->m_forwardmove + cos( ( yaw_delta + 90.f ) * M_PIRAD ) * last_cmd->m_sidemove;
+ m_cmd->m_sidemove = sin( yaw_delta * M_PIRAD ) * last_cmd->m_forwardmove + sin( ( yaw_delta + 90.f ) * M_PIRAD ) * last_cmd->m_sidemove;
+
+ if( fix_forward_move )
+ m_cmd->m_forwardmove *= -1.f;
+
+ if( g_ctx.m_local->m_nMoveType( ) != MOVETYPE_LADDER ) {
+ if( m_cmd->m_forwardmove ) {
+ m_cmd->m_buttons &= ~( m_cmd->m_forwardmove < 0 ? IN_FORWARD : IN_BACK );
+ m_cmd->m_buttons |= ( m_cmd->m_forwardmove > 0 ? IN_FORWARD : IN_BACK );
+ }
+ if( m_cmd->m_sidemove ) {
+ m_cmd->m_buttons &= ~( m_cmd->m_sidemove < 0 ? IN_MOVERIGHT : IN_MOVELEFT );
+ m_cmd->m_buttons |= ( m_cmd->m_sidemove > 0 ? IN_MOVERIGHT : IN_MOVELEFT );
+ }
+ }
+ }
+
+ bool c_ragebot::c_antiaim::run_edge_dtc( ) {
+ if( !g_settings.rage.edge_dtc_normal )
+ return false;
+
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ return false;
+
+ if( g_settings.rage.edge_dtc_normal == 1 ) {
+ float speed = g_ctx.m_local->m_vecVelocity( ).length2d( );
+ if( speed < 30.f ) return false;
+ }
+
+ bool peeking = g_ctx.m_local->m_vecVelocity( ).length( ) > 30.f;
+ if( is_fakewalking( ) ) peeking = false;
+ CTraceFilterWorldAndPropsOnly filter;
+
+ float max_dist = peeking ? g_settings.rage.edge_dtc_moving : g_settings.rage.edge_dtc_standing;
+ float min_dist = 64.f;
+ float edge_yaw = 0.f;
+ float final_yaw = 0.f;
+ bool detected = false;
+
+ const float step = 45.f;
+ vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
+
+ for( float rot = -180.f; rot < 180.f; rot += step ) {
+ float rot_left = rot - 90.f;
+ float rot_right = rot + 90.f;
+
+ vec3_t pos_left = math::get_rotated_pos( eye_pos, rot_left, 30.f );
+ vec3_t pos_right = math::get_rotated_pos( eye_pos, rot_right, 30.f );
+
+ vec3_t forward = math::angle_vectors( vec3_t( 0.f, rot, 0.f ) );
+ forward *= 4000.f;
+
+ CGameTrace trace_left, trace_right;
+ Ray_t ray_left, ray_right;
+
+ ray_left.Init( pos_left, pos_left + forward );
+ ray_right.Init( pos_right, pos_right + forward );
+
+ g_csgo.m_trace( )->TraceRay( ray_left, MASK_SHOT_HULL, &filter, &trace_left );
+ g_csgo.m_trace( )->TraceRay( ray_right, MASK_SHOT_HULL, &filter, &trace_right );
+
+ float dist_left = ( pos_left - trace_left.endpos ).length( );
+ float dist_right = ( pos_right - trace_right.endpos ).length( );
+
+ if( dist_right > dist_left ) {
+ if( dist_right > max_dist && dist_left < min_dist ) {
+ max_dist = dist_right;
+ edge_yaw = rot_left;
+ detected = true;
+ }
+ }
+ else {
+ if( dist_left > max_dist && dist_right < min_dist ) {
+ max_dist = dist_left;
+ edge_yaw = rot_right;
+ detected = true;
+ }
+ }
+ }
+
+ if( !detected )
+ return false;
+
+ final_yaw = edge_yaw;
+ if( g_cheat.m_lagmgr.get_state( ) ) {
+ final_yaw = edge_yaw + 180.f;
+ }
+
+ m_cmd->m_viewangles.y = final_yaw;
+ return true;
+ }
+
+ float get_damage( const vec3_t& start, const vec3_t& end, c_base_player* a, c_base_player* b ) {
+ static weapon_info_t wpn_data{ };
+ wpn_data.damage = 200;
+ wpn_data.range_modifier = 1.0f;
+ wpn_data.penetration = 3.0f;
+ wpn_data.armor_ratio = 0.5f;
+ wpn_data.range = 8192.f;
+
+ fire_bullet_data_t data{ };
+ data.src = start;
+ data.filter.pSkip = a;
+ data.length_to_end = ( end - start ).length( );
+
+ vec3_t angle = math::vector_angles( start, end );
+ data.direction = math::angle_vectors( angle );
+
+ data.direction.normalize_vector( );
+
+ if( g_cheat.m_autowall.fire_bullet( a, b, &wpn_data, data, false, false ) ) {
+ return data.current_damage;
+ }
+
+ return -1.f;
+ }
+
+ vec3_t trace_ent_pos( vec3_t start, vec3_t end, c_base_player* ent ) {
+ Ray_t ray;
+ CGameTrace tr;
+ CTraceFilter filter;
+
+ const vec3_t min( -2.f, -2.f, -2.f );
+ const vec3_t max( 2.f, 2.f, 2.f );
+
+ ray.Init( start, end, min, max );
+ filter.pSkip = ent;
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &tr );
+
+ return tr.endpos;
+ }
+
+ bool c_ragebot::c_antiaim::run_freestanding( int player ) {
+ if( !g_settings.rage.edge_detection )
+ return false;
+
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ return false;
+
+ bool is_fake = g_cheat.m_lagmgr.get_state( );
+ vec3_t enemy_pos;
+ vec3_t local_pos;
+
+ vec3_t aim_angle;
+
+ float cur_damage{ 30.f };
+ bool direction{ false };
+ int enemy_index;
+
+ enemy_index = player == -1 ? util::get_closest_player( ) : player;
+
+ if( enemy_index == -1 )
+ return false;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( enemy_index );
+
+ if( !ent || !ent->is_valid( ) )
+ return false;
+
+ enemy_pos = ent->m_vecOrigin( );
+ enemy_pos.z = ent->get_hitbox_pos( 0 ).z;
+
+ local_pos = g_ctx.m_local->get_eye_pos( );
+ aim_angle = math::vector_angles( enemy_pos, local_pos );
+
+ float dist = ( float )( g_settings.rage.freestanding_distance( ) );
+
+ float start_dmg = get_damage( enemy_pos, local_pos, ent, g_ctx.m_local );
+
+ auto test_dmg = [ & ]( float dist ) {
+ vec3_t enemy_left = math::get_rotated_pos( enemy_pos, aim_angle.y - 90.f, dist );
+ vec3_t enemy_right = math::get_rotated_pos( enemy_pos, aim_angle.y + 90.f, dist );
+
+ enemy_left = trace_ent_pos( enemy_pos, enemy_left, ent );
+ enemy_right = trace_ent_pos( enemy_pos, enemy_right, ent );
+
+ vec3_t local_left = math::get_rotated_pos( local_pos, aim_angle.y + 90.f, dist );
+ vec3_t local_right = math::get_rotated_pos( local_pos, aim_angle.y - 90.f, dist );
+
+ local_left = trace_ent_pos( local_pos, local_left, g_ctx.m_local );
+ local_right = trace_ent_pos( local_pos, local_right, g_ctx.m_local );
+
+ float dmg_left = get_damage( enemy_left, local_left, ent, g_ctx.m_local )
+ + get_damage( enemy_right, local_left, ent, g_ctx.m_local );
+
+ float dmg_right = get_damage( enemy_left, local_right, ent, g_ctx.m_local )
+ + get_damage( enemy_right, local_right, ent, g_ctx.m_local );
+
+ if( std::abs( dmg_left - dmg_right ) < 50.f )
+ return false;
+
+ float max_dmg = math::max( dmg_left, dmg_right );
+ direction = dmg_left > dmg_right;
+
+ cur_damage = max_dmg;
+ return max_dmg > 50.f;
+ };
+
+ if( !test_dmg( 20.f ) ) {
+ if( cur_damage < start_dmg * 2.f )
+ return false;
+ }
+
+ if( !test_dmg( dist ) )
+ return false;
+
+ m_direction = direction;
+ aim_angle.y += direction ? -90.f : 90.f;
+ aim_angle.y = math::find_closest_step( aim_angle.y, 30.f );
+
+ if( g_settings.rage.pitch == 3 && g_settings.rage.break_lby_edge && m_breaker.get_next_update( ) < 2 && g_ctx.m_local->get_animstate( )->m_velocity < 0.1f ) {
+ vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
+ vec3_t rotated_pos = math::get_rotated_pos( eye_pos, aim_angle.y - 180.f, 25.f );
+
+ vec3_t velocity = g_ctx.m_local->m_vecVelocity( );
+
+ vec3_t middle_pos = eye_pos + velocity * TICK_INTERVAL( ) * 2.f;
+ middle_pos.z += 10.f;
+
+ int dmg_rot = get_damage( enemy_pos, rotated_pos, ent, g_ctx.m_local );
+ int dmg_mid = get_damage( enemy_pos, middle_pos, ent, g_ctx.m_local );
+
+ if( dmg_mid < dmg_rot )
+ m_cmd->m_viewangles.x = 0.f;
+ }
+
+ if( is_fake ) {
+ int jitter = g_settings.rage.edge_dtc_jitter;
+ if( jitter ) {
+ aim_angle.y += math::random_number< float >( -jitter, jitter );
+ }
+ aim_angle.y -= 180.f;
+ }
+
+ m_cmd->m_viewangles.y = aim_angle.clamp( ).y;
+ return true;
+ }
+
+ void c_ragebot::c_antiaim::run_fakewalk( ) {
+ m_is_fakewalking = false;
+ if( !g_ctx.m_local->get_weapon( ) )
+ return;
+
+ bool in_move = !( m_cmd->m_buttons & IN_FORWARD ) && !( m_cmd->m_buttons & IN_BACK ) && !( m_cmd->m_buttons & IN_LEFT ) && !( m_cmd->m_buttons & IN_RIGHT );
+
+ if( !m_cmd->m_sidemove && !m_cmd->m_forwardmove && !g_ctx.m_local->m_vecVelocity( ) && !in_move )
+ return;
+
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) )
+ return;
+
+ if( m_cmd->m_buttons & IN_WALK ) {
+ m_cmd->m_buttons &= ~IN_WALK;
+ }
+
+ if( m_cmd->m_buttons & IN_SPEED ) {
+ m_cmd->m_buttons &= ~IN_SPEED;
+ }
+
+ m_is_fakewalking = true;
+
+ auto velocity = g_ctx.m_local->m_vecVelocity( );
+
+ static auto predict_velocity = [ ]( vec3_t* velocity ) {
+ static auto sv_friction = g_csgo.m_cvar( )->FindVar( xors( "sv_friction" ) );
+ static auto sv_stopspeed = g_csgo.m_cvar( )->FindVar( xors( "sv_stopspeed" ) );
+
+ float speed = velocity->length( );
+ if( speed >= 0.1f ) {
+ float friction = sv_friction->get_float( );
+ float stop_speed = std::max< float >( speed, sv_stopspeed->get_float( ) );
+ float time = std::max< float >( g_csgo.m_globals->m_interval_per_tick, g_csgo.m_globals->m_frametime );
+ *velocity *= std::max< float >( 0.f, speed - friction * stop_speed * time / speed );
+ }
+ };
+
+ static auto quick_stop = [ & ]( ) {
+ vec3_t vel = g_ctx.m_local->m_vecVelocity( );
+ float speed = vel.length2d( );
+
+ if( speed < 1.f ) {
+ g_ctx.get_last_cmd( )->m_forwardmove = 0.f;
+ g_ctx.get_last_cmd( )->m_sidemove = 0.f;
+ return;
+ }
+
+ static auto sv_accelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_accelerate" ) );
+ float accel = sv_accelerate->get_float( );
+ float max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed;
+ if( g_ctx.m_local->get_weapon( )->is_sniper( ) && g_ctx.m_local->m_bIsScoped( ) ) {
+ max_speed = g_ctx.m_local->get_weapon( )->get_wpn_info( )->max_speed_alt;
+ }
+
+ if( g_ctx.m_local->m_fFlags( ) & FL_DUCKING ) {
+ max_speed /= 3.f;
+ accel /= 3.f;
+ }
+
+ float surf_friction = 1.f;
+ float max_accelspeed = accel * g_csgo.m_globals->m_interval_per_tick * max_speed * surf_friction;
+
+ float wishspeed{ };
+
+ if( speed - max_accelspeed <= -1.f ) {
+ wishspeed = max_accelspeed / ( speed / ( accel * g_csgo.m_globals->m_interval_per_tick ) );
+ }
+ else {
+ wishspeed = max_accelspeed;
+ }
+
+ vec3_t ndir = math::vector_angles( vel * -1.f );
+ ndir.y = m_cmd->m_viewangles.y - ndir.y;
+ ndir = math::angle_vectors( ndir );
+
+ g_ctx.get_last_cmd( )->m_forwardmove = ndir.x * wishspeed;
+ g_ctx.get_last_cmd( )->m_sidemove = ndir.y * wishspeed;
+ };
+
+ //int ticks_to_update = g_settings.rage.break_lby( ) ? m_breaker.get_next_update( ) - 1 : g_settings.rage.fakewalk_ticks;
+
+ int ticks_to_stop;
+ for( ticks_to_stop = 0; ticks_to_stop < 15; ++ticks_to_stop ) {
+ if( velocity.length2d( ) < 0.1f )
+ break;
+
+ predict_velocity( &velocity );
+ }
+
+ // Doesn't this output some fucked up value for weapons other than the revolver?
+ float time_to_shoot = g_ctx.m_local->get_weapon( )->m_flPostponeFireReadyTime( ) - g_ctx.pred_time( );
+ int revolver_ticks = TIME_TO_TICKS( time_to_shoot ) - 1;
+ if( revolver_ticks < -1 )
+ revolver_ticks = INT_MAX;
+
+ int update_ticks = m_breaker.get_next_update( ) - 1;
+
+ const int max_ticks = math::min< int >( g_settings.rage.fakewalk_ticks, update_ticks, revolver_ticks );
+ const int choked = g_cheat.m_lagmgr.get_choked( );
+ int ticks_left = max_ticks - choked;
+
+ if( choked < max_ticks || ticks_to_stop ) {
+ g_cheat.m_lagmgr.set_state( false );
+ }
+
+ if( !g_ctx.m_local->m_vecVelocity( ).length2d( ) && !g_cheat.m_lagmgr.get_sent( ) && choked > max_ticks ) {
+ g_cheat.m_lagmgr.set_state( true );
+ }
+
+ if( ticks_to_stop > ticks_left - 1 || !choked ) {
+ quick_stop( );
+ }
+ }
+
+ float c_ragebot::c_antiaim::get_pitch( ) {
+ switch( g_settings.rage.pitch( ) ) {
+ case 1: //custom
+ return float( g_settings.rage.pitch_offset( ) );
+ case 2: //flip
+ return g_cheat.m_lagmgr.get_state( ) ? 75.f : 89.f;
+ case 3:
+ return 89.f;
+ // These won't work the way you want them to, better to make a slider
+ // for the amount of revolutions or something, idk.
+ case 4:
+ return 1080.f + g_settings.rage.pitch_offset( );
+ case 5:
+ return -1080.f + g_settings.rage.pitch_offset( );
+ case 6:
+ return m_cmd->m_cmd_nr % 2 ? 1080.f : -1080.f;
+ case 7: //random
+ return math::random_number( -89.f, 89.f );
+ }
+
+ return 0.f;
+ }
+
+ float c_ragebot::c_antiaim::get_yaw( bool fake, float original, bool no_jitter ) {
+ constexpr static double rate = 360.0 / 1.618033988749895;
+ constexpr static int switch_rate = 10;
+ static float last_onground = 0.f;
+ static int ticks = 0;
+ static bool side_switch = false;
+ bool on_ground = false;
+
+ int setting = fake ? g_settings.rage.fake_yaw : g_settings.rage.real_yaw;
+ int jitter = fake ? g_settings.rage.fake_yaw_jitter : g_settings.rage.real_yaw_jitter;
+ int add = fake ? g_settings.rage.fake_yaw_add : g_settings.rage.real_yaw_add;
+ if( !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) {
+ if( !fake && g_settings.rage.air_yaw( ) ) {
+ setting = g_settings.rage.air_yaw;
+ jitter = g_settings.rage.air_yaw_jitter;
+ add = g_settings.rage.air_yaw_add;
+ }
+ }
+ else if( g_ctx.m_local->m_vecVelocity( ).length( ) > 0.1f && !is_fakewalking( ) ) {
+ if( !fake && g_settings.rage.real_yaw_moving( ) ) {
+ setting = g_settings.rage.real_yaw_moving( );
+ jitter = g_settings.rage.real_moving_jitter( );
+ add = g_settings.rage.real_yaw_moving_add( );
+ }
+ }
+
+ if( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) {
+ last_onground = g_ctx.pred_time( );
+ on_ground = true;
+ }
+
+ ticks++;
+ if( ticks > switch_rate ) {
+ side_switch ^= 1;
+ ticks = 0;
+ }
+
+ float rand = 0.f;
+ if( setting && jitter && !no_jitter ) {
+ rand = math::random_number( -float( jitter ), float( jitter ) );
+ }
+
+ if( setting && add ) {
+ original += add;
+ }
+
+ switch( setting ) {
+ case 0:
+ return g_csgo.m_engine( )->GetViewAngles( ).y;
+ case 1: //back
+ return original - 180.f + rand;
+ case 2: {//back spin
+ float time = on_ground ? g_csgo.m_globals->m_curtime * 0.5f : ( g_csgo.m_globals->m_curtime - last_onground );
+ float range = on_ground ? jitter : jitter * 2.f;
+ return original - 180.f - range * 0.5f + ( no_jitter ? range : std::fmod( time * rate, range + 1.f ) );
+ }
+ case 3: //sideways
+ return rand + ( fake ? ( side_switch ? original + 90.f : original - 90.f ) :
+ ( side_switch ? original - 90.f : original + 90.f ) );
+ case 4: //slowpin lol
+ return rand + std::fmod( g_csgo.m_globals->m_curtime * rate, 360.f );
+ case 5: //random
+ return math::random_number( -180.f, 180.f );
+ case 6: //direction
+ return rand + ( fake ? ( m_direction ? original - 90.f : original + 90.f ) :
+ ( m_direction ? original + 90.f : original - 90.f ) );
+ case 7:
+ return original - 180.f + ( no_jitter ? 0 : ( side_switch ? -jitter : jitter ) );
+ }
+
+ return original;
+ }
+
+ float c_ragebot::c_antiaim::get_yaw( bool no_jitter ) {
+ const auto is_fake = g_cheat.m_lagmgr.get_state( );
+ auto original = g_ctx.get_last_cmd( )->m_viewangles.y;
+
+ if( g_settings.rage.at_players ) {
+ auto closest_ent = util::get_closest_player( );
+ if( closest_ent != -1 ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( closest_ent );
+ if( ent ) {
+ vec3_t ang = math::vector_angles( g_ctx.m_local->m_vecOrigin( ),
+ ent->m_vecOrigin( ) );
+
+ original = ang.y;
+ }
+ }
+ }
+
+ if( is_fake && !g_settings.rage.fake_yaw( ) )
+ return original;
+ if( !is_fake && !g_settings.rage.real_yaw( ) )
+ return original;
+
+ if( g_settings.rage.angle_step( ) && g_settings.rage.angle_step_degrees( ) ) {
+ float step = float( g_settings.rage.angle_step_degrees( ) );
+ original = math::find_closest_step( original, step );
+ }
+ return get_yaw( is_fake, original, no_jitter );
+ }
+
+ void c_ragebot::c_antiaim::run( ) {
+ m_is_edging = false;
+ if( !g_settings.rage.anti_aim( ) )
+ return;
+
+ auto is_everyone_dormant = [ ]( ) {
+ for( int i{ 1 }; i < g_csgo.m_globals->m_maxclients; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+ if( ent && ent->is_valid( ) &&
+ ( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( )
+ || g_settings.rage.friendlies ) ) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ if( ( m_cmd->m_forwardmove || m_cmd->m_sidemove ) &&
+ ( g_ctx.m_local->m_nMoveType( ) == MOVETYPE_LADDER ||
+ g_ctx.m_local->m_nMoveType( ) == MOVETYPE_NOCLIP ) )
+ return;
+
+ if( g_ctx.m_local->m_fFlags( ) & FL_FROZEN )
+ return;
+
+ if( is_everyone_dormant( ) && g_settings.rage.dormant_check )
+ return;
+
+ if( g_settings.rage.fakewalk( ) && g_input.is_key_pressed( g_settings.rage.fakewalk_key( ) ) ) {
+ run_fakewalk( );
+ }
+ else {
+ m_is_fakewalking = false;
+ }
+
+ if( ( m_cmd->m_buttons & IN_ATTACK ) && g_ctx.m_local->can_attack( ) )
+ return;
+
+ if( *( bool* )( c_base_player::get_game_rules( ) + 0x20 ) )
+ return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( weapon && weapon->is_grenade( ) ) {
+ if( weapon->m_fThrowTime( ) > g_csgo.m_globals->m_interval_per_tick ) {
+ return;
+ }
+ }
+
+ if( ( m_cmd->m_buttons & IN_ATTACK2 ) && weapon->is_knife( ) && g_ctx.m_local->can_attack( ) )
+ return;
+
+ if( m_cmd->m_buttons & IN_USE )
+ return;
+
+ if( g_settings.rage.real_yaw( ) ||
+ g_settings.rage.fake_yaw( ) ) {
+ m_cmd->m_viewangles.y = get_yaw( );
+ }
+
+ if( g_settings.rage.pitch( ) ) {
+ m_cmd->m_viewangles.x = get_pitch( );
+ }
+
+ bool edge_detected = false;
+ bool freestanding = false;
+
+ if( !g_settings.rage.edge_dtc_priority ) {
+ freestanding = run_freestanding( );
+ if( !freestanding )
+ edge_detected = run_edge_dtc( );
+ }
+ else {
+ edge_detected = run_edge_dtc( );
+ if( !edge_detected )
+ freestanding = run_freestanding( );
+ }
+
+ m_is_edging = freestanding || edge_detected;
+
+ if( g_settings.rage.break_lby( ) && ( !m_is_edging || g_settings.rage.break_lby_edge ) ) {
+ float yaw = m_is_edging ? m_cmd->m_viewangles.y : get_yaw( true );
+
+ m_breaker.override_angles( &m_cmd->m_viewangles.y,
+ yaw,
+ std::remainderf( 180.f - float( g_settings.rage.lby_delta ), 360.f ),
+ freestanding );
+ }
+
+ if( g_cheat.m_lagmgr.get_state( ) && !g_settings.rage.fake_yaw( ) )
+ m_cmd->m_viewangles.y = g_csgo.m_engine( )->GetViewAngles( ).y;
+
+ //since we're going to have fake pitches most likely
+ //make sure to clamp yaw anyway just in case some retard
+ //decides to enable untrusted shit in an mm server or w/e
+ m_cmd->m_viewangles.y = std::remainderf( m_cmd->m_viewangles.y, 360.f );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ragebot_lagcomp.cpp b/internal_rewrite/ragebot_lagcomp.cpp new file mode 100644 index 0000000..f19828f --- /dev/null +++ b/internal_rewrite/ragebot_lagcomp.cpp @@ -0,0 +1,645 @@ +#include "ragebot.hpp"
+#include "interface.hpp"
+#include "settings.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+#include "mem.hpp"
+#include "hooks.hpp"
+
+namespace features
+{
+ c_ragebot::lag_record_t::lag_record_t( c_base_player* ent ) : m_ent( ent ) {
+ if( !m_ent || !m_ent->is_valid( ) ) return;
+ m_valid = true;
+
+ m_flSimulationTime = m_ent->m_flSimulationTime( );
+ m_flOldSimulationTime = m_ent->m_flOldSimulationTime( );
+ m_tickcount = TIME_TO_TICKS( m_flSimulationTime + util::get_lerptime( ) );
+ m_choked = m_ent->get_choked_ticks( );
+
+ m_flLowerBodyYawTarget = m_ent->m_flLowerBodyYawTarget( );
+ m_flCycle = m_ent->m_flCycle( );
+ m_fFlags = m_ent->m_fFlags( );
+ m_animDuck = m_ent->get_animdata( ).m_last_duck;
+ m_animVelocity = m_ent->get_animdata( ).m_anim_velocity;
+ m_prevVelocity = m_ent->get_animdata( ).m_last_velocity;
+ m_flDuckSpeed = m_ent->m_flDuckSpeed( );
+ m_flDuckAmount = m_ent->m_flDuckAmount( );
+
+ m_vecHeadPos = ent->get_hitbox_pos( 0 );
+ m_vecPelvisPos = ent->get_hitbox_pos( HITBOX_PELVIS );
+
+ //we need mins/maxs because traces check them before checking if it hit a player
+ m_vecMins = *( vec3_t* )( uintptr_t( m_ent ) + 0x318 + 0x8 );
+ m_vecMaxs = *( vec3_t* )( uintptr_t( m_ent ) + 0x318 + 0x14 );
+
+ m_vecOrigin = m_ent->m_vecOrigin( );
+ m_vecAngles = m_ent->m_angEyeAngles( );
+ m_vecRenderAngles = m_ent->ce( )->GetRenderAngles( );
+ m_vecRenderOrigin = m_ent->ce( )->GetRenderOrigin( );
+
+ memcpy( &m_state,
+ m_ent->get_animstate( ),
+ sizeof( CCSGOPlayerAnimState ) );
+
+ memcpy( m_PoseParameters,
+ m_ent->m_flPoseParameter( ),
+ sizeof( float ) * 24 );
+
+ memcpy( m_AnimLayers,
+ m_ent->m_AnimOverlay( ).GetElements( ),
+ sizeof( C_AnimationLayer ) * 13 );
+
+ for( int i{ }; i < 13; ++i )
+ m_ent->m_AnimOverlay( ).GetElements( )[ i ].m_player = ent;
+
+ m_valid = m_ent->ce( )->SetupBones( m_matrix, 128, BONE_USED_BY_HITBOX, m_flSimulationTime );
+ }
+
+ bool c_ragebot::lag_record_t::restore( bool recalculate, bool reanimate ) {
+ if( !m_ent || !m_ent->is_valid( ) ) return false;
+
+ *( vec3_t* )( uintptr_t( m_ent ) + 0x318 + 0x8 ) = m_vecMins;
+ *( vec3_t* )( uintptr_t( m_ent ) + 0x318 + 0x14 ) = m_vecMaxs;
+
+ memcpy( ( void* )( m_ent->m_CachedBoneData( ).GetElements( ) ),
+ m_matrix,
+ sizeof( matrix3x4 ) * m_ent->m_CachedBoneData( ).GetSize( ) );
+
+ if( !recalculate ) {
+ return true;
+ }
+
+ m_ent->set_abs_angles( m_vecRenderAngles );
+
+ //m_ent->m_flDuckAmount( ) = m_flDuckAmount;
+ m_ent->m_flLowerBodyYawTarget( ) = m_flLowerBodyYawTarget;
+ m_ent->m_fFlags( ) = m_fFlags;
+ m_ent->m_flSimulationTime( ) = m_flSimulationTime;
+
+ memcpy( m_ent->m_flPoseParameter( ),
+ m_PoseParameters,
+ sizeof( float ) * 24 );
+
+ memcpy( m_ent->m_AnimOverlay( ).GetElements( ),
+ m_AnimLayers,
+ sizeof( C_AnimationLayer ) * 13 );
+
+ //why?
+ //why not?
+ if( reanimate ) {
+ vec3_t velocity = m_ent->m_vecVelocity( );
+ int backup_eflags = m_ent->get< int >( 0xe4 );
+ int backup_byte = m_ent->get< byte >( 0x35f8 );
+
+ m_ent->m_vecVelocity( ) = m_animVelocity;
+ m_ent->get< vec3_t >( 0x94 ) = m_animVelocity;
+ m_ent->get< byte >( 0x35f8 ) = 1;
+ m_ent->get< int >( 0xe4 ) &= ~0x1000;
+
+ m_state.m_flFeetYawRate = 0.f;
+
+ float backup_curtime = g_csgo.m_globals->m_curtime;
+ float backup_frametime = g_csgo.m_globals->m_frametime;
+
+ g_csgo.m_globals->m_curtime = m_flOldSimulationTime + TICK_INTERVAL( );
+ g_csgo.m_globals->m_frametime = TICK_INTERVAL( );
+
+ m_state.m_iLastClientSideAnimationUpdateFramecount -= 1;
+
+ g_cheat.m_ragebot.m_resolver->brute_force( m_ent );
+
+ float lby_delta = m_flLowerBodyYawTarget - m_ent->m_angEyeAngles( ).y;
+ lby_delta = std::remainderf( lby_delta, 360.f );
+ lby_delta = std::clamp( lby_delta, -60.f, 60.f );
+
+ float feet_yaw = std::remainderf( m_ent->m_angEyeAngles( ).y + lby_delta, 360.f );
+ if( feet_yaw < 0.f )
+ feet_yaw += 360.f;
+
+ m_state.m_flGoalFeetYaw = m_state.m_flCurrentFeetYaw = feet_yaw;
+
+ m_ent->m_flPoseParameter( )[ BODY_YAW ] = std::clamp( ( lby_delta + 180.f ) / 360.f, 0.f, 1.f );
+ m_ent->m_flPoseParameter( )[ LEAN_YAW ] = std::clamp( ( lby_delta + 180.f ) / 360.f, 0.f, 1.f );
+
+ float backup_duck = m_ent->m_flDuckAmount( );
+ float backup_duckspeed = m_ent->m_flDuckSpeed( );
+
+ m_ent->m_flDuckSpeed( ) = m_flDuckSpeed;
+ m_ent->m_flDuckAmount( ) = m_animDuck;
+
+ m_state.m_flLastClientSideAnimationUpdateTime = m_flOldSimulationTime;
+ m_state.update( m_ent->m_angEyeAngles( ).y, m_ent->m_angEyeAngles( ).x );
+
+ m_ent->m_flDuckAmount( ) = backup_duck;
+ m_ent->m_flDuckSpeed( ) = backup_duckspeed;
+
+ g_csgo.m_globals->m_curtime = backup_curtime;
+ g_csgo.m_globals->m_frametime = backup_frametime;
+
+ m_ent->m_vecVelocity( ) = velocity;
+ m_ent->get< vec3_t >( 0x94 ) = velocity;
+ m_ent->get< byte >( 0x35f8 ) = backup_byte;
+ m_ent->get< int >( 0xe4 ) = backup_eflags;
+ }
+
+ m_ent->set_abs_origin( m_vecRenderOrigin );
+
+ byte backup = m_ent->get< byte >( 0x270 );
+
+ m_ent->get< byte >( 0x270 ) = 0;
+ m_ent->invalidate_bone_cache( );
+ bool ret = m_ent->ce( )->SetupBones( m_matrix, 128, BONE_USED_BY_HITBOX, m_flSimulationTime + TICK_INTERVAL( ) );
+
+ m_ent->get< byte >( 0x270 ) = backup;
+
+ return ret;
+ }
+
+ bool c_ragebot::lag_record_t::is_valid( ) {
+ if( !m_valid ) return false;
+
+ return util::is_tick_valid( m_tickcount );
+ }
+
+ void c_ragebot::c_lagcomp::restore_animations( ) {
+ if( g_csgo.m_engine( )->IsInGame( ) ) {
+ if( g_ctx.m_local ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( ent && ent->is_player( ) ) {
+ ent->set_needs_interpolate( true );
+ ent->invalidate_bone_cache( );
+ ent->ce( )->SetupBones( nullptr, -1, BONE_USED_BY_ANYTHING, 0.f );
+
+ ent->m_bClientSideAnimation( ) = true;
+ }
+ }
+ }
+ }
+ }
+
+ void c_ragebot::c_lagcomp::store_visuals( ) {
+ if( g_csgo.m_engine( )->IsInGame( ) ) {
+ static float last_simtime[ 65 ]{ };
+
+ if( g_ctx.m_local && g_ctx.m_local->is_valid( ) ) {
+ for( int i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+ auto& data = m_data_render[ i ];
+
+ if( ent == g_ctx.m_local )
+ continue;
+
+ if( ent && ent->is_valid( ) && !ent->m_bGunGameImmunity( ) &&
+ !!std::abs( last_simtime[ i ] - ent->m_flSimulationTime( ) ) ) {
+ render_record_t new_record;
+ new_record.m_simtime = ent->m_flSimulationTime( ) + util::get_lerptime( );
+ new_record.m_origin = ent->m_vecOrigin( );
+
+ float delta = ent->m_flSimulationTime( ) - ent->m_flOldSimulationTime( );
+ new_record.m_globaltime = g_csgo.m_globals->m_curtime;
+
+ if( g_settings.legit.enabled( ) )
+ new_record.m_globaltime -= util::get_lerptime( );
+ else
+ new_record.m_globaltime -= TICK_INTERVAL( );
+
+ if( ent->ce( )->SetupBones( new_record.m_matrix, 128, BONE_USED_BY_ANYTHING, 0.f ) ) {
+ data.push_front( new_record );
+ }
+
+ last_simtime[ i ] = ent->m_flSimulationTime( );
+ }
+
+ while( !data.empty( ) &&
+ data.size( ) > TIME_TO_TICKS( 1.f ) ) {
+ data.pop_back( );
+ }
+ }
+ }
+ }
+ }
+
+ bool c_ragebot::c_lagcomp::get_render_record( int ent_index, matrix3x4* out ) {
+ auto& data = m_data_render[ ent_index ];
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+
+ auto is_time_valid = [ & ]( float time ) -> bool {
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( !nci ) return false;
+
+ float latency = util::get_total_latency( );
+ float correct = std::clamp( latency + util::get_lerptime( ), 0.f, 1.f );
+ float delta = correct - ( g_csgo.m_globals->m_curtime - time );
+
+ return std::abs( delta ) <= 0.2f;
+ };
+
+ for( auto it = data.rbegin( ); it != data.rend( ) && ( it + 1 ) != data.rend( ); it++ ) {
+ if( is_time_valid( it->m_globaltime ) ) {
+ if( it->m_origin.dist_to( ent->m_vecOrigin( ) ) < 1.f )
+ return false;
+
+ if( ent->is_breaking_lc( ) )
+ return false;
+
+ if( !it->m_validtime )
+ it->m_validtime = g_csgo.m_globals->m_curtime;
+
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ float latency = util::get_total_latency( );
+ float correct = latency + util::get_lerptime( );
+
+ float deadtime = it->m_globaltime + correct + 0.2f;
+ float totaltime = deadtime - it->m_validtime;
+
+ float curtime = g_csgo.m_globals->m_curtime;
+ float delta = ( 0.2f + correct - ( curtime - it->m_globaltime ) ) / totaltime;
+
+ vec3_t next = ( it + 1 )->m_origin;
+ vec3_t lerp = math::lerp( it->m_origin, next, std::clamp( 1.f - delta, 0.f, 1.f ) );
+
+ matrix3x4 ret[ 128 ];
+
+ util::memcpy( ret,
+ it->m_matrix,
+ sizeof( ret ) );
+
+ for( size_t i{ }; i < 128; ++i ) {
+ vec3_t matrix_delta = math::get_matrix_position( it->m_matrix[ i ] ) - it->m_origin;
+ math::set_matrix_position( matrix_delta + lerp, ret[ i ] );
+ }
+
+ util::memcpy( out,
+ ret,
+ sizeof( ret ) );
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ void c_ragebot::c_lagcomp::fsn_net_update_start( ) {
+ static bool restored = true;
+
+ if( !g_settings.rage.enabled( ) ) {
+ if( !restored ) {
+ restore_animations( );
+ restored = true;
+ }
+
+ return;
+ }
+
+ restored = false;
+ if( g_csgo.m_engine( )->IsInGame( ) ) {
+ if( g_ctx.m_local && g_ctx.m_local->is_valid( ) ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( ent && ent->is_valid( ) && ent != g_ctx.m_local ) {
+ ent->set_needs_interpolate( false );
+ }
+ }
+ }
+ }
+ }
+
+ void c_ragebot::c_lagcomp::fsn_render_start( ) {
+ if( !g_settings.rage.enabled( ) )
+ return;
+
+ if( !g_ctx.m_local )
+ return;
+
+ static bool invalidated = true;
+ if( !g_ctx.m_local->is_valid( ) ) {
+ if( !invalidated )
+ restore_animations( );
+
+ invalidated = true;
+ return;
+ }
+
+ invalidated = false;
+
+ static float stored_lby[ 65 ];
+ static bool was_dormant[ 65 ];
+
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || !ent->is_player( ) ) {
+ //invalidate_animstate( i );
+ m_first_update[ i ] = true;
+ continue;
+ }
+
+ if( ent == g_ctx.m_local ) {
+ if( g_ctx.m_stage == FRAME_RENDER_START ) {
+ //printf( "ya\n" );
+ //hooks::update_clientside_animation( ent, 0 );
+ }
+ continue;
+ }
+
+ if( !ent->is_alive( ) ) {
+ ent->m_bClientSideAnimation( ) = true;
+ was_dormant[ i ] = true;
+ m_first_update[ i ] = true;
+ continue;
+ }
+
+ if( ent->ce( )->IsDormant( ) ) {
+ ent->m_bClientSideAnimation( ) = true;
+ m_first_update[ i ] = true;
+ was_dormant[ i ] = true;
+ continue;
+ }
+
+ if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( )
+ && !g_settings.rage.friendlies ) {
+ ent->m_bClientSideAnimation( ) = true;
+ continue;
+ }
+
+ ent->restore_anim_data( false );
+ if( was_dormant[ i ] ) {
+ g_cheat.m_ragebot.m_resolver->update_player( i );
+ ent->calc_anim_velocity( true );
+ ent->fix_animations( true );
+ ent->do_ent_interpolation( true );
+ m_last_simtime[ i ] = ent->m_flSimulationTime( );
+ }
+ else if( g_ctx.m_stage == FRAME_RENDER_START ) {
+ ent->m_bClientSideAnimation( ) = false;
+ ent->do_ent_interpolation( was_dormant[ i ] );
+ continue;
+ }
+
+ was_dormant[ i ] = false;
+
+ if( m_data_lby[ i ].size( ) &&
+ m_data_lby[ i ].front( ).m_ent != ent ) {
+ m_data_lby[ i ].clear( );
+ }
+
+ if( m_data_normal[ i ].size( ) &&
+ m_data_normal[ i ].front( ).m_ent != ent ) {
+ m_data_normal[ i ].clear( );
+ }
+
+ auto update_anims = [ this, &ent ]( int e ) {
+ ent->fix_animations( );
+ };
+
+
+
+ float lby = ent->m_flLowerBodyYawTarget( );
+
+ float last_simtime = m_last_simtime[ i ];
+ float simtime = ent->m_flSimulationTime( );
+
+ bool yaw_change = g_cheat.m_ragebot.m_resolver->yaw_change( i );
+
+ if( !!std::abs( simtime - last_simtime ) ) {
+ ent->calc_anim_velocity( was_dormant[ i ] );
+
+ bool is_moving = ent->get_anim_velocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( )
+ && ( ent->m_fFlags( ) & FL_ONGROUND );
+
+ if( ent->m_bGunGameImmunity( ) ) {
+ update_anims( i );
+ }
+
+ else if( is_moving && !was_dormant[ i ] && g_settings.rage.resolver ) {
+ m_first_update[ i ] = false;
+ ent->m_angEyeAngles( ).y = lby;
+
+ update_anims( i );
+ lag_record_t new_record( ent );
+
+ m_data_lby[ i ].push_front( new_record );
+ }
+
+ else if( ( lby != stored_lby[ i ] ) && !was_dormant[ i ] && g_settings.rage.resolver ) {
+ if( !m_first_update[ i ] ) {
+ stored_lby[ i ] = lby;
+ ent->m_angEyeAngles( ).y = lby;
+
+ update_anims( i );
+ lag_record_t new_record( ent );
+
+ m_data_lby[ i ].push_front( new_record );
+ m_flick_time[ i ] = ent->m_flOldSimulationTime( ) + TICK_INTERVAL( );
+ }
+ else {
+ ent->fix_animations( false, yaw_change );
+
+ lag_record_t new_record( ent );
+ new_record.m_sim_record = true;
+
+ new_record.m_shots = g_cheat.m_ragebot.m_resolver->get_shots( i );
+
+ m_data_normal[ i ].push_front( new_record );
+ }
+
+ m_first_update[ i ] = false;
+ }
+ else {
+ bool has_updated = false;
+ if( g_settings.rage.resolver( ) ) {
+ float anim_time = ent->m_flOldSimulationTime( ) + TICK_INTERVAL( );
+
+ if( ent->m_flSimulationTime( ) - m_flick_time[ i ] > 1.1f && !m_first_update[ i ] ) {
+ has_updated = true;
+
+ ent->m_angEyeAngles( ).y = lby;
+ m_flick_time[ i ] = anim_time;
+ update_anims( i );
+ lag_record_t new_record( ent );
+ new_record.m_balanceadjust = true;
+ m_data_lby[ i ].push_front( new_record );
+ }
+ }
+
+ if( !has_updated ) {
+ ent->fix_animations( false, yaw_change );
+
+ lag_record_t new_record( ent );
+ new_record.m_sim_record = true;
+
+ new_record.m_shots = g_cheat.m_ragebot.m_resolver->get_shots( i );
+
+ m_data_normal[ i ].push_front( new_record );
+ }
+ }
+ }
+
+
+ ent->do_ent_interpolation( false );
+ m_last_simtime[ i ] = simtime;
+
+ g_cheat.m_ragebot.m_resolver->yaw_change( i ) = false;
+
+ while( !m_data_lby[ i ].empty( ) &&
+ m_data_lby[ i ].size( ) > TIME_TO_TICKS( 1.0f ) ) {
+ m_data_lby[ i ].pop_back( );
+ }
+
+ while( !m_data_normal[ i ].empty( ) &&
+ m_data_normal[ i ].size( ) > TIME_TO_TICKS( 1.0f ) ) {
+ m_data_normal[ i ].pop_back( );
+ }
+ }
+ }
+
+ RecordType_t c_ragebot::c_lagcomp::can_backtrack_entity( int ent_index ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+ if( ent->is_breaking_lc( ) ) {
+ return RECORD_NONE;
+ }
+
+ auto data_lby = &m_data_lby[ ent_index ];
+ auto data_normal = &m_data_normal[ ent_index ];
+
+ if( !data_lby->empty( ) ) {
+ for( auto& it : *data_lby ) {
+ if( it.is_valid( ) ) return RECORD_LBY;
+ }
+ }
+
+ if( !data_normal->empty( ) ) {
+ for( auto& it : *data_normal ) {
+ if( it.is_valid( ) ) return RECORD_NORMAL;
+ }
+ }
+
+ return RECORD_NONE;
+ }
+
+ void c_ragebot::c_lagcomp::invalidate_bone_caches( ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+ if( !ent || !ent->is_player( ) )
+ continue;
+
+ ent->m_iMostRecentModelBoneCounter( ) -= 1;
+ ent->m_flLastBoneSetupTime( ) = -FLT_MAX;
+ }
+ }
+
+ c_ragebot::lag_record_t* c_ragebot::c_lagcomp::get_newest_record( int ent_index ) {
+ lag_record_t* newest_record{ };
+ if( get_records( ent_index, RECORD_LBY )->size( ) )
+ newest_record = &get_records( ent_index, RECORD_LBY )->front( );
+
+ if( get_records( ent_index, RECORD_NORMAL )->size( ) ) {
+ auto& newest_rec = get_records( ent_index, RECORD_NORMAL )->front( );
+ if( ( newest_record && newest_rec.m_flSimulationTime > newest_record->m_flSimulationTime ) ||
+ !newest_record ) {
+ newest_record = &newest_rec;
+ }
+ }
+
+ return newest_record;
+ }
+
+ c_ragebot::lag_record_t* c_ragebot::c_lagcomp::get_newest_valid_record( int ent_index ) {
+ lag_record_t* last_simtime_record{ };
+ for( auto& it : *get_records( ent_index, RECORD_LBY ) ) {
+ if( !it.is_valid( ) ) continue;
+ last_simtime_record = ⁢
+ break;
+ }
+
+ for( auto& it : *get_records( ent_index, RECORD_NORMAL ) ) {
+ if( !it.is_valid( ) ) continue;
+ if( !last_simtime_record || ( last_simtime_record && it.m_flSimulationTime > last_simtime_record->m_flSimulationTime ) ) {
+ last_simtime_record = ⁢
+ }
+ break;
+ }
+
+ return last_simtime_record;
+ }
+
+ int c_ragebot::c_lagcomp::backtrack_entity( int ent_index, RecordType_t type, lag_record_t** out_record ) {
+ if( type == RECORD_NONE ) return -1;
+
+ auto& data = *get_records( ent_index, type );
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+
+ auto check_record = [ &ent, &out_record, &ent_index ]( lag_record_t* record, bool check_pelvis ) {
+ if( record->m_balanceadjust && record->m_shot ) return -1;
+
+ vec3_t head_pos = record->m_vecHeadPos;
+ vec3_t pelvis_pos = record->m_vecPelvisPos;
+
+ float damage = g_cheat.m_autowall.run( g_ctx.m_local, ent, head_pos, false ) * 4.f;
+ float min_damage = std::min< float >( ent->m_iHealth( ),
+ g_settings.rage.active->m_damage );
+
+ //g_con->log( xors( "record: %d damage: %f" ), counter++, damage );
+
+ int shots = g_cheat.m_ragebot.m_resolver->get_shots( ent_index );
+ bool recalc = shots != record->m_shots && record->m_sim_record;
+
+
+ if( damage > min_damage ) {
+ if( !record->restore( recalc, recalc ) )
+ return -1;
+
+ if( out_record ) {
+ *out_record = record;
+ }
+ return record->m_tickcount;
+ }
+
+ if( check_pelvis ) {
+ float pelvis_damage = g_cheat.m_autowall.run( g_ctx.m_local, ent, pelvis_pos, false );
+ if( pelvis_damage > min_damage ) {
+ if( !record->restore( recalc, recalc ) )
+ return -1;
+
+ if( out_record ) {
+ *out_record = record;
+ }
+ return record->m_tickcount;
+ }
+ }
+
+ return -1;
+ };
+
+ if( data.empty( ) )
+ return -1;
+
+ auto* back = &data.back( );
+ auto* front = &data.front( );
+
+ for( auto& it : data ) {
+ if( !it.is_valid( ) ) continue;
+ front = ⁢
+ break;
+ }
+
+ for( auto& it : util::reverse_iterator( data ) ) {
+ if( !it.is_valid( ) ) continue;
+ back = ⁢
+ break;
+ }
+
+ int front_result = check_record( front, true );
+ if( front_result != -1 ) return front_result;
+
+ int back_result = check_record( back, true );
+ if( back_result != -1 ) return back_result;
+
+ return -1;
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ragebot_resolver.cpp b/internal_rewrite/ragebot_resolver.cpp new file mode 100644 index 0000000..a56a00c --- /dev/null +++ b/internal_rewrite/ragebot_resolver.cpp @@ -0,0 +1,614 @@ +#include "ragebot.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+#include "math.hpp"
+#include "input_system.hpp"
+
+namespace features
+{
+ constexpr float FLT_ANG_LBY = 360.f;
+ constexpr float FLT_ANG_MOVING_LBY_UP = -360.f;
+ constexpr float FLT_ANG_180 = 720.f;
+ constexpr float FLT_ANG_FREESTANDING = -720.f;
+ constexpr float FLT_ANG_90 = 480.f;
+ constexpr float FLT_ANG_MINUS_90 = -480.f;
+ constexpr float FLT_ANG_MINUS_135 = -700.f;
+ constexpr float FLT_ANG_135 = 700.f;
+ constexpr float FLT_ANG_PITCH_UP = 1080.f;
+
+ static const std::vector< float > possible_angles_none = {
+ FLT_ANG_MOVING_LBY_UP,
+ FLT_ANG_180,
+ FLT_ANG_90,
+ FLT_ANG_MINUS_90,
+ FLT_ANG_MINUS_135,
+ FLT_ANG_135,
+ };
+
+
+ static const std::vector< float > possible_angles_adjust = {
+ FLT_ANG_FREESTANDING,
+ FLT_ANG_MOVING_LBY_UP,
+ FLT_ANG_180,
+ FLT_ANG_90,
+ FLT_ANG_MINUS_90,
+ FLT_ANG_135,
+ FLT_ANG_MINUS_135,
+ //180.f,
+ };
+
+ bool dbg_resolver( ) {
+ static con_var< bool > var{ &data::holder_, fnv( "dbg_resolver" ), false };
+ return var( );
+ }
+
+ int c_ragebot::c_resolver::try_freestanding( c_base_player* ent ) {
+ if( !( ent->m_fFlags( ) & FL_ONGROUND ) || ( ent->m_vecVelocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( ) ) )
+ return -1;
+
+ int ret_dir = -1;
+ float cur_damage = 0.f;
+
+ vec3_t enemy_pos = ent->m_vecOrigin( );
+ enemy_pos.z = ent->get_hitbox_pos( 0 ).z;
+
+ vec3_t local_pos = g_ctx.m_local->get_eye_pos( );
+ local_pos -= g_ctx.m_local->m_vecOrigin( );
+ local_pos += g_ctx.m_last_origin;
+
+ vec3_t aim_angle = math::vector_angles(
+ enemy_pos,
+ local_pos
+ );
+
+ auto get_damage = [ & ]( const vec3_t& start, const vec3_t& end, c_base_player* a, c_base_player* b ) {
+ static weapon_info_t wpn_data{ };
+ wpn_data.damage = 200;
+ wpn_data.range_modifier = 1.0f;
+ wpn_data.penetration = 3.0f;
+ wpn_data.armor_ratio = 0.5f;
+ wpn_data.range = 8192.f;
+
+ fire_bullet_data_t data{ };
+ data.src = start;
+ data.filter.pSkip = a;
+ data.length_to_end = ( end - start ).length( );
+
+ vec3_t angle = math::vector_angles( start, end );
+ data.direction = math::angle_vectors( angle );
+
+ data.direction.normalize_vector( );
+
+ if( g_cheat.m_autowall.fire_bullet( a, b, &wpn_data, data, false, false ) ) {
+ return data.current_damage;
+ }
+
+ return -1.f;
+ };
+
+ float start_dmg = get_damage( local_pos, enemy_pos, g_ctx.m_local, ent );
+
+ auto trace_ent_pos = [ & ]( vec3_t start, vec3_t end, c_base_player* ent ) {
+ Ray_t ray;
+ CGameTrace tr;
+ CTraceFilter filter;
+
+ const vec3_t min( -2.f, -2.f, -2.f );
+ const vec3_t max( 2.f, 2.f, 2.f );
+
+ ray.Init( start, end, min, max );
+ filter.pSkip = ent;
+
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &tr );
+
+ return tr.endpos;
+ };
+
+ auto test_dmg = [ & ]( float dist ) {
+ vec3_t enemy_left = math::get_rotated_pos( enemy_pos, aim_angle.y - 90.f, dist );
+ vec3_t enemy_right = math::get_rotated_pos( enemy_pos, aim_angle.y + 90.f, dist );
+
+ enemy_left = trace_ent_pos( enemy_pos, enemy_left, ent );
+ enemy_right = trace_ent_pos( enemy_pos, enemy_right, ent );
+
+ vec3_t local_left = math::get_rotated_pos( local_pos, aim_angle.y + 90.f, dist );
+ vec3_t local_right = math::get_rotated_pos( local_pos, aim_angle.y - 90.f, dist );
+
+ local_left = trace_ent_pos( local_pos, local_left, g_ctx.m_local );
+ local_right = trace_ent_pos( local_pos, local_right, g_ctx.m_local );
+
+ float dmg_left = get_damage( local_left, enemy_left, ent, g_ctx.m_local )
+ + get_damage( local_right, enemy_left, ent, g_ctx.m_local );
+
+ float dmg_right = get_damage( local_left, enemy_right, ent, g_ctx.m_local )
+ + get_damage( local_right, enemy_right, ent, g_ctx.m_local );
+
+ if( std::abs( dmg_left - dmg_right ) < 50.f )
+ return false;
+
+ float max_dmg = math::max( dmg_left, dmg_right );
+ ret_dir = dmg_left > dmg_right;
+
+ cur_damage = max_dmg;
+ return max_dmg > 50.f;
+ };
+
+ float dist = ( ent->m_vecOrigin( ) - ent->get_hitbox_pos( 0 ) ).length2d( );
+
+ if( !test_dmg( dist + 1.f ) ) {
+ if( cur_damage < start_dmg * 2.f )
+ return -1;
+ }
+
+ if( !test_dmg( 50.f ) )
+ return -1;
+
+ return ret_dir;
+ }
+
+ void c_ragebot::c_resolver::resolve_log_t::update( int ent_index ) {
+ static C_AnimationLayer last_layer[ 65 ]{ };
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+
+ if( !ent || ent == g_ctx.m_local || !ent->is_player( ) || !ent->is_alive( ) || ent->ce( )->IsDormant( ) || !ent->has_valid_anim( ) ) {
+ m_was_invalid = true;
+ m_has_valid_lby = false;
+ return;
+ }
+
+ if( m_was_invalid && m_last_pos.dist_to( ent->m_vecOrigin( ) ) > 4.f )
+ reset( );
+
+ if( !( ent->m_fFlags( ) & FL_ONGROUND ) ) {
+ m_breaking = BREAKING_NONE;
+ return;
+ }
+
+ if( ent->m_vecVelocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( ) ) {
+ m_breaking = BREAKING_NONE;
+ m_has_valid_lby = true;
+ return;
+ }
+
+ m_last_pos = ent->m_vecOrigin( );
+
+ m_was_invalid = false;
+ m_shots %= 100;
+ float lby = ent->m_flLowerBodyYawTarget( );
+ if( lby != m_last_lby ) {
+ m_last_lby = lby;
+ m_last_update = ent->m_flSimulationTime( );
+ m_breaking = BREAKING_NONE;
+ }
+
+ if( ent->m_flSimulationTime( ) - m_last_update > TICK_INTERVAL( ) ) {
+ m_breaking = BREAKING;
+ }
+
+ m_has_valid_lby = true;
+ }
+
+ void c_ragebot::c_resolver::resolve_log_t::reset( ) {
+ //assuming theyre STILL not moving this shouldnt change
+ //however if they are, it will be reset to none anyway
+ m_breaking = BREAKING_NONE;
+ m_last_update = 0.f;
+ m_last_lby = 0.f;
+ m_missed_shots = 0;
+ m_shots = 0;
+ m_logged = false;
+ m_logged_shots = 0;
+ }
+
+ std::vector< float > c_ragebot::c_resolver::get_shot_vec( int ent ) {
+ auto& data = m_data[ ent ];
+
+ if( data.m_breaking )
+ return possible_angles_adjust;
+
+ return possible_angles_none;
+ }
+
+ float c_ragebot::c_resolver::get_shot_yaw( int shots, int ent_index ) {
+ auto& data = m_data[ ent_index ];
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+
+ //if( data.m_logged && data.m_breaking ) {
+ // return data.m_logged_lby;
+ //}
+
+ auto vec = get_shot_vec( ent_index );
+ return vec.at( shots % vec.size( ) );
+ }
+
+ void c_ragebot::c_resolver::aimbot( int ent_index, int hitbox, vec3_t angle, vec3_t position, vec3_t min, vec3_t max, float radius ) {
+ if( !g_cheat.m_player_mgr.is_cheater( ent_index ) )
+ return;
+
+ auto& data = m_data[ ent_index ];
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( ent_index );
+ bool moving = ent->m_vecVelocity( ).length2d( ) > 0.1f && ( ent->m_fFlags( ) & FL_ONGROUND );
+
+ if( moving && !ent->is_fakewalking( ) ) {
+ return;
+ }
+
+ if( !data.m_breaking ) {
+ increment_shots( ent_index );
+ return;
+ }
+
+ auto model = ent->ce( )->GetModel( );
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) );
+
+ if( hitbox == HITBOX_HEAD ) {
+ auto box = set->pHitbox( 0 );
+ if( box ) {
+ auto dist = box->bbmin.dist_to( box->bbmax );
+
+ context::shot_data_t new_shot{ };
+ new_shot.m_angle = angle;
+ new_shot.m_enemy_pos = position;
+ new_shot.m_enemy_index = ent_index;
+ new_shot.m_local_pos = g_ctx.m_local->get_eye_pos( );
+ new_shot.m_resolver_shots = data.m_shots;
+ new_shot.m_resolver_state = true;
+ new_shot.m_hitbox.min = min;
+ new_shot.m_hitbox.min = max;
+ new_shot.m_hitbox.radius = radius;
+ new_shot.m_missed = true;
+ new_shot.m_hitgroup = HITGROUP_HEAD;
+
+ g_ctx.m_last_shot++;
+ g_ctx.m_last_shot %= 128;
+ g_ctx.m_shot_data[ g_ctx.m_last_shot ] = new_shot;
+
+ g_ctx.m_has_incremented_shots = true;
+
+
+ data.m_snapshot[ g_ctx.m_last_shot ] = data;
+
+ if( data.m_logged ) {
+ if( !--data.m_logged_shots ) {
+ data.m_logged = false;
+ }
+ }
+ else {
+ int shots = data.m_shots;
+
+ increment_shots( ent_index );
+
+#if _DEBUG
+ if( dbg_resolver( ) ) {
+ char str[ 128 ];
+ sprintf_s< 128 >( str, "[\3moneybot\1] incrementing shots from %d to %d", shots, data.m_shots );
+
+ g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, str );
+ }
+#endif
+ }
+ }
+ }
+ else {
+ matrix3x4 bone_matrix[ 128 ];
+ if( model && hdr && set && ent->ce( )->SetupBones( bone_matrix, 128, 0x100, g_csgo.m_globals->m_curtime ) ) {
+ auto box = set->pHitbox( hitbox );
+ if( !box ) return;
+
+ auto origin = ent->m_vecOrigin( );
+
+ vec3_t shot_pos = position;
+ vec3_t rotated_center;
+
+ vec3_t offset = position - origin;
+ float radius = offset.length2d( );
+ float cos_ = offset.x / radius;
+
+ float deg = RAD2DEG( acos( cos_ ) );
+ if( offset.y < 0 ) deg = -deg;
+
+ float rot = ( deg - 180.f ) * ( M_PI / 180.f );
+ rotated_center.x = origin.x + cos( rot ) * radius;
+ rotated_center.y = origin.y + sin( rot ) * radius;
+ rotated_center.z = position.z;
+
+ Ray_t ray;
+ CTraceFilterOneEntity filter;
+ CGameTrace tr_center;
+ CGameTrace tr_rot;
+
+ filter.ent = ent;
+
+ ray.Init( g_ctx.m_local->get_eye_pos( ), position );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &tr_center );
+
+ ray.Init( g_ctx.m_local->get_eye_pos( ), rotated_center );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT, &filter, &tr_rot );
+
+ bool is_within = tr_center.hitbox == tr_rot.hitbox;
+
+ if( !is_within ) {
+ auto dist = box->bbmin.dist_to( box->bbmax );
+
+ context::shot_data_t new_shot{ };
+ new_shot.m_angle = angle;
+ new_shot.m_enemy_pos = position;
+ new_shot.m_enemy_index = ent_index;
+ new_shot.m_local_pos = g_ctx.m_local->get_eye_pos( );
+ new_shot.m_resolver_shots = data.m_shots;
+ new_shot.m_resolver_state = true;
+ new_shot.m_hitbox.min = min;
+ new_shot.m_hitbox.min = max;
+ new_shot.m_hitbox.radius = radius;
+ new_shot.m_missed = true;
+ new_shot.m_hitgroup = util::hitbox_to_hitgroup( hitbox );
+
+ g_ctx.m_last_shot++;
+ g_ctx.m_last_shot %= 128;
+ g_ctx.m_shot_data[ g_ctx.m_last_shot ] = new_shot;
+
+ g_ctx.m_has_incremented_shots = true;
+
+ if( data.m_logged ) {
+ if( !--data.m_logged_shots ) {
+ data.m_logged = false;
+ }
+ }
+ else {
+ int shots = data.m_shots;
+ increment_shots( ent_index );
+
+#if _DEBUG
+ if( dbg_resolver( ) ) {
+ char str[ 128 ];
+ sprintf_s< 128 >( str, "[\3moneybot\1] incrementing shots from %d to %d", shots, data.m_shots );
+
+ g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, str );
+ }
+#endif
+ }
+
+ data.m_snapshot[ g_ctx.m_last_shot ] = data;
+ }
+ }
+ }
+
+ //printf( "resolver: logging aimbot shot %d missed: %d state: %d time: %f\n",
+ // data.m_shots, data.m_missed_shots[ data.m_breaking ], data.m_breaking, g_Interfaces.Globals->curtime );
+ }
+
+ void c_ragebot::c_resolver::increment_shots( int ent_index ) {
+ m_data[ ent_index ].m_shots++;
+ m_data[ ent_index ].m_missed_shots++;
+ m_data[ ent_index ].m_angle_change = true;
+ }
+
+ void c_ragebot::c_resolver::on_missed_spread( int ent_index, int shots ) {
+ if( !g_cheat.m_player_mgr.is_cheater( ent_index ) )
+ return;
+
+ auto& data = m_data[ ent_index ];
+ auto& snapshot = data.m_snapshot[ shots % 150 ];
+
+ data.m_shots = snapshot.m_shots;
+
+ if( snapshot.m_logged ) {
+ data.m_logged = true;
+ data.m_logged_shots = snapshot.m_logged_shots;
+ }
+ }
+
+ void c_ragebot::c_resolver::listener( int ent_index, int shots ) {
+ if( !g_cheat.m_player_mgr.is_cheater( ent_index ) )
+ return;
+
+ auto& data = m_data[ ent_index ];
+ auto& snapshot = data.m_snapshot[ shots ];
+
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( !nci )
+ return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon )
+ return;
+
+ auto rate = weapon->get_wpn_info( )->cycle_time;
+
+ data.m_shots = snapshot.m_shots;
+ data.m_logged = true;
+
+ int latency_shots = ( nci->GetLatency( 0 ) + g_csgo.m_globals->m_frametime ) / rate + 1;
+
+ data.m_logged_shots = latency_shots;
+
+#if _DEBUG
+ if( dbg_resolver( ) ) {
+ char str[ 128 ];
+ sprintf_s< 128 >( str, "[\3moneybot\1] resolver: logging %d shots for %d with %d", data.m_logged_shots, ent_index, data.m_shots );
+
+ g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, str );
+ }
+#endif
+ }
+
+ void c_ragebot::c_resolver::update_player( int i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+ bool was_invalid = m_data[ i ].m_was_invalid;
+
+ m_data[ i ].update( i );
+ if( g_settings.rage.resolver_override( ) ) {
+ if( g_input.is_key_pressed( g_settings.rage.resolver_override_key( ) ) ) {
+ int dir = manual_override( ent );
+ if( dir ) {
+ if( dir != m_data[ i ].m_overriding )
+ m_data[ i ].m_angle_change = true;
+
+ //to be finished
+ m_data[ i ].m_overriding = dir;
+ return;
+ }
+ }
+ }
+
+ m_data[ i ].m_overriding = 0;
+ brute_force( ent );
+ }
+
+ void c_ragebot::c_resolver::frame_stage_notify( ) {
+ if( !g_settings.rage.enabled( ) || !g_settings.rage.resolver( ) )
+ return;
+
+ if( !g_ctx.run_frame( ) || !g_ctx.m_local->is_valid( ) )
+ return;
+
+ for( int i{ 1 }; i < g_csgo.m_globals->m_maxclients; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || ent == g_ctx.m_local || ent->ce( )->IsDormant( ) || !ent->is_player( )
+ || !ent->is_alive( ) || !g_cheat.m_player_mgr.is_cheater( i ) ) {
+ m_data[ i ].m_was_invalid = true;
+ m_data[ i ].m_has_valid_lby = false;
+ continue;
+ }
+
+ if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && !g_settings.rage.friendlies )
+ continue;
+
+ update_player( i );
+ }
+ }
+
+ void c_ragebot::c_resolver::force_yaw( c_base_player* ent, float yaw ) {
+ ent->m_angEyeAngles( ).y = yaw;// + 180.f;
+ }
+
+ int c_ragebot::c_resolver::manual_override( c_base_player* ent ) {
+ if( ent->m_vecVelocity( ).length( ) > 0.1f && !ent->is_fakewalking( ) ) { //no point in overriding moving targets, it will also fuck up backtrack records otherwise
+ return OVERRIDE_NONE;
+ }
+
+ vec3_t pos;
+ vec3_t angle;
+ vec3_t local_angle;
+ vec3_t local_pos;
+ float delta;
+ float dist;
+
+
+ local_pos = g_ctx.m_local->m_vecOrigin( );
+ g_csgo.m_engine( )->GetViewAngles( local_angle );
+ pos = ent->get_hitbox_pos( 0 );
+
+ angle = math::vector_angles( local_pos, pos );
+ dist = pos.dist_to( local_pos );
+ delta = ( angle - local_angle ).clamp( ).y;
+ float yaw_delta = sin( DEG2RAD( ( angle - local_angle ).clamp( ).y ) ) * dist;
+
+ if( std::abs( yaw_delta ) < 25.f ) {
+ force_yaw( ent, angle.y );
+ return OVERRIDE_CENTER;
+ }
+ else {
+ force_yaw( ent, angle.y + ( ( delta < 0.f ) ? 90.f : -90.f ) );
+ return delta > 0.f ? OVERRIDE_LEFT : OVERRIDE_RIGHT;
+ }
+ }
+
+ void c_ragebot::c_resolver::force_lby( c_base_player* ent ) {
+ force_yaw( ent, ent->m_flLowerBodyYawTarget( ) );
+ }
+
+ void c_ragebot::c_resolver::brute_force( c_base_player* ent ) {
+ if( ent->m_flSimulationTime( ) == g_cheat.m_ragebot.m_lagcomp->get_last_updated_simtime( ent->ce( )->GetIndex( ) ) )
+ return;
+
+ if( ent->m_vecVelocity( ).length( ) > 0.1f && ( ent->m_fFlags( ) & FL_ONGROUND ) && !ent->is_fakewalking( ) ) {
+ m_data[ ent->ce( )->GetIndex( ) ].m_last_moving_lby = ent->m_flLowerBodyYawTarget( );
+ m_data[ ent->ce( )->GetIndex( ) ].m_has_valid_lby = true;
+ force_lby( ent );
+ return;
+ }
+
+ int i = ent->ce( )->GetIndex( );
+ auto& data = m_data[ i ];
+ float start = ent->m_flLowerBodyYawTarget( );
+ float new_yaw{ };
+ float new_ang{ };
+ int shots{ };
+
+ shots = data.m_shots;
+ new_ang = get_shot_yaw( shots, i );
+ float ang;
+ if( g_ctx.run_frame( ) ) {
+ auto local_pos = g_ctx.m_local->m_vecOrigin( );
+ auto enemy_pos = ent->m_vecOrigin( );
+
+ ang = math::vector_angles( enemy_pos, local_pos ).y;
+ }
+ else {
+ ang = start;
+ }
+
+ float pitch = ent->m_angEyeAngles( ).x;
+
+ if( g_settings.rage.pitch_resolver ) {
+ if( new_ang == FLT_ANG_MOVING_LBY_UP )
+ ent->m_angEyeAngles( ).x = -89.f;
+ else
+ ent->m_angEyeAngles( ).x = 89.f;
+ }
+
+ if( new_ang == FLT_ANG_LBY )
+ new_yaw = ent->m_flLowerBodyYawTarget( );
+ else if( new_ang == FLT_ANG_MOVING_LBY_UP ) {
+ if( !data.m_has_valid_lby && !g_settings.rage.pitch_resolver && ( ent->m_fFlags( ) & FL_ONGROUND ) ) {
+ data.m_shots++;
+ return brute_force( ent );
+ }
+
+ auto delta = std::remainderf( data.m_last_moving_lby - data.m_last_lby, 360.f );
+ bool breaking_lby = std::abs( delta ) > 35.f;
+
+ new_yaw = breaking_lby ? data.m_last_moving_lby : data.m_last_lby;
+ }
+ else if( new_ang == FLT_ANG_180 ) {
+ if( data.m_last_freestanding == -1 && ( ent->m_fFlags( ) & FL_ONGROUND ) ) {
+ data.m_shots++;
+ return brute_force( ent );
+ }
+
+ new_yaw = ang - 180.f;
+ }
+ else if( new_ang == FLT_ANG_FREESTANDING ) {
+ int freestanding = try_freestanding( ent );
+ if( freestanding == -1 )
+ new_yaw = ang + 180.f;
+ else
+ new_yaw = ang + ( freestanding ? 90.f : -90.f );
+
+ if( data.m_last_freestanding != freestanding )
+ data.m_angle_change = true;
+
+ data.m_last_freestanding = freestanding;
+ }
+ else if( new_ang == FLT_ANG_MINUS_90 ) {
+ new_yaw = ang - 90.f;
+ }
+ else if( new_ang == FLT_ANG_90 ) {
+ new_yaw = ang + 90.f;
+ }
+ else if( new_ang == FLT_ANG_135 )
+ new_yaw = ang + 135.f;
+ else if( new_ang == FLT_ANG_MINUS_135 )
+ new_yaw = ang - 135.f;
+ else
+ new_yaw = std::remainderf( start + new_ang, 360.f );
+
+ new_yaw = std::remainderf( new_yaw, 360.f );
+
+ force_yaw( ent, new_yaw );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/renderer.cpp b/internal_rewrite/renderer.cpp new file mode 100644 index 0000000..3d22805 --- /dev/null +++ b/internal_rewrite/renderer.cpp @@ -0,0 +1,93 @@ +#include "renderer.hpp" +#include "interface.hpp" + +#undef CreateFont + + +drawings::c_fonts g_fonts; +drawings::c_drawings g_renderer; + +NAMESPACE_REGION( drawings ) + +c_fonts::font_t::font_t( std::string name, int size, + int weight, ulong_t flags ) : + m_name( name ), m_size( size ), + m_weight( weight ), m_flags( flags ) { + g_fonts.m_container.push_back( this ); +}; + +void c_fonts::font_t::initialize( ) { + m_font = g_csgo.m_surface( )->CreateFont( ); + g_csgo.m_surface( )->SetFontGlyphSet( + m_font, m_name.c_str( ), m_size, + m_weight, 0, 0, + m_flags + ); +} + +void c_fonts::initialize( ) { + for( auto& it : m_container ) { + it->initialize( ); + } +} + +void c_drawings::draw_string( const wchar_t* text, HFont font, int x, int y, const clr_t& color ) { + g_csgo.m_surface( )->DrawSetTextPos( x, y ); + g_csgo.m_surface( )->DrawSetTextFont( font ); + g_csgo.m_surface( )->DrawSetTextColor( color ); + g_csgo.m_surface( )->DrawPrintText( text, wcslen( text ) ); +} + +void c_drawings::draw_rect( int x, int y, int w, int h, const clr_t& color ) { + g_csgo.m_surface( )->DrawSetColor( color ); + g_csgo.m_surface( )->DrawFilledRect( x, y, x + w, y + h ); +} + +void c_drawings::draw_line( int x, int y, int x1, int y1, const clr_t& clr ) { + g_csgo.m_surface( )->DrawSetColor( clr ); + g_csgo.m_surface( )->DrawLine( x, y, x1, y1 ); +} + +void c_drawings::draw_box( int x, int y, int w, int h, const clr_t& clr ) { + draw_line( x, y, x + w, y, clr ); + draw_line( x + w, y, x + w, y + h, clr ); + draw_line( x, y + h, x + w + 1, y + h, clr ); + draw_line( x, y, x, y + h, clr ); +} + +void c_drawings::draw_circle( int x, int y, int r, const clr_t& col, int res ) { + g_csgo.m_surface( )->DrawSetColor( col ); + g_csgo.m_surface( )->DrawOutlinedCircle( x, y, r, res ); +} + +void c_drawings::draw_filled_circle( int x, int y, int r, const clr_t& col, int res ) { + vertex_t* v = ( vertex_t* )( _alloca( res * sizeof( vertex_t ) ) ); + const float step = M_PI * 2.0f / res; + + for( size_t i{ }; i < res; ++i ) { + float theta = i * step; + float x_off = r * cos( theta ); + float y_off = r * sin( theta ); + v[ i ].init( x + x_off, y + y_off ); + } + + draw_polygon( res, v, col ); +} + +void c_drawings::draw_line( const vec2_t& begin, const vec2_t& end, const clr_t& clr ) { + draw_line( ( int )begin.x, ( int )begin.y, ( int )end.x, ( int )end.y, clr ); +} + +void c_drawings::draw_polygon( int count, vertex_t* vertices, const clr_t& col ) { + static int texture = g_csgo.m_surface( )->CreateNewTextureID( true ); + + clr_t buf( 255, 255, 255 ); + + g_csgo.m_surface( )->DrawSetTextureRGBA( texture, ( byte* )( &buf ), 1, 1 ); + g_csgo.m_surface( )->DrawSetColor( col ); + g_csgo.m_surface( )->DrawSetTexture( texture ); + + g_csgo.m_surface( )->DrawTexturedPolygon( count, vertices ); +} + +END_REGION
\ No newline at end of file diff --git a/internal_rewrite/renderer.hpp b/internal_rewrite/renderer.hpp new file mode 100644 index 0000000..de156d7 --- /dev/null +++ b/internal_rewrite/renderer.hpp @@ -0,0 +1,126 @@ +#pragma once
+#include <stdio.h>
+#include <stdarg.h>
+#include <vector>
+
+#include "util.hpp"
+#include "sdk.hpp"
+
+enum e_font_style : size_t {
+
+};
+
+enum FontAlign_t : size_t {
+ ALIGN_CENTER,
+ ALIGN_LEFT,
+ ALIGN_RIGHT
+};
+
+NAMESPACE_REGION( drawings )
+
+
+class c_fonts {
+protected:
+ struct font_t {
+ friend class c_fonts;
+ font_t( std::string name, int size,
+ int weight, ulong_t flags );
+
+ operator HFont( ) {
+ return m_font;
+ }
+
+ private:
+ void initialize( );
+
+ HFont m_font;
+ std::string m_name;
+ int m_size;
+ int m_weight;
+ ulong_t m_flags;
+ };
+
+ std::vector< font_t* > m_container;
+ friend struct c_fonts::font_t;
+public:
+ void initialize( );
+
+ font_t f_esp_small{ xors( "Tahoma" ), 11, 500, FONTFLAG_OUTLINE };
+ font_t f_bold{ xors( "Verdana" ), 18, 900, FONTFLAG_DROPSHADOW | FONTFLAG_ANTIALIAS };
+ font_t f_12{
+#ifndef COMIC_SANS
+ xors( "Tahoma" )
+#else
+ xors( "Comic Sans" )
+#endif
+ , 12, 0, FONTFLAG_DROPSHADOW };
+ font_t f_14{ xors( "Verdana" ), 14, 700, 128 };
+ font_t f_16{ xors( "Verdana" ), 16, 700, 128 };
+ font_t f_18{ xors( "Verdana" ), 18, 700, 128 };
+};
+
+
+
+//im going to fill ur triangles
+class c_drawings {
+private:
+ //dumb hacky fix for template functions
+ void draw_string( const wchar_t* msg, HFont font, int x, int y, const clr_t& color );
+
+public:
+ void draw_line( const vec2_t& begin, const vec2_t& end, const clr_t& color );
+ void draw_line( int x, int y, int x1, int y2, const clr_t& color );
+ void draw_rect( int x, int y, int w, int h, const clr_t& color );
+ void draw_box( int x, int y, int w, int h, const clr_t& color ); //thicc
+ void draw_polygon( int count, vertex_t* vertices, const clr_t& col );
+ void draw_circle( int x, int y, int r, const clr_t& col, int res = 48 );
+ void draw_filled_circle( int x, int y, int r, const clr_t& col, int res = 48 );
+
+ template < FontAlign_t align = ALIGN_LEFT > //fuck ur sprintf nigga varargs nigga
+ void draw_string( HFont font, int x, int y, const clr_t& color, const wchar_t* msg, ... ) {
+ wchar_t* buffer = ( wchar_t* )_alloca( 2048 );
+ va_list list{ };
+ int wide, tall;
+
+ memset( buffer, 0, 2048 );
+
+ __crt_va_start( list, msg );
+ vswprintf_s( buffer, 1024, msg, list );
+ __crt_va_end( list );
+
+ g_csgo.m_surface( )->GetTextSize(
+ font, buffer, wide, tall );
+
+ switch( align ) {
+ case ALIGN_CENTER:
+ x -= wide / 2;
+ break;
+ case ALIGN_RIGHT:
+ x -= wide;
+ break;
+ default: break;
+ }
+
+ draw_string( buffer, font, x, y, color );
+ }
+
+ template < FontAlign_t align = ALIGN_LEFT > //debatable whether it should be center or not
+ void draw_string( HFont font, int x, int y, const clr_t& color, const char* msg, ... ) {
+ char* buffer = ( char* )_alloca( 1024 );
+ va_list list{ };
+
+ memset( buffer, 0, 1024 );
+
+ __crt_va_start( list, msg );
+ vsprintf_s( buffer, 1024, msg, list );
+ __crt_va_end( list );
+
+ auto wide_str = util::ascii_to_unicode( buffer );
+ draw_string< align >( font, x, y, color, wide_str.c_str( ) );
+ }
+};
+
+END_REGION
+
+extern drawings::c_fonts g_fonts;
+extern drawings::c_drawings g_renderer;
\ No newline at end of file diff --git a/internal_rewrite/run_command.cpp b/internal_rewrite/run_command.cpp new file mode 100644 index 0000000..c92dd7b --- /dev/null +++ b/internal_rewrite/run_command.cpp @@ -0,0 +1,12 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::run_command( void* ecx_, void* edx_, IClientEntity* entity, user_cmd_t* ucmd, IMoveHelper* move_helper) { + static auto run_command_o = g_csgo.m_prediction->get_old_function< decltype( &hooks::run_command ) >( 19 ); + if( !g_csgo.m_panic && g_settings.rage.anti_aim( ) && entity == g_ctx.m_local->ce( ) ) { + g_cheat.m_ragebot.m_antiaim->on_runcommand( ); + } + + run_command_o( ecx_, edx_, entity, ucmd, move_helper ); +}
\ No newline at end of file diff --git a/internal_rewrite/scene_end.cpp b/internal_rewrite/scene_end.cpp new file mode 100644 index 0000000..be3ceeb --- /dev/null +++ b/internal_rewrite/scene_end.cpp @@ -0,0 +1,43 @@ +#include "hooks.hpp" +#include "settings.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::scene_end( void* ecx_, void* edx_ ) { + static auto scene_end_o = g_csgo.m_render_view->get_old_function< decltype( &hooks::scene_end ) >( 9 ); + scene_end_o( edx_, 0 ); + + if( !g_csgo.m_panic && g_ctx.m_local && g_settings.visuals.chams.enabled( ) && g_settings.visuals.chams.ignore_z( ) && g_settings.visuals.chams.clear_occlusion ) { + g_ctx.m_drawing_screneend = true; + for( int i = 1; i < g_csgo.m_globals->m_maxclients; ++i ) { + auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i ); + + if( ent && ent->is_valid( ) && !ent->m_bGunGameImmunity( ) ) { + if( ent == g_ctx.m_local && ent->m_bIsScoped( ) ) { + continue; + } + + int team = ent->m_iTeamNum( ); + bool enemy = team != g_ctx.m_local->m_iTeamNum( ); + + if( enemy || g_settings.visuals.chams.friendlies( ) ) { + IMaterial* mat = g_settings.visuals.chams.flat ? g_cheat.m_chams.m_materials.m_chams_flat : g_cheat.m_chams.m_materials.m_chams; + fclr_t clr_vis = enemy ? g_settings.visuals.chams.color_visible_enemy( ).to_fclr( ) : g_settings.visuals.chams.color_visible_friendly( ).to_fclr( ); + fclr_t clr_hid = enemy ? g_settings.visuals.chams.color_hidden_enemy( ).to_fclr( ) : g_settings.visuals.chams.color_hidden_friendly( ).to_fclr( ); + + mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true ); + g_cheat.m_chams.m_materials.force_material( mat, clr_hid ); + ent->ce( )->DrawModel( 0x1, 255 ); + + mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false ); + g_cheat.m_chams.m_materials.force_material( mat, clr_vis ); + ent->ce( )->DrawModel( 0x1, 255 ); + + g_csgo.m_model_render( )->ForcedMaterialOverride( nullptr ); + } + } + } + + g_ctx.m_drawing_screneend = false; + } +}
\ No newline at end of file diff --git a/internal_rewrite/sdk.hpp b/internal_rewrite/sdk.hpp new file mode 100644 index 0000000..91f9bba --- /dev/null +++ b/internal_rewrite/sdk.hpp @@ -0,0 +1,28 @@ +#pragma once +#include "vector.hpp" + +#include "IClientMode.hpp" +#include "CHLClient.hpp" +#include "ISurface.hpp" +#include "IPanel.hpp" +#include "IVEngineClient.hpp" +#include "IClientEntityList.hpp" +#include "GlobalVars_t.hpp" +#include "IPrediction.hpp" +#include "ICvar.hpp" +#include "IVModelInfoClient.hpp" +#include "IMaterialSystem.hpp" +#include "IEngineTrace.hpp" +#include "IVRenderView.hpp" +#include "IPhysicsSurfaceProps.hpp" +#include "CUtlVector.hpp" +#include "IMemAlloc.hpp" +#include "IGameEventManager.hpp" +#include "KeyValues.hpp" +#include "CInput.hpp" +#include "bf_write.hpp" +#include "match_framework.h" + + +#include "c_base_player.hpp" +#include "ISteamClient.hpp"
\ No newline at end of file diff --git a/internal_rewrite/send_datagram.cpp b/internal_rewrite/send_datagram.cpp new file mode 100644 index 0000000..8a7b21b --- /dev/null +++ b/internal_rewrite/send_datagram.cpp @@ -0,0 +1,33 @@ +#include "mem.hpp" +#include "base_cheat.hpp" +#include "context.hpp" +#include "hooks.hpp" + +uintptr_t cl_sendmove = 0; + +int __fastcall hooks::send_datagram( INetChannel* channel, void* edx_, void* datagram ) { + auto send_datagram_o = g_csgo.m_net_channel->get_old_function< decltype( &hooks::send_datagram ) >( 46 ); + if( g_csgo.m_panic || !g_settings.misc.net_fakelag || datagram ) { + return send_datagram_o( channel, 0, datagram ); + } + + auto cl = g_csgo.m_global_state->get_client_state( ); + if( !cl || cl->m_delta_tick <= 0 ) { + return send_datagram_o( channel, 0, datagram ); + } + + // There is no need to restore the reliable state sequence since + // we are not fucking with reliable state with 'proper' fake latency. + + int backup_sequence = channel->m_nInSequenceNr; + + g_cheat.m_extra.add_latency( channel ); + + auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); + + int ret = send_datagram_o( channel, 0, datagram ); + + channel->m_nInSequenceNr = backup_sequence; + + return ret; +}
\ No newline at end of file diff --git a/internal_rewrite/settings.hpp b/internal_rewrite/settings.hpp new file mode 100644 index 0000000..45c012e --- /dev/null +++ b/internal_rewrite/settings.hpp @@ -0,0 +1,447 @@ +#pragma once
+#include "simple_settings.hpp"
+#include "strings.hpp"
+#include "color.hpp"
+#include <unordered_map>
+//later i will implement a way to load all config files
+
+namespace data
+{
+
+
+ extern SettingHolder holder_;
+
+ struct skin_data {
+
+ skin_data( int id_input = 0, int paintkit_input = 0, const char* name_input = nullptr, float wear_input = 0.0f, int seed_input = 0 ) {
+ id = id_input;
+ name = name_input;
+ paintkit = paintkit_input;
+ seed = seed_input;
+ wear = wear_input;
+ }
+
+ int id = 0;
+ int paintkit = 0;
+ int seed = 0;
+ float wear = 0.0f;
+ const char* name = nullptr;
+ };
+
+
+ class legitbot_settings : SettingHolder {
+ public:
+ using SettingHolder::SettingHolder;
+
+ con_var< float > m_fov{ this, fnv( "fov" ), 5.f };
+ con_var< float > m_speed{ this, fnv( "speed" ), 10.f };
+ con_var< float > m_rcs{ this, fnv( "rcs" ), 25.f };
+ con_var< float > m_assist_strength{ this, fnv( "assist_strength" ), 0.f };
+ con_var< int > m_hitbox{ this, fnv( "hitbox" ), 0 };
+ };
+
+ class ragebot_settings : SettingHolder {
+ public:
+ using SettingHolder::SettingHolder;
+
+ con_var< int > m_damage{ this, fnv( "damage" ), 0 };
+ con_var< int > m_damage_scale{ this, fnv( "damage_scale" ), 0 };
+ con_var< int > m_hitchance{ this, fnv( "hitchance" ), 0 };
+ con_var< bool > m_baim_air{ this, fnv( "baim_air" ), 0 };
+ con_var< bool > m_baim_fake{ this, fnv( "baim_fake" ), 0 };
+ con_var< bool > m_baim_lethal{ this, fnv( "baim_lethal" ), 0 };
+ con_var< int > m_baim_shots{ this, fnv( "baim_shots" ), 5 };
+ con_var< int > m_baim_health{ this, fnv( "baim_health" ), 50 };
+ con_var< int > m_delay{ this, fnv( "delay" ), 0 };
+ con_var< int > m_delay_type{ this, fnv( "delay_type" ), 0 };
+ con_var< bool > m_spread_limit{ this, fnv( "spread_limit" ), 0 };
+ con_var< int > m_spread_limit_min{ this, fnv( "spread_limit_min" ), 100 };
+ con_var< bool > m_auto_stop{ this, fnv( "auto_stop" ), false };
+ con_var< float > m_hitbox_scale{ this, fnv( "point_scale" ), 0.5f };
+ };
+
+ class c_settings {
+ public:
+ c_settings( ) {
+ memset( this->misc.skins.skins( ).data( ), -1, sizeof( this->misc.skins.skins( ) ) );
+ }
+
+ void load( ) {
+ switch( menu.cur_setting ) {
+ case 0:
+ holder_.load( "", xors( "./csgo/cfg/money_legit.cfg" ) );
+ break;
+ case 1:
+ holder_.load( "", xors( "./csgo/cfg/money_closet.cfg" ) );
+ break;
+ case 2:
+ holder_.load( "", xors( "./csgo/cfg/money_rage1.cfg" ) );
+ break;
+ case 3:
+ holder_.load( "", xors( "./csgo/cfg/money_rage2.cfg" ) );
+ break;
+ case 4:
+ holder_.load( "", xors( "./csgo/cfg/money_test.cfg" ) );
+ break;
+ }
+
+ menu.anti_untrusted = true;
+ misc.skins.current_skin = -1;
+ }
+
+ void save( ) {
+ switch( menu.cur_setting ) {
+ case 0:
+ holder_.save( "", xors( "./csgo/cfg/money_legit.cfg" ) );
+ break;
+ case 1:
+ holder_.save( "", xors( "./csgo/cfg/money_closet.cfg" ) );
+ break;
+ case 2:
+ holder_.save( "", xors( "./csgo/cfg/money_rage1.cfg" ) );
+ break;
+ case 3:
+ holder_.save( "", xors( "./csgo/cfg/money_rage2.cfg" ) );
+ break;
+ case 4:
+ holder_.save( "", xors( "./csgo/cfg/money_test.cfg" ) );
+ break;
+ }
+ }
+
+ void copy_to_clipboard( ) {
+ holder_.save( "", xors( "./csgo/cfg/money_temp.cfg" ) );
+ std::vector< uint8_t > file_data;
+ FILE* f = fopen( xors( "./csgo/cfg/money_temp.cfg" ), "r" );
+ size_t size = 0;
+ fseek( f, 0, SEEK_END );
+ size = ftell( f );
+
+ char* buf = ( char* )malloc( size );
+ fread( buf, 1, size, f );
+ fclose( f );
+ for( size_t i{ }; i < size; ++i ) {
+ file_data.push_back( buf[ i ] );
+ }
+
+ free( buf );
+
+ EmptyClipboard( );
+ OpenClipboard( nullptr );
+
+ auto g = GlobalAlloc( GMEM_FIXED, size );
+ memcpy( g, file_data.data( ), size );
+
+ SetClipboardData( CF_TEXT, g );
+ CloseClipboard( );
+ //DeleteFileA( xors( "./csgo/cfg/money_temp.cfg" ) );
+ }
+
+ void load_from_clipboard( ) {
+ FILE* f = fopen( xors( "./csgo/cfg/money_temp.cfg" ), "wb" );
+ auto data = GetClipboardData( CF_TEXT );
+
+ auto size = GlobalSize( data );
+ fwrite( data, 1, size, f );
+ fclose( f );
+
+ holder_.load( "", xors( "./csgo/cfg/money_temp.cfg" ) );
+
+ CloseClipboard( );
+ //DeleteFileA( xors( "./csgo/cfg/money_temp.cfg" ) );
+ }
+
+ struct {
+ con_var< bool > enabled{ &holder_, fnv( "legit_active" ), false };
+ con_var< size_t > sample_size{ &holder_, fnv( "legit_sample_size" ), 12 };
+ con_var< float > smooth_factor{ &holder_, fnv( "legit_smooth_factor" ), 1.0f };
+ con_var< bool > dynamic_smoothing{ &holder_, fnv( "legit_dynamic_smoothing" ), false };
+ con_var< bool > awp_baim{ &holder_, fnv( "legit_awp_baim" ), false };
+ con_var< bool > assist{ &holder_, fnv( "legit_assist" ), false };
+ con_var< bool > friendlies{ &holder_, fnv( "legit_friendlies" ), false };
+ con_var< int > activation_type{ &holder_, fnv( "legit_activation_type" ), 1 };
+ con_var< int > key{ &holder_, fnv( "legit_key" ), 0 };
+ con_var< bool > backtracking{ &holder_, fnv( "legit_backtracking" ), 0 };
+ con_var< float > backtracking_time{ &holder_, fnv( "legit_bt_time" ), 0.2f };
+ con_var< float > backtracking_fov{ &holder_, fnv( "legit_bt_fov" ), 5.0f };
+ con_var< bool > backtracking_target{ &holder_, fnv( "legit_bt_target" ), false };
+ con_var< bool > backtracking_visualize{ &holder_, fnv( "legit_bt_visualize" ), 0 };
+ con_var< clr_t > backtracking_col{ &holder_, fnv( "legit_bt_col" ), clr_t( 255, 255, 255, 120 ) };
+ con_var< bool > triggerbot{ &holder_, fnv( "legit_triggerbot" ), false };
+ con_var< int > trigger_key{ &holder_, fnv( "legit_triggerkey" ), 0 };
+ con_var< float > trigger_delay{ &holder_, fnv( "legit_triggerdelay" ), 0.f };
+ con_var< bool > trigger_magnet{ &holder_, fnv( "legit_trigger_magnet" ) };
+ legitbot_settings pistols{ &holder_, "legit_pistols" };
+ legitbot_settings rifles{ &holder_, "legit_rifles" };
+ legitbot_settings snipers{ &holder_, "legit_snipers" };
+ legitbot_settings general{ &holder_, "legit_general" };
+ legitbot_settings* active = &general;
+ } legit;
+
+ struct {
+ con_var< bool > enabled{ &holder_, fnv( "rage_enabled" ), false };
+ con_var< int > activation_type{ &holder_, fnv( "rage_activation_type" ), 0 };
+ con_var< float > fov{ &holder_, fnv( "rage_fov" ), 0.f };
+ con_var< bool > friendlies{ &holder_, fnv( "rage_friendlies" ), false };
+ con_var< int > hitbox{ &holder_, fnv( "rage_hitbox" ), false };
+ struct {
+ con_var< bool > head{ &holder_, fnv( "rage_hitscan_head" ), true };
+ con_var< bool > stomach{ &holder_, fnv( "rage_hitscan_stomach" ), true };
+ con_var< bool > arms{ &holder_, fnv( "rage_hitscan_arms" ), false };
+ con_var< bool > legs{ &holder_, fnv( "rage_hitscan_legs" ), false };
+ con_var< bool > feet{ &holder_, fnv( "rage_hitscan_feet" ), false };
+ con_var< bool > chest{ &holder_, fnv( "rage_hitscan_chest" ), false };
+ } hitscan;
+
+
+ con_var< bool > ignore_limbs_moving{ &holder_, fnv( "rage_ignore_limbs_moving" ), false };
+ con_var< int > silent{ &holder_, fnv( "rage_silent" ), false };
+ con_var< int > aimkey{ &holder_, fnv( "rage_key" ), 0 };
+ con_var< bool > auto_scope{ &holder_, fnv( "rage_auto_scope" ), false };
+ con_var< bool > resolver{ &holder_, fnv( "rage_resolver" ), false };
+ con_var< bool > resolver_override{ &holder_, fnv( "rage_resolver_override" ), false };
+ con_var< bool > pitch_resolver{ &holder_, fnv( "rage_pitch_resolver" ) };
+ con_var< int > resolver_override_key{ &holder_, fnv( "override_key" ), 0 };
+ con_var< bool > bt_visualize{ &holder_, fnv( "rage_visualize_records" ), false };
+ con_var< clr_t > bt_col{ &holder_, fnv( "rage_bt_color" ), clr_t( 150, 150, 150, 20 ) };
+ con_var< int > fakelag_resolver{ &holder_, fnv( "rage_fakelag_resolver" ) };
+ con_var< bool > preserve_fps{ &holder_, fnv( "rage_preserve_fps" ), false };
+ con_var< int > multipoint{ &holder_, fnv( "rage_multipoint" ), false };
+ con_var< bool > compensate_spread{ &holder_, fnv( "rage_compensate_spread" ) };
+ con_var< bool > autowall_fps { &holder_, fnv( "rage_autowall_fps" ), false };
+
+ con_var< int > selection_type{ &holder_, fnv( "rage_selection_type" ) };
+ con_var< bool > prefer_moving{ &holder_, fnv( "rage_prefer_moving" ) };
+ con_var< bool > prefer_low_hp{ &holder_, fnv( "rage_low_hp" ) };
+
+ ragebot_settings general{ &holder_, "rage_general" };
+ ragebot_settings heavy_pistols{ &holder_, "rage_pistols" };
+ ragebot_settings snipers{ &holder_, "rage_snipers" };
+ ragebot_settings auto_snipers{ &holder_, "rage_auto" };
+ ragebot_settings* active = &general;
+
+ struct {
+ con_var< int > mode{ &holder_, fnv( "fakelag_mode" ), 0 };
+ con_var< int > ticks{ &holder_, fnv( "fakelag_ticks" ), 0 };
+ con_var< int > fluctuate{ &holder_, fnv( "fakelag_fluctuate" ), 0 };
+ con_var< bool > in_air{ &holder_, fnv( "fakelag_in_air" ), false };
+ con_var< bool > on_peek{ &holder_, fnv( "fakelag_on_peek" ), false };
+ con_var< bool > in_move{ &holder_, fnv( "fakelag_in_move" ), false };
+ con_var< bool > in_attack{ &holder_, fnv( "fakelag_in_attack" ), false };
+ con_var< bool > avoid_ground{ &holder_, fnv( "fakelag_avoid_ground" ), false };
+ } fakelag;
+
+ con_var< bool > anti_aim{ &holder_, fnv( "rage_anti_aim" ), false };
+ con_var< bool > dormant_check{ &holder_, fnv( "rage_dormant_check" ), false };
+ con_var< bool > at_players{ &holder_, fnv( "rage_at_players" ), false };
+ con_var< int > pitch{ &holder_, fnv( "rage_pitch" ), 0 };
+ con_var< int > pitch_offset{ &holder_, fnv( "rage_pitch_offset" ), 0 };
+
+ con_var< int > real_yaw{ &holder_, fnv( "rage_real_yaw" ), 0 };
+ con_var< int > real_yaw_add{ &holder_, fnv( "rage_real_yaw_add" ), 0 };
+ con_var< int > real_yaw_jitter{ &holder_, fnv( "rage_real_jitter" ), 0 };
+
+ con_var< int > air_yaw{ &holder_, fnv( "rage_air_yaw" ), 0 };
+ con_var< int > air_yaw_add{ &holder_, fnv( "rage_air_yaw_add" ), 0 };
+ con_var< int > air_yaw_jitter{ &holder_, fnv( "rage_air_yaw_jitter" ), 0 };
+
+ con_var< int > fake_yaw{ &holder_, fnv( "rage_fake_yaw" ), 0 };
+ con_var< int > fake_yaw_add{ &holder_, fnv( "rage_fake_yaw_add" ), 0 };
+ con_var< int > fake_yaw_jitter{ &holder_, fnv( "rage_fake_jitter" ), 0 };
+
+ con_var< int > real_yaw_moving{ &holder_, fnv( "rage_real_yaw_moving" ), 0 };
+ con_var< int > real_yaw_moving_add{ &holder_, fnv( "rage_real_yaw_moving_add" ), 0 };
+ con_var< int > real_moving_jitter{ &holder_, fnv( "rage_real_moving_jitter" ), 0 };
+
+ con_var< bool > edge_detection{ &holder_, fnv( "rage_edge_dtc" ), 0 };
+ con_var< int > edge_dtc_jitter{ &holder_, fnv( "rage_edge_dtc_jitter" ), 0 };
+
+ con_var< bool > break_lby_edge{ &holder_, fnv( "rage_break_lby_edge" ) };
+ con_var< int > edge_dtc_normal{ &holder_, fnv( "rage_edge_dtc_normal" ), 0 };
+ con_var< int > freestanding_distance{ &holder_, fnv( "rage_freestanding_dist" ), 50 };
+ con_var< int > edge_dtc_standing{ &holder_, fnv( "rage_edge_dtc_standing" ), 100 };
+ con_var< int > edge_dtc_moving{ &holder_, fnv( "rage_edge_dtc_moving" ), 100 };
+ con_var< int > edge_dtc_priority{ &holder_, fnv( "rage_edge_dtc_priority" ), 0 };
+ con_var< bool > edge_break_lby{ &holder_, fnv( "rage_edge_break_lby" ) };
+
+ con_var< bool > break_lby{ &holder_, fnv( "rage_break_lby" ), 0 };
+ con_var< int > lby_delta{ &holder_, fnv( "rage_lby_delta" ), 180 };
+ con_var< bool > lby_avoid_updates{ &holder_, fnv( "rage_lby_avoid_updates" ) };
+
+ con_var< bool > fakewalk{ &holder_, fnv( "rage_fakewalk" ), 0 };
+ con_var< int > fakewalk_key{ &holder_, fnv( "rage_fakewalk_key" ), 0 };
+ con_var< int > fakewalk_ticks{ &holder_, fnv( "rage_fakewalk_ticks" ), 7 };
+
+ con_var< bool > angle_step{ &holder_, fnv( "rage_angle_step" ), false };
+ con_var< int > angle_step_degrees{ &holder_, fnv( "range_angle_step_degrees" ), false };
+ } rage;
+
+ struct {
+ struct {
+ con_var< bool > enabled{ &holder_, fnv( "visuals_chams_enabled" ), 0 };
+ con_var< bool > flat{ &holder_, fnv( "visuals_chams_flat" ), 0 };
+ con_var< bool > ignore_z{ &holder_, fnv( "visuals_chams_ignore_z" ), 0 };
+ con_var< float > reflectivity{ &holder_, fnv( "visuals_chams_reflectivity" ), 1.0f };
+ con_var< float > shine{ &holder_, fnv( "visuals_chams_shine" ), 1.0f };
+ con_var< bool > friendlies{ &holder_, fnv( "visuals_chams_friendlies" ), 0 };
+ con_var< clr_t > color_visible_friendly{ &holder_, fnv( "visuals_chams_color_friendly" ), clr_t( 0, 255, 255 ) };
+ con_var< clr_t > color_visible_enemy{ &holder_, fnv( "visuals_chams_color_enemy" ), clr_t( 255, 255, 0 ) };
+ con_var< clr_t > color_hidden_friendly{ &holder_, fnv( "visuals_chams_color_h_friendly" ), clr_t( 0, 0, 255 ) };
+ con_var< clr_t > color_hidden_enemy{ &holder_, fnv( "visuals_chams_color_h_enemy" ), clr_t( 255, 0, 0 ) };
+ con_var< bool > clear_occlusion{ &holder_, fnv( "visuals_chams_clear_occlusion" ) };
+ } chams;
+
+ con_var< int > activation_type{ &holder_, fnv( "visuals_activation" ), false };
+ con_var< bool > box{ &holder_, fnv( "visuals_box" ), false };
+ con_var< bool > dormant{ &holder_, fnv( "visuals_dormant" ), false };
+ con_var< bool > health{ &holder_, fnv( "visuals_health" ), false };
+ con_var< bool > weapon{ &holder_, fnv( "visuals_weapon" ), false };
+ con_var< bool > name{ &holder_, fnv( "visuals_name" ), false };
+ con_var< bool > out_of_pov{ &holder_, fnv( "visuals_out_of_pov" ), false };
+ con_var< float > out_of_pov_radius{ &holder_, fnv( "visuals_out_of_pov_radius" ), 0.75f };
+ con_var< int > out_of_pov_size{ &holder_, fnv( "visuals_out_of_pov_size" ), 25 };
+ con_var< bool > friendlies{ &holder_, fnv( "visuals_friendlies" ), false };
+ con_var< bool > skeleton{ &holder_, fnv( "visuals_skeleton" ) };
+ con_var< bool > glow{ &holder_, fnv( "visuals_glow" ), false };
+ con_var< bool > flags{ &holder_, fnv( "visuals_flags" ), false };
+ con_var< bool > resolver_indicator{ &holder_, fnv( "visuals_resolver_indicator" ), false };
+ con_var< bool > ammo{ &holder_, fnv( "visuals_ammo" ), false };
+ con_var< bool > money{ &holder_, fnv( "visuals_money" ) };
+ con_var< bool > ping{ &holder_, fnv( "visuals_ping" ) };
+ con_var< bool > floating_ragdolls{ &holder_, fnv( "visuals_floating_ragdolls" ) };
+ con_var< bool > sound{ &holder_, fnv( "visuals_sound" ), false };
+ con_var< clr_t > box_enemy{ &holder_, fnv( "visuals_clr_enemy" ), clr_t( 0, 255, 255 ) };
+ con_var< clr_t > box_friendly{ &holder_, fnv( "visuals_clr_friendly" ), clr_t( 255, 0, 255 ) };
+
+ con_var< clr_t > glow_enemy{ &holder_, fnv( "visuals_glow_enemy" ), clr_t( 255, 0, 255, 150 ) };
+ con_var< clr_t > glow_friendly{ &holder_, fnv( "visuals_glow_friendly" ), clr_t( 255, 120, 0, 150 ) };
+ con_var< clr_t > skeleton_enemy{ &holder_, fnv( "visuals_skeleton_enemy" ), clr_t( 255, 255, 255 ) };
+ con_var< clr_t > skeleton_friendly{ &holder_, fnv( "visuals_skeleton_friendly" ), clr_t( 255, 255, 255 ) };
+
+ con_var< clr_t > name_enemy{ &holder_, fnv( "visuals_name_enemy" ), clr_t( 255, 255, 255 ) };
+ con_var< clr_t > name_friendly{ &holder_, fnv( "visuals_name_friendly" ), clr_t( 255, 255, 255 ) };
+
+ con_var< clr_t > ammo_bar_clr{ &holder_, fnv( "visuals_ammo_bar_clr" ), clr_t( 84, 173, 247 ) };
+ con_var< clr_t > lby_bar_clr{ &holder_, fnv( "visuals_lby_bar_clr" ), clr_t( 0xf4, 0x7c, 0xa8 ) };
+
+ con_var< int > bullet_tracers{ &holder_, fnv( "visuals_bullet_tracers" ), 0 };
+ con_var< bool > target{ &holder_, fnv( "visuals_target" ) };
+ con_var< int > target_time{ &holder_, fnv( "visuals_target_time" ) };
+ con_var< int > sound_range{ &holder_, fnv( "visuals_sound_range" ), 360 };
+
+ con_var< int > key{ &holder_, fnv( "visuals_key" ), 0 };
+ con_var< bool > hitmarkers{ &holder_, fnv( "visuals_hitmarkers" ), false };
+ bool active = true;
+
+ con_var< bool > world_modulate{ &holder_, fnv( "visuals_world_modulate" ), false };
+ con_var< bool > night_mode{ &holder_, fnv( "visuals_night_mode" ), false };
+ con_var< bool > transparent_props{ &holder_, fnv( "visuals_transparent_props" ), false };
+
+ con_var< bool > recoil_crosshair{ &holder_, fnv( "misc_recoil_crosshair" ), false };
+ con_var< bool > autowall_crosshair{ &holder_, fnv( "visual_recoil_crosshair" ), false };
+ con_var< bool > draw_spread{ &holder_, fnv( "visual_draw_spread" ), false };
+ con_var< bool > snipers_crosshair{ &holder_, fnv( "visuals_sniper_crosshair" ), false };
+ con_var< bool > grenade_prediction{ &holder_, fnv( "visuals_grenade_prediction" ), false };
+
+ con_var< int > weapon_esp{ &holder_, fnv( "visuals_weapon_esp" ), 0 };
+ con_var< int > grenade_esp{ &holder_, fnv( "visuals_grenade_esp" ), 0 };
+ con_var< bool > grenade_owner{ &holder_, fnv( "visuals_grenade_owner" ), false };
+
+ con_var< clr_t > weapon_esp_clr{ &holder_, fnv( "visuals_weapon_esp_clr" ), clr_t( 255, 255, 255, 180 ) };
+ con_var< clr_t > grenade_esp_clr{ &holder_, fnv( "visuals_grenade_esp_clr" ), clr_t( 255, 255, 255, 180 ) };
+
+ con_var< bool > spec_list{ &holder_, fnv( "visuals_spec_list" ), false };
+ con_var< bool > radar{ &holder_, fnv( "visuals_radar" ), false };
+ con_var< bool > fullbright{ &holder_, fnv( "visuals_fullbright" ), false };
+ con_var< bool > bomb_info{ &holder_, fnv( "visuals_bomb_information" ), false };
+ } visuals;
+
+ struct {
+ con_var< bool > watermark{ &holder_, fnv( "misc_watermark" ), false };
+ con_var< bool > bunny_hop{ &holder_, fnv( "misc_bhop" ), false };
+ con_var< bool > auto_strafe{ &holder_, fnv( "misc_autostrafe" ), false };
+ con_var< bool > circle_strafe{ &holder_, fnv( "misc_circlestrafe" ), false };
+ con_var< int > circle_strafe_key{ &holder_, fnv( "misc_circle_key" ), 0 };
+ con_var< bool > edge_jump{ &holder_, fnv( "misc_edgejump" ), false };
+ con_var< int > edge_jump_key{ &holder_, fnv( "misc_edge_jump_key" ), false };
+ con_var< bool > auto_jumpbug{ &holder_, fnv( "misc_auto_jumpbug" ), false };
+ con_var< int > auto_jumpbug_key{ &holder_, fnv( "misc_auto_jumpbug_key" ), 0 };
+ con_var< bool > show_jump_stats{ &holder_, fnv( "misc_show_jump_stats" ), 0 };
+ con_var< int > viewmodel_fov{ &holder_, fnv( "misc_viewmodel_fov" ), 0 };
+ con_var< int > fov_changer{ &holder_, fnv( "fov_changer" ), 90 };
+ con_var< bool > clantag_changer{ &holder_, fnv( "misc_clantag" ), false };
+ con_var< bool > log_hits{ &holder_, fnv( "misc_log_hits" ) };
+ con_var< int > name_changer{ &holder_, fnv( "misc_namechanger" ), 0 };
+ con_var< bool > thirdperson{ &holder_, fnv( "misc_thirdperson" ), false };
+ con_var< int > thirdperson_key{ &holder_, fnv( "misc_tp_key" ), 0 };
+ con_var< bool > auto_accept{ &holder_, fnv( "misc_autoaccept" ), false };
+ con_var< int > auto_accept_delay{ &holder_, fnv( "misc_autoaccept_delay" ), 0 };
+ con_var< int > net_fakelag{ &holder_, fnv( "misc_net_fakelag" ), false };
+ con_var< int > net_fakeping_amount{ &holder_, fnv( "net_fakeping_amount" ), 0 };
+ con_var< int > net_fakeping_key{ &holder_, fnv( "net_fakeping_key" ), 0 };
+ con_var< bool > air_duck{ &holder_, fnv( "air_duck" ) };
+ bool net_fakeping_active = false;
+
+ struct {
+ con_var< int > main_weapon{ &holder_, fnv( "misc_autobuy_main_weapon" ), 0 };
+ con_var< int > secondary_weapon{ &holder_, fnv( "misc_autobuy_secondary_weapon" ), 0 };
+ con_var< bool > zeus{ &holder_, fnv( "misc_autobuy_zeus" ), false };
+ con_var< bool > armor{ &holder_, fnv( "misc_autobuy_armor" ), false };
+ con_var< bool > defuser{ &holder_, fnv( "misc_autobuy_defuse" ), false };
+ con_var< bool > molly{ &holder_, fnv( "misc_autobuy_molly" ), false };
+ con_var< bool > grenade{ &holder_, fnv( "misc_autobuy_nade" ), false };
+ con_var< bool > smoke{ &holder_, fnv( "misc_autobuy_smoke" ), false };
+ con_var< bool > flash{ &holder_, fnv( "misc_autobuy_flash" ), false };
+ con_var< bool > decoy{ &holder_, fnv( "misc_autobuy_decoy" ), false };
+ } autobuy;
+
+ con_var< bool > team_dmg{ &holder_, fnv( "misc_teamdmg" ), false };
+ con_var< bool > server_information{ &holder_, fnv( "misc_server_info" ), false };
+ con_var< bool > rich_presence{ &holder_, fnv( "misc_rich_presence" ), false };
+ con_var< bool > no_sound{ &holder_, fnv( "misc_no_sound" ), false };
+ con_var< bool > rank_reveal{ &holder_, fnv( "misc_rank_reveal" ), 0 };
+ con_var< bool > unlock_inventory{ &holder_, fnv( "misc_unlock_inventory" ), 0 };
+ con_var< bool > auto_revolver{ &holder_, fnv( "misc_auto_revolver" ), 0 };
+ con_var< bool > no_scope{ &holder_, fnv( "misc_no_scope" ), false };
+ con_var< bool > no_zoom{ &holder_, fnv( "misc_no_zoom" ), false };
+ con_var< bool > no_recoil{ &holder_, fnv( "misc_no_recoil" ), false };
+ con_var< bool > no_smoke{ &holder_, fnv( "misc_no_smoke" ), false };
+ con_var< bool > no_flash{ &holder_, fnv( "misc_no_flash" ), false };
+ con_var< bool > transparent_vm{ &holder_, fnv( "misc_transparent_vm" ), false };
+ con_var< bool > hide_from_obs{ &holder_, fnv( "misc_hide_from_obs" ), false };
+ con_var< bool > disable_post_process{ &holder_, fnv( "misc_disable_post_process" ), false };
+ con_var< int > recording_start_key{ &holder_, fnv( "recording_start_key" ), 0 };
+ con_var< int > recording_stop_key{ &holder_, fnv( "recording_stop_key" ), 0 };
+ con_var< int > recording_show_angles{ &holder_, fnv( "recording_show_angles" ), 0 };
+
+ con_var< bool > money_talk { &holder_, fnv( "misc_money_talk" ), false };
+
+ struct {
+ con_var< int > knife{ &holder_, fnv( "misc_skins_knife" ), 0 };
+ con_var< int > glove{ &holder_, fnv( "misc_skins_glove" ), 0 };
+ con_var< int > glove_skin{ &holder_, fnv( "misc_skins_glove_skin" ) };
+ int current_skin;
+ con_var< std::array< int, 65 > > skins{ &holder_, fnv( "misc_skins_data" ) };
+ } skins;
+
+ bool recorder_enable = false;
+ } misc;
+
+ struct {
+ con_var< uint8_t > menu_color_1r{ &holder_, fnv( "menu_color_1r" ), 231 };
+ con_var< uint8_t > menu_color_1g{ &holder_, fnv( "menu_color_1g" ), 105 };
+ con_var< uint8_t > menu_color_1b{ &holder_, fnv( "menu_color_1b" ), 105 };
+
+ con_var< uint8_t > menu_color_2r{ &holder_, fnv( "menu_color_2r" ), 0xf4 };
+ con_var< uint8_t > menu_color_2g{ &holder_, fnv( "menu_color_2g" ), 0x7c };
+ con_var< uint8_t > menu_color_2b{ &holder_, fnv( "menu_color_2b" ), 0xa8 };
+
+ bool anti_untrusted = true;
+ bool open = false;
+ bool logs_enable = false;
+ int cur_setting = 0;
+ } menu;
+ };
+}
+
+extern data::c_settings g_settings;
\ No newline at end of file diff --git a/internal_rewrite/shut_down.cpp b/internal_rewrite/shut_down.cpp new file mode 100644 index 0000000..9a0ec0d --- /dev/null +++ b/internal_rewrite/shut_down.cpp @@ -0,0 +1,14 @@ +#include "hooks.hpp" +#include "chams.hpp" +#include "base_cheat.hpp" + +void __fastcall hooks::shut_down( void* ecx_, void* edx_ ) { + static auto original_fn = g_csgo.m_chl->get_old_function< decltype( &shut_down ) >( 3 ); + + g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "host_writeconfig" ) ); + //fuck you + abort( ); + + g_cheat.m_chams.m_materials.destroy_materials( ); + return original_fn( ecx_, edx_ ); +}
\ No newline at end of file diff --git a/internal_rewrite/simple_settings.cpp b/internal_rewrite/simple_settings.cpp new file mode 100644 index 0000000..b6b3281 --- /dev/null +++ b/internal_rewrite/simple_settings.cpp @@ -0,0 +1,32 @@ +#include "settings.hpp" + +SettingHolder data::holder_{ "iloveyou" }; +data::c_settings g_settings; + +#pragma warning(disable: 4996) + +void simple_save( const char* path, const char* name, const void* src, size_t size, const char* filename ) { + auto buffer = reinterpret_cast< char* >( _alloca( size * 2 + 1 ) ); + auto data = reinterpret_cast< const uint8_t* >( src ); + + for ( size_t i = 0; i < size; i++ ) + sprintf( &buffer[ 2 * i ], "%02X", data[ i ] ); + + WritePrivateProfileStringA( path, name, buffer, filename ); +} + +void simple_load( const char* path, const char* name, void* dest, size_t size, const char* filename ) { + auto buffer = reinterpret_cast< char* >( _alloca( size * 2 + 1 ) ); + auto data = reinterpret_cast< uint8_t* >( dest ); + + GetPrivateProfileStringA( path, name, "", buffer, size * 2 + 1, filename ); + + if ( *buffer == 0 ) + return; + + for ( size_t i = 0; i < size; i++ ) { + unsigned temp; + sscanf( &buffer[ 2 * i ], "%02X", &temp ); + data[ i ] = temp; + } +}
\ No newline at end of file diff --git a/internal_rewrite/simple_settings.hpp b/internal_rewrite/simple_settings.hpp new file mode 100644 index 0000000..71fd627 --- /dev/null +++ b/internal_rewrite/simple_settings.hpp @@ -0,0 +1,204 @@ +#pragma once +#include <Windows.h> +#include <memory> +#include <vector> +#include <string> + +#include "util.hpp" +#include "fnv.hpp" + +//nama stuff +extern void simple_save( const char* path, const char* name, const void* src, size_t size, const char* filename ); +extern void simple_load( const char* path, const char* name, void* dest, size_t size, const char* filename ); + +class ISettingNode { +public: + virtual ~ISettingNode( ) = default; + + virtual void load( const char* path, const char* file ) = 0; + virtual void save( const char* path, const char* file ) const = 0; + virtual void register_( ISettingNode* node_ptr ) = 0; + virtual bool has_nodes( ) { return false; } + virtual hash_t get_hash( ) { return 0; } +}; + +class SettingHolder : public ISettingNode { +public: + __forceinline SettingHolder( const char* name ) : name_( name ) {} + __forceinline SettingHolder( SettingHolder* holder_ptr, const char* name ) : name_( name ) { holder_ptr->register_( this ); } + + void register_( ISettingNode* node_ptr ) override { + setting_nodes_.push_back( node_ptr ); + } + + void load( const char* path, const char* file ) override { + char full_path[ 64 ]; + strcpy_s( full_path, path ); + strcat_s( full_path, "_" ); + strcat_s( full_path, name_ ); + for ( auto x : setting_nodes_ ) + x->load( full_path, file ); + } + + void save( const char* path, const char* file ) const override { + char full_path[ 64 ]; + strcpy_s( full_path, path ); + strcat_s( full_path, "_" ); + strcat_s( full_path, name_ ); + for ( auto x : setting_nodes_ ) + x->save( full_path, file ); + } + + auto& get_nodes( ) { + return setting_nodes_; + } + + virtual bool has_nodes( ) { + return true; + } + +private: + const char* name_; + bool has_nodes_; + std::vector<ISettingNode*> setting_nodes_; +}; + +class ISetting : public ISettingNode { + void register_( ISettingNode* node_ptr ) override {} +public: + virtual void set( float value ) = 0; + virtual void set( int value ) = 0; + virtual void set( ulong_t value ) = 0; + virtual std::string get_string( ) = 0; + virtual hash_t get_hash( ) = 0; + virtual std::string get_data_string( ) = 0; + virtual void load_from_string( const std::string& ) = 0; +}; + +template < size_t L > +class SettingString : ISetting { +public: + __forceinline SettingString( SettingHolder* holder_ptr, hash_t hash ) : + m_name( name ), m_value( "" ) { + holder_ptr->register_( this ); + }; + + void load( const char* path, const char* file ) override { + GetPrivateProfileStringA( path, std::to_string( m_name ).c_str( ), "", m_value, L, file ); + } + + void save( const char* path, const char* file ) const override { + WritePrivateProfileStringA( path, std::to_string( m_name ).c_str( ), m_value, file ); + } + + char* get( ) { + return m_value; + } + +private: + char m_value[ L ]; + hash_t m_name; +}; + +template < typename T > +class con_var : public ISetting { +public: + __forceinline con_var( SettingHolder* holder_ptr, hash_t name ) : + name_( name ), + is_float_( std::is_floating_point_v< T > ), + is_integral_( std::is_integral_v< T > ) { + holder_ptr->register_( this ); + } + __forceinline con_var( SettingHolder* holder_ptr, hash_t name , const T& rhs ) : + value_( rhs ), + name_( name ), + is_float_( std::is_floating_point_v< T > ), + is_integral_( std::is_integral_v< T > ) { + holder_ptr->register_( this ); + } + + void load( const char* path, const char* file ) override { simple_load( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), file ); } + + void save( const char* path, const char* file ) const override { simple_save( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), file ); } + + __forceinline operator T&( ) { return value_; } + __forceinline T* operator &( ) { return &value_; } + + __forceinline T& operator ()( ) { return value_; } + + virtual std::string get_string( ) { + if constexpr( std::is_arithmetic_v< T > ) { + return std::to_string( value_ ); + } + else { + return util::to_hex_str( *( ulong_t* )( &value_ ) ); + } + } + + virtual void set( float value ) { + if constexpr( std::is_arithmetic_v< T > ) { + value_ = ( T )( value ); + } + } + + virtual void set( int value ) { + if constexpr( std::is_arithmetic_v< T > ) { + value_ = ( T )( value ); + } + else { + value_ = *( T* )( &value ); + } + } + + virtual void set( ulong_t value ) { + if constexpr( sizeof( T ) == sizeof( ulong_t ) ) { + *( ulong_t* )( &value_ ) = value; + return; + } + + memcpy( &value_, &value, sizeof( value_ ) ); + } + + virtual hash_t get_hash( ) { + return name_; + } + + __forceinline bool is_floating_point( ) { + return is_float_; + } + + __forceinline bool is_integral( ) { + return is_integral_; + } + + virtual std::string get_data_string( ) override { + auto buffer = reinterpret_cast< char* >( _alloca( sizeof( T ) * 2 + 1 ) ); + auto data = reinterpret_cast< const uint8_t* >( &value_ ); + + for( size_t i = 0; i < sizeof( T ); i++ ) + sprintf( &buffer[ 2 * i ], "%02X", data[ i ] ); + + return buffer; + } + + virtual void load_from_string( const std::string& str ) override { + auto data = reinterpret_cast< uint8_t* >( &value_ ); + auto buffer = str.data( ); + + if( *buffer == 0 ) + return; + + for( size_t i = 0; i < sizeof( T ); i++ ) { + unsigned temp; + sscanf( &buffer[ 2 * i ], "%02X", &temp ); + data[ i ] = temp; + } + } + + +private: + hash_t name_; + bool is_float_; + bool is_integral_; + T value_; +};
\ No newline at end of file diff --git a/internal_rewrite/simulate.cpp b/internal_rewrite/simulate.cpp new file mode 100644 index 0000000..2e47483 --- /dev/null +++ b/internal_rewrite/simulate.cpp @@ -0,0 +1,41 @@ +#include <intrin.h>
+
+#include "hooks.hpp"
+#include "base_cheat.hpp"
+#include "context.hpp"
+
+void __fastcall hooks::simulate( void* ecx, void* edx ) {
+ static auto simulate_o = g_csgo.m_engine_vgui->get_old_function< decltype( &hooks::simulate ) >( 39 );
+
+ static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_engine.dll( ), "8B CE 6A FF 8B 06", -0x81 );
+ if( _ReturnAddress( ) == ret_addr ) {
+ g_ctx.m_stage = FRAME_RENDER_START;
+ g_cheat.m_visuals.world_modulate( );
+
+ //g_con->game_console_print( "render start\n" );
+ g_cheat.m_extra.disable_post_processing( );
+ g_cheat.m_extra.no_flash( );
+ g_cheat.m_extra.no_recoil( false );
+ util::disable_pvs( );
+ g_cheat.m_ragebot.m_lagcomp->fsn_render_start( );
+ //g_cheat.m_ragebot.m_lagcomp->invalidate_bone_caches( );
+ if( g_csgo.m_input( )->m_fCameraInThirdPerson ) {
+ bool real_yaw = g_settings.rage.anti_aim( );
+ if( g_ctx.get_last_cmd( ) && g_ctx.m_local && g_ctx.m_local->is_valid( ) ) {
+ //g_ctx.m_local->m_vecThirdpersonAngles( ) = ( real_yaw ? g_ctx.m_thirdperson_angle : g_ctx.get_last_cmd( )->m_viewangles );
+ }
+ }
+
+ g_cheat.m_extra.no_smoke( );
+ if( g_settings.misc.no_smoke ) {
+ static auto smoke_count = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "55 8B EC 83 EC 08 8B 15 ? ? ? ? 0F 57 C0" ) );
+ **reinterpret_cast< int** >( smoke_count + 0x8 ) = 0;
+ }
+
+ simulate_o( ecx, edx );
+ }
+ else {
+ simulate_o( ecx, edx );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/skins.cpp b/internal_rewrite/skins.cpp new file mode 100644 index 0000000..4abef06 --- /dev/null +++ b/internal_rewrite/skins.cpp @@ -0,0 +1,271 @@ +#include "skins.hpp"
+#include "settings.hpp"
+#include "context.hpp"
+#include "interface.hpp"
+
+namespace features
+{
+ int c_skins::get_knife_index( ) {
+ switch( g_settings.misc.skins.knife( ) ) {
+ case 0:
+ return 0;
+ case 1:
+ return 500;
+ case 2:
+ return 505;
+ case 3:
+ return 506;
+ case 4:
+ return 507;
+ case 5:
+ return 508;
+ case 6:
+ return 509;
+ }
+
+ return 0;
+ }
+
+ const char* c_skins::get_model_str( ) {
+ switch( g_settings.misc.skins.knife( ) ) {
+ case 0:
+ return 0;
+ case 1:
+ return xors( "models/weapons/v_knife_bayonet.mdl" );
+ case 2:
+ return xors( "models/weapons/v_knife_flip.mdl" );
+ case 3:
+ return xors( "models/weapons/v_knife_gut.mdl" );
+ case 4:
+ return xors( "models/weapons/v_knife_karam.mdl" );
+ case 5:
+ return xors( "models/weapons/v_knife_m9_bay.mdl" );
+ case 6:
+ return xors( "models/weapons/v_knife_tactical.mdl" );
+ }
+
+ return nullptr;
+ }
+
+ const char* c_skins::get_glove_model( ) {
+ switch( g_settings.misc.skins.glove ) {
+ case 5027:
+ return xors( "models/weapons/v_models/arms/glove_bloodhound/v_glove_bloodhound.mdl" );
+ case 5030:
+ return xors( "models/weapons/v_models/arms/glove_sporty/v_glove_sporty.mdl" );
+ case 5031:
+ return xors( "models/weapons/v_models/arms/glove_slick/v_glove_slick.mdl" );
+ case 5032:
+ return xors( "models/weapons/v_models/arms/glove_handwrap_leathery/v_glove_handwrap_leathery.mdl" );
+ case 5033:
+ return xors( "models/weapons/v_models/arms/glove_motorcycle/v_glove_motorcycle.mdl" );
+ case 5034:
+ return xors( "models/weapons/v_models/arms/glove_specialist/v_glove_specialist.mdl" );
+ }
+
+ return nullptr;
+ }
+
+ const char* c_skins::get_killicon_str( ) {
+ switch( g_settings.misc.skins.knife( ) ) {
+ case 0:
+ return 0;
+ case 1:
+ return xors( "bayonet" );
+ case 2:
+ return xors( "knife_flip" );
+ case 3:
+ return xors( "knife_gut" );
+ case 4:
+ return xors( "knife_karambit" );
+ case 5:
+ return xors( "knife_m9_bayonet" );
+ case 6:
+ return xors( "knife_tactical" );
+ }
+
+ return nullptr;
+ }
+
+ int c_skins::get_current_weapon_id( ) {
+ if( !g_ctx.m_local || !g_ctx.m_local->is_valid( ) )
+ return WEAPON_KNIFE;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon )
+ return WEAPON_KNIFE;
+
+ return get_weapon_id( weapon );
+ }
+
+ int c_skins::get_weapon_id( c_base_weapon* weapon ) {
+ if( weapon->is_knife( ) || weapon->is_grenade( ) )
+ return WEAPON_KNIFE;
+
+ if( weapon->m_iItemDefinitionIndex( ) == WEAPON_TASER )
+ return WEAPON_KNIFE;
+
+ return std::clamp< int >( weapon->m_iItemDefinitionIndex( ), 0, 64 );
+ }
+
+ // This is nasty.
+ void c_skins::replace_deaths( IGameEvent* event ) {
+ if( !strcmp( event->GetName( ), xors( "player_death" ) ) && g_csgo.m_engine( )->GetPlayerForUserID( event->GetInt( xors( "attacker" ) ) ) == g_csgo.m_engine( )->GetLocalPlayer( ) ) {
+ if( ( !strcmp( event->GetString( xors( "weapon" ) ), xors( "knife_default_ct" ) ) || !strcmp( event->GetString( xors( "weapon" ) ), xors( "knife_t" ) ) ) ) {
+ if( get_killicon_str( ) )
+ event->SetString( xors( "weapon" ), get_killicon_str( ) );
+ }
+ }
+ }
+
+ //stop this
+ void c_skins::override_weapon( c_base_weapon* wep ) {
+ auto aw = g_csgo.m_entlist( )->GetClientEntityFromHandle< c_base_weapon >( g_ctx.m_local->m_hActiveWeapon( ) );
+ auto vm = g_csgo.m_entlist( )->GetClientEntityFromHandle< c_base_weapon >( g_ctx.m_local->m_hViewModel( ) );
+ auto wm = g_csgo.m_entlist( )->GetClientEntityFromHandle< c_base_weapon >( g_ctx.m_local->get_weapon( )->m_hWeaponWorldModel( ) );
+
+ auto info = g_ctx.m_local->get_info( );
+ int index = get_knife_index( );
+
+ if( wep->is_knife( ) && index ) {
+ int model = g_csgo.m_model_info( )->GetModelIndex( get_model_str( ) );
+
+ wep->m_iItemDefinitionIndex( ) = index;
+ wep->m_nModelIndex( ) = model;
+ wep->m_iWorldDroppedModelIndex( ) = model + 2;
+ wep->m_iWorldModelIndex( ) = model + 1;
+ wep->m_iViewModelIndex( ) = model;
+ wep->m_iItemIDHigh( ) = -1;
+ wep->m_iEntityQuality( ) = 3;
+
+ if( aw->m_iItemDefinitionIndex( ) == wep->m_iItemDefinitionIndex( ) )
+ vm->m_nModelIndex( ) = model;
+
+ if( wm && wep == aw ) {
+ wm->m_nModelIndex( ) = model + 1;
+ }
+ }
+
+ if( m_last_index != g_settings.misc.skins.current_skin ) {
+ g_settings.misc.skins.skins( )[ get_current_weapon_id( ) ] = g_settings.misc.skins.current_skin;
+
+ if( g_csgo.m_global_state->get_client_state( )->m_delta_tick != -1 ) {
+ g_csgo.m_global_state->get_client_state( )->m_delta_tick = -1; // fullupdate happens
+ }
+
+
+ m_last_index = g_settings.misc.skins.current_skin;
+ g_ctx.run_frame( );
+ }
+
+ if( ( wep->m_hOwner( ) & 0xfff ) == g_ctx.m_local->ce( )->GetIndex( ) ) {
+ if( g_settings.misc.skins.skins( )[ get_weapon_id( wep ) ] <= 0 )
+ return;
+
+ if( g_settings.misc.skins.skins( )[ get_weapon_id( wep ) ] != wep->m_nFallbackPaintKit( ) ) {
+ wep->m_iItemIDHigh( ) = -1;
+ wep->m_iAccountID( ) = info.m_xuidlow;
+ }
+
+ wep->m_nFallbackPaintKit( ) = g_settings.misc.skins.skins( )[ get_weapon_id( wep ) ];
+ wep->m_nFallbackStatTrak( ) = -1;
+ wep->m_nFallbackSeed( ) = math::random_number( 0, 1000 );
+
+ wep->m_flFallbackWear( ) = 0.0000001f;
+ }
+ }
+
+ void c_skins::override_gloves( ) {
+ static int last_glove = 0;
+ static int last_skin = 0;
+ static ulong_t glove_handle = 0;
+ auto wearables = ( uint32_t* )( uintptr_t( g_ctx.m_local ) + 0x2EF4 );
+
+ auto glove = ( c_base_weapon* )( g_csgo.m_entlist( )->GetClientEntityFromHandle( wearables[ 0 ] ) );
+
+ if( !glove ) {
+ auto last_glove = ( c_base_weapon* )( g_csgo.m_entlist( )->GetClientEntityFromHandle( glove_handle ) );
+
+ if( last_glove ) {
+ wearables[ 0 ] = glove_handle;
+ glove = last_glove;
+ }
+ }
+
+ if( !g_ctx.m_local->is_alive( ) || !g_settings.misc.skins.glove ) {
+ if( glove ) {
+ glove->ce( )->GetClientNetworkable( )->SetDestroyedOnRecreateEntities( );
+ glove->ce( )->GetClientNetworkable( )->Release( );
+ }
+
+ return;
+ }
+
+ if( !g_settings.misc.skins.glove || !g_settings.misc.skins.glove_skin )
+ return;
+
+ bool update = false;
+ if( last_glove != g_settings.misc.skins.glove || last_skin != g_settings.misc.skins.glove_skin ) {
+ g_csgo.m_global_state->get_client_state( )->m_delta_tick = -1;
+ update = true;
+ }
+
+ last_glove = g_settings.misc.skins.glove;
+ last_skin = g_settings.misc.skins.glove_skin;
+
+ if( !glove ) {
+ for( auto cc = g_csgo.m_chl( )->GetAllClasses( ); !!cc; cc = cc->m_next ) {
+ if( cc->m_class_id != CEconWearable )
+ continue;
+
+ int entry = g_csgo.m_entlist( )->GetHighestEntityIndex( ) + 1;
+ int serial = math::random_number( 0, 4095 );
+
+ cc->m_create_fn( entry, serial );
+
+ glove = g_csgo.m_entlist( )->GetClientEntity< c_base_weapon >( entry );
+ wearables[ 0 ] = entry | serial << 16;
+ glove_handle = wearables[ 0 ];
+ update = true;
+
+ break;
+ }
+ }
+
+ if( glove ) {
+ auto desired_glove = g_settings.misc.skins.glove;
+ if( !desired_glove )
+ return;
+
+ glove->m_iItemDefinitionIndex( ) = desired_glove;
+ glove->m_nFallbackPaintKit( ) = g_settings.misc.skins.glove_skin;
+ glove->m_iEntityQuality( ) = 4;
+ glove->m_nFallbackSeed( ) = math::random_number( 0, 600 );
+ glove->m_iItemIDHigh( ) = -1;
+ glove->m_iAccountID( ) = g_ctx.m_local->get_info( ).m_xuidlow;
+
+ if( update ) {
+ int model_index = g_csgo.m_model_info( )->GetModelIndex( get_glove_model( ) );
+ glove->set_glove_model( desired_glove );
+ glove->ce( )->GetClientNetworkable( )->PreDataUpdate( 0 );
+ }
+ }
+ }
+
+
+ void c_skins::operator()( ) {
+ if( g_csgo.m_engine( )->IsInGame( ) && g_ctx.run_frame( ) && g_ctx.m_local->is_player( ) ) {
+ override_gloves( );
+
+ if( g_ctx.m_local->m_iHealth( ) > 0 && g_ctx.m_local->get_weapon( ) ) {
+ auto weapons = ( uint32_t* )( uintptr_t( g_ctx.m_local ) + 0x2DE8 );
+ for( int i{ }; weapons[ i ]; ++i ) {
+ auto wep = g_csgo.m_entlist( )->GetClientEntityFromHandle< c_base_weapon >( weapons[ i ] );
+ if( wep && wep->m_OriginalOwnerXuidLow( ) == g_ctx.m_local->get_info( ).m_xuidlow && !wep->is_grenade( ) && wep->m_iItemDefinitionIndex( ) != WEAPON_TASER ) {
+ override_weapon( wep );
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/skins.hpp b/internal_rewrite/skins.hpp new file mode 100644 index 0000000..f60deef --- /dev/null +++ b/internal_rewrite/skins.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include <cstring> + +class c_base_weapon; +class IGameEvent; +namespace features +{ + class c_skins { + private: + int m_last_index{ 0 }; + bool m_needs_update{ }; + + int get_knife_index( ); + const char* get_model_str( ); + + const char* get_glove_model( ); + + const char* get_killicon_str( ); + + //void override_knife( ); + void override_gloves( ); + void override_weapon( c_base_weapon* wep ); + //void update_active_skin( ); + int get_current_weapon_id( ); + int get_weapon_id( c_base_weapon* ); + + + public: + void operator()( ); + void replace_deaths( IGameEvent* event ); + }; +}
\ No newline at end of file diff --git a/internal_rewrite/strings.hpp b/internal_rewrite/strings.hpp new file mode 100644 index 0000000..f34c082 --- /dev/null +++ b/internal_rewrite/strings.hpp @@ -0,0 +1,162 @@ +//-------------------------------------------------------------------------------- +//-- XorCompileTime.hpp +// +// Author: frk +// Date: 12.12.2015 +// +//-------------------------------------------------------------------------------- + +#pragma once +#include <string> +#include <array> +#include <cstdarg> + +#define BEGIN_NAMESPACE( x ) namespace x { +#define END_NAMESPACE } + +BEGIN_NAMESPACE( strenc ) + +constexpr auto time = __TIME__; +constexpr auto seed = static_cast< int >( time[ 7 ] ) + static_cast< int >( time[ 6 ] ) * 10 + static_cast< int >( time[ 4 ] ) * 60 + static_cast< int >( time[ 3 ] ) * 600 + static_cast< int >( time[ 1 ] ) * 3600 + static_cast< int >( time[ 0 ] ) * 36000; + +// 1988, Stephen Park and Keith Miller +// "Random Number Generators: Good Ones Are Hard To Find", considered as "minimal standard" +// Park-Miller 31 bit pseudo-random number generator, implemented with G. Carta's optimisation: +// with 32-bit math and without division + +template < int N > +struct RandomGenerator { +private: + static constexpr unsigned a = 16807; // 7^5 + static constexpr unsigned m = 2147483647; // 2^31 - 1 + + static constexpr unsigned s = RandomGenerator< N - 1 >::value; + static constexpr unsigned lo = a * ( s & 0xFFFF ); // Multiply lower 16 bits by 16807 + static constexpr unsigned hi = a * ( s >> 16 ); // Multiply higher 16 bits by 16807 + static constexpr unsigned lo2 = lo + ( ( hi & 0x7FFF ) << 16 ); // Combine lower 15 bits of hi with lo's upper bits + static constexpr unsigned hi2 = hi >> 15; // Discard lower 15 bits of hi + static constexpr unsigned lo3 = lo2 + hi; + +public: + static constexpr unsigned max = m; + static constexpr unsigned value = lo3 > m ? lo3 - m : lo3; +}; + +template <> +struct RandomGenerator< 0 > { + static constexpr unsigned value = seed; +}; + +template < int N, int M > +struct RandomInt { + static constexpr auto value = RandomGenerator< N + 1 >::value % M; +}; + +template < int N > +struct RandomChar { + static const char value = static_cast< char >( 1 + RandomInt< N, 0x7F - 1 >::value ); +}; + +template < size_t N, int K > +struct XorString { +private: + const char _key; + std::array< char, N + 1 > _encrypted; + bool decrypted = false; + + constexpr char enc( char c ) const { + return c ^ _key; + } + + char dec( char c ) const { + return c ^ _key; + } + +public: + template < size_t... Is > + constexpr __forceinline XorString( const char* const str, std::index_sequence< Is... > ) : _key( RandomChar< K >::value ), _encrypted{ enc( str[ Is ] )... } { + } + + __forceinline const char* decrypt( void ) { + if( !decrypted ) { + for( size_t i = 0; i < N; ++i ) { + _encrypted[ i ] = dec( _encrypted[ i ] ); + } + _encrypted[ N ] = '\0'; + decrypted = true; + } + printf( "N: %u K: %d str: %s address: %08x\n", N, K, _encrypted.data( ), _encrypted.data( ) ); + + return _encrypted.data( ); + } +}; + +//-------------------------------------------------------------------------------- +//-- Note: XorStr will __NOT__ work directly with functions like printf. +// To work with them you need a wrapper function that takes a const char* +// as parameter and passes it to printf and alike. +// +// The Microsoft Compiler/Linker is not working correctly with variadic +// templates! +// +// Use the functions below or use std::cout (and similar)! +//-------------------------------------------------------------------------------- + +static auto w_printf = [ ]( const char* fmt, ... ) { + va_list args; + va_start( args, fmt ); + vprintf_s( fmt, args ); + va_end( args ); +}; + +static auto w_printf_s = [ ]( const char* fmt, ... ) { + va_list args; + va_start( args, fmt ); + vprintf_s( fmt, args ); + va_end( args ); +}; + +static auto w_sprintf = [ ]( char* buf, const char* fmt, ... ) { + va_list args; + va_start( args, fmt ); + vsprintf( buf, fmt, args ); + va_end( args ); +}; + +static auto w_sprintf_s = [ ]( char* buf, size_t buf_size, const char* fmt, ... ) { + va_list args; + va_start( args, fmt ); + vsprintf_s( buf, buf_size, fmt, args ); + va_end( args ); +}; + +//for compatibility with debug mode +struct debug_ret { +private: + const char* ret; + +public: + debug_ret( const char* str ) : ret( str ) { }; + + auto decrypt( ) { + return ret; + } +}; + +constexpr size_t strlen_ct( const char* const str ) { + size_t out = 1; + + for( ; str[ out ] != '\0'; ++out ); + + return out; +} + +#if 0 +#define xors_raw( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ) ) +#define xors( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() ) +#else +#define xors_raw( s ) ( [ ]{ strenc::debug_ret ret{ s }; return ret; }( ) ) +#define xors( s ) ( s ) +#endif + +END_NAMESPACE
\ No newline at end of file diff --git a/internal_rewrite/suppress_lists.cpp b/internal_rewrite/suppress_lists.cpp new file mode 100644 index 0000000..11a0805 --- /dev/null +++ b/internal_rewrite/suppress_lists.cpp @@ -0,0 +1,41 @@ +#include <intrin.h> + +#include "hooks.hpp" +#include "context.hpp" +#include "settings.hpp" +#include "base_cheat.hpp" + +void __fastcall hooks::suppress_lists( void* ecx, void* edx, int list_mask, bool suppress ) { + static auto suppress_lists_o = g_csgo.m_partition->get_old_function< decltype( &hooks::suppress_lists ) >( 16 ); + + static auto net_update_ret = pattern::first_code_match< void* >( g_csgo.m_chl.dll( ), "5F 5E 5D C2 04 00 83 3D ? ? ? ? ?" ); + + if( _ReturnAddress( ) == net_update_ret ) { + g_ctx.m_stage = FRAME_NET_UPDATE_START; + g_cheat.m_visuals.world_modulate( ); + // FRAME_NET_UPDATE_START + //g_con->game_console_print( "net start\n" ); + + static bool rich_presence_active = false; + + g_ctx.run_frame( ); + g_cheat.m_ragebot.m_lagcomp->fsn_net_update_start( ); + + if( g_settings.misc.rich_presence( ) ) { + g_cheat.m_extra.rich_presence_flex( ); + rich_presence_active = true; + } + else if( rich_presence_active ) { + if( !g_settings.misc.rich_presence( ) ) + g_cheat.m_extra.remove_rich_presence_flex( ); + + rich_presence_active = false; + } + g_cheat.m_visuals.draw_sound( ); + g_cheat.m_visuals.draw_tracers( ); + + } + + suppress_lists_o( ecx, edx, list_mask, suppress ); + +}
\ No newline at end of file diff --git a/internal_rewrite/traceray.cpp b/internal_rewrite/traceray.cpp new file mode 100644 index 0000000..8ca6d79 --- /dev/null +++ b/internal_rewrite/traceray.cpp @@ -0,0 +1,33 @@ +#include "hooks.hpp"
+
+#include <intrin.h>
+#include "mem.hpp"
+
+void __fastcall hooks::trace_ray( void* ecx_, void* edx_, const Ray_t& ray, unsigned int fMask, ITraceFilter* pTraceFilter, CBaseTrace* pTrace ) {
+ static auto trace_ray_o = g_csgo.m_trace->get_old_function< decltype( &trace_ray ) >( 5 );
+
+/* if( std::this_thread::get_id( ) == g_csgo.m_d3d_thread ) {
+ void* address = _ReturnAddress( );
+ //MEMORY_BASIC_INFORMATION info;
+ //VirtualQuery( address, &info, sizeof( MEMORY_BASIC_INFORMATION ) );
+
+ char mod[ MAX_PATH ];
+ //GetModuleFileNameA( ( HMODULE )info.AllocationBase, mod, MAX_PATH );
+
+ //printf( "TRACERAY CALLED FROM D3D\n" );
+ stack_t stack( get_baseptr( ) );
+
+ int i{ };
+ for( ; stack.get( ) > 0x100; stack = stack.next( ), i++ ) {
+ MEMORY_BASIC_INFORMATION info;
+ VirtualQuery( ( void* )( stack.return_address( ) ), &info, sizeof( MEMORY_BASIC_INFORMATION ) );
+
+ GetModuleFileNameA( ( HMODULE )info.AllocationBase, mod, MAX_PATH );
+
+ if( strstr( mod, "moneybot" ) )
+ printf( "stack frame: %d retaddr: %08x %s\n", i, stack.return_address( ), mod );
+ }
+ }*/
+
+ return trace_ray_o( ecx_, edx_, ray, fMask, pTraceFilter, pTrace );
+}
\ No newline at end of file diff --git a/internal_rewrite/ui.h b/internal_rewrite/ui.h new file mode 100644 index 0000000..7cb5fdd --- /dev/null +++ b/internal_rewrite/ui.h @@ -0,0 +1,849 @@ +#pragma once
+#include "ui_base_item.h"
+#include "ui_menu.h"
+#include "ui_form.h"
+#include "ui_render.h"
+#include "ui_checkbox.h"
+#include "ui_tab_manager.h"
+#include "ui_slider.h"
+#include "ui_dropdown.h"
+#include "ui_key_picker.h"
+#include "ui_button.h"
+#include "ui_color_picker.h"
+#include "ui_label.h"
+#include "ui_itemlist.h"
+#include "ui_itemlist_def.h"
+
+#include "settings.hpp"
+#include "base_cheat.hpp"
+
+namespace ui
+{
+ int current_category = 0;
+
+ static std::string date_str = __DATE__;
+ auto menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "quebot" ),
+ __DATE__ );
+
+ static void render( ) {
+ static bool was_setup = false;
+ if ( !was_setup ) {
+ std::transform( date_str.begin( ), date_str.end( ), date_str.begin( ),
+ [ ]( char c ) { return ::tolower( c ); }
+ );
+
+ menu.reset( );
+
+#ifndef _DEBUG
+ menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "moneybot" ),
+ date_str.c_str( ) );
+#else
+ menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "moneybot (cooler edition)" ),
+ date_str.c_str( ) );
+#endif
+
+ auto tab_sheet = std::make_shared< ui::c_tab_manager >( );
+
+ //todo: replace with icons?
+ auto tab_legit = std::make_shared< ui::c_tab_sheet >( xors( "legit" ), &icons::sprite_legit ); {
+ auto subtab_sheet = std::make_shared< ui::c_subtab_manager >( );
+
+ auto subtab_main = std::make_shared< ui::c_tab_sheet >( xors( "main" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto main_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "main" ) ); {
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.legit.enabled ) );
+ auto activation_dropdown = std::make_shared< ui::c_dropdown< > >(
+ 0, 0, 120, xors( "activation type" ),
+ &g_settings.legit.activation_type,
+ &ui::dropdowns::activation_types_aimbot );
+ activation_dropdown->add_item( std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.legit.key ) )->set_cond(
+ [ ]( ) { return g_settings.legit.activation_type == 1; } );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "friendlies" ), &g_settings.legit.friendlies ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "aim assist" ), &g_settings.legit.assist ) );
+
+ main_form->add_item( activation_dropdown );
+ }
+
+ auto smooth_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "smoothing" ) ); {
+ smooth_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "dynamic smoothing" ), &g_settings.legit.dynamic_smoothing ) );
+ smooth_form->add_item( std::make_shared< ui::c_slider< size_t > >( 0, 0, 120, 2, 28, xors( "sample size" ), &g_settings.legit.sample_size ) );
+ smooth_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.1f, 2.0f, xors( "multiplier" ), &g_settings.legit.smooth_factor ) );
+ }
+
+ auto backtracking_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "backtracking" ) ); {
+ backtracking_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.legit.backtracking ) );
+ backtracking_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "target" ), &g_settings.legit.backtracking_target ) );
+ auto visualize_checkbox = backtracking_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "visualize" ), &g_settings.legit.backtracking_visualize ) );
+ visualize_checkbox->add_item( std::make_shared< ui::c_color_picker >( 175, 2, 15, &g_settings.legit.backtracking_col ) );
+ visualize_checkbox->set_cond( [ ] { return !g_settings.misc.hide_from_obs( ); } );
+
+ backtracking_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 50.f, xors( "max fov" ), &g_settings.legit.backtracking_fov ) );
+ backtracking_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 0.2f, xors( "max time" ), &g_settings.legit.backtracking_time, "s" ) );
+ }
+
+ auto triggerbot_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "triggerbot" ) ); {
+ triggerbot_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.legit.triggerbot ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.legit.trigger_key ) );
+
+ triggerbot_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "magnet" ), &g_settings.legit.trigger_magnet ) );
+
+ triggerbot_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 0.2f, xors( "trigger delay" ), &g_settings.legit.trigger_delay, "s" )
+ )->set_cond( [] { return g_settings.legit.triggerbot( ); } );
+ }
+
+ left_column->add_item( main_form );
+ left_column->add_item( smooth_form );
+
+ right_column->add_item( backtracking_form );
+ right_column->add_item( triggerbot_form );
+
+ subtab_main->add_item( left_column );
+ subtab_main->add_item( right_column );
+ }
+
+ //make a subtab for each weapon type?
+ auto subtab_weapons = std::make_shared< ui::c_tab_sheet >( xors( "weapons" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto general_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "general" ) ); {
+ general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 40.f, xors( "fov" ), &g_settings.legit.general.m_fov ) );
+ general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 50.f, xors( "speed" ), &g_settings.legit.general.m_speed ) );
+ general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 100.f, xors( "rcs" ), &g_settings.legit.general.m_rcs ) );
+ general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.general.m_assist_strength ) );
+ }
+
+ auto snipers_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "snipers" ) ); {
+ snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 40.f, xors( "fov" ), &g_settings.legit.snipers.m_fov ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 50.f, xors( "speed" ), &g_settings.legit.snipers.m_speed ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 100.f, xors( "rcs" ), &g_settings.legit.snipers.m_rcs ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.snipers.m_assist_strength ) );
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "awp body aim" ), &g_settings.legit.awp_baim ) );
+ }
+
+ auto rifles_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "rifles" ) ); {
+ rifles_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 40.f, xors( "fov" ), &g_settings.legit.rifles.m_fov ) );
+ rifles_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 50.f, xors( "speed" ), &g_settings.legit.rifles.m_speed ) );
+ rifles_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 100.f, xors( "rcs" ), &g_settings.legit.rifles.m_rcs ) );
+ rifles_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.rifles.m_assist_strength ) );
+ }
+
+ auto pistols_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "pistols" ) ); {
+ pistols_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 40.f, xors( "fov" ), &g_settings.legit.pistols.m_fov ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 50.f, xors( "speed" ), &g_settings.legit.pistols.m_speed ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 100.f, xors( "rcs" ), &g_settings.legit.pistols.m_rcs ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.pistols.m_assist_strength ) );
+ }
+
+ left_column->add_item( general_form );
+ left_column->add_item( snipers_form );
+ right_column->add_item( rifles_form );
+ right_column->add_item( pistols_form );
+
+ subtab_weapons->add_item( left_column );
+ subtab_weapons->add_item( right_column );
+ }
+
+ subtab_sheet->add_item( subtab_weapons );
+ subtab_sheet->add_item( subtab_main );
+
+ tab_legit->add_item( subtab_sheet );
+ }
+
+
+ auto tab_rage = std::make_shared< ui::c_tab_sheet >( xors( "rage" ), &icons::sprite_rage ); {
+ auto subtab_sheet = std::make_shared< ui::c_subtab_manager >( );
+
+ auto subtab_aimbot = std::make_shared< ui::c_tab_sheet >( xors( "aimbot" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto main_form = std::make_shared< ui::c_form >( 0, 0, 215, 235, xors( "main" ), 235 ); {
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.rage.enabled ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "friendlies" ), &g_settings.rage.friendlies ) );
+ main_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 180.f, xors( "max fov" ), &g_settings.rage.fov ) );
+
+
+ main_form->add_item( std::make_shared< ui::c_dropdown< int > >(
+ 0, 0, 120, xors( "activation type" ),
+ &g_settings.rage.activation_type,
+ &dropdowns::activation_types_aimbot ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.rage.aimkey ) )->set_cond(
+ [ ]( ) { return g_settings.rage.activation_type == 1; } );
+
+ main_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "silent" ),
+ &g_settings.rage.silent, &dropdowns::silent_aimbot_types ) );
+
+
+ main_form->add_item( std::make_shared< ui::c_dropdown< int > >( 0, 0, 120, xors( "hitbox" ),
+ &g_settings.rage.hitbox, &dropdowns::hitboxes ) );
+
+ auto hitscan_form = main_form->add_item( std::make_shared< ui::c_form >( 0, 5, 119, 0, xors( "hitscan" ), 0, true ) );
+ hitscan_form->set_cond( [ ]( ) { return g_settings.rage.hitbox == -1; } );
+
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "head" ), &g_settings.rage.hitscan.head ) );
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "chest" ), &g_settings.rage.hitscan.chest ) );
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "stomach" ), &g_settings.rage.hitscan.stomach ) );
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "arms" ), &g_settings.rage.hitscan.arms ) );
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "legs" ), &g_settings.rage.hitscan.legs ) );
+ hitscan_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "feet" ), &g_settings.rage.hitscan.feet ) );
+
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "ignore limbs when moving" ), &g_settings.rage.ignore_limbs_moving )
+ )->set_cond( [ ]( ) { return g_settings.rage.hitbox == -1; } );
+ main_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "multipoint" ), &g_settings.rage.multipoint, &dropdowns::multipoint_types ) );
+
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "preserve fps" ), &g_settings.rage.preserve_fps ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "preserve autowall fps" ), &g_settings.rage.autowall_fps ) );
+ }
+
+ auto accuracy_form = std::make_shared< ui::c_form >( 0, 0, 215, 157, xors( "accuracy" ), 157 ); {
+ accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto scope" ), &g_settings.rage.auto_scope ) );
+ accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "anti-aim correction" ), &g_settings.rage.resolver ) );
+ accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "pitch correction" ), &g_settings.rage.pitch_resolver )
+ )->set_cond( [ ]( ) { return g_settings.rage.resolver; } );
+ accuracy_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "fake lag correction" ), &g_settings.rage.fakelag_resolver, &dropdowns::fakelag_fix_types )
+ )->set_cond( [ ]( ) { return g_settings.rage.resolver; } );
+
+ auto override_checkbox = accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "resolver override" ), &g_settings.rage.resolver_override ) );
+ override_checkbox->add_item( std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.rage.resolver_override_key ) );
+ override_checkbox->set_cond( [ ]( ) { return g_settings.rage.resolver; } );
+ auto visualize_checkbox = accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "visualize lag compensation" ), &g_settings.rage.bt_visualize ) );
+ visualize_checkbox->set_cond( [ ]( ) { return g_settings.rage.resolver( ) && !g_settings.misc.hide_from_obs( );; } );
+ visualize_checkbox->add_item( std::make_shared< ui::c_color_picker >( 175, 2, 15, &g_settings.rage.bt_col ) );
+
+ accuracy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "compensate spread" ), &g_settings.rage.compensate_spread ) );
+ }
+
+ auto selection_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "selection" ) ); {
+ selection_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "type" ), &g_settings.rage.selection_type, &dropdowns::selection_type ) );
+ selection_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "prefer moving" ), &g_settings.rage.prefer_moving ) );
+ selection_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "prefer low hp" ), &g_settings.rage.prefer_low_hp ) );
+ }
+
+
+
+ auto general_form = std::make_shared< ui::c_form >( 0, 0, 215, 306, xors( "weapon specific" ), 306 ); {
+ general_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "category" ), ¤t_category, &dropdowns::weapon_configs ) );
+
+ general_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto stop" ), &g_settings.rage.general.m_auto_stop ) );
+ general_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spread limit" ), &g_settings.rage.general.m_spread_limit )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.general.m_spread_limit_min )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread && g_settings.rage.general.m_spread_limit; } );
+ general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "hitbox scale" ), &g_settings.rage.general.m_hitbox_scale ) )->set_cond(
+ [ ]( ) { return g_settings.rage.multipoint( ); } );
+
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "hitchance" ), &g_settings.rage.general.m_hitchance )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "min damage" ), &g_settings.rage.general.m_damage ) );
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.general.m_damage_scale, xors( "%%hp" ) ) );
+ general_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "delay shot" ), &g_settings.rage.general.m_delay_type, &dropdowns::delay_type ) );
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 300, &g_settings.rage.general.m_delay, xors( "ms" ) )
+ )->set_cond( [ ]( ) { return g_settings.rage.general.m_delay_type == 2; } );
+
+ general_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head in air" ), &g_settings.rage.general.m_baim_air ) );
+ general_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head on fake angles" ), &g_settings.rage.general.m_baim_fake ) );
+ general_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "body aim if lethal" ), &g_settings.rage.general.m_baim_lethal ) );
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 20, xors( "body aim after" ), &g_settings.rage.general.m_baim_shots, xors( "shots" ) ) );
+ general_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "body aim under" ), &g_settings.rage.general.m_baim_health, xors( "hp" ) ) );
+ }
+
+ general_form->set_cond( [ ]( ) { return current_category == 0; } );
+
+ auto pistols_form = std::make_shared< ui::c_form >( 0, 0, 215, 306, xors( "weapon specific" ), 306 ); {
+ pistols_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "category" ), ¤t_category, &dropdowns::weapon_configs ) );
+
+ pistols_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto stop" ), &g_settings.rage.heavy_pistols.m_auto_stop ) );
+ pistols_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spread limit" ), &g_settings.rage.heavy_pistols.m_spread_limit )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.heavy_pistols.m_spread_limit_min )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread && g_settings.rage.heavy_pistols.m_spread_limit; } );
+ pistols_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "hitbox scale" ), &g_settings.rage.heavy_pistols.m_hitbox_scale ) )->set_cond(
+ [ ]( ) { return g_settings.rage.multipoint( ); } );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "hitchance" ), &g_settings.rage.heavy_pistols.m_hitchance )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "min damage" ), &g_settings.rage.heavy_pistols.m_damage ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.heavy_pistols.m_damage_scale, xors( "%%hp" ) ) );
+ pistols_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "delay shot" ), &g_settings.rage.heavy_pistols.m_delay_type, &dropdowns::delay_type ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 300, &g_settings.rage.heavy_pistols.m_delay, xors( "ms" ) )
+ )->set_cond( [ ]( ) { return g_settings.rage.heavy_pistols.m_delay_type == 2; } );
+
+ pistols_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head in air" ), &g_settings.rage.heavy_pistols.m_baim_air ) );
+ pistols_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head on fake angles" ), &g_settings.rage.heavy_pistols.m_baim_fake ) );
+ pistols_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "body aim if lethal" ), &g_settings.rage.heavy_pistols.m_baim_lethal ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 20, xors( "body aim after" ), &g_settings.rage.heavy_pistols.m_baim_shots, xors( "shots" ) ) );
+ pistols_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "body aim under" ), &g_settings.rage.heavy_pistols.m_baim_health, xors( "hp" ) ) );
+ }
+
+ pistols_form->set_cond( [ ]( ) { return current_category == 1; } );
+
+ auto snipers_form = std::make_shared< ui::c_form >( 0, 0, 215, 306, xors( "weapon specific" ), 306 ); {
+ snipers_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "category" ), ¤t_category, &dropdowns::weapon_configs ) );
+
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto stop" ), &g_settings.rage.snipers.m_auto_stop ) );
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spread limit" ), &g_settings.rage.snipers.m_spread_limit )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.snipers.m_spread_limit_min )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread && g_settings.rage.snipers.m_spread_limit; } );
+ snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "hitbox scale" ), &g_settings.rage.snipers.m_hitbox_scale ) )->set_cond(
+ [ ]( ) { return g_settings.rage.multipoint( ); } );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "hitchance" ), &g_settings.rage.snipers.m_hitchance )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "min damage" ), &g_settings.rage.snipers.m_damage ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.snipers.m_damage_scale, xors( "%%hp" ) ) );
+ snipers_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "delay shot" ), &g_settings.rage.snipers.m_delay_type, &dropdowns::delay_type ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 300, &g_settings.rage.snipers.m_delay, xors( "ms" ) )
+ )->set_cond( [ ]( ) { return g_settings.rage.snipers.m_delay_type == 2; } );
+
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head in air" ), &g_settings.rage.snipers.m_baim_air ) );
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head on fake angles" ), &g_settings.rage.snipers.m_baim_fake ) );
+ snipers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "body aim if lethal" ), &g_settings.rage.snipers.m_baim_lethal ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 20, xors( "body aim after" ), &g_settings.rage.snipers.m_baim_shots, xors( "shots" ) ) );
+ snipers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "body aim under" ), &g_settings.rage.snipers.m_baim_health, xors( "hp" ) ) );
+ }
+
+ snipers_form->set_cond( [ ]( ) { return current_category == 2; } );
+
+ auto auto_form = std::make_shared< ui::c_form >( 0, 0, 215, 306, xors( "weapon specific" ), 306 ); {
+ auto_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "category" ), ¤t_category, &dropdowns::weapon_configs ) );
+
+ auto_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto stop" ), &g_settings.rage.auto_snipers.m_auto_stop ) );
+ auto_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spread limit" ), &g_settings.rage.auto_snipers.m_spread_limit )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.auto_snipers.m_spread_limit_min )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread && g_settings.rage.auto_snipers.m_spread_limit; } );
+ auto_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "hitbox scale" ), &g_settings.rage.auto_snipers.m_hitbox_scale ) )->set_cond(
+ [ ]( ) { return g_settings.rage.multipoint( ); } );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "hitchance" ), &g_settings.rage.auto_snipers.m_hitchance )
+ )->set_cond( [ ]( ) { return !g_settings.rage.compensate_spread; } );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "min damage" ), &g_settings.rage.auto_snipers.m_damage ) );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, &g_settings.rage.auto_snipers.m_damage_scale, xors( "%%hp" ) ) );
+ auto_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "delay shot" ), &g_settings.rage.auto_snipers.m_delay_type, &dropdowns::delay_type ) );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 300, &g_settings.rage.auto_snipers.m_delay, xors( "ms" ) )
+ )->set_cond( [ ]( ) { return g_settings.rage.auto_snipers.m_delay_type == 2; } );
+
+ auto_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head in air" ), &g_settings.rage.auto_snipers.m_baim_air ) );
+ auto_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid head on fake angles" ), &g_settings.rage.auto_snipers.m_baim_fake ) );
+ auto_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "body aim if lethal" ), &g_settings.rage.auto_snipers.m_baim_lethal ) );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 20, xors( "body aim after" ), &g_settings.rage.auto_snipers.m_baim_shots, xors( "shots" ) ) );
+ auto_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 100, xors( "body aim under" ), &g_settings.rage.auto_snipers.m_baim_health, xors( "hp" ) ) );
+ }
+
+ auto_form->set_cond( [ ]( ) { return current_category == 3; } );
+
+ left_column->add_item( main_form );
+ left_column->add_item( accuracy_form );
+ right_column->add_item( selection_form );
+ right_column->add_item( general_form );
+ right_column->add_item( pistols_form );
+ right_column->add_item( snipers_form );
+ right_column->add_item( auto_form );
+
+
+ subtab_aimbot->add_item( left_column );
+ subtab_aimbot->add_item( right_column );
+ }
+
+ auto subtab_antiaim = std::make_shared< ui::c_tab_sheet >( xors( "antiaim" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto main_form = std::make_shared< ui::c_form >( 0, 0, 215, 110, xors( "main" ), 110 ); {
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.rage.anti_aim ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "at players" ), &g_settings.rage.at_players ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "dormant check" ), &g_settings.rage.dormant_check ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "angle step" ), &g_settings.rage.angle_step ) );
+ main_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 45, &g_settings.rage.angle_step_degrees ) )->set_cond(
+ [ ]( ) { return g_settings.rage.angle_step( ); } );
+ }
+
+ auto pitch_form = std::make_shared< ui::c_form >( 0, 0, 215, 60, xors( "pitch" ) ); {
+ pitch_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "pitch" ), &g_settings.rage.pitch, &dropdowns::antiaim_pitch ) );
+ pitch_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -89, 89, &g_settings.rage.pitch_offset ) )->set_cond(
+ [ ]( ) { return g_settings.rage.pitch == 1 || g_settings.rage.pitch == 4 || g_settings.rage.pitch == 5; } );
+ }
+
+ auto yaw_form = std::make_shared< ui::c_form >( 0, 0, 215, 211, xors( "yaw" ), 211 ); {
+ yaw_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "real yaw" ), &g_settings.rage.real_yaw, &dropdowns::antiaim_yaw ) );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -180, 180, &g_settings.rage.real_yaw_add( ) ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 90, xors( "real yaw jitter" ), &g_settings.rage.real_yaw_jitter ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "real yaw moving" ), &g_settings.rage.real_yaw_moving, &dropdowns::antiaim_yaw ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -180, 180, &g_settings.rage.real_yaw_moving_add( ) ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw_moving( ) && !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 90, xors( "real yaw moving jitter" ), &g_settings.rage.real_moving_jitter ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw_moving( ) && !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "in-air yaw" ), &g_settings.rage.air_yaw, &dropdowns::antiaim_yaw ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -180, 180, &g_settings.rage.air_yaw_add( ) ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.air_yaw( ) && !!g_settings.rage.real_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 90, xors( "in-air yaw jitter" ), &g_settings.rage.air_yaw_jitter ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.air_yaw( ) && !!g_settings.rage.real_yaw( ); } );
+
+
+ yaw_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "fake yaw" ), &g_settings.rage.fake_yaw, &dropdowns::antiaim_yaw ) );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -180, 180, &g_settings.rage.fake_yaw_add( ) ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.fake_yaw( ); } );
+ yaw_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 90, xors( "fake yaw jitter" ), &g_settings.rage.fake_yaw_jitter ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.fake_yaw( ); } );
+ }
+
+ auto edge_form = std::make_shared< ui::c_form >( 0, 0, 215, 110, xors( "edge detection" ), 110 ); {
+ edge_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "edge" ), &g_settings.rage.edge_dtc_normal,
+ &dropdowns::antiaim_edge ) );
+
+ edge_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 70, 300, &g_settings.rage.edge_dtc_standing ) )->set_cond(
+ [ ]( ) { return g_settings.rage.edge_dtc_normal( ) == 2; } );
+
+ edge_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 70, 300, &g_settings.rage.edge_dtc_moving ) )->set_cond(
+ [ ]( ) { return !!g_settings.rage.edge_dtc_normal( ); } );
+
+ edge_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "freestanding" ),
+ &g_settings.rage.edge_detection ) );
+
+ edge_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 50, 200, &g_settings.rage.freestanding_distance )
+ )->set_cond( [ ]( ) { return g_settings.rage.edge_detection( ); } );
+
+ edge_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "priority" ),
+ &g_settings.rage.edge_dtc_priority, &dropdowns::edge_priority )
+ )->set_cond( [ ]( ) { return g_settings.rage.edge_dtc_normal( ) && g_settings.rage.edge_detection( ); } );
+
+ edge_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "break lby when edging" ), &g_settings.rage.break_lby_edge( ) )
+ )->set_cond( [ ]( ) { return g_settings.rage.break_lby; } );
+
+ edge_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 90, xors( "fake jitter" ), &g_settings.rage.edge_dtc_jitter ) );
+ }
+
+ auto lby_form = std::make_shared< ui::c_form >( 0, 0, 215, 106, xors( "lby breaker" ), 106 ); {
+ lby_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "break lby" ), &g_settings.rage.break_lby ) );
+ lby_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, -120, 120, &g_settings.rage.lby_delta ) )->set_cond(
+ [ ]( ) { return g_settings.rage.break_lby( ); } );
+
+ lby_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid updates" ), &g_settings.rage.lby_avoid_updates ) );
+
+ lby_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "fakewalk" ), &g_settings.rage.fakewalk ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.rage.fakewalk_key )
+ );
+ lby_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 7, 15, &g_settings.rage.fakewalk_ticks ) )->set_cond(
+ [ ]( ) { return g_settings.rage.fakewalk; } );
+ }
+
+ auto fakelag_form = std::make_shared< ui::c_form >( 0, 0, 215, 165, xors( "fakelag" ), 165 ); {
+ fakelag_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 140, xors( "mode" ), &g_settings.rage.fakelag.mode, &dropdowns::fakelag_types ) );
+ fakelag_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 14, &g_settings.rage.fakelag.ticks ) );
+ fakelag_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 140, 0, 50, xors( "variance" ), &g_settings.rage.fakelag.fluctuate ) );
+
+ auto flags_form = fakelag_form->add_item( std::make_shared< ui::c_form >( 0, 5, 139, 0, xors( "flags" ), 0, true ) );
+
+ flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "in air" ), &g_settings.rage.fakelag.in_air ) );
+ flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "on move" ), &g_settings.rage.fakelag.in_move ) );
+ flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "on peek" ), &g_settings.rage.fakelag.on_peek ) );
+ flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "while shooting" ), &g_settings.rage.fakelag.in_attack ) );
+ flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "avoid ground" ), &g_settings.rage.fakelag.avoid_ground ) );
+ }
+
+ left_column->add_item( main_form );
+ left_column->add_item( pitch_form );
+ left_column->add_item( yaw_form );
+
+ right_column->add_item( edge_form );
+ right_column->add_item( lby_form );
+ right_column->add_item( fakelag_form );
+
+ subtab_antiaim->add_item( left_column );
+ subtab_antiaim->add_item( right_column );
+ }
+
+ subtab_sheet->add_item( subtab_antiaim );
+ subtab_sheet->add_item( subtab_aimbot );
+
+ tab_rage->add_item( subtab_sheet );
+ }
+
+
+ auto tab_visuals = std::make_shared< ui::c_tab_sheet >( xors( "visuals" ), &icons::sprite_visuals ); {
+ auto subtab_sheet = std::make_shared< ui::c_subtab_manager >( );
+
+ auto subtab_players = std::make_shared< ui::c_tab_sheet >( xors( "players" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto main_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "main" ) ); {
+ main_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "activation type" ), &g_settings.visuals.activation_type, &dropdowns::activation_type_visuals ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.visuals.key ) )->set_cond( [ ]( ) { return g_settings.visuals.activation_type > 1; } );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "friendlies" ), &g_settings.visuals.friendlies ) );
+ }
+
+ auto player_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "players" ) ); {
+ auto box_checkbox = player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "box" ), &g_settings.visuals.box ) );
+ box_checkbox->add_item( std::make_shared< ui::c_color_picker >( 160, 4, 15, &g_settings.visuals.box_enemy( ) ) );
+ box_checkbox->add_item( std::make_shared< ui::c_color_picker >( 180, -9, 15, &g_settings.visuals.box_friendly( ) ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.friendlies; } );
+
+ auto glow_checkbox = player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "glow" ), &g_settings.visuals.glow ) );
+ glow_checkbox->add_item( std::make_shared< ui::c_color_picker >( 160, 2, 15, &g_settings.visuals.glow_enemy ) );
+ glow_checkbox->add_item( std::make_shared< ui::c_color_picker >( 180, -11, 15, &g_settings.visuals.glow_friendly ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.friendlies || g_settings.visuals.chams.friendlies; } );
+ glow_checkbox->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs; } );
+
+ auto skeleton_checkbox = player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "skeleton" ), &g_settings.visuals.skeleton ) );
+ skeleton_checkbox->add_item( std::make_shared< ui::c_color_picker >( 160, 2, 15, &g_settings.visuals.skeleton_enemy ) );
+ skeleton_checkbox->add_item( std::make_shared< ui::c_color_picker >( 180, -11, 15, &g_settings.visuals.skeleton_friendly ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.friendlies; } );
+
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "dormant" ), &g_settings.visuals.dormant ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "health" ), &g_settings.visuals.health ) );
+ auto name_checkbox = player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "name" ), &g_settings.visuals.name ) );
+ name_checkbox->add_item( std::make_shared< ui::c_color_picker >( 160, 4, 15, &g_settings.visuals.name_enemy( ) ) );
+ name_checkbox->add_item( std::make_shared< ui::c_color_picker >( 180, -9, 15, &g_settings.visuals.name_friendly( ) ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.friendlies; } );
+
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "weapon" ), &g_settings.visuals.weapon ) );
+
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "ammo" ), &g_settings.visuals.ammo ) )->add_item(
+ std::make_shared< ui::c_color_picker >( 160, 4, 15, &g_settings.visuals.ammo_bar_clr( ) ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "flags" ), &g_settings.visuals.flags ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "money" ), &g_settings.visuals.money ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "high ping warning" ), &g_settings.visuals.ping ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "resolver indicator" ), &g_settings.visuals.resolver_indicator ) )->add_item(
+ std::make_shared< ui::c_color_picker >( 160, 4, 15, &g_settings.visuals.lby_bar_clr( ) ) );
+ player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "sound" ), &g_settings.visuals.sound ) )->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs; } );
+ player_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 220, 500, &g_settings.visuals.sound_range ) )->set_cond( [ ]( ) { return g_settings.visuals.sound && !g_settings.misc.hide_from_obs; } );
+ }
+
+ auto hud_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "hud" ) ); {
+ hud_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "out of pov" ), &g_settings.visuals.out_of_pov ) );
+ hud_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.25f, 1.f, &g_settings.visuals.out_of_pov_radius )
+ )->set_cond( [ ]( ) { return g_settings.visuals.out_of_pov( ); } );
+
+ hud_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 15, 40, &g_settings.visuals.out_of_pov_size, xors( "px" ) )
+ )->set_cond( [ ]( ) { return g_settings.visuals.out_of_pov( ); } );
+ hud_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "hitmarkers" ), &g_settings.visuals.hitmarkers ) );
+ hud_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spectator list" ), &g_settings.visuals.spec_list ) );
+ hud_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "radar" ), &g_settings.visuals.radar ) );
+ }
+
+ auto other_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "other" ), 100 ); {
+ other_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "bullet tracers" ), &g_settings.visuals.bullet_tracers, &dropdowns::tracer_type ) );
+ other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "floating ragdolls" ), &g_settings.visuals.floating_ragdolls ) );
+ other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "rank revealer" ), &g_settings.misc.rank_reveal ) );
+ other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "target" ), &g_settings.visuals.target ) );
+ other_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 1, 7, &g_settings.visuals.target_time, "s" )
+ )->set_cond( [ ]( ) { return g_settings.visuals.target; } );
+ }
+
+ auto chams_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "chams" ), 165 ); {
+ chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.visuals.chams.enabled( ) ) );
+ chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "through walls" ), &g_settings.visuals.chams.ignore_z( ) ) );
+ chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "clear occlusion" ), &g_settings.visuals.chams.clear_occlusion ) );
+ chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "friendlies" ), &g_settings.visuals.chams.friendlies( ) ) );
+ chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "flat" ), &g_settings.visuals.chams.flat( ) ) )->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs( ); } );
+ chams_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "reflectivity" ), &g_settings.visuals.chams.reflectivity )
+ )->set_cond( [ ]( ) { return !g_settings.visuals.chams.flat && !g_settings.misc.hide_from_obs; } );
+
+ chams_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "shine" ), &g_settings.visuals.chams.shine )
+ )->set_cond( [ ]( ) { return !g_settings.visuals.chams.flat && !g_settings.misc.hide_from_obs; } );
+
+ chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "friendlies visible" ), &g_settings.visuals.chams.color_visible_friendly( ) ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.chams.friendlies( ); } );
+ chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "friendlies hidden" ), &g_settings.visuals.chams.color_hidden_friendly( ) ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.chams.friendlies( ) && g_settings.visuals.chams.ignore_z( ); } );
+ chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "enemies visible" ), &g_settings.visuals.chams.color_visible_enemy( ) ) );
+ chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "enemies hidden" ), &g_settings.visuals.chams.color_hidden_enemy( ) ) )->set_cond(
+ [ ]( ) { return g_settings.visuals.chams.ignore_z( ); } );
+ }
+
+ chams_form->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs( ); } );
+
+ left_column->add_item( main_form );
+ left_column->add_item( player_form );
+
+ right_column->add_item( hud_form );
+ right_column->add_item( other_form );
+ right_column->add_item( chams_form );
+
+ subtab_players->add_item( left_column );
+ subtab_players->add_item( right_column );
+ }
+
+ auto subtab_other = std::make_shared< ui::c_tab_sheet >( xors( "other" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto world_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "world" ) ); {
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "world modulate" ), &g_settings.visuals.world_modulate )
+ )->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs( ); } );
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "night mode" ), &g_settings.visuals.night_mode )
+ )->set_cond( [ ]( ) { return g_settings.visuals.world_modulate && !g_settings.misc.hide_from_obs( ); } );
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "transparent props" ), &g_settings.visuals.transparent_props )
+ )->set_cond( [ ]( ) { return g_settings.visuals.world_modulate && !g_settings.misc.hide_from_obs( ); } );
+
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "fullbright" ), &g_settings.visuals.fullbright ) );
+ world_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "dropped weapons" ), &g_settings.visuals.weapon_esp, &dropdowns::world_esp_type )
+ )->add_item( std::make_shared< ui::c_color_picker >( 180, 4, 15, &g_settings.visuals.weapon_esp_clr( ) ) );
+
+ world_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "grenades" ), &g_settings.visuals.grenade_esp, &dropdowns::world_esp_type )
+ )->add_item( std::make_shared< ui::c_color_picker >( 180, 4, 15, &g_settings.visuals.grenade_esp_clr( ) ) );
+
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "grenade owner" ), &g_settings.visuals.grenade_owner )
+ )->set_cond( [ ]( ) { return g_settings.visuals.grenade_esp == 1 || g_settings.visuals.grenade_esp == 3; } );
+
+ world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "bomb information" ), &g_settings.visuals.bomb_info ) );
+ }
+
+ auto local_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "local player" ) ); {
+ local_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "recoil crosshair" ), &g_settings.visuals.recoil_crosshair( ) ) );
+ local_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "draw spread" ), &g_settings.visuals.draw_spread ) );
+ local_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "autowall crosshair" ), &g_settings.visuals.autowall_crosshair( ) ) );
+ local_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "grenade prediction" ), &g_settings.visuals.grenade_prediction( ) ) );
+ local_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "snipers crosshair" ), &g_settings.visuals.snipers_crosshair( ) ) );
+ }
+
+ auto view_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "view" ) ); {
+ view_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "watermark" ), &g_settings.misc.watermark ) );
+ view_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "thirdperson" ), &g_settings.misc.thirdperson( ) ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.misc.thirdperson_key )
+ );
+ view_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 40, xors( "viewmodel fov" ), &g_settings.misc.viewmodel_fov( ) ) );
+ view_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 90, 130, xors( "view fov" ), &g_settings.misc.fov_changer( ) ) );
+ }
+
+ auto removals_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "removals" ) ); {
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no scope" ), &g_settings.misc.no_scope ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no zoom" ), &g_settings.misc.no_zoom ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no recoil" ), &g_settings.misc.no_recoil ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no flash" ), &g_settings.misc.no_flash ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no smoke" ), &g_settings.misc.no_smoke ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "transparent viewmodel" ), &g_settings.misc.transparent_vm ) );
+ removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no post processing" ), &g_settings.misc.disable_post_process ) );
+ }
+
+ left_column->add_item( world_form );
+ left_column->add_item( local_form );
+
+ right_column->add_item( view_form );
+ right_column->add_item( removals_form );
+
+ subtab_other->add_item( left_column );
+ subtab_other->add_item( right_column );
+ }
+
+ subtab_sheet->add_item( subtab_other );
+ subtab_sheet->add_item( subtab_players );
+
+ tab_visuals->add_item( subtab_sheet );
+ }
+
+
+ auto tab_misc = std::make_shared< ui::c_tab_sheet >( xors( "miscellaneous" ), &icons::sprite_misc ); {
+ auto subtab_sheet = std::make_shared< ui::c_subtab_manager >( );
+
+ auto subtab_general = std::make_shared< ui::c_tab_sheet >( xors( "general" ) ); {
+ auto column_left = subtab_general->add_item( std::make_shared< ui::base_item >( 0, 0, 0, 0 ) );
+ auto column_right = subtab_general->add_item( std::make_shared< ui::base_item >( 220, -5, 0, 0 ) );
+
+ auto movement_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "movement" ), 145 ); {
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto strafe" ), &g_settings.misc.auto_strafe ) );
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "bhop" ), &g_settings.misc.bunny_hop( ) ) );
+ auto circle_box = movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "circle strafe" ), &g_settings.misc.circle_strafe ) );
+ circle_box->add_item( std::make_shared< ui::c_key_picker_small >( 195, 1, &g_settings.misc.circle_strafe_key ) );
+ circle_box->set_cond( [ ]( ) { return g_settings.misc.bunny_hop && g_settings.misc.auto_strafe; } );
+
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "air duck" ), &g_settings.misc.air_duck ) );
+
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "edge jump" ), &g_settings.misc.edge_jump( ) ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 1, &g_settings.misc.edge_jump_key( ) )
+ );
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto jumpbug" ), &g_settings.misc.auto_jumpbug( ) ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 1, &g_settings.misc.auto_jumpbug_key( ) )
+ );
+ movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "show jump stats" ), &g_settings.misc.show_jump_stats ) );
+ }
+
+ auto identity_form = std::make_shared< ui::c_form >( 0, 1, 215, 0, xors( "identity" ), 95 ); {
+ identity_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "clantag changer" ), &g_settings.misc.clantag_changer( ) ) );
+ identity_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "name changer" ), &g_settings.misc.name_changer,
+ &dropdowns::name_changers ) );
+ identity_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "rich presence" ), &g_settings.misc.rich_presence( ) ) );
+ identity_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "money talk" ), &g_settings.misc.money_talk ) );
+ }
+
+ auto fake_ping = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "fake latency" ) ); {
+ fake_ping->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "enabled" ), &g_settings.misc.net_fakelag,
+ &dropdowns::fake_ping_activation ) )->add_item( std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.misc.net_fakeping_key )
+ )->set_cond( [ ]( ) { return g_settings.misc.net_fakelag == 1 || g_settings.misc.net_fakelag == 2; } );
+ fake_ping->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 800, xors( "amount" ), &g_settings.misc.net_fakeping_amount( ) )
+ )->set_cond( [ ]( ) { return g_settings.misc.net_fakelag != 4; } );
+ }
+
+ auto helpers_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "helpers" ) ); {
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto revolver" ), &g_settings.misc.auto_revolver ) );
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto match accept" ), &g_settings.misc.auto_accept ) );
+ helpers_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 0, 10, xors( "accept delay" ), &g_settings.misc.auto_accept_delay )
+ )->set_cond( [ ]( ) { return g_settings.misc.auto_accept( ); } );
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "server information" ), &g_settings.misc.server_information ) );
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "unlock inventory" ), &g_settings.misc.unlock_inventory ) );
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "log hits" ), &g_settings.misc.log_hits ) );
+ helpers_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "show team damage" ), &g_settings.misc.team_dmg ) );
+ }
+
+ auto autobuy_form = std::make_shared< ui::c_form>( 0, 0, 215, 0, xors( "autobuy" ), 165 ); {
+ autobuy_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "primary" ), &g_settings.misc.autobuy.main_weapon,
+ &dropdowns::autobuy_main_wep ) );
+ autobuy_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "secondary" ), &g_settings.misc.autobuy.secondary_weapon,
+ &dropdowns::autobuy_second_wep ) );
+ autobuy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "armor" ), &g_settings.misc.autobuy.armor ) );
+ autobuy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "defuser" ), &g_settings.misc.autobuy.defuser ) );
+ autobuy_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "zeus" ), &g_settings.misc.autobuy.zeus ) );
+
+ auto grenades_form = autobuy_form->add_item( std::make_shared< ui::c_form >( 0, 5, 139, 0, xors( "grenades" ), 0, true ) );
+
+ grenades_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "molotov/incendiary" ), &g_settings.misc.autobuy.molly ) );
+ grenades_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "grenade" ), &g_settings.misc.autobuy.grenade ) );
+ grenades_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "smoke" ), &g_settings.misc.autobuy.smoke ) );
+ grenades_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "flash" ), &g_settings.misc.autobuy.flash ) );
+ grenades_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "decoy" ), &g_settings.misc.autobuy.decoy ) );
+ }
+
+ auto other_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "other" ) ); {
+ other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "remove gun sounds" ), &g_settings.misc.no_sound ) );
+ other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "hide from obs" ), &g_settings.misc.hide_from_obs ) );
+ other_form->add_item( std::make_shared< ui::c_button >( 0, 0, 120, 20, xors( "unlock hidden cvars" ), []( ) { g_cheat.m_extra.unlock_hidden_cvars( ); } ) );
+ }
+
+ column_left->add_item( movement_form );
+ column_left->add_item( identity_form );
+ column_left->add_item( fake_ping );
+ column_left->add_item( other_form );
+
+ column_right->add_item( helpers_form );
+ column_right->add_item( autobuy_form );
+ }
+
+ auto subtab_skins = std::make_shared< ui::c_tab_sheet >( xors( "money compensator" ) ); {
+ auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+ auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+ auto knife_form = left_column->add_item( std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "knife" ) ) ); {
+ knife_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "override knife" ), &g_settings.misc.skins.knife, &dropdowns::skin_knives ) );
+ }
+
+ auto skin_form = left_column->add_item( std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "skin" ), 325 ) ); {
+ skin_form->add_item( std::make_shared< ui::c_itemlist< int, 20 > >( 0, 0, 180, xors( "override skin" ), &dropdowns::skins, &g_settings.misc.skins.current_skin ) );
+ }
+
+ auto gloves_form = right_column->add_item( std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "glove" ) ) ); {
+ gloves_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "override glove" ), &g_settings.misc.skins.glove, &dropdowns::gloves ) );
+ }
+
+ auto gloves_skin_form = right_column->add_item( std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "glove skin" ), 325 ) ); {
+ gloves_skin_form->add_item( std::make_shared< ui::c_itemlist< int, 20 > >( 0, 0, 180, xors( "override skin" ), &dropdowns::glove_skins, &g_settings.misc.skins.glove_skin ) );
+ }
+
+ subtab_skins->add_item( left_column );
+ subtab_skins->add_item( right_column );
+ }
+
+ auto subtab_movement_recorder = std::make_shared< ui::c_tab_sheet >( xors( "movement recorder" ) ); {
+ auto main_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "main" ) ); {
+ main_form->add_item( std::make_shared< ui::c_label >( 0, 0, xors( "idle" ) ) );
+ main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "enabled" ), &g_settings.misc.recorder_enable ) );
+ main_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "show angles" ), &g_settings.misc.recording_show_angles, &dropdowns::recorder_angles ) );
+ main_form->add_item( std::make_shared< ui::c_label >( 0, 0, xors( "recording start key" ) ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.misc.recording_start_key )
+ );
+ main_form->add_item( std::make_shared< ui::c_label >( 0, 0, xors( "recording stop key" ) ) )->add_item(
+ std::make_shared< ui::c_key_picker_small >( 195, 0, &g_settings.misc.recording_stop_key )
+ );
+
+ main_form->add_item( std::make_shared< ui::c_button >( 0, 0, 120, 20, xors( "play" ), [ ]( ) { g_cheat.m_move_rec.play_back( ); } ) );
+ main_form->add_item( std::make_shared< ui::c_button >( 0, 0, 120, 20, xors( "stop playing" ), [ ]( ) { g_cheat.m_move_rec.stop_playback( ); } ) );
+ main_form->add_item( std::make_shared< ui::c_button >( 0, 0, 120, 20, xors( "clear recording" ), [ ]( ) { g_cheat.m_move_rec.clear_recording( ); } ) );
+ }
+
+ subtab_movement_recorder->add_item( main_form );
+ }
+
+ subtab_sheet->add_item( subtab_movement_recorder );
+ subtab_sheet->add_item( subtab_skins );
+ subtab_sheet->add_item( subtab_general );
+
+ tab_misc->add_item( subtab_sheet );
+ }
+
+
+ auto tab_config = std::make_shared< ui::c_tab_sheet >( xors( "config" ), &icons::sprite_config ); {
+ auto cfg_form = std::make_shared< ui::c_form >( 0, 10, 200, 93, xors( "config" ) );
+ cfg_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 180, xors( "setting" ), &g_settings.menu.cur_setting, &dropdowns::configs ) );
+ cfg_form->add_item( std::make_shared< ui::c_button >( 0, 0, 85, 20, xors( "save" ), []( ) { g_settings.save( ); } ) );
+ cfg_form->add_item( std::make_shared< ui::c_button >( 95, -25, 85, 20, xors( "load" ), []( ) { g_settings.load( ); } ) );
+ //cfg_form->add_item( std::make_shared< ui::c_button >( 0, -25, 85, 20, xors( "to clipboard" ), [ ]( ) { g_settings.copy_to_clipboard( ); } ) );
+ //cfg_form->add_item( std::make_shared< ui::c_button >( 95, -50, 85, 20, xors( "from clipboard" ), [ ]( ) { g_settings.load_from_clipboard( ); } ) );
+ cfg_form->add_item( std::make_shared< ui::c_checkbox >( 0, -25, xors( "anti-untrusted" ), &g_settings.menu.anti_untrusted ) );
+
+ tab_config->add_item( cfg_form );
+ }
+
+ tab_sheet->add_item( tab_config );
+ tab_sheet->add_item( tab_misc );
+ tab_sheet->add_item( tab_visuals );
+ tab_sheet->add_item( tab_rage );
+ tab_sheet->add_item( tab_legit );
+
+ menu->add_item( tab_sheet );
+
+ was_setup = true;
+ }
+ else {
+ static auto movement_state = menu->find_item(
+ xors( "movement recorder" ) )->find_item(
+ xors( "main" ) )->find_item(
+ xors( "idle" )
+ );
+
+ if( !g_settings.misc.recorder_enable )
+ movement_state->set_text( xors( "idle" ) );
+ else if( g_cheat.m_move_rec.is_playing( ) ) {
+ movement_state->set_text( xors( "playing" ) );
+ }
+ else if( g_cheat.m_move_rec.is_recording( ) ) {
+ movement_state->set_text( xors( "recording" ) );
+ }
+ else {
+ movement_state->set_text( xors( "idle" ) );
+ }
+
+ static auto jitter_real = menu->find_item( xors( "real yaw jitter" ) );
+ jitter_real->set_text( g_settings.rage.real_yaw == 2 ? xors( "spin range" ) : xors( "real yaw jitter" ) );
+
+ static auto jitter_real_moving = menu->find_item( xors( "real yaw moving jitter" ) );
+ jitter_real_moving->set_text( g_settings.rage.real_yaw_moving == 2 ? xors( "spin range" ) : xors( "real yaw moving jitter" ) );
+
+ static auto jitter_fake = menu->find_item( xors( "fake yaw jitter" ) );
+ jitter_fake->set_text( g_settings.rage.fake_yaw == 2 ? xors( "spin range" ) : xors( "fake yaw jitter" ) );
+
+ static auto jitter_air = menu->find_item( xors( "in-air yaw jitter" ) );
+ jitter_air->set_text( g_settings.rage.air_yaw == 2 ? xors( "spin range" ) : xors( "in-air yaw jitter" ) );
+
+ render_item( menu.get( ) );
+
+ // This was annoying me so I decided to remove it in Release mode.
+#ifdef _DEBUG
+ //reset the menu if home is pressed for debugging purposes
+ if ( g_input.is_key_pressed( KEYS_END ) ) {
+ menu.reset( );
+ menu = std::make_shared< c_menu >( 10, 10, 580, 470, xors( "golden cheat" ) );
+ was_setup = false;
+ }
+#endif
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ui_base_item.h b/internal_rewrite/ui_base_item.h new file mode 100644 index 0000000..482481a --- /dev/null +++ b/internal_rewrite/ui_base_item.h @@ -0,0 +1,164 @@ +#pragma once +#include <memory> +#include <vector> +#include <functional> + +#include "ui_draw.h" + +namespace ui +{ + //the offset between each item + constexpr int ITEM_OFFSET = 5; + + class base_item : public std::enable_shared_from_this< base_item > { + public: + base_item( ) { } + base_item( int x, int y, int w, int h, const char* name = nullptr ) : + m_x( x ), m_y( y ), m_width( w ), m_height( h ) { + if( name ) { + strcpy( m_text, name ); + } + } + + virtual void render( ) { }; + virtual bool is_hovered( ) { return false; } + virtual bool is_form( ) const { return false; } + + virtual void reset( ) { + m_y_offset = 0; + } + + virtual int get_total_height( ) const { + return m_height; + } + + void set_y_offset( int offset ) { + m_y_offset = offset; + } + + int get_y_offset( ) const { + return m_y_offset; + } + + auto add_item( std::shared_ptr< base_item > item ) { + item.get( )->m_parent = shared_from_this( ); + m_items.emplace( m_items.begin( ), item ); + + return item; + } + + auto& get_items( ) { return m_items; } + auto get_parent( ) { return m_parent; } + + virtual int x( ) const { return m_x; } + virtual int y( ) const { return m_y; } + virtual int w( ) const { return m_width; } + virtual int h( ) const { return m_height; } + + void set_x( int x ) { m_x = x; } + void set_y( int y ) { m_y = y; } + + void set_width( int w ) { m_width = w; } + void set_height( int h ) { m_height = h; } + + bool get_visible( ) const { + if( m_cond && !m_cond( ) ) { + return false; + } + + return m_visible; + } + + void set_cond( std::function< bool( ) > func ) { + m_cond = func; + } + + void set_visible( bool vis ) { m_visible = vis; } + void set_text( const char* text ) { + strcpy( m_text, text ); + } + auto get_text( ) const { + return m_text; + } + + std::shared_ptr< base_item > find_item( const char* name ) { + if( !m_items.empty( ) ) { + for( auto& it : m_items ) { + if( it->get_text( ) && !strcmp( it->get_text( ), name ) ) { + return it; + } + + auto it_find = it->find_item( name ); + if( it_find != it ) return it_find; + } + } + + return shared_from_this( ); + } + + auto get_top_parent( ) { + for( auto parent = m_parent; ; + parent = parent->get_parent( ) ) { + if( !parent->get_parent( ) ) { + return parent; + } + } + + return shared_from_this( ); + } + + int get_relative_x( ) { + int x = m_x; + for( auto parent = get_parent( ); !!parent; + parent = parent->get_parent( ) ) { + x += parent->x( ); + } + + return x; + } + + int get_relative_y( ) { + int y = m_y + get_y_offset( ); + for( auto parent = get_parent( ); !!parent; + parent = parent->get_parent( ) ) { + y += parent->y( ) + parent->get_y_offset( ); + } + + return y; + } + + void set_disabled( bool disabled ) { + m_disabled = disabled; + + for( auto& it : m_items ) { + it->set_disabled( disabled ); + } + } + + void set_disabled_callbacks( bool disabled ) { + auto top = get_top_parent( ); + + top->set_disabled( disabled ); + + m_disabled = false; + } + + protected: + int m_x{ }; + int m_y{ }; + + int m_width{ }; + int m_height{ }; + + //current y position for rendering + int m_y_offset{ }; + + bool m_visible = true; + bool m_disabled = false; + char m_text[ 256 ]{ }; + + std::shared_ptr< base_item > m_parent; + std::vector< std::shared_ptr< base_item > > m_items; + std::function< bool( ) > m_cond; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_button.h b/internal_rewrite/ui_button.h new file mode 100644 index 0000000..0472360 --- /dev/null +++ b/internal_rewrite/ui_button.h @@ -0,0 +1,56 @@ +#pragma once + +#include <functional> + +#include "ui_base_item.h" + +namespace ui +{ + class c_button : public base_item { + public: + c_button( int x, int y, int w, int h, const char* name, std::function< void( ) > fn ) : + base_item( x, y, w, h, name ), m_fn( fn ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ); + int h = m_height; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + + return mouse_x >= x && mouse_x <= x + m_width + && mouse_y >= y && mouse_y <= y + h; + } + + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + ui_draw_rect( x, y, m_width, m_height, ui_get_disabled_col( ) ); + ui_draw_outlined_rect( x - 1, y - 1, m_width + 1, m_height + 1, + is_hovered( ) ? ui_get_text_col( ) : ui_get_accent_col( ) ); + + if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + ui_draw_rect( x, y, m_width, m_height, ui_get_bg_col( ) ); + if ( !m_mouse_held ) { + m_fn( ); + } + m_mouse_held = true; + } + else { + m_mouse_held = false; + } + + ui_draw_string( x + m_width / 2, y + 2, true, ui_get_text_col( ), m_text ); + } + + protected: + std::function< void( ) > m_fn; + bool m_mouse_held{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_checkbox.h b/internal_rewrite/ui_checkbox.h new file mode 100644 index 0000000..3b0c251 --- /dev/null +++ b/internal_rewrite/ui_checkbox.h @@ -0,0 +1,68 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_checkbox : public base_item { + public: + c_checkbox( int x, int y, const char* txt, bool* setting ) : + base_item( x, y, 16, 16, txt ), m_setting( setting ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + int rel_x = get_relative_x( ); + int rel_y = get_relative_y( ); + + return mouse_x >= rel_x && mouse_x <= rel_x + m_width + && mouse_y >= rel_y && mouse_y <= rel_y + m_height; + } + + inline void render_checkbox( const int& x, const int& y ) { + clr_t col = ui_get_bg_col( ); + if ( is_hovered( ) ) { + col = *m_setting ? ui_get_accent_col( ) * 0.8f : ui_get_bg_col( ) * 1.3f; + } + else if ( *m_setting ) { + col = ui_get_accent_col( ); + } + + ui_draw_rect( x, y, m_width, m_height, ui_get_disabled_col( ) ); + ui_draw_rect( x + 1, y + 1, m_width - 2, m_height - 2, col ); + + //ui_draw_outlined_rect( x, y, m_width, m_height, ui_get_accent_col( ) ); + } + + inline void input( ) { + bool mouse_presesed = g_input.is_key_pressed( KEYS_MOUSE1 ); + + if ( is_hovered( ) && mouse_presesed ) { + if ( !m_mouse_held ) { + *m_setting = !*m_setting; + } + m_mouse_held = true; + } + else { + m_mouse_held = false; + } + } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + render_checkbox( x, y ); + input( ); + + + ui_draw_string( x + m_width + 6, y + 2, false, ui_get_text_col( ), m_text ); + } + + protected: + bool* m_setting; + bool m_mouse_held{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_color_picker.h b/internal_rewrite/ui_color_picker.h new file mode 100644 index 0000000..7155691 --- /dev/null +++ b/internal_rewrite/ui_color_picker.h @@ -0,0 +1,201 @@ +#pragma once + +#include "ui_base_item.h" +#include "d3d.hpp" + +namespace ui +{ + class c_color_picker : public base_item { + static constexpr int BOX_WIDTH = 106; + static constexpr int BOX_HEIGHT = 125; + public: + c_color_picker( int x, int y, int w, const char* name, clr_t* setting ) : + base_item( x, y, w, 4, name ), m_setting( setting ), + m_has_text( true ) { } + + c_color_picker( int x, int y, int w, clr_t* setting ) : + base_item( x, y, w, 8, xors( "COLOR_PICKER" ) ), m_setting( setting ), + m_has_text( false ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ); + + int cursor_x, cursor_y; + ui_get_cursor_pos( cursor_x, cursor_y ); + + if ( m_has_text ) y += 12; + + if ( !m_active ) { + return cursor_x >= x && cursor_x <= x + m_width + && cursor_y >= y && cursor_y <= y + m_height; + } + + return cursor_x >= x && cursor_x <= x + BOX_WIDTH + 23 + && cursor_y >= y && cursor_y <= y + BOX_HEIGHT + 2; + } + + virtual int get_total_height( ) const override { + return m_has_text ? ( m_height + 12 ) : m_height; + } + + void input( ) { + bool active_backup = m_active; + bool active_changed = false; + + if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if ( !m_active ) { + m_mouse_held = true; + } + + m_active = true; + } + else if ( m_active && !is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + m_active = false; + } + else { + m_mouse_held = false; + } + + active_changed = active_backup != m_active; + if ( active_changed ) { + set_disabled_callbacks( m_active ); + } + + m_hue = m_setting->hue( ); + if ( m_hue > 1.0f ) { + m_hue -= 359.f; + } + + m_saturation = m_setting->saturation( ); + m_brightness = m_setting->brightness( ) / 255.f; + m_alpha = m_setting->a( ); + } + + void output( ) { + *m_setting = clr_t::from_hsb( m_hue, m_saturation, m_brightness ); + m_setting->a( ) = m_alpha; + } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + if ( m_has_text ) { + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + y += 12; + } + + input( ); + + if ( m_active ) { + RECT old_rect; + g_d3d.get_device( )->GetScissorRect( &old_rect ); + + RECT new_rect{ + x - 1, y - 1, + x + BOX_WIDTH + 22, + y + BOX_HEIGHT + 2 + }; + + g_d3d.get_device( )->SetScissorRect( &new_rect ); + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + clr_t bg_col( 0, 0, 0, 90 ); + ui_draw_rect( x, y, BOX_WIDTH + 20, BOX_HEIGHT, bg_col ); + ui_draw_outlined_rect( x - 1, y - 1, BOX_WIDTH + 22, BOX_HEIGHT + 2, ui_get_accent_col( ) ); + + for ( int i{ }; i < 100; i += 3 ) { + for ( int i2{ }; i2 < 100; i2 += 3 ) { + ui_draw_rect( x + i + 1, y + i2 + 1, 3, 3, + clr_t::from_hsb( m_hue, float( i2 ) * 0.01f, float( i ) * 0.01f ) ); + } + } + + if ( g_input.is_key_pressed( KEYS_MOUSE1 ) && !m_mouse_held + && mouse_x > x && mouse_x <= x + 100 + && mouse_y > y && mouse_y <= y + 100 ) { + + int mouse_x_c = std::clamp( mouse_x, x, x + 100 ); + int mouse_y_c = std::clamp( mouse_y, y, y + 100 ); + + int delta_y = std::clamp( mouse_y_c - y, 0, 100 ); + int delta_x = std::clamp( mouse_x_c - x, 0, 100 ); + + m_saturation = float( delta_y ) * 0.01f; + m_brightness = float( delta_x ) * 0.01f; + } + + auto is_hue_slider_hovered = [&]( ) -> bool { + return mouse_x > x + 110 && mouse_x < x + 122 + && mouse_y > y && mouse_y < y + 100; + }; + + auto draw_slider_hue = [&]( ) { + for ( int i{ }; i < 100; ++i ) { + auto cur_col = clr_t::from_hsb( float( i ) * 0.01f, m_saturation, m_brightness ); + + ui_draw_rect( x + 110, y + i + 1, 12, 2, cur_col ); + } + + ui_draw_outlined_rect( x + 109, y + int( m_hue * 100.f ) + 1, 14, 3, + is_hue_slider_hovered( ) ? ui_get_text_col( ) : ui_get_disabled_col( ) ); + }; + + auto is_alpha_slider_hovered = [&]( ) -> bool { + return mouse_x > x + 1 && mouse_x < x + 122 + && mouse_y > y + 110 && mouse_y < y + 124; + }; + + auto draw_slider_alpha = [&]( ) { + for ( int i{ 121 }; i >= 0; --i ) { + auto col = *m_setting; + col.a( ) = ( int )( float( i ) * 255.f / 121.f ); + + ui_draw_rect( x + i + 1, y + 110, 1, 12, col ); + } + + int a_pos = ( int )( float( m_alpha ) * 121.f / 255.f ); + ui_draw_outlined_rect( x + 1 + a_pos, y + 109, 3, 14, + is_alpha_slider_hovered( ) ? ui_get_text_col( ) : ui_get_disabled_col( ) ); + }; + + draw_slider_hue( ); + if ( is_hue_slider_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + int delta = std::clamp( mouse_y - y, 0, 100 ); + m_hue = float( delta ) * 0.01f; + } + + draw_slider_alpha( ); + if ( is_alpha_slider_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + int delta = std::clamp( mouse_x - x, 0, 121 ); + m_alpha = ( int )( float( delta ) * 255.f / 121.f ); + } + + output( ); + + g_d3d.get_device( )->SetScissorRect( &old_rect ); + } + else { + if ( is_hovered( ) ) { + ui_draw_rect( x - 1, y - 1, m_width + 2, m_height + 2, ui_get_text_col( ) ); + } + ui_draw_rect( x, y, m_width, m_height, *m_setting ); + } + } + + protected: + clr_t* m_setting = nullptr; + bool m_active = false; + bool m_mouse_held = false; + float m_saturation = 1.0f; + float m_brightness = 1.0f; + float m_hue = 0.f; + uint8_t m_alpha = 255; + bool m_has_text = false; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_draw.h b/internal_rewrite/ui_draw.h new file mode 100644 index 0000000..26a1c27 --- /dev/null +++ b/internal_rewrite/ui_draw.h @@ -0,0 +1,163 @@ +#pragma once
+#include "color.hpp"
+#include "d3d.hpp"
+#include "icons.hpp"
+#include "d3d_sprite.hpp"
+#include "input_system.hpp"
+
+namespace ui
+{
+ extern float get_csgo_frametime( );
+ /*__forceinline auto ui_get_background_texture( ) {
+ static auto buffer = std::make_shared< byte[ 512 ] >( );
+ static auto color = D3DCOLOR_RGBA( 27, 27, 27, 233 );
+ static auto color_bright = D3DCOLOR_RGBA( 31, 31, 31, 255 );
+ static IDirect3DTexture9* texture;
+
+ if ( !texture ) {
+ for ( int i = 0; i < 512; i += 4 ) {
+ *( ulong_t* )( uintptr_t( buffer.get( ) ) + i ) = !( i % 12 ) ? color : color_bright;
+ }
+
+ D3DXCreateTextureFromFileInMemory( g_d3d.get_device( ), buffer.get( ), 512, &texture );
+ }
+
+ return texture;
+ }*/
+
+ extern float anim_time;
+
+ __forceinline void set_animtime( float animtime ) {
+ anim_time = animtime;
+ }
+
+ __forceinline void setup_sprites( IDirect3DDevice9* device ) {
+ //fuck msvc
+ icons::sprite_legit.init( device, icons::legit_icon, icons::legit_size, 66, 66 );
+ icons::sprite_rage.init( device, icons::rage_icon, icons::rage_size, 66, 66 );
+ icons::sprite_visuals.init( device, icons::raw::visuals, icons::visuals_size, 66, 66 );
+ icons::sprite_misc.init( device, icons::misc_icon, icons::misc_size, 66, 66 );
+ icons::sprite_config.init( device, icons::config_icon, icons::config_size, 66, 66 );
+ }
+
+ __forceinline clr_t ui_get_accent_col( ) {
+ clr_t col_start = {
+ g_settings.menu.menu_color_1r,
+ g_settings.menu.menu_color_1g,
+ g_settings.menu.menu_color_1b
+ };
+
+ clr_t col_end = {
+ g_settings.menu.menu_color_2r,
+ g_settings.menu.menu_color_2g,
+ g_settings.menu.menu_color_2b
+ };
+
+ clr_t col = clr_t::blend( col_start, col_end, anim_time );
+
+ return col;
+ }
+
+ __forceinline clr_t& ui_get_disabled_col( ) {
+ static clr_t col = clr_t( 61, 61, 61, 255 );
+ return col;
+ }
+
+ __forceinline clr_t& ui_get_bg_col( ) {
+ static clr_t col = clr_t( 24, 25, 27, 255 );
+ return col;
+ }
+
+ __forceinline clr_t& ui_get_text_col( ) {
+ static clr_t col = clr_t( 221, 221, 221, 255 );
+ return col;
+ }
+
+ __forceinline void ui_draw_gradient( int x, int y, int w, int h, clr_t start,
+ clr_t end, GradientType_t type = GRADIENT_HORIZONTAL ) {
+
+ g_d3d.draw_gradient( start, end, x, y, w, h, type );
+ }
+
+ __forceinline void ui_draw_line( int x, int y, int x1, int y1, clr_t color ) {
+ g_d3d.draw_line( color, x, y, x1, y1 );
+ }
+
+ __forceinline void ui_draw_rect( int x, int y, int w, int h, clr_t color ) {
+ g_d3d.draw_filled_rect( color, x, y, w, h );
+ }
+
+ __forceinline void ui_draw_outlined_rect( int x, int y, int w, int h, clr_t color ) {
+ g_d3d.draw_rect( color, x, y, w, h );
+ }
+
+ __forceinline void ui_draw_circle( int x, int y, int r, clr_t color, int res = 48 ) {
+ g_d3d.draw_circle( color, x, y, r, res );
+ }
+
+ __forceinline void ui_draw_filled_circle( int x, int y, int r, clr_t color, int res = 48 ) {
+ g_d3d.draw_filled_circle( color, x, y, r, res );
+ }
+
+ __forceinline void ui_draw_string( int x, int y, bool center, clr_t color, const char* str, ... ) {
+ char buf[ 2048 ]{ };
+ va_list list{ };
+
+ __crt_va_start( list, str );
+ vsprintf_s( buf, 2048, str, list );
+ __crt_va_end( list );
+
+ g_d3d.draw_text( d3d::fonts.f_menu, color, x, y,
+ center ? ALIGN_CENTER : ALIGN_LEFT, D3DFONTFLAG_DROPSHADOW, buf );
+ }
+
+ __forceinline void ui_get_text_size( int& w, int& h, const char* text, ... ) {
+ char* buf = ( char* )_alloca( 2048 );
+ va_list list{ };
+
+ __crt_va_start( list, text );
+ vsprintf_s( buf, 2048, text, list );
+ __crt_va_end( list );
+
+ w = g_d3d.get_text_width( d3d::fonts.f_menu, 0, buf );
+ h = g_d3d.get_text_height( d3d::fonts.f_menu, 0, buf );
+ }
+
+ __forceinline void ui_get_cursor_pos( int& x, int& y ) {
+ g_input.get_cursor_pos( x, y );
+ }
+
+ __forceinline float ui_get_frametime( ) {
+ return get_csgo_frametime( );
+ }
+
+ __forceinline void ui_draw_cursor( ) {
+ const clr_t black( 0, 0, 0, 255 ), accent( ui_get_accent_col( ) );
+ int x, y;
+ ui_get_cursor_pos( x, y );
+
+
+ for ( int i{ }; i <= 9; ++i ) {
+ ui_draw_line( x, y, x + i, y + 11, accent );
+ }
+
+ for ( int i{ }; i <= 7; ++i ) {
+ ui_draw_line( x, y + 9 + i, x + i, y + 9, accent );
+ }
+
+ for ( int i{ }; i <= 3; ++i ) {
+ ui_draw_line( x + 6 + i, y + 11, x, y + i, accent );
+ }
+
+ ui_draw_line( x + 5, y + 11, x + 8, y + 18, accent );
+ ui_draw_line( x + 4, y + 11, x + 7, y + 18, accent );
+
+ ui_draw_line( x, y, x, y + 17, black );
+ ui_draw_line( x, y + 17, x + 3, y + 14, black );
+ ui_draw_line( x + 4, y + 14, x + 7, y + 19, black );
+ ui_draw_line( x + 7, y + 18, x + 9, y + 18, black );
+ ui_draw_line( x + 10, y + 18, x + 7, y + 12, black );
+ ui_draw_line( x + 7, y + 12, x + 11, y + 12, black );
+ ui_draw_line( x + 11, y + 12, x, y, black );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ui_dropdown.h b/internal_rewrite/ui_dropdown.h new file mode 100644 index 0000000..12a9e98 --- /dev/null +++ b/internal_rewrite/ui_dropdown.h @@ -0,0 +1,219 @@ +#pragma once +#include "ui_dropdown_item.h" + +namespace ui +{ + template < typename t = int > + class c_dropdown : public base_item { + public: + c_dropdown( int x, int y, int w, const char* name, t* setting, + std::vector< dropdowns::dropdown_item_t< t > >* items, size_t max_items = 8 ) : + base_item( x, y, w, 16, name ), m_dropdown_items( items ), m_setting( setting ), + m_max_items( max_items ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ) + 12; + int h = m_height; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + + return mouse_x >= x && mouse_x <= x + m_width + && mouse_y >= y && mouse_y <= y + h; + } + + inline bool is_any_item_hovered( ) { + if ( m_disabled || !m_active ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ) + m_height + 12; + int h = m_height * ( std::min< size_t >( + m_dropdown_items->size( ), m_max_items ) ); + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + + return mouse_x >= x && mouse_x <= x + m_width + && mouse_y >= y && mouse_y <= y + h; + } + + virtual int get_total_height( ) const override { + return m_height + 13; + } + + void draw_box( const int& x, const int& y, const char* str, bool hovered = false ) { + ui_draw_rect( x, y, m_width, m_height, hovered ? ui_get_disabled_col( ) : ui_get_bg_col( ) ); + ui_draw_line( x, y + m_height, x + m_width, y + m_height, ui_get_accent_col( ) ); + + ui_draw_string( x + m_width / 2, y + 2, true, ui_get_text_col( ), str ); + } + + void update_value( ) { + for ( auto& it : *m_dropdown_items ) { + if ( it.m_value == *m_setting ) { + m_selected_item = ⁢ + } + } + } + + void draw_items( const int& x, const int& y ) { + auto& items = *m_dropdown_items; + auto it = &items.front( ); + int offset = m_height + 1; + int hovered = 0; + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + auto is_hovered = [ & ] ( int y_offset ) { + return mouse_x >= x && mouse_x <= x + m_width + && mouse_y >= y + y_offset && mouse_y <= y + y_offset + m_height; + }; + + + for ( size_t i = items.size( ) > m_max_items ? m_curr_scroll : 0; + i < std::min< size_t >( m_dropdown_items->size( ), m_max_items + m_curr_scroll ); + ++i, offset += m_height + 1 + ) { + it = &items.at( i ); + + draw_box( x, y + offset, it->m_name ); + + if ( is_hovered( offset ) ) { + hovered = offset; + if ( g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + m_selected_item = it; + *m_setting = it->m_value; + m_active = false; + m_has_clicked_item = true; + } + } + } + + if ( hovered ) { + ui_draw_outlined_rect( x - 1, y - 1 + hovered, + m_width + 1, m_height + 1, ui_get_text_col( ) ); + } + } + + void input( ) { + static float enable_time{ }; + static bool needs_reenable{ }; + bool active_backup = m_active; + bool active_changed = false; + + if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if ( !m_mouse_held ) { + m_active = !m_active; + } + m_mouse_held = true; + } + else if ( !is_any_item_hovered( ) ) { + m_mouse_held = false; + } + + if ( !is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) && !is_any_item_hovered( ) ) { + m_active = false; + } + + if ( GetTickCount( ) * 0.001f > enable_time && needs_reenable) { + set_disabled_callbacks( false ); + needs_reenable = false; + } + + + active_changed = m_active != active_backup; + //disable input on all items + if ( active_changed || m_has_clicked_item ) { + if ( !m_active ) { + enable_time = GetTickCount( ) * 0.001f + 0.220f; + needs_reenable = true; + } + else { + set_disabled_callbacks( true ); + } + + m_has_clicked_item = false; + } + + if ( m_selected_item ) { + *m_setting = m_selected_item->m_value; + } + + if ( m_active && m_dropdown_items->size( ) > m_max_items ) { + int scroll_input = g_input.get_scroll_state( ); + + if ( m_curr_scroll > 0 || scroll_input < 0 ) //we dont want scroll to loop around from 0 to max + m_curr_scroll -= scroll_input; //because positive is scroll up, we gotta flip it + + if ( m_curr_scroll > m_dropdown_items->size( ) - m_max_items ) + m_curr_scroll = m_dropdown_items->size( ) - m_max_items; + } + } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + bool restore = false; + RECT prev_rect{ }; + + if ( m_active ) { + restore = true; + g_d3d.get_device( )->GetScissorRect( &prev_rect ); + + RECT new_rect{ + prev_rect.left, + prev_rect.top, + g_d3d.m_width, + g_d3d.m_height, + }; + + g_d3d.get_device( )->SetScissorRect( &new_rect ); + + draw_items( x, y + 11 ); + + + //draw scrollbar + size_t total_items = m_dropdown_items->size( ); + if ( total_items > m_max_items ) { + const size_t height = ( m_height + 1 ) * m_max_items; + const float slider_step = ( float )( height ) / float( total_items - m_max_items + 1 ); + + size_t slider_pos = static_cast< size_t >( slider_step * m_curr_scroll ); + ui_draw_rect( x + m_width - 1, y + slider_pos + m_height + 13, 2, ( int )slider_step, ui_get_accent_col( ) ); + } + } + + update_value( ); + input( ); + + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + ui_draw_rect( x, y + 13, m_width, m_height, ui_get_disabled_col( ) ); + ui_draw_outlined_rect( x - 1, y + 12, m_width + 1, m_height + 1, + is_hovered( ) || m_active ? ui_get_text_col( ) : ui_get_accent_col( ) ); + + if ( m_selected_item ) { + ui_draw_string( x + m_width / 2, y + 14, true, ui_get_text_col( ), m_selected_item->m_name ); + } + + if( restore ) { + g_d3d.get_device( )->SetScissorRect( &prev_rect ); + } + } + + protected: + std::vector< dropdowns::dropdown_item_t< t > >* m_dropdown_items{ }; + dropdowns::dropdown_item_t< t >* m_selected_item{ }; + bool m_active = false; + bool m_mouse_held = false; + bool m_has_clicked_item = true; + t* m_setting{ }; + size_t m_max_items{ }; + size_t m_curr_scroll{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_dropdown_item.h b/internal_rewrite/ui_dropdown_item.h new file mode 100644 index 0000000..0475746 --- /dev/null +++ b/internal_rewrite/ui_dropdown_item.h @@ -0,0 +1,844 @@ +#pragma once
+
+#include "ui_base_item.h"
+
+namespace ui
+{
+ namespace dropdowns
+ {
+ template < typename t = int >
+ struct dropdown_item_t {
+ const char* m_name;
+ t m_value;
+ };
+
+ static std::vector< dropdown_item_t< > > activation_types_aimbot = {
+ { xors( "always" ), 0 },
+ { xors( "on key" ), 1 },
+ };
+
+ static std::vector< dropdown_item_t< > > silent_aimbot_types = {
+ { xors( "none" ), 0 },
+ { xors( "client-side" ), 1 },
+ { xors( "server-side" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > hitboxes = {
+ { xors( "hitscan" ), -1 },
+ { xors( "head" ), 0 },
+ { xors( "neck" ), 1 },
+ { xors( "pelvis" ), 3 },
+ { xors( "chest" ), 6 },
+ { xors( "thorax" ), 5 },
+ };
+
+ static std::vector< dropdown_item_t< > > antiaim_yaw = {
+ { xors( "normal" ), 0 },
+ { xors( "backwards" ), 1 },
+ { xors( "backwards spin" ), 2 },
+ { xors( "direction" ), 6 },
+ { xors( "switch" ), 7 },
+ { xors( "sideways" ), 3 },
+ { xors( "golden spin" ), 4 },
+ { xors( "random" ), 5 },
+ };
+
+ static std::vector< dropdown_item_t< > > delay_type = {
+ { xors( "none" ), 0 },
+ { xors( "time" ), 2 },
+ { xors( "velocity" ), 3 },
+ };
+
+ static std::vector< dropdown_item_t< > > antiaim_pitch = {
+ { xors( "normal" ), 0 },
+ { xors( "custom" ), 1 },
+ { xors( "flip" ), 2 },
+ { xors( "minimal" ), 3 },
+ { xors( "fake down" ), 4 },
+ { xors( "fake up" ), 5 },
+ { xors( "fake flip" ), 6 },
+ { xors( "random" ), 7 }
+ };
+
+ static std::vector< dropdown_item_t< > > antiaim_freestanding = {
+ { xors( "disabled" ), 0 },
+ { xors( "static" ), 1 },
+ { xors( "narrow angle" ), 2 },
+ { xors( "wide angle" ), 3 },
+ };
+
+ static std::vector< dropdown_item_t< > > antiaim_edge = {
+ { xors( "off" ), 0 },
+ { xors( "peek" ), 1 },
+ { xors( "full" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > antiaim_edge_type = {
+ { xors( "static" ), 0 },
+ { xors( "narrow angle" ), 1 },
+ { xors( "wide angle" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > fakelag_types = {
+ { xors( "disabled" ), 0 },
+ { xors( "adaptive" ), 1 },
+ { xors( "fluctuate" ), 2 },
+ { xors( "static" ), 3 },
+ };
+
+ static std::vector< dropdown_item_t< > > fakelag_fix_types = {
+ { xors( "disabled" ), 0 },
+ { xors( "wait" ), 1 },
+ { xors( "predict" ), 2 }
+ };
+
+ static std::vector< dropdown_item_t< > > activation_type_visuals = {
+ { xors( "never" ), 0 },
+ { xors( "always" ), 1 },
+ { xors( "on hold" ), 2 },
+ { xors( "toggle" ), 3 },
+ };
+
+ static std::vector< dropdown_item_t< > > configs = {
+ { xors( "legit" ), 0 },
+ { xors( "closet" ), 1 },
+ { xors( "rage 1" ), 2 },
+ { xors( "rage 2" ), 3 },
+#if _DEBUG
+ { xors( "test" ), 4 },
+#endif
+ };
+
+ static std::vector< dropdown_item_t< > > recorder_angles = {
+ { xors( "none" ), 0 },
+ { xors( "shot" ), 1 },
+ { xors( "all" ), 2 }
+ };
+
+ static std::vector< dropdown_item_t< > > baim_types = {
+ { xors( "off" ), 0 },
+ { xors( "basic" ), 1 },
+ { xors( "smart" ), 2 },
+ { xors( "aggressive" ), 3 },
+ { xors( "force" ), 4 },
+ };
+
+ static std::vector< dropdown_item_t< > > name_changers = {
+ { xors( "off" ), 0 },
+ { xors( "dollar" ), 1 },
+ { xors( "moneybot.cc" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > weapon_esp_types = {
+ { xors( "none" ), 0 },
+ { xors( "icon" ), 1 },
+ { xors( "name" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > fake_ping_activation = {
+ { xors( "off" ), 0 },
+ { xors( "on hold" ), 1 },
+ { xors( "toggle" ), 2 },
+ { xors( "always" ), 3 },
+ { xors( "auto" ), 4 }
+ };
+
+ static std::vector< dropdown_item_t< > > world_esp_type = {
+ { xors( "off" ), 0 },
+ { xors( "name" ), 1 },
+ { xors( "glow" ), 2 },
+ { xors( "both" ), 3 }
+ };
+
+ static std::vector< dropdown_item_t< > > multipoint_types = {
+ { xors( "off" ), 0 },
+ { xors( "minimal" ), 1 },
+ { xors( "vitals" ), 2 },
+ { xors( "full" ), 3 }
+ };
+
+ static std::vector< dropdown_item_t< > > edge_priority = {
+ { xors( "freestanding" ), 0 },
+ { xors( "edge" ), 1 }
+ };
+
+ static std::vector< dropdown_item_t< > > selection_type = {
+ { xors( "fov" ), 0 },
+ { xors( "distance" ), 1 },
+ { xors( "simulation time" ), 2 }
+ };
+
+ static std::vector< dropdown_item_t< > > autobuy_main_wep = {
+ { xors( "none" ), 0 },
+ { xors( "autosniper" ), 1 },
+ { xors( "scout" ), 2 },
+ { xors( "sniper" ), 3 },
+ { xors( "ak/m4" ), 4 },
+ { xors( "aug/sg" ), 5 },
+ { xors( "mac10/mp9" ), 6 },
+ };
+
+ static std::vector< dropdown_item_t< > > autobuy_second_wep = {
+ { xors( "none" ), 0 },
+ { xors( "deagle/r8" ), 1 },
+ { xors( "dualies" ), 2 },
+ };
+
+ static std::vector< dropdown_item_t< > > skin_knives = {
+ { xors( "none" ), 0 },
+ { xors( "bayonet" ), 1 },
+ { xors( "flip knife" ), 2 },
+ { xors( "gut knife" ), 3 },
+ { xors( "karambit" ), 4 },
+ { xors( "m9 bayonet" ), 5 },
+ { xors( "huntsman" ), 6 },
+ };
+
+ static std::vector< dropdown_item_t< > > weapon_configs = {
+ { xors( "general" ), 0 },
+ { xors( "heavy pistols" ), 1 },
+ { xors( "snipers" ), 2 },
+ { xors( "auto snipers" ), 3 }
+ };
+
+ static std::vector< dropdown_item_t< > > tracer_type = {
+ { xors( "none" ), 0 },
+ { xors( "line" ), 1 },
+ { xors( "beam" ), 2 }
+ };
+
+ static std::vector< dropdown_item_t< > > gloves = {
+ { xors( "none" ), 0 },
+ { xors( "bloodhound" ), 5027 },
+ { xors( "sporty" ), 5030 },
+ { xors( "slick" ), 5031 },
+ { xors( "handwrap" ), 5032 },
+ { xors( "motorcycle" ), 5033 },
+ { xors( "specialist" ), 5034 }
+ };
+
+ static std::vector< dropdown_item_t< > > glove_skins = {
+ { xors( "charred" ), 10006 },
+ { xors( "snakebite" ), 10007 },
+ { xors( "bronzed" ), 10008 },
+ { xors( "leather" ), 10009 },
+ { xors( "spruce ddpat" ), 10010 },
+ { xors( "lunar weave" ), 10013 },
+ { xors( "convoy" ), 10015 },
+ { xors( "crimson weave" ), 10016 },
+ { xors( "superconductor" ), 10018 },
+ { xors( "arid" ), 10019 },
+ { xors( "slaughter" ), 10021 },
+ { xors( "eclipse" ), 10024 },
+ { xors( "spearmint" ), 10026 },
+ { xors( "boom!" ), 10027 },
+ { xors( "cool mint" ), 10028 },
+ { xors( "forest ddpat" ), 10030 },
+ { xors( "crimson kimono" ), 10033 },
+ { xors( "emerald web" ), 10034 },
+ { xors( "foundation" ), 10035 },
+ { xors( "badlands" ), 10036 },
+ { xors( "pandora's box" ), 10037 },
+ { xors( "hedge maze" ), 10038 },
+ { xors( "guerrilla" ), 10039 },
+ { xors( "diamondback" ), 10040 },
+ { xors( "king snake" ), 10041 },
+ { xors( "imperial plaid" ), 10042 },
+ { xors( "overtake" ), 10043 },
+ { xors( "racing green" ), 10044 },
+ { xors( "amphibious" ), 10045 },
+ { xors( "bronze morph" ), 10046 },
+ { xors( "omega" ), 10047 },
+ { xors( "vice" ), 10048 },
+ { xors( "pow!" ), 10049 },
+ { xors( "turtle" ), 10050 },
+ { xors( "transport" ), 10051 },
+ { xors( "polygon" ), 10052 },
+ { xors( "cobalt skulls" ), 10053 },
+ { xors( "overprint" ), 10054 },
+ { xors( "duct tape" ), 10055 },
+ { xors( "arboreal" ), 10056 },
+ { xors( "emerald" ), 10057 },
+ { xors( "mangrove" ), 10058 },
+ { xors( "rattler" ), 10059 },
+ { xors( "case hardened" ), 10060 },
+ { xors( "crimson web" ), 10061 },
+ { xors( "buckshot" ), 10062 },
+ { xors( "fade" ), 10063 },
+ { xors( "mogul" ), 10064 },
+ };
+
+ static std::vector< dropdown_item_t< > > skins = {
+ { xors( "none" ), -1 },
+ { xors( "groundwater" ), 2 },
+ { xors( "candy apple" ), 3 },
+ { xors( "forest ddpat" ), 5 },
+ { xors( "arctic camo" ), 6 },
+ { xors( "desert storm" ), 8 },
+ { xors( "bengal tiger" ), 9 },
+ { xors( "copperhead" ), 10 },
+ { xors( "skulls" ), 11 },
+ { xors( "crimson web" ), 12 },
+ { xors( "blue streak" ), 13 },
+ { xors( "red laminate" ), 14 },
+ { xors( "gunsmoke" ), 15 },
+ { xors( "jungle tiger" ), 16 },
+ { xors( "urban ddpat" ), 17 },
+ { xors( "virus" ), 20 },
+ { xors( "granite marbleized" ), 21 },
+ { xors( "contrast spray" ), 22 },
+ { xors( "forest leaves" ), 25 },
+ { xors( "lichen dashed" ), 26 },
+ { xors( "bone mask" ), 27 },
+ { xors( "anodized navy" ), 28 },
+ { xors( "snake camo" ), 30 },
+ { xors( "silver" ), 32 },
+ { xors( "hot rod" ), 33 },
+ { xors( "metallic ddpat" ), 34 },
+ { xors( "ossified" ), 36 },
+ { xors( "blaze" ), 37 },
+ { xors( "fade" ), 38 },
+ { xors( "bulldozer" ), 39 },
+ { xors( "night" ), 40 },
+ { xors( "copper" ), 41 },
+ { xors( "blue steel" ), 42 },
+ { xors( "stained" ), 43 },
+ { xors( "case hardened" ), 44 },
+ { xors( "contractor" ), 46 },
+ { xors( "colony" ), 47 },
+ { xors( "dragon tattoo" ), 48 },
+ { xors( "lightning strike" ), 51 },
+ { xors( "slaughter" ), 59 },
+ { xors( "dark water" ), 60 },
+ { xors( "hypnotic" ), 61 },
+ { xors( "bloomstick" ), 62 },
+ { xors( "cold blooded" ), 67 },
+ { xors( "carbon fiber" ), 70 },
+ { xors( "scorpion" ), 71 },
+ { xors( "safari mesh" ), 72 },
+ { xors( "wings" ), 73 },
+ { xors( "polar camo" ), 74 },
+ { xors( "blizzard marbleized" ), 75 },
+ { xors( "winter forest" ), 76 },
+ { xors( "boreal forest" ), 77 },
+ { xors( "forest night" ), 78 },
+ { xors( "orange ddpat" ), 83 },
+ { xors( "pink ddpat" ), 84 },
+ { xors( "mudder" ), 90 },
+ { xors( "cyanospatter" ), 92 },
+ { xors( "caramel" ), 93 },
+ { xors( "grassland" ), 95 },
+ { xors( "blue spruce" ), 96 },
+ { xors( "ultraviolet" ), 98 },
+ { xors( "sand dune" ), 99 },
+ { xors( "storm" ), 100 },
+ { xors( "tornado" ), 101 },
+ { xors( "whiteout" ), 102 },
+ { xors( "grassland leaves" ), 104 },
+ { xors( "polar mesh" ), 107 },
+ { xors( "condemned" ), 110 },
+ { xors( "glacier mesh" ), 111 },
+ { xors( "sand mesh" ), 116 },
+ { xors( "sage spray" ), 119 },
+ { xors( "jungle spray" ), 122 },
+ { xors( "sand spray" ), 124 },
+ { xors( "urban perforated" ), 135 },
+ { xors( "waves perforated" ), 136 },
+ { xors( "orange peel" ), 141 },
+ { xors( "urban masked" ), 143 },
+ { xors( "jungle dashed" ), 147 },
+ { xors( "sand dashed" ), 148 },
+ { xors( "urban dashed" ), 149 },
+ { xors( "jungle" ), 151 },
+ { xors( "demolition" ), 153 },
+ { xors( "afterimage" ), 154 },
+ { xors( "bullet rain" ), 155 },
+ { xors( "death by kitty" ), 156 },
+ { xors( "palm" ), 157 },
+ { xors( "walnut" ), 158 },
+ { xors( "brass" ), 159 },
+ { xors( "splash" ), 162 },
+ { xors( "modern hunter" ), 164 },
+ { xors( "splash jam" ), 165 },
+ { xors( "blaze orange" ), 166 },
+ { xors( "radiation hazard" ), 167 },
+ { xors( "nuclear threat" ), 168 },
+ { xors( "fallout warning" ), 169 },
+ { xors( "predator" ), 170 },
+ { xors( "irradiated alert" ), 171 },
+ { xors( "black laminate" ), 172 },
+ { xors( "boom" ), 174 },
+ { xors( "scorched" ), 175 },
+ { xors( "faded zebra" ), 176 },
+ { xors( "memento" ), 177 },
+ { xors( "doomkitty" ), 178 },
+ { xors( "nuclear threat" ), 179 },
+ { xors( "fire serpent" ), 180 },
+ { xors( "corticera" ), 181 },
+ { xors( "emerald dragon" ), 182 },
+ { xors( "overgrowth" ), 183 },
+ { xors( "corticera" ), 184 },
+ { xors( "golden koi" ), 185 },
+ { xors( "wave spray" ), 186 },
+ { xors( "zirka" ), 187 },
+ { xors( "graven" ), 188 },
+ { xors( "bright water" ), 189 },
+ { xors( "black limba" ), 190 },
+ { xors( "tempest" ), 191 },
+ { xors( "shattered" ), 192 },
+ { xors( "bone pile" ), 193 },
+ { xors( "spitfire" ), 194 },
+ { xors( "demeter" ), 195 },
+ { xors( "emerald" ), 196 },
+ { xors( "anodized navy" ), 197 },
+ { xors( "hazard" ), 198 },
+ { xors( "dry season" ), 199 },
+ { xors( "mayan dreams" ), 200 },
+ { xors( "palm" ), 201 },
+ { xors( "jungle ddpat" ), 202 },
+ { xors( "rust coat" ), 203 },
+ { xors( "mosaico" ), 204 },
+ { xors( "jungle" ), 205 },
+ { xors( "tornado" ), 206 },
+ { xors( "facets" ), 207 },
+ { xors( "sand dune" ), 208 },
+ { xors( "groundwater" ), 209 },
+ { xors( "anodized gunmetal" ), 210 },
+ { xors( "ocean foam" ), 211 },
+ { xors( "graphite" ), 212 },
+ { xors( "ocean foam" ), 213 },
+ { xors( "graphite" ), 214 },
+ { xors( "x-ray" ), 215 },
+ { xors( "blue titanium" ), 216 },
+ { xors( "blood tiger" ), 217 },
+ { xors( "hexane" ), 218 },
+ { xors( "hive" ), 219 },
+ { xors( "hemoglobin" ), 220 },
+ { xors( "serum" ), 221 },
+ { xors( "blood in the water" ), 222 },
+ { xors( "nightshade" ), 223 },
+ { xors( "water sigil" ), 224 },
+ { xors( "ghost camo" ), 225 },
+ { xors( "blue laminate" ), 226 },
+ { xors( "electric hive" ), 227 },
+ { xors( "blind spot" ), 228 },
+ { xors( "azure zebra" ), 229 },
+ { xors( "steel disruption" ), 230 },
+ { xors( "cobalt disruption" ), 231 },
+ { xors( "crimson web" ), 232 },
+ { xors( "tropical storm" ), 233 },
+ { xors( "ash wood" ), 234 },
+ { xors( "varicamo" ), 235 },
+ { xors( "night ops" ), 236 },
+ { xors( "urban rubble" ), 237 },
+ { xors( "varicamo blue" ), 238 },
+ { xors( "calicamo" ), 240 },
+ { xors( "hunting blind" ), 241 },
+ { xors( "army mesh" ), 242 },
+ { xors( "gator mesh" ), 243 },
+ { xors( "teardown" ), 244 },
+ { xors( "army recon" ), 245 },
+ { xors( "amber fade" ), 246 },
+ { xors( "damascus steel" ), 247 },
+ { xors( "red quartz" ), 248 },
+ { xors( "cobalt quartz" ), 249 },
+ { xors( "full stop" ), 250 },
+ { xors( "pit viper" ), 251 },
+ { xors( "silver quartz" ), 252 },
+ { xors( "acid fade" ), 253 },
+ { xors( "nitro" ), 254 },
+ { xors( "asiimov" ), 255 },
+ { xors( "the kraken" ), 256 },
+ { xors( "guardian" ), 257 },
+ { xors( "mehndi" ), 258 },
+ { xors( "redline" ), 259 },
+ { xors( "pulse" ), 260 },
+ { xors( "marina" ), 261 },
+ { xors( "rose iron" ), 262 },
+ { xors( "rising skull" ), 263 },
+ { xors( "sandstorm" ), 264 },
+ { xors( "kami" ), 265 },
+ { xors( "magma" ), 266 },
+ { xors( "cobalt halftone" ), 267 },
+ { xors( "tread plate" ), 268 },
+ { xors( "the fuschia is now" ), 269 },
+ { xors( "victoria" ), 270 },
+ { xors( "undertow" ), 271 },
+ { xors( "titanium bit" ), 272 },
+ { xors( "heirloom" ), 273 },
+ { xors( "copper galaxy" ), 274 },
+ { xors( "red fragcam" ), 275 },
+ { xors( "panther" ), 276 },
+ { xors( "stainless" ), 277 },
+ { xors( "blue fissure" ), 278 },
+ { xors( "asiimov" ), 279 },
+ { xors( "chameleon" ), 280 },
+ { xors( "corporal" ), 281 },
+ { xors( "redline" ), 282 },
+ { xors( "trigon" ), 283 },
+ { xors( "heat" ), 284 },
+ { xors( "terrain" ), 285 },
+ { xors( "antique" ), 286 },
+ { xors( "pulse" ), 287 },
+ { xors( "sergeant" ), 288 },
+ { xors( "sandstorm" ), 289 },
+ { xors( "guardian" ), 290 },
+ { xors( "heaven guard" ), 291 },
+ { xors( "death rattle" ), 293 },
+ { xors( "green apple" ), 294 },
+ { xors( "franklin" ), 295 },
+ { xors( "meteorite" ), 296 },
+ { xors( "tuxedo" ), 297 },
+ { xors( "army sheen" ), 298 },
+ { xors( "caged steel" ), 299 },
+ { xors( "emerald pinstripe" ), 300 },
+ { xors( "atomic alloy" ), 301 },
+ { xors( "vulcan" ), 302 },
+ { xors( "isaac" ), 303 },
+ { xors( "slashed" ), 304 },
+ { xors( "torque" ), 305 },
+ { xors( "antique" ), 306 },
+ { xors( "retribution" ), 307 },
+ { xors( "kami" ), 308 },
+ { xors( "howl" ), 309 },
+ { xors( "curse" ), 310 },
+ { xors( "desert warfare" ), 311 },
+ { xors( "cyrex" ), 312 },
+ { xors( "orion" ), 313 },
+ { xors( "heaven guard" ), 314 },
+ { xors( "poison dart" ), 315 },
+ { xors( "jaguar" ), 316 },
+ { xors( "bratatat" ), 317 },
+ { xors( "road rash" ), 318 },
+ { xors( "detour" ), 319 },
+ { xors( "red python" ), 320 },
+ { xors( "master piece" ), 321 },
+ { xors( "nitro" ), 322 },
+ { xors( "rust coat" ), 323 },
+ { xors( "chalice" ), 325 },
+ { xors( "knight" ), 326 },
+ { xors( "chainmail" ), 327 },
+ { xors( "hand cannon" ), 328 },
+ { xors( "dark age" ), 329 },
+ { xors( "briar" ), 330 },
+ { xors( "royal blue" ), 332 },
+ { xors( "indigo" ), 333 },
+ { xors( "twist" ), 334 },
+ { xors( "module" ), 335 },
+ { xors( "desert-strike" ), 336 },
+ { xors( "tatter" ), 337 },
+ { xors( "pulse" ), 338 },
+ { xors( "caiman" ), 339 },
+ { xors( "jet set" ), 340 },
+ { xors( "first class" ), 341 },
+ { xors( "leather" ), 342 },
+ { xors( "commuter" ), 343 },
+ { xors( "dragon lore" ), 344 },
+ { xors( "first class" ), 345 },
+ { xors( "coach class" ), 346 },
+ { xors( "pilot" ), 347 },
+ { xors( "red leather" ), 348 },
+ { xors( "osiris" ), 349 },
+ { xors( "tigris" ), 350 },
+ { xors( "conspiracy" ), 351 },
+ { xors( "fowl play" ), 352 },
+ { xors( "water elemental" ), 353 },
+ { xors( "urban hazard" ), 354 },
+ { xors( "desert-strike" ), 355 },
+ { xors( "koi" ), 356 },
+ { xors( "ivory" ), 357 },
+ { xors( "supernova" ), 358 },
+ { xors( "asiimov" ), 359 },
+ { xors( "cyrex" ), 360 },
+ { xors( "abyss" ), 361 },
+ { xors( "labyrinth" ), 362 },
+ { xors( "traveler" ), 363 },
+ { xors( "business class" ), 364 },
+ { xors( "olive plaid" ), 365 },
+ { xors( "green plaid" ), 366 },
+ { xors( "reactor" ), 367 },
+ { xors( "setting sun" ), 368 },
+ { xors( "nuclear waste" ), 369 },
+ { xors( "bone machine" ), 370 },
+ { xors( "styx" ), 371 },
+ { xors( "nuclear garden" ), 372 },
+ { xors( "contamination" ), 373 },
+ { xors( "toxic" ), 374 },
+ { xors( "radiation hazard" ), 375 },
+ { xors( "chemical green" ), 376 },
+ { xors( "hot shot" ), 377 },
+ { xors( "fallout warning" ), 378 },
+ { xors( "cerberus" ), 379 },
+ { xors( "wasteland rebel" ), 380 },
+ { xors( "grinder" ), 381 },
+ { xors( "murky" ), 382 },
+ { xors( "basilisk" ), 383 },
+ { xors( "griffin" ), 384 },
+ { xors( "firestarter" ), 385 },
+ { xors( "dart" ), 386 },
+ { xors( "urban hazard" ), 387 },
+ { xors( "cartel" ), 388 },
+ { xors( "fire elemental" ), 389 },
+ { xors( "highwayman" ), 390 },
+ { xors( "cardiac" ), 391 },
+ { xors( "delusion" ), 392 },
+ { xors( "tranquility" ), 393 },
+ { xors( "cartel" ), 394 },
+ { xors( "man-o'-war" ), 395 },
+ { xors( "urban shock" ), 396 },
+ { xors( "naga" ), 397 },
+ { xors( "chatterbox" ), 398 },
+ { xors( "catacombs" ), 399 },
+ { xors( "dragon king" ), 400 },
+ { xors( "system lock" ), 401 },
+ { xors( "malachite" ), 402 },
+ { xors( "deadly poison" ), 403 },
+ { xors( "muertos" ), 404 },
+ { xors( "serenity" ), 405 },
+ { xors( "grotto" ), 406 },
+ { xors( "quicksilver" ), 407 },
+ { xors( "tiger tooth" ), 409 },
+ { xors( "damascus steel" ), 410 },
+ { xors( "damascus steel" ), 411 },
+ { xors( "marble fade" ), 413 },
+ { xors( "rust coat" ), 414 },
+ { xors( "doppler" ), 415 },
+ { xors( "doppler" ), 416 },
+ { xors( "doppler" ), 417 },
+ { xors( "doppler" ), 418 },
+ { xors( "doppler" ), 419 },
+ { xors( "doppler" ), 420 },
+ { xors( "doppler" ), 421 },
+ { xors( "elite build" ), 422 },
+ { xors( "armor core" ), 423 },
+ { xors( "worm god" ), 424 },
+ { xors( "bronze deco" ), 425 },
+ { xors( "valence" ), 426 },
+ { xors( "monkey business" ), 427 },
+ { xors( "eco" ), 428 },
+ { xors( "djinn" ), 429 },
+ { xors( "hyper beast" ), 430 },
+ { xors( "heat" ), 431 },
+ { xors( "man-o'-war" ), 432 },
+ { xors( "neon rider" ), 433 },
+ { xors( "origami" ), 434 },
+ { xors( "pole position" ), 435 },
+ { xors( "grand prix" ), 436 },
+ { xors( "twilight galaxy" ), 437 },
+ { xors( "chronos" ), 438 },
+ { xors( "hades" ), 439 },
+ { xors( "icarus fell" ), 440 },
+ { xors( "minotaur's labyrinth" ), 441 },
+ { xors( "asterion" ), 442 },
+ { xors( "pathfinder" ), 443 },
+ { xors( "daedalus" ), 444 },
+ { xors( "hot rod" ), 445 },
+ { xors( "medusa" ), 446 },
+ { xors( "duelist" ), 447 },
+ { xors( "pandora's box" ), 448 },
+ { xors( "poseidon" ), 449 },
+ { xors( "moon in libra" ), 450 },
+ { xors( "sun in leo" ), 451 },
+ { xors( "shipping forecast" ), 452 },
+ { xors( "emerald" ), 453 },
+ { xors( "para green" ), 454 },
+ { xors( "akihabara accept" ), 455 },
+ { xors( "hydroponic" ), 456 },
+ { xors( "bamboo print" ), 457 },
+ { xors( "bamboo shadow" ), 458 },
+ { xors( "bamboo forest" ), 459 },
+ { xors( "aqua terrace" ), 460 },
+ { xors( "counter terrace" ), 462 },
+ { xors( "terrace" ), 463 },
+ { xors( "neon kimono" ), 464 },
+ { xors( "orange kimono" ), 465 },
+ { xors( "crimson kimono" ), 466 },
+ { xors( "mint kimono" ), 467 },
+ { xors( "midnight storm" ), 468 },
+ { xors( "sunset storm" ), 469 },
+ { xors( "sunset storm" ), 470 },
+ { xors( "daybreak" ), 471 },
+ { xors( "impact drill" ), 472 },
+ { xors( "seabird" ), 473 },
+ { xors( "aquamarine revenge" ), 474 },
+ { xors( "hyper beast" ), 475 },
+ { xors( "yellow jacket" ), 476 },
+ { xors( "neural net" ), 477 },
+ { xors( "rocket pop" ), 478 },
+ { xors( "bunsen burner" ), 479 },
+ { xors( "evil daimyo" ), 480 },
+ { xors( "nemesis" ), 481 },
+ { xors( "ruby poison dart" ), 482 },
+ { xors( "loudmouth" ), 483 },
+ { xors( "ranger" ), 484 },
+ { xors( "handgun" ), 485 },
+ { xors( "elite build" ), 486 },
+ { xors( "cyrex" ), 487 },
+ { xors( "riot" ), 488 },
+ { xors( "torque" ), 489 },
+ { xors( "frontside misty" ), 490 },
+ { xors( "dualing dragons" ), 491 },
+ { xors( "survivor z" ), 492 },
+ { xors( "flux" ), 493 },
+ { xors( "stone cold" ), 494 },
+ { xors( "wraiths" ), 495 },
+ { xors( "nebula crusader" ), 496 },
+ { xors( "golden coil" ), 497 },
+ { xors( "rangeen" ), 498 },
+ { xors( "cobalt core" ), 499 },
+ { xors( "special delivery" ), 500 },
+ { xors( "wingshot" ), 501 },
+ { xors( "green marine" ), 502 },
+ { xors( "big iron" ), 503 },
+ { xors( "kill confirmed" ), 504 },
+ { xors( "scumbria" ), 505 },
+ { xors( "point disarray" ), 506 },
+ { xors( "ricochet" ), 507 },
+ { xors( "fuel rod" ), 508 },
+ { xors( "corinthian" ), 509 },
+ { xors( "retrobution" ), 510 },
+ { xors( "the executioner" ), 511 },
+ { xors( "royal paladin" ), 512 },
+ { xors( "power loader" ), 514 },
+ { xors( "imperial" ), 515 },
+ { xors( "shapewood" ), 516 },
+ { xors( "yorick" ), 517 },
+ { xors( "outbreak" ), 518 },
+ { xors( "tiger moth" ), 519 },
+ { xors( "avalanche" ), 520 },
+ { xors( "teclu burner" ), 521 },
+ { xors( "fade" ), 522 },
+ { xors( "amber fade" ), 523 },
+ { xors( "fuel injector" ), 524 },
+ { xors( "elite build" ), 525 },
+ { xors( "photic zone" ), 526 },
+ { xors( "kumicho dragon" ), 527 },
+ { xors( "cartel" ), 528 },
+ { xors( "valence" ), 529 },
+ { xors( "triumvirate" ), 530 },
+ { xors( "royal legion" ), 532 },
+ { xors( "the battlestar" ), 533 },
+ { xors( "lapis gator" ), 534 },
+ { xors( "praetorian" ), 535 },
+ { xors( "impire" ), 536 },
+ { xors( "hyper beast" ), 537 },
+ { xors( "necropos" ), 538 },
+ { xors( "jambiya" ), 539 },
+ { xors( "lead conduit" ), 540 },
+ { xors( "fleet flock" ), 541 },
+ { xors( "judgement of anubis" ), 542 },
+ { xors( "red astor" ), 543 },
+ { xors( "ventilators" ), 544 },
+ { xors( "orange crash" ), 545 },
+ { xors( "firefight" ), 546 },
+ { xors( "spectre" ), 547 },
+ { xors( "chantico's fire" ), 548 },
+ { xors( "bioleak" ), 549 },
+ { xors( "oceanic" ), 550 },
+ { xors( "asiimov" ), 551 },
+ { xors( "fubar" ), 552 },
+ { xors( "atlas" ), 553 },
+ { xors( "ghost crusader" ), 554 },
+ { xors( "re-entry" ), 555 },
+ { xors( "primal saber" ), 556 },
+ { xors( "black tie" ), 557 },
+ { xors( "lore" ), 558 },
+ { xors( "lore" ), 559 },
+ { xors( "lore" ), 560 },
+ { xors( "lore" ), 561 },
+ { xors( "lore" ), 562 },
+ { xors( "black laminate" ), 563 },
+ { xors( "black laminate" ), 564 },
+ { xors( "black laminate" ), 565 },
+ { xors( "black laminate" ), 566 },
+ { xors( "black laminate" ), 567 },
+ { xors( "gamma doppler" ), 568 },
+ { xors( "gamma doppler" ), 569 },
+ { xors( "gamma doppler" ), 570 },
+ { xors( "gamma doppler" ), 571 },
+ { xors( "gamma doppler" ), 572 },
+ { xors( "autotronic" ), 573 },
+ { xors( "autotronic" ), 574 },
+ { xors( "autotronic" ), 575 },
+ { xors( "autotronic" ), 576 },
+ { xors( "autotronic" ), 577 },
+ { xors( "bright water" ), 578 },
+ { xors( "bright water" ), 579 },
+ { xors( "freehand" ), 580 },
+ { xors( "freehand" ), 581 },
+ { xors( "freehand" ), 582 },
+ { xors( "aristocrat" ), 583 },
+ { xors( "phobos" ), 584 },
+ { xors( "violent daimyo" ), 585 },
+ { xors( "wasteland rebel" ), 586 },
+ { xors( "mecha industries" ), 587 },
+ { xors( "desolate space" ), 588 },
+ { xors( "carnivore" ), 589 },
+ { xors( "exo" ), 590 },
+ { xors( "imperial dragon" ), 591 },
+ { xors( "iron clad" ), 592 },
+ { xors( "chopper" ), 593 },
+ { xors( "harvester" ), 594 },
+ { xors( "reboot" ), 595 },
+ { xors( "limelight" ), 596 },
+ { xors( "bloodsport" ), 597 },
+ { xors( "aerial" ), 598 },
+ { xors( "ice cap" ), 599 },
+ { xors( "neon revolution" ), 600 },
+ { xors( "syd mead" ), 601 },
+ { xors( "imprint" ), 602 },
+ { xors( "directive" ), 603 },
+ { xors( "roll cage" ), 604 },
+ { xors( "scumbria" ), 605 },
+ { xors( "ventilator" ), 606 },
+ { xors( "weasel" ), 607 },
+ { xors( "petroglyph" ), 608 },
+ { xors( "airlock" ), 609 },
+ { xors( "dazzle" ), 610 },
+ { xors( "grim" ), 611 },
+ { xors( "powercore" ), 612 },
+ { xors( "triarch" ), 613 },
+ { xors( "fuel injector" ), 614 },
+ { xors( "briefing" ), 615 },
+ { xors( "slipstream" ), 616 },
+ { xors( "doppler" ), 617 },
+ { xors( "doppler" ), 618 },
+ { xors( "doppler" ), 619 },
+ { xors( "ultraviolet" ), 620 },
+ { xors( "ultraviolet" ), 621 },
+ { xors( "polymer" ), 622 },
+ { xors( "ironwork" ), 623 },
+ { xors( "dragonfire" ), 624 },
+ { xors( "royal consorts" ), 625 },
+ { xors( "mecha industries" ), 626 },
+ { xors( "cirrus" ), 627 },
+ { xors( "stinger" ), 628 },
+ { xors( "black sand" ), 629 },
+ { xors( "sand scale" ), 630 },
+ { xors( "flashback" ), 631 },
+ { xors( "buzz kill" ), 632 },
+ { xors( "sonar" ), 633 },
+ { xors( "gila" ), 634 },
+ { xors( "turf" ), 635 },
+ { xors( "shallow grave" ), 636 },
+ { xors( "cyrex" ), 637 },
+ { xors( "wasteland princess" ), 638 },
+ { xors( "bloodsport" ), 639 },
+ { xors( "fever dream" ), 640 },
+ { xors( "jungle slipstream" ), 641 },
+ { xors( "blueprint" ), 642 },
+ { xors( "xiangliu" ), 643 },
+ { xors( "decimator" ), 644 },
+ { xors( "oxide blaze" ), 645 },
+ { xors( "capillary" ), 646 },
+ { xors( "crimson tsunami" ), 647 },
+ { xors( "emerald poison dart" ), 648 },
+ { xors( "akoben" ), 649 },
+ { xors( "ripple" ), 650 },
+ { xors( "last dive" ), 651 },
+ { xors( "scaffold" ), 652 },
+ { xors( "neo-noir" ), 653 },
+ { xors( "seasons" ), 654 },
+ };
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/ui_form.h b/internal_rewrite/ui_form.h new file mode 100644 index 0000000..e9841e4 --- /dev/null +++ b/internal_rewrite/ui_form.h @@ -0,0 +1,187 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_form : public base_item { + public: + c_form( int x, int y, int w, int h, const char* name, int max_h = 0, bool collapse = false, bool default_collapsed = false ) : + base_item( x, y, w, h, name ), m_dynamic( !h ), m_max_height( max_h ), m_collapse( collapse ), m_open( !default_collapsed ) { }; + + virtual int x( ) const override { + return m_x + 10; + } + + virtual int y( ) const override { + return m_y + m_scroll_offset + 9; + } + + virtual bool is_form( ) const override { + return true; + } + + virtual bool is_hovered( ) override { + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + int x = get_relative_x( ); + int y = get_relative_y( ); + + return mouse_x > x && mouse_x < x + w( ) + && mouse_y > y && mouse_y < y + h( ); + } + + bool is_collapse_hovered( ) { + if( !m_collapse ) return false; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + int x = get_relative_x( ) + m_width - 8; + int y = get_relative_y( ) + 2; + + return mouse_x >= x && mouse_x <= x + 5 + && mouse_y >= y && mouse_y <= y + 7; + } + + bool is_collapsed( ) { + return ( m_collapse && !m_open ); + } + + inline void update_size( ) { + if ( !m_dynamic ) return; + + int total_height{ ITEM_OFFSET * 2 }; + for ( auto& it : m_items ) { + if ( it->get_visible( ) ) { + auto item_height = it->get_total_height( ) + ITEM_OFFSET; + if( m_max_height && total_height + item_height > m_max_height ) { + total_height = m_max_height; + break; + } + total_height += it->get_total_height( ) + ITEM_OFFSET; + } + } + + m_height = total_height; + } + + virtual int get_total_height( ) const override { + if( !m_open && m_collapse ) return 18; + return m_height + 5; + } + + int get_total_item_height( ) { + int total_height{ ITEM_OFFSET * 2 }; + for( auto& it : m_items ) { + if( it->get_visible( ) ) { + auto item_height = it->get_total_height( ) + ITEM_OFFSET; + total_height += it->get_total_height( ) + ITEM_OFFSET; + } + } + + return total_height; + } + + void input( ) { + if( m_collapse ) { + bool hovered = is_collapse_hovered( ); + bool clicked = g_input.is_key_pressed( KEYS_MOUSE1 ); + if( hovered && clicked ) { + if( !m_was_pressed ) { + m_open ^= 1; + } + m_was_pressed = true; + } + else { + m_was_pressed = false; + } + } + + if( m_max_height && get_total_item_height( ) > m_max_height ) { + if( !m_disabled && is_hovered( ) ) { + auto scroll_state = g_input.get_scroll_state( ); + if( !!scroll_state && m_was_hovered ) { + scroll_state > 0 ? m_scroll_offset += 13 : m_scroll_offset -= 13; + } + } + m_scroll_offset = std::clamp( m_scroll_offset, -( get_total_item_height( ) - m_height + 3 ), 0 ); + } + else { + m_scroll_offset = 0; + } + } + + virtual void render( ) override { + update_size( ); + input( ); + int x = get_relative_x( ); + int y = get_relative_y( ); + + int text_w, text_h; + ui_get_text_size( text_w, text_h, m_text ); + + if( m_collapse ) { + if( !m_open && m_collapse ) { + ui_draw_outlined_rect( x, y, m_width, 14, ui_get_accent_col( ) ); + ui_draw_line( x + 3, y, x + text_w + 1, y, ui_get_bg_col( ) ); + ui_draw_string( x + 3, y - 7, false, ui_get_text_col( ), m_text ); + + int button_x = x + m_width - 6; + int button_y = y + 2; + + ui_draw_string( button_x, button_y, true, + is_collapse_hovered( ) ? ui_get_accent_col( ) : ui_get_text_col( ), "+" ); + return; + } + } + + for( int i{ }; i < 8; ++i ) { + clr_t col = ui_get_bg_col( ) * ( 0.72f + i * 0.04f ); + ui_draw_rect( x, y + i, m_width, m_height - i * 2, col ); + } + + ui_draw_outlined_rect( x, y, m_width, m_height, ui_get_accent_col( ) ); + + if( m_max_height && get_total_item_height( ) > m_height ) { + const size_t height = get_total_height( ) - 20; + const float delta = ( float )( get_total_item_height( ) - height + 1 ); + const float slider_step = ( ( float )( height ) / delta ); + const float slider_height = slider_step * 13.f; + + size_t slider_pos = static_cast< size_t >( slider_step * m_scroll_offset ); + ui_draw_rect( x + m_width - 7, y + 8, 4, height, ui_get_disabled_col( ) ); + ui_draw_rect( x + m_width - 7, y - slider_pos + 8, 4, ( int )slider_height + 1, ui_get_accent_col( ) ); + } + + if( is_hovered( ) != m_was_hovered ) { + bool backup = m_disabled; + if( !backup ) { + set_disabled( !is_hovered( ) ); + } + m_disabled = backup; + } + + ui_draw_line( x + 3, y, x + text_w + 1, y, ui_get_bg_col( ) ); + ui_draw_string( x + 3, y - 7, false, ui_get_text_col( ), m_text ); + if( m_collapse ) { + int button_x = x + m_width - 6; + int button_y = y + 2; + + ui_draw_string( button_x, button_y, true, + is_collapse_hovered( ) ? ui_get_accent_col( ) : ui_get_text_col( ), "-" ); + } + + m_was_hovered = is_hovered( ); + } + + protected: + bool m_dynamic{ }; + bool m_was_hovered{ }; + int m_max_height{ }; + int m_scroll_offset{ }; + bool m_was_pressed{ }; + bool m_collapse{ }; + bool m_open{ true }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_itemlist.h b/internal_rewrite/ui_itemlist.h new file mode 100644 index 0000000..e692746 --- /dev/null +++ b/internal_rewrite/ui_itemlist.h @@ -0,0 +1,127 @@ +#pragma once +#include "ui_base_item.h" +#include "ui_dropdown_item.h" + +#include <algorithm> + +namespace ui +{ + template < typename t, size_t size > + class c_itemlist : public base_item { + public: + static constexpr size_t ITEM_SIZE = 18; + + c_itemlist( int x, int y, int width, const char* name, std::vector< dropdowns::dropdown_item_t< t > >* dropdowns, t* setting ) + : base_item( x, y, width, 20, name ), m_items( dropdowns ), m_setting( setting ) { } + + void text_input( ); + bool is_textbox_hovered( ) { + if( m_disabled ) + return false; + + int x = get_relative_x( ); + int y = get_relative_y( ) + 12; + + int mx, my; + ui_get_cursor_pos( mx, my ); + + return mx >= x && my >= y + && mx <= x + m_width && my <= y + ITEM_SIZE; + } + + void input( ) { + text_input( ); + } + + virtual int get_total_height( ) const override { + size_t total_items = 0; + + if( strlen( m_search_text ) ) { + for( size_t i{ }; i < m_items->size( ); ++i ) { + if( !strstr( m_items->at( i ).m_name, m_search_text ) ) + continue; + + ++total_items; + } + } + else + total_items = m_items->size( ); + + return 12 + 20 + total_items * 20; + } + + bool is_item_hovered( int x, int y ) { + if( m_disabled ) + return false; + + int mx, my; + ui_get_cursor_pos( mx, my ); + + return mx >= x && mx <= x + m_width + && my >= y && my <= y + ITEM_SIZE; + } + + void draw_items( int x, int y ) { + int max_y = INT_MAX; + + auto parent = get_parent( ); + if( parent->is_form( ) ) { + max_y = parent->get_relative_y( ) + parent->get_total_height( ) + ITEM_SIZE; + } + + std::string search_str( m_search_text ); + std::transform( search_str.begin( ), search_str.end( ), search_str.begin( ), [ ]( char c ) { return tolower( c ); } ); + + int text_len = strlen( m_search_text ); + for( size_t i{ }; i < m_items->size( ); ++i ) { + if( y > max_y ) + break; + + auto& item = m_items->at( i ); + + if( !strstr( item.m_name, m_search_text ) ) + continue; + + ui_draw_rect( x - 1, y - 1, m_width + 2, ITEM_SIZE + 2, + is_item_hovered( x, y ) || *m_setting == item.m_value + ? ui_get_text_col( ) : ui_get_accent_col( ) ); + + ui_draw_rect( x, y, m_width, ITEM_SIZE, ui_get_disabled_col( ) ); + + ui_draw_string( x + 2, y + 3, false, ui_get_text_col( ), item.m_name ); + + if( g_input.is_key_pressed( KEYS_MOUSE1 ) && is_item_hovered( x, y ) ) + *m_setting = item.m_value; + + y += ITEM_SIZE + 2; + } + } + + virtual void render( ) override { + input( ); + + int x = get_relative_x( ); + int y = get_relative_y( ); + + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + + ui_draw_rect( x - 1, y + 12, m_width + 2, ITEM_SIZE + 2, is_textbox_hovered( ) || m_box_active ? ui_get_text_col( ) : ui_get_accent_col( ) ); + if( is_textbox_hovered( ) ) { + ui_draw_rect( x, y + 13, m_width, ITEM_SIZE, ui_get_text_col( ) ); + } + ui_draw_rect( x + 1, y + 14, m_width - 2, ITEM_SIZE - 2, ui_get_disabled_col( ) ); + ui_draw_string( x + 3, y + 17, false, ui_get_text_col( ), m_box_active ? "%s_" : "%s", m_search_text ); + + draw_items( x, y + 14 + ITEM_SIZE ); + } + + private: + std::vector< dropdowns::dropdown_item_t< t > >* m_items; + bool m_box_active{ }; + bool m_was_held{ }; + char m_search_text[ size ]{ }; + float m_last_key_input[ KEYS_LAST ]{ }; + uint8_t m_key_states[ 256 ]{ }; + t* m_setting{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_itemlist_def.h b/internal_rewrite/ui_itemlist_def.h new file mode 100644 index 0000000..fd64f12 --- /dev/null +++ b/internal_rewrite/ui_itemlist_def.h @@ -0,0 +1,61 @@ +#include "ui_itemlist.h" +#include <windows.h> + +namespace ui +{ + template < typename t, size_t size > + void c_itemlist< t, size >::text_input( ) { + if( is_textbox_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if( !m_was_held ) { + m_box_active ^= 1; + } + m_was_held = true; + } + else { + m_was_held = false; + } + + if( m_box_active ) { + if( !is_textbox_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + m_box_active = false; + } + + float current_time = GetTickCount( ) * 0.001f; + size_t length = strlen( m_search_text ); + + for( size_t i{ }; i < 0xfe; ++i ) { + if( g_input.is_key_pressed( i ) ) { + float delta_time = current_time - m_last_key_input[ i ]; + if( fabs( delta_time ) > 0.2f ) { + if( i == KEYS_BACK ) { + m_search_text[ length - 1 ] = 0; + m_last_key_input[ i ] = current_time; + continue; + } + + m_key_states[ i ] = 0xf0; + wchar_t pressed_char; + const auto scan = MapVirtualKeyA( i, 2 ); + auto ret = ToAscii( i, scan, ( BYTE* )m_key_states, ( LPWORD )&pressed_char, 1 ); + + if( ret == 1 ) { + if( length < size ) { + m_search_text[ length ] = ( char )( pressed_char ); + m_search_text[ length + 1 ] = 0; + } + } + m_last_key_input[ i ] = current_time; + } + } + else { + m_last_key_input[ i ] = 0.f; + m_key_states[ i ] = 0; + } + } + + if( g_input.is_key_pressed( KEYS_RETURN ) ) { + m_box_active = false; + } + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/ui_key_picker.h b/internal_rewrite/ui_key_picker.h new file mode 100644 index 0000000..dea681c --- /dev/null +++ b/internal_rewrite/ui_key_picker.h @@ -0,0 +1,164 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_key_picker : public base_item { + public: + c_key_picker( int x, int y, int w, const char* name, int* setting ) : + base_item( x, y, w, 16, name ), m_setting( setting ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ) + 12; + int h = m_height; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + + return mouse_x >= x && mouse_x <= x + m_width + && mouse_y >= y && mouse_y <= y + h; + } + + virtual int get_total_height( ) const override { + return m_height + 12; + } + + void input( ) { + bool active_backup = m_active; + bool active_changed = false; + + if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if ( !m_mouse_held ) { + m_active = true; + } + m_mouse_held = true; + } + + if ( g_input.is_key_pressed( KEYS_ESCAPE ) ) { + m_active = false; + *m_setting = KEYS_NONE; + } + + if ( m_active && !m_mouse_held ) { + int key = g_input.is_any_key_pressed( ); + if ( key != KEYS_NONE ) { + *m_setting = key; + m_active = false; + } + } + + active_changed = active_backup != m_active; + if ( active_changed ) { + set_disabled_callbacks( m_active ); + } + } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + input( ); + + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + ui_draw_rect( x, y + 13, m_width, m_height, ui_get_disabled_col( ) ); + ui_draw_outlined_rect( x - 1, y + 12, m_width + 1, m_height + 1, + is_hovered( ) || m_active ? ui_get_text_col( ) : ui_get_accent_col( ) ); + + ui_draw_string( x + m_width / 2, y + 14, true, ui_get_text_col( ), + g_input.get_key_name( ( VirtualKeys_t )*m_setting ) ); + } + + protected: + int* m_setting{ }; + bool m_active{ }; + bool m_mouse_held{ }; + }; + + //skEeT PiCkErS + class c_key_picker_small : public base_item { + public: + c_key_picker_small( int x, int y, int* setting ) : + base_item( x, y, 0, 0, xors( "KEY_PICKER" ) ), m_setting( setting ) { } + + virtual int get_total_height( ) const override { + const char* name = g_input.get_short_name( ( VirtualKeys_t )*m_setting ); + int w, h; + ui_get_text_size( w, h, name ); + + return h; + } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + const char* name = g_input.get_short_name( ( VirtualKeys_t )*m_setting ); + int x = get_relative_x( ); + int y = get_relative_y( ); + int mouse_x, mouse_y; + int w, h; + + ui_get_text_size( w, h, "[%s]", name ); + ui_get_cursor_pos( mouse_x, mouse_y ); + + return mouse_x >= x - w && mouse_x <= x + && mouse_y >= y && mouse_y <= y + h; + } + + void input( ) { + + bool active_backup = m_active; + bool active_changed = false; + + if ( g_input.is_key_pressed( KEYS_ESCAPE ) ) { + m_active = false; + *m_setting = KEYS_NONE; + } + + if ( m_active && !m_mouse_held ) { + int key = g_input.is_any_key_pressed( ); + if ( key != KEYS_NONE ) { + *m_setting = key; + m_active = false; + } + } + + if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if ( !m_mouse_held ) { + m_active = true; + } + m_mouse_held = true; + } + else { + m_mouse_held = false; + } + + active_changed = active_backup != m_active; + if ( active_changed ) { + set_disabled_callbacks( m_active ); + } + } + + virtual void render( ) override { + const char* name = g_input.get_short_name( ( VirtualKeys_t )*m_setting ); + int x = get_relative_x( ); + int y = get_relative_y( ); + + int w, h; + ui_get_text_size( w, h, "[%s]", name ); + + input( ); + + ui_draw_string( x - w, y, false, is_hovered( ) || m_active ? + ui_get_accent_col( ) : ui_get_text_col( ), "[%s]", name ); + } + + protected: + int* m_setting; + bool m_active{ }; + bool m_mouse_held{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_label.h b/internal_rewrite/ui_label.h new file mode 100644 index 0000000..712b547 --- /dev/null +++ b/internal_rewrite/ui_label.h @@ -0,0 +1,18 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_label : public base_item { + public: + c_label( int x, int y, const char* text ) : + base_item( x, y, 0, 16, text ) { } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + + ui_draw_string( x + 2, y + 2, false, ui_get_text_col( ), m_text ); + } + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_menu.h b/internal_rewrite/ui_menu.h new file mode 100644 index 0000000..37b16f9 --- /dev/null +++ b/internal_rewrite/ui_menu.h @@ -0,0 +1,89 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_menu : public base_item { + public: + c_menu( int start_x, int start_y, int width, + int height, const char* name, const char* right_text = nullptr ) : + base_item( start_x, start_y, width, height, name ), + m_right_text( right_text ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + return mouse_x >= m_x && mouse_x <= m_x + w( ) + && mouse_y >= m_y && mouse_y <= m_y + 19; + } + + virtual int y( ) const override { + return m_y + 19; + } + + inline void input( ) { + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + bool mouse_clicked = g_input.is_key_pressed( KEYS_MOUSE1 ); + + if ( is_hovered( ) ) { + m_mouse_held = true; + } + + if ( !mouse_clicked ) { + m_mouse_held = is_hovered( ); + } + + if ( m_mouse_held && !mouse_clicked ) { + m_drag_offset_y = mouse_y - m_y; + m_drag_offset_x = mouse_x - m_x; + } + + if ( m_mouse_held && mouse_clicked ) { + m_x = mouse_x - m_drag_offset_x; + m_y = mouse_y - m_drag_offset_y; + } + } + + virtual void render( ) override { + constexpr auto top_height = 19; + + input( ); + + //draw a c00l shadow + ui_draw_outlined_rect( m_x, m_y + 1, m_width + 1, m_height, clr_t( 0, 0, 0, 166 ) ); + + ui_draw_rect( m_x + 1, m_y + 1, m_width - 1, top_height - 2, ui_get_bg_col( ) * 1.2f ); + if( is_hovered( ) ) { + ui_draw_rect( m_x + 1, m_y + 1, m_width - 1, top_height - 2, clr_t( 61, 61, 61 ) ); + } + + for( int i{ }; i < 8; ++i ) { + clr_t col = ui_get_bg_col( ) * ( 0.72f + i * 0.04f ); + ui_draw_rect( m_x, m_y + i + top_height - 1, m_width, m_height - i * 2 - top_height + 1, col ); + } + ui_draw_outlined_rect( m_x, m_y, m_width, m_height, ui_get_accent_col( ) ); + + if( m_right_text ) { + ui_draw_string( m_x + 5, m_y + 4, false, ui_get_text_col( ), m_text ); + + int width, height; + ui_get_text_size( width, height, m_right_text ); + + ui_draw_string( m_x + m_width - 5 - width, m_y + 4, false, ui_get_text_col( ), m_right_text ); + } + else { + ui_draw_string( m_x + m_width / 2, m_y + 4, true, ui_get_text_col( ), m_text ); + } + } + + protected: + int m_drag_offset_x{ }; + int m_drag_offset_y{ }; + bool m_mouse_held{ }; + const char* m_right_text{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_render.h b/internal_rewrite/ui_render.h new file mode 100644 index 0000000..1f10223 --- /dev/null +++ b/internal_rewrite/ui_render.h @@ -0,0 +1,63 @@ +#pragma once + +#include "ui_base_item.h" + +namespace ui +{ + //recursively render all items + static void render_item( base_item* item, int offset = 0, bool allow_rect = true ) { + if( !item->get_visible( ) ) return; + + item->reset( ); + item->render( ); + bool reset = false; + RECT original; + + if( allow_rect && item->is_form( ) ) { + auto device = g_d3d.get_device( ); + device->GetScissorRect( &original ); + + auto x = item->get_relative_x( ); + auto y = item->get_relative_y( ); + + RECT new_rect{ + x, + y + 4, + x + item->w( ), + y + item->get_total_height( ) - 7 + }; + + device->SetScissorRect( &new_rect ); + reset = true; + } + + bool draw = true; + if( item->is_form( ) ) { + auto form_cast = static_cast< c_form* >( item ); + draw = !form_cast->is_collapsed( ); + } + + if( item->get_items( ).size( ) && draw ) { + //madr0fl + int* height_offset = ( int* )_alloca( sizeof( int ) * item->get_items( ).size( ) ); + int cur_offset = 0; + for( int i = ( int )item->get_items( ).size( ) - 1; i >= 0; --i ) { + auto& cur_item = item->get_items( )[ i ]; + height_offset[ i ] = cur_offset; + cur_offset += cur_item->get_visible( ) ? cur_item->get_total_height( ) + ITEM_OFFSET : 0; + } + + int i{ }; + for( auto& it : item->get_items( ) ) { + item->set_y_offset( height_offset[ i ] ); + render_item( it.get( ), height_offset[ i ], !reset && allow_rect ); + ++i; + } + } + + if( reset ) { + auto device = g_d3d.get_device( ); + device->SetScissorRect( &original ); + } + } +}
\ No newline at end of file diff --git a/internal_rewrite/ui_slider.h b/internal_rewrite/ui_slider.h new file mode 100644 index 0000000..e13ffae --- /dev/null +++ b/internal_rewrite/ui_slider.h @@ -0,0 +1,167 @@ +#pragma once + +#include "ui_base_item.h" + +namespace ui +{ + template < typename t > + class c_slider : public base_item { + public: + c_slider( int x, int y, int w, t min, t max, const char* text, t* setting, t full, const char* suffix = 0 ) : + base_item( x, y, w, 5, text ), m_setting( setting ), m_suffix( suffix ), + m_min( float( min ) ), m_max( float( max ) ), m_full( full ), m_has_text( true ) { }; + + c_slider( int x, int y, int w, t min, t max, const char* text, t* setting, const char* suffix = 0 ) : + base_item( x, y, w, 5, text ), m_setting( setting ), m_suffix( suffix ), + m_min( float( min ) ), m_max( float( max ) ), m_full( max ), m_has_text( true ) { }; + + c_slider( int x, int y, int w, t min, t max, t* setting, const char* suffix = 0 ) : + base_item( x, y, w, 5, nullptr ), m_setting( setting ), m_suffix( suffix ), + m_min( float( min ) ), m_max( float( max ) ), m_full( max ), m_has_text( false ) { } + + virtual bool is_hovered( ) override { + if ( m_disabled ) return false; + + int x = get_relative_x( ); + int y = get_relative_y( ) + ( m_has_text ? 11 : 2 ); + + int mouse_x, mouse_y; + ui_get_cursor_pos( mouse_x, mouse_y ); + + if( !m_has_text ) { + x += 4; + return mouse_x >= x && mouse_x <= x + m_width - 8 + && mouse_y >= y && mouse_y <= y + m_height + 2; + } + + return mouse_x >= x - 1 && mouse_x <= x + m_width + 1 + && mouse_y >= y && mouse_y <= y + m_height + 2; + } + + void input( ) { + bool mouse_clicked = g_input.is_key_pressed( KEYS_MOUSE1 ); + bool hovered = is_hovered( ); + float progress = 0.f; + int x = get_relative_x( ); + int y = get_relative_y( ) + 2; + int mouse_x, mouse_y; + + *m_setting = ( t )( std::clamp< float >( *m_setting, m_min, m_max ) ); + ui_get_cursor_pos( mouse_x, mouse_y ); + + if ( hovered && mouse_clicked ) { + + float progress{ }; + + if( m_has_text ) { + progress = std::clamp< float >( float( mouse_x - x ) / ( m_width - 3 ), 0.f, 1.0f ); + } + else { + progress = std::clamp< float >( float( mouse_x - x - 4 ) / ( m_width - 10 ), 0.f, 1.0f ); + } + + *m_setting = progress == 1.0f ? m_full : ( t )( ( ( m_max - m_min ) * progress ) + m_min ); + } + + if( !m_has_text ) { + bool y_hover = mouse_y >= y && mouse_y <= y + m_height + 1; + + bool minus_hovered = mouse_x >= x - 1 && mouse_x <= x + 3 && y_hover; + bool plus_hovered = mouse_x >= x + m_width - 2 && mouse_x <= x + m_width + 2 && y_hover; + + if( mouse_clicked ) { + if( !m_mouse_held ) { + if( !std::is_floating_point< t >::value ) { + if( minus_hovered ) *m_setting -= ( t )1; + if( plus_hovered ) *m_setting += ( t )1; + } + else if( m_max - m_min <= 2.0f ) { + if( minus_hovered ) *m_setting -= ( t )0.1f; + if( plus_hovered ) *m_setting += ( t )0.1f; + } + } + + m_mouse_held = true; + } + else { + m_mouse_held = false; + } + } + }; + + void draw_slider( int x, int y ) { + float val = float( *m_setting ); + float progress = ( val - m_min ) / ( m_max - m_min ); + + ui_draw_rect( x, y, m_width, m_height, ui_get_disabled_col( ) ); + + ui_draw_rect( x, y, ( int )( ( m_width - 3 ) * progress ), m_height, ui_get_accent_col( ) ); + ui_draw_rect( x + ( int )( ( m_width - 3 ) * progress ), y, 3, m_height, + is_hovered( ) ? ui_get_text_col( ) : ui_get_accent_col( ) * 0.7f ); + } + + void draw_slider_small( int x, int y ) { + float val = float( *m_setting ); + float progress = ( val - m_min ) / ( m_max - m_min ); + x -= 1; //i couldnt be fucked + + ui_draw_rect( x + 5, y, m_width - 8, m_height, ui_get_disabled_col( ) ); + + ui_draw_rect( x + 5, y, ( int )( ( m_width - 10 ) * progress ), m_height, ui_get_accent_col( ) ); + ui_draw_rect( x + ( int )( ( m_width - 10 ) * progress ) + 3, y, 3, m_height, + is_hovered( ) ? ui_get_text_col( ) : ui_get_accent_col( ) * 0.7f ); + + ui_draw_string( x, y - 3, false, ui_get_text_col( ), "-" ); + ui_draw_string( x + m_width - 2, y - 3, false, ui_get_text_col( ), "+" ); + + char val_str[ 12 ]; + if( m_suffix ) + sprintf_s( val_str, 12, t( 0.1f ) == t( 0 ) ? "%d %s" : "%0.2f %s", *m_setting, m_suffix ); + else + sprintf_s( val_str, 12, t( 0.1f ) == t( 0 ) ? "%d" : "%0.2f", *m_setting ); + + int text_h, text_w; + ui_get_text_size( text_w, text_h, val_str ); + ui_draw_string( x + ( int )( ( m_width - 8 ) * progress ), y + 2, false, ui_get_text_col( ), val_str ); + } + + virtual int get_total_height( ) const override { + return m_height + ( m_has_text ? 12 : 6 ); + } + + virtual void render( ) override { + int x = get_relative_x( ); + int y = get_relative_y( ); + int text_w, text_h; + char val[ 12 ]; + + input( ); + + //weird hacky fix for floating point vars + if ( m_suffix ) + sprintf_s( val, 12, t( 0.1f ) == t( 0 ) ? "%d %s" : "%0.2f %s", *m_setting, m_suffix ); + else + sprintf_s( val, 12, t( 0.1f ) == t( 0 ) ? "%d" : "%0.2f", *m_setting ); + + if( m_has_text ) { + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + ui_get_text_size( text_w, text_h, val ); + ui_draw_string( x + m_width - text_w - 1, y, false, ui_get_text_col( ), val ); + draw_slider( x, y + 12 ); + } + else { + draw_slider_small( x, y + 2 ); + } + } + + + protected: + t* m_setting; + t m_full; + float m_min; + float m_max; + bool m_has_text = true; + const char* m_suffix; + bool m_mouse_held = false; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_tab_manager.h b/internal_rewrite/ui_tab_manager.h new file mode 100644 index 0000000..293d48b --- /dev/null +++ b/internal_rewrite/ui_tab_manager.h @@ -0,0 +1,227 @@ +#pragma once +#include "ui_base_item.h" + + + +namespace ui +{ + namespace { + constexpr int BUTTON_WIDTH = 120; + constexpr int BUTTON_HEIGHT = 80; + + constexpr int SUBTAB_HEIGHT = 25; + } + + class c_tab_sheet : public base_item { + public: + c_tab_sheet( const char* tab_name ) : + base_item( 0, 0, 0, 0, tab_name ), + m_fade_progress( 0 ) { }; + + c_tab_sheet( const char* tab_name, d3d::c_sprite* sprite ) : + base_item( 0, 0, 0, 0, tab_name ), m_sprite( sprite ), + m_fade_progress( 0.f ) { }; + + virtual void render( ) override { }; + virtual bool is_hovered( ) override { + return false; + }; + + public: + float m_fade_progress{ }; + d3d::c_sprite* m_sprite{ }; + }; + + + class c_tab_manager : public base_item { + public: + c_tab_manager( ) : base_item( BUTTON_WIDTH + 11, 0, 0, 0, + xors( "TAB_MANAGER" ) ) { }; + + virtual bool is_hovered( ) override { + return false; + } + + inline void scale_button_fade( c_tab_sheet* item, bool hovered ) { + if ( hovered ) { + constexpr float frequency = 1.f / 0.3f; + const float step = ui_get_frametime( ) * frequency; + + item->m_fade_progress = std::clamp( item->m_fade_progress + step, 0.f, 0.8f ); + } + else { + item->m_fade_progress = 0.f; + } + } + + auto get_selected_tab( ) { + return m_selected_tab; + } + + void draw_tab_button( decltype( m_parent )& button, int start, bool hovered ) { + auto item = ( c_tab_sheet* )button.get( ); + auto text = item->get_text( ); + auto parent_x = m_parent->x( ) + 5; + auto parent_y = m_parent->y( ) + 5; + int item_height = BUTTON_HEIGHT; + + scale_button_fade( item, hovered ); + + ui_draw_rect( parent_x, parent_y + start, BUTTON_WIDTH + 1, + item_height + 1, ui_get_bg_col( ) ); + + ui_draw_line( parent_x + BUTTON_WIDTH - 8, parent_y + start - 1, + parent_x + BUTTON_WIDTH - 8, parent_y + start + BUTTON_HEIGHT + 2, + ui_get_disabled_col( ) ); + + if( hovered ) { + ui_draw_line( parent_x + BUTTON_WIDTH - 8, parent_y + start - 1, + parent_x + BUTTON_WIDTH - 8, parent_y + start + BUTTON_HEIGHT + 2, + ui_get_accent_col( ) * ( item->m_fade_progress + 0.2f ) * 0.8f ); + } + + if( item->m_sprite ) { + auto sprite_color = hovered ? ui_get_text_col( ) * ( ( item->m_fade_progress + 0.3f ) * 0.7f ) : ui_get_disabled_col( ); + item->m_sprite->draw( parent_x + ( BUTTON_WIDTH - 8 ) / 2 - 2, + parent_y + BUTTON_HEIGHT / 2 + start, sprite_color ); + } + else { + g_con->log( "sprite is null" ); + } + } + + inline bool is_button_hovered( int start ) { + auto item_x = m_parent->x( ) + 5; + auto item_y = m_parent->y( ) + 5 + start; + int item_height = BUTTON_HEIGHT; + int mouse_x, mouse_y; + + ui_get_cursor_pos( mouse_x, mouse_y ); + + return mouse_x >= item_x && mouse_x <= item_x + BUTTON_WIDTH - 8 + && mouse_y >= item_y && mouse_y <= item_y + item_height; + } + + virtual void render( ) override { + if ( !m_items.empty( ) ) { + int cur_y{ 10 }; + for ( auto& it : m_items ) { + it->set_visible( false ); + bool hovered = is_button_hovered( cur_y ); + if ( g_input.is_key_pressed( KEYS_MOUSE1 ) && hovered ) { + //fix items that disable input mess it up when changing tabs + set_disabled_callbacks( false ); + m_selected_tab = it; + } + + draw_tab_button( it, cur_y, hovered || it == m_selected_tab ); + cur_y += BUTTON_HEIGHT + 4; + } + } + + if ( !m_selected_tab ) { + m_selected_tab = m_items.front( ); + } + + m_selected_tab->set_visible( true ); + } + + protected: + decltype( m_parent ) m_selected_tab{ }; + }; + + + class c_subtab_manager : public base_item { + public: + c_subtab_manager( ) : base_item( 0, 35, 0, 5, + xors( "SUBTAB_MANAGER" ) ) { } + + virtual bool is_hovered( ) override { return false; } + + int get_button_width( ) { + int width = get_top_parent( )->w( ) - BUTTON_WIDTH - 26; + + if ( !m_items.empty( ) ) + return ( int )std::ceilf( float( width ) / float( m_items.size( ) ) ); + + return width; + } + + inline void scale_button_fade( c_tab_sheet* item, bool hovered ) { + if ( hovered ) { + constexpr float frequency = 1.f / 0.3f; + const float step = ui_get_frametime( ) * frequency; + + item->m_fade_progress = std::clamp( item->m_fade_progress + step, 0.f, 0.8f ); + } + else { + item->m_fade_progress = 0.f; + } + } + + auto get_selected_tab( ) { + return m_selected_tab; + } + + void render_button( decltype( m_parent )& button, int start, bool hovered ) { + auto item = ( c_tab_sheet* )button.get( ); + auto item_x = get_relative_x( ) + start - 2; + auto item_y = get_relative_y( ) + 3 - m_y; + auto width = get_button_width( ); + + scale_button_fade( item, hovered ); + clr_t tab_clr = ui_get_disabled_col( ); + + //ui_draw_rect( item_x, item_y, get_button_width( ), SUBTAB_HEIGHT, ui_get_bg_col( ) ); + ui_draw_rect( item_x + 1, item_y + SUBTAB_HEIGHT - 2, width, 2, tab_clr ); + if ( hovered ) { + clr_t col = ui_get_accent_col( ); + col.a( ) *= item->m_fade_progress; + ui_draw_rect( item_x + 1, item_y + SUBTAB_HEIGHT - 2, width, 2, col ); + } + + ui_draw_string( item_x + width / 2, item_y + 4, true, ui_get_text_col( ), item->get_text( ) ); + } + + bool is_button_hovered( decltype( m_parent )& button, int start ) { + int item_x = get_relative_x( ) + start - 2; + int item_y = get_relative_y( ) + 3 - m_y - 3; + int item_w = get_button_width( ); + int mouse_x, mouse_y; + + ui_get_cursor_pos( mouse_x, mouse_y ); + + return mouse_x >= item_x && mouse_x <= item_x + item_w && + mouse_y >= item_y && mouse_y <= item_y + SUBTAB_HEIGHT; + } + + virtual void render( ) override { + if ( !m_items.empty( ) ) { + int start = 2; + int width = get_button_width( ); + + for ( auto& it : m_items ) { + it->set_visible( false ); + bool hovered = is_button_hovered( it, start ); + if ( g_input.is_key_pressed( KEYS_MOUSE1 ) && hovered ) { + //fix items that disable input mess it up when changing tabs + set_disabled_callbacks( false ); + m_selected_tab = it; + } + + render_button( it, start, hovered || it == m_selected_tab ); + start += width; + } + + if ( !m_selected_tab ) { + m_selected_tab = m_items.front( ); + } + + m_selected_tab->set_visible( true ); + } + } + + protected: + decltype( m_parent ) m_selected_tab; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/ui_text_input.cpp b/internal_rewrite/ui_text_input.cpp new file mode 100644 index 0000000..44a4ebc --- /dev/null +++ b/internal_rewrite/ui_text_input.cpp @@ -0,0 +1,69 @@ +#include "ui_text_input.h" +#include <Windows.h> + +void ui::c_text_input::render( ) { + if( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + if( !m_was_held ) { + m_active ^= 1; + } + m_was_held = true; + } + else { + m_was_held = false; + } + + if( m_active ) { + if( !is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) { + m_active = false; + } + + float current_time = GetTickCount( ) * 0.001f; + size_t length = strlen( m_text_ptr ); + + for( size_t i{ }; i < 0xfe; ++i ) { + if( g_input.is_key_pressed( i ) ) { + float delta_time = current_time - m_last_key_input[ i ]; + if( fabs( delta_time ) > 0.2f ) { + if( i == KEYS_BACK ) { + m_text_ptr[ length - 1 ] = 0; + m_last_key_input[ i ] = current_time; + continue; + } + + m_key_states[ i ] = 0xf0; + wchar_t pressed_char; + const auto scan = MapVirtualKeyA( i, 2 ); + auto ret = ToAscii( i, scan, ( BYTE* )m_key_states, ( LPWORD )&pressed_char, 1 ); + + if( ret == 1 ) { + if( length < m_text_len ) { + m_text_ptr[ length ] = ( char )( pressed_char ); + m_text_ptr[ length + 1 ] = 0; + } + } + m_last_key_input[ i ] = current_time; + } + } + else { + m_last_key_input[ i ] = 0.f; + m_key_states[ i ] = 0; + } + } + + if( g_input.is_key_pressed( KEYS_RETURN ) ) { + m_active = false; + } + } + + int x = get_relative_x( ); + int y = get_relative_y( ); + + ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text ); + y += 12; + + ui_draw_rect( x - 1, y - 1, m_width + 2, m_height + 2, + ( is_hovered( ) || m_active ) ? ui_get_text_col( ) : ui_get_accent_col( ) ); + ui_draw_rect( x, y, m_width, m_height, ui_get_disabled_col( ) ); + + ui_draw_string( x + 2, y + 3, false, ui_get_text_col( ), m_active ? "%s_" : "%s", m_text_ptr ); +}
\ No newline at end of file diff --git a/internal_rewrite/ui_text_input.h b/internal_rewrite/ui_text_input.h new file mode 100644 index 0000000..b651828 --- /dev/null +++ b/internal_rewrite/ui_text_input.h @@ -0,0 +1,37 @@ +#pragma once +#include "ui_base_item.h" + +namespace ui +{ + class c_text_input : public base_item { + public: + c_text_input( int x, int y, int w, const char* name, size_t max_chars, char* str ) : + base_item( x, y, w, 16, name ), m_text_len( max_chars ), m_text_ptr( str ) { + } + + virtual bool is_hovered( ) override { + int cursor_x, cursor_y; + ui_get_cursor_pos( cursor_x, cursor_y ); + + int x = get_relative_x( ); + int y = get_relative_y( ) + 12; + + return cursor_x >= x && cursor_x <= x + m_width + && cursor_y >= y && cursor_y <= y + m_height; + } + + virtual int get_total_height( ) const override { + return m_height + 12; + } + + virtual void render( ) override; + + protected: + bool m_was_held{ }; + char* m_text_ptr{ }; + size_t m_text_len{ }; + bool m_active{ }; + float m_last_key_input[ KEYS_LAST ]{ }; + uint8_t m_key_states[ 256 ]{ }; + }; +}
\ No newline at end of file diff --git a/internal_rewrite/update_clientside_animation.cpp b/internal_rewrite/update_clientside_animation.cpp new file mode 100644 index 0000000..b95c8ae --- /dev/null +++ b/internal_rewrite/update_clientside_animation.cpp @@ -0,0 +1,121 @@ +#include "hooks.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+
+void __fastcall hooks::update_clientside_animation( void* ecx_, void* edx_ ) {
+ static bool first_update = true;
+
+ auto old_func = g_csgo.m_local->get_old_function< decltype( &hooks::update_clientside_animation ) >( 218 );
+ auto ent = ( c_base_player* )( ecx_ );
+
+ static ent_animdata_t prev_anims;
+ static float last_choke;
+ static float last_update;
+
+ // Arbitrary number much.
+ if( !g_settings.rage.anti_aim || !g_ctx.m_local->is_valid( ) || std::abs( last_update - g_csgo.m_globals->m_curtime ) > TICKS_TO_TIME( 20 ) ) {
+ last_update = g_csgo.m_globals->m_curtime;
+ first_update = true;
+ return old_func( ecx_, edx_ );
+ }
+
+ *( byte* )( uintptr_t( ent ) + 0x270 ) = 1;
+ if( !g_cheat.m_lagmgr.get_choked( ) || g_cheat.m_lagmgr.get_sent( ) > 1 || first_update ) {
+ vec3_t backup;
+ g_csgo.m_prediction( )->GetLocalViewAngles( backup );
+
+ float backup_curtime = g_csgo.m_globals->m_curtime;
+ float backup_frametime = g_csgo.m_globals->m_frametime;
+
+ g_csgo.m_globals->m_curtime = g_ctx.pred_time( );
+ g_csgo.m_globals->m_frametime = TICK_INTERVAL( );
+
+ if( g_csgo.m_globals->m_curtime != ent->get_animstate( )->m_flLastClientSideAnimationUpdateTime ) {
+ last_update = backup_curtime;
+
+ last_choke = std::max( g_csgo.m_globals->m_curtime - ent->get_animstate( )->m_flLastClientSideAnimationUpdateTime, TICK_INTERVAL( ) );
+
+ vec3_t real_angle = g_ctx.m_thirdperson_angle;
+
+ float min_pitch = 10.0f;
+ if( g_ctx.m_local->get_animstate( )->m_bInHitGroundAnimation ) {
+ if( real_angle.x > min_pitch ) {
+ real_angle.x = -min_pitch;
+ }
+ }
+
+ g_csgo.m_prediction( )->SetViewAngles( real_angle );
+ ent->get_animstate( )->update( real_angle.y, real_angle.x );
+ old_func( ecx_, edx_ );
+
+ memcpy( &prev_anims, &ent->get_animdata( ), sizeof( prev_anims ) );
+ ent->cache_anim_data( );
+ }
+
+ g_csgo.m_prediction( )->SetLocalViewAngles( backup );
+ g_csgo.m_globals->m_curtime = backup_curtime;
+ g_csgo.m_globals->m_frametime = backup_frametime;
+ }
+
+ ent->restore_anim_data( true );
+ float yaw = ent->get_animstate( )->m_flGoalFeetYaw;
+
+ //interpolate EVERYTHING
+ if( !first_update && !( ent->get_animstate( )->m_bInHitGroundAnimation && ent->get_animstate( )->m_bOnGround ) ) {
+ for( size_t i{ }; i < 18; ++i ) {
+ float lerp = std::min( last_choke, TICK_INTERVAL( ) * 2.f );
+ float update_delta = last_choke;
+ float update_lerp = std::clamp( update_delta - lerp, 0.f, 1.f );
+ if( update_delta > 0.f )
+ lerp = std::clamp( lerp, 0.f, update_delta );
+
+ float lerp_progress = ( last_update + lerp - g_csgo.m_globals->m_curtime ) / lerp;
+
+ float old_param = prev_anims.m_poseparams.at( i );
+ float param = ent->get_animdata( ).m_poseparams.at( i );
+
+ if( i == BODY_YAW )
+ continue;
+
+ if( !isfinite( old_param ) || !isfinite( param ) )
+ continue;
+
+ float jmp_param = math::lerp( old_param, param, update_lerp / update_delta );
+ float final_param = math::lerp( param, jmp_param, std::clamp( lerp_progress, 0.f, 1.f ) );
+
+ ent->m_flPoseParameter( )[ i ] = final_param;
+ }
+
+ float lerp = std::min( last_choke, TICK_INTERVAL( ) * 2.f );
+ float update_delta = last_choke;
+ float update_lerp = std::clamp( update_delta - lerp, 0.f, 1.f );
+ if( update_delta > 0.f )
+ lerp = std::clamp( lerp, 0.f, update_delta );
+
+ for( size_t i{ }; i < 13; ++i ) {
+ auto old_cycle = prev_anims.m_animlayers.at( i ).m_flCycle;
+ auto cycle = ent->get_animdata( ).m_animlayers.at( i ).m_flCycle;
+
+ float lerp_progress = ( last_update + lerp - g_csgo.m_globals->m_curtime ) / lerp;
+
+ float jmp_cycle = math::lerp( old_cycle, cycle, update_lerp / update_delta );
+ float final_cycle = math::lerp( cycle, jmp_cycle, std::clamp( lerp_progress, 0.f, 1.f ) );
+
+ ent->m_AnimOverlay( ).GetElements( )[ i ].m_flCycle = final_cycle;
+ }
+ }
+
+ if( !first_update ) {
+ //*( byte* )( uintptr_t( ent ) + 0x270 ) = 0;
+ ent->set_abs_angles( vec3_t( 0, yaw, 0 ) );
+ bool backup = ent->get_animstate( )->m_bOnGround;
+ ent->get_animstate( )->m_bOnGround = false;
+
+ ent->invalidate_bone_cache( );
+ ent->ce( )->SetupBones( nullptr, 128, BONE_USED_BY_ANYTHING, 0.f );
+
+ ent->get_animstate( )->m_bOnGround = backup;
+ }
+
+ first_update = false;
+}
\ No newline at end of file diff --git a/internal_rewrite/util.cpp b/internal_rewrite/util.cpp new file mode 100644 index 0000000..7e07d2f --- /dev/null +++ b/internal_rewrite/util.cpp @@ -0,0 +1,558 @@ +#include "util.hpp"
+
+#include "interface.hpp"
+#include "c_base_player.hpp"
+#include "pattern.hpp"
+#include "context.hpp"
+#include "settings.hpp"
+#include "math.hpp"
+#include "base_cheat.hpp"
+
+float TICK_INTERVAL( ) {
+ return g_csgo.m_globals->m_interval_per_tick;
+}
+
+int TIME_TO_TICKS( float dt ) {
+ return static_cast< int >( 0.5f + dt / TICK_INTERVAL( ) );
+}
+
+float TICKS_TO_TIME( int tick ) {
+ return tick * TICK_INTERVAL( );
+}
+
+bool util::is_low_fps( ) {
+ return g_csgo.m_globals->m_frametime > g_csgo.m_globals->m_interval_per_tick;
+}
+
+int util::get_closest_player( ) {
+ float cur_fov{ 360.f };
+ int ret{ -1 };
+ vec3_t viewangles{ };
+ vec3_t local_pos{ };
+
+ bool friendlies = g_settings.rage.active ?
+ g_settings.rage.friendlies : g_settings.legit.friendlies;
+
+ local_pos = g_ctx.m_local->get_eye_pos( );
+ g_csgo.m_engine( )->GetViewAngles( viewangles );
+
+ for( int i{ 1 }; i < g_csgo.m_globals->m_maxclients; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent ) continue;
+ if( ent == g_ctx.m_local ) continue;
+ if( !ent->is_valid( ) ) continue;
+ int team = ent->m_iTeamNum( );
+ if( team == g_ctx.m_local->m_iTeamNum( ) && !friendlies ) {
+ continue;
+ }
+
+ auto ang = math::vector_angles( local_pos, ent->get_hitbox_pos( 0 ) );
+ ang.clamp( );
+
+ float fov = ( viewangles - ang ).clamp( ).length2d( );
+ if( fov < cur_fov ) {
+ ret = i;
+ cur_fov = fov;
+ }
+ }
+
+ return ret;
+}
+
+void util::clip_trace_to_player( IClientEntity* player, const vec3_t& src, const vec3_t& end,
+ unsigned mask, CTraceFilter* filter, CGameTrace* tr ) {
+ CGameTrace player_trace;
+ Ray_t ray;
+ float smallest_fraction = tr->fraction;
+
+ ray.Init( src, end );
+
+ if ( !filter->ShouldHitEntity( player, mask ) ) {
+ return;
+ }
+
+ g_csgo.m_trace( )->ClipRayToEntity( ray, mask | CONTENTS_HITBOX, player, &player_trace );
+
+ if ( player_trace.fraction < smallest_fraction ) {
+ *tr = player_trace;
+ smallest_fraction = player_trace.fraction;
+ }
+}
+
+std::string util::hitgroup_to_string( int hitgroup ) {
+ switch( hitgroup ) {
+ case HITGROUP_CHEST:
+ return xors( "chest" );
+ case HITGROUP_HEAD:
+ return xors( "head" );
+ case HITGROUP_LEFTARM:
+ return xors( "left arm" );
+ case HITGROUP_LEFTLEG:
+ return xors( "left leg" );
+ case HITGROUP_RIGHTARM:
+ return xors( "right arm" );
+ case HITGROUP_RIGHTLEG:
+ return xors( "right leg" );
+ case HITGROUP_STOMACH:
+ return xors( "stomach" );
+ default:
+ return xors( "generic" );
+ }
+}
+
+bool util::trace_ray( const vec3_t& start, const vec3_t& end, IClientEntity* a, IClientEntity* b ) {
+ CGameTrace tr;
+ Ray_t ray;
+ CTraceFilter filter;
+
+ filter.pSkip = a;
+
+ ray.Init( start, end );
+
+ g_csgo.m_trace( )->TraceRay( ray, 0x46004003 | CONTENTS_HITBOX, &filter, &tr );
+ clip_trace_to_player( b, start, end, ( unsigned )0x46004003, &filter, &tr );
+
+ return tr.m_pEnt == b || tr.fraction > 0.98f;
+}
+
+void util::set_random_seed( int seed ) {
+ using fn = int( __cdecl* )( int );
+ fn fn_ptr = ( fn )( GetProcAddress(
+ GetModuleHandleA( xors( "vstdlib.dll" ) ),
+ xors( "RandomSeed" ) ) );
+
+ fn_ptr( seed );
+}
+
+float util::get_random_float( float min, float max ) {
+ using fn = float( *)( float, float );
+ fn fn_ptr = ( fn )( GetProcAddress(
+ GetModuleHandleA( xors( "vstdlib.dll" ) ),
+ xors( "RandomFloat" ) ) );
+
+ return fn_ptr( min, max );
+}
+
+std::array< util::hitchance_data_t, 256 > hitchance_data;
+void util::calculate_spread_runtime( ) {
+ constexpr float pi_2 = 2.0f * ( float ) M_PI;
+
+ for ( size_t n { }; n < 256; ++n ) {
+ set_random_seed( n );
+
+ const float rand_a = get_random_float( 0.0f, 1.0f );
+ const float rand_pi_a = get_random_float( 0.0f, pi_2 );
+ const float rand_b = get_random_float( 0.0f, 1.0f );
+ const float rand_pi_b = get_random_float( 0.0f, pi_2 );
+
+ hitchance_data [ n ] = {
+ { rand_a, rand_b },
+ { std::cos( rand_pi_a ), std::sin( rand_pi_a ) },
+ { std::cos( rand_pi_b ), std::sin( rand_pi_b ) }
+ };
+ }
+}
+
+// This is gay, I didn't want to fuck up the project.
+vec3_t util::get_spread_dir( void *weapon, float inaccuracy, float spread, vec3_t angles, int seed ) {
+ const int rnsd = ( seed & 0xFF );
+ const auto *data = &hitchance_data [ rnsd ];
+ auto *wpn = ( c_base_weapon * ) weapon;
+
+ if ( !wpn )
+ return vec3_t{ };
+
+ float rand_a = data->m_random[ 0 ];
+ float rand_b = data->m_random[ 1 ];
+
+ const uint16_t item_def = wpn->m_iItemDefinitionIndex( );
+
+ // Because fuck you.
+ if ( item_def == WEAPON_R8REVOLVER ) {
+ rand_a = 1.0f - rand_a * rand_a;
+ rand_b = 1.0f - rand_b * rand_b;
+ }
+ else if ( item_def == WEAPON_NEGEV ) {
+ const int recoil_seed = wpn->get_wpn_info( )->recoil_seed;
+
+ if ( recoil_seed < 3 ) {
+ // Shoutouts to toast for the epic simplified math :^)
+ rand_a = 1.0f - std::powf( rand_a, ( 3 - recoil_seed ) + 1 );
+ rand_b = 1.0f - std::powf( rand_b, ( 3 - recoil_seed ) + 1 );
+ }
+ }
+
+ // Calculate spread.
+ const float rand_inacc = rand_a * wpn->get_inaccuracy( );
+ const float rand_spread = rand_b * wpn->get_spread( );
+
+ const float spread_x = data->m_inaccuracy [ 0 ] * rand_inacc + data->m_spread [ 0 ] * rand_spread;
+ const float spread_y = data->m_inaccuracy [ 1 ] * rand_inacc + data->m_spread [ 1 ] * rand_spread;
+
+ // Transform angle to direction.
+ vec3_t forward, right, up;
+ math::angle_vectors( angles, &forward, &right, &up );
+
+ return forward + right * spread_x + up * spread_y;
+}
+
+bool __vectorcall util::intersects_hitbox( vec3_t eye_pos, vec3_t end_pos, vec3_t min, vec3_t max, float radius ) {
+ auto dist = math::dist_segment_to_segment( eye_pos, end_pos, min, max );
+
+ return ( dist < radius );
+}
+
+// Note: abuse this as much as you can to achieve the full potential it offers.
+bool util::hitchance( int target, const vec3_t& angles, int percentage ) {
+ if( g_settings.rage.compensate_spread )
+ return true;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( target );
+
+ if ( !ent ) return false;
+ if ( percentage <= 1 ) return true;
+
+ int hits_needed = percentage * 256 / 100;
+ int hits = 0;
+
+ auto wep = g_ctx.m_local->get_weapon( );
+ if ( !wep ) return false;
+
+ vec3_t eye_pos = g_ctx.m_local->get_eye_pos( );
+ auto wpn_info = wep->get_wpn_info( );
+ if( !wpn_info ) return false;
+
+ float length = wpn_info->range;
+
+ wep->update_accuracy_penalty( );
+
+ float inaccuracy = wep->get_inaccuracy( );
+ float spread = wep->get_spread( );
+
+ if( g_settings.rage.active->m_spread_limit( ) ) {
+ bool crouched = g_ctx.m_local->m_vecViewOffset( ).z < 50.f;
+ bool alt_inaccuracy = wep->is_sniper( ) || wep->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER;
+ float min_accuracy = crouched ? ( alt_inaccuracy ? wpn_info->inaccuracy_crouch_alt : wpn_info->inaccuracy_crouch )
+ : ( alt_inaccuracy ? wpn_info->inaccuracy_stand_alt : wpn_info->inaccuracy_stand );
+
+ float max_accuracy = alt_inaccuracy ? wpn_info->inaccuracy_move_alt : wpn_info->inaccuracy_move;
+ min_accuracy += 0.0005f;
+
+ float spread_accuracy_fraction = -( g_settings.rage.active->m_spread_limit_min( ) * 0.01f - 1.0f );
+ float spread_accuracy_tolerance = max_accuracy * spread_accuracy_fraction;
+ min_accuracy += spread_accuracy_tolerance;
+
+ if( wep->m_iItemDefinitionIndex( ) == WEAPON_SSG08 && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) {
+ min_accuracy = 0.008750f;
+ }
+
+ if( min_accuracy >= inaccuracy )
+ return true;
+ }
+
+ struct hitbox_data_t {
+ hitbox_data_t( const vec3_t& min, const vec3_t& max, float radius ) {
+ m_min = min;
+ m_max = max;
+ m_radius = radius;
+ }
+
+ vec3_t m_min{ };
+ vec3_t m_max{ };
+ float m_radius{ };
+ };
+
+ std::vector< hitbox_data_t > m_hitbox_data;
+
+ auto model = ent->ce( )->GetModel( );
+ if( !model ) return false;
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !hdr ) return false;
+
+ matrix3x4 bone_matrix[ 128 ];
+ if( !ent->ce()->SetupBones( bone_matrix, 128, 0x100, g_csgo.m_globals->m_curtime ) ) {
+ return false;
+ }
+
+ auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) );
+ if( !set ) return false;
+
+ for( int hitbox{ }; hitbox < set->numhitboxes; ++hitbox ) {
+ auto box = set->pHitbox( hitbox );
+ if( !box ) continue;
+
+ auto min = math::vector_transform( box->bbmin, bone_matrix[ box->bone ] );
+ auto max = math::vector_transform( box->bbmax, bone_matrix[ box->bone ] );
+ auto radius = box->m_flRadius;
+
+ if( radius == -1.f ) {
+ radius = min.dist_to( max );
+ }
+
+ m_hitbox_data.push_back( hitbox_data_t( min, max, radius ) );
+ }
+
+ if( m_hitbox_data.empty( ) )
+ return false;
+
+ for ( int i{ }; i < 256; i ++ ) {
+ vec3_t spread_dir = get_spread_dir( wep, inaccuracy, spread, angles, i );
+
+ //Ray_t ray;
+ //vec3_t end_pos = eye_pos + spread_dir * length;
+ //ray.Init( eye_pos, end_pos );
+ //
+ //
+ //CGameTrace tr;
+ //g_csgo.m_trace( )->ClipRayToEntity( ray, 0x46004003, ent->ce( ), &tr );
+
+ vec3_t end_pos = eye_pos + ( spread_dir * length );
+
+ for( const auto& hitbox : m_hitbox_data ) {
+ if( intersects_hitbox( eye_pos, end_pos, hitbox.m_min, hitbox.m_max, hitbox.m_radius ) ) {
+ hits++;
+ break; // cannot hit more than one hitbox
+ }
+ }
+
+ if ( hits >= hits_needed )
+ return true;
+ }
+
+ return false;
+}
+
+
+float util::get_total_latency( ) {
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+
+ if ( nci ) {
+ float latency = nci->GetLatency( 0 ) + nci->GetLatency( 1 );
+ return latency;
+ }
+
+ return 0.f;
+}
+
+float util::get_lerptime( ) {
+ static cvar_t* cl_interpolate = g_csgo.m_cvar( )->FindVar( xors( "cl_interpolate" ) );
+ static cvar_t* cl_interp = g_csgo.m_cvar( )->FindVar( xors( "cl_interp" ) );
+ static cvar_t* cl_updaterate = g_csgo.m_cvar( )->FindVar( xors( "cl_updaterate" ) );
+ static cvar_t* cl_interp_ratio = g_csgo.m_cvar( )->FindVar( xors( "cl_interp_ratio" ) );
+
+ if( cl_interp && cl_interpolate && cl_updaterate && cl_interp_ratio ) {
+ bool interpolate = cl_interpolate->get_int( );
+ if( interpolate ) {
+ float interp = cl_interp->get_float( );
+ float interp_ratio = cl_interp_ratio->get_float( );
+ float updaterate = cl_updaterate->get_float( );
+
+ return std::max< float >( interp, interp_ratio / updaterate );
+ }
+ }
+
+ return 0.f;
+}
+
+bool util::is_tick_valid( int tickcount ) {
+ float latency = get_total_latency( );
+ float correct = std::clamp( latency + get_lerptime( ), 0.f, 1.f );
+ float delta = correct - ( g_ctx.pred_time( ) - TICKS_TO_TIME( tickcount ) );
+
+ if( g_settings.rage.enabled ) {
+ return std::abs( delta ) < ( 0.2f - TICK_INTERVAL( ) * 2.f );
+ }
+
+ return std::abs( delta ) < 0.2f;
+}
+
+void util::disable_pvs( ) {
+ for( int i{ 1 }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || !ent->is_valid( ) )
+ continue;
+
+ if( ent == g_ctx.m_local )
+ continue;
+
+ *( int* )( uintptr_t( ent ) + 0xa30 ) = g_csgo.m_globals->m_framecount;
+ *( int* )( uintptr_t( ent ) + 0xa28 ) = 0;
+ }
+}
+
+vec2_t util::screen_transform( vec3_t world ) {
+ vec2_t screen;
+ auto w2s = [ &world, &screen ]( ) -> bool {
+ static uintptr_t view_matrix = 0;
+ if( !view_matrix ) {
+ view_matrix = pattern::first_code_match( g_csgo.m_chl.dll( ),
+ xors( "0F 10 05 ? ? ? ? 8D 85 ? ? ? ? B9" ) );
+
+ view_matrix = *reinterpret_cast< uintptr_t* >( view_matrix + 0x3 ) + 176;
+ }
+
+ const matrix3x4& matrix = *( matrix3x4* )view_matrix;
+ screen.x = matrix[ 0 ][ 0 ] * world[ 0 ] + matrix[ 0 ][ 1 ] * world[ 1 ] + matrix[ 0 ][ 2 ] * world[ 2 ] + matrix[ 0 ][ 3 ];
+ screen.y = matrix[ 1 ][ 0 ] * world[ 0 ] + matrix[ 1 ][ 1 ] * world[ 1 ] + matrix[ 1 ][ 2 ] * world[ 2 ] + matrix[ 1 ][ 3 ];
+
+ float w = matrix[ 3 ][ 0 ] * world[ 0 ] + matrix[ 3 ][ 1 ] * world[ 1 ] + matrix[ 3 ][ 2 ] * world[ 2 ] + matrix[ 3 ][ 3 ];
+
+ if( w < 0.001f ) {
+ //screen.x *= 100000.f;
+ //screen.y *= 100000.f;
+ return true;
+ }
+
+ float invw = 1.0f / w;
+ screen.x *= invw;
+ screen.y *= invw;
+
+ return false;
+ };
+
+ w2s( );
+ //if ( !w2s( ) ) {
+ int w, h;
+ g_csgo.m_engine( )->GetScreenSize( w, h );
+
+ screen.x = ( w * .5f ) + ( screen.x * w ) * .5f;
+ screen.y = ( h * .5f ) - ( screen.y * h ) * .5f;
+
+ return screen;
+ //}
+
+ return vec2_t{ };
+}
+
+int util::hitbox_to_hitgroup( int hitbox ) {
+ switch( hitbox ) {
+ case HITBOX_HEAD:
+ case HITBOX_NECK:
+ return HITGROUP_HEAD;
+ case HITBOX_BODY:
+ case HITBOX_CHEST:
+ case HITBOX_THORAX:
+ case HITBOX_PELVIS:
+ return HITGROUP_STOMACH;
+ case HITBOX_LEFT_CALF:
+ case HITBOX_LEFT_THIGH:
+ case HITBOX_LEFT_FOOT:
+ return HITGROUP_RIGHTLEG;
+ case HITBOX_RIGHT_CALF:
+ case HITBOX_RIGHT_THIGH:
+ case HITBOX_RIGHT_FOOT:
+ return HITGROUP_LEFTLEG;
+ case HITBOX_LEFT_HAND:
+ case HITBOX_LEFT_FOREARM:
+ case HITBOX_LEFT_UPPER_ARM:
+ return HITGROUP_LEFTARM;
+ case HITBOX_RIGHT_HAND:
+ case HITBOX_RIGHT_FOREARM:
+ case HITBOX_RIGHT_UPPER_ARM:
+ return HITGROUP_RIGHTARM;
+ default:
+ return HITGROUP_GENERIC;
+ }
+}
+
+const char* util::definition_index_to_name( int index ) {
+ index = std::clamp( index, 0, 65 );
+
+ switch( index ) {
+ case 0:
+ return xors( "knife" );
+ case WEAPON_DEAGLE:
+ return xors( "deagle" );
+ case WEAPON_ELITE:
+ return xors( "elite" );
+ case WEAPON_FIVESEVEN:
+ return xors( "five seven" );
+ case WEAPON_GLOCK:
+ return xors( "glock" );
+ case WEAPON_AK47:
+ return xors( "ak47" );
+ case WEAPON_AUG:
+ return xors( "aug" );
+ case WEAPON_AWP:
+ return xors( "awp" );
+ case WEAPON_FAMAS:
+ return xors( "famas" );
+ case WEAPON_G3SG1:
+ return xors( "g3sg1" );
+ case WEAPON_GALILAR:
+ return xors( "galil" );
+ case WEAPON_M249:
+ return xors( "m249" );
+ case WEAPON_M4A1:
+ return xors( "m4a4" );
+ case WEAPON_MAC10:
+ return xors( "mac10" );
+ case WEAPON_P90:
+ return xors( "p90" );
+ case WEAPON_UMP45:
+ return xors( "ump45" );
+ case WEAPON_XM1014:
+ return xors( "xm1014" );
+ case WEAPON_BIZON:
+ return xors( "bizon" );
+ case WEAPON_MAG7:
+ return xors( "mag7" );
+ case WEAPON_NEGEV:
+ return xors( "negev" );
+ case WEAPON_SAWEDOFF:
+ return xors( "sawed-off" );
+ case WEAPON_TEC9:
+ return xors( "tec9" );
+ case WEAPON_TASER:
+ return xors( "zeus" );
+ case WEAPON_HKP2000:
+ return xors( "p2000" );
+ case WEAPON_MP7:
+ return xors( "mp7" );
+ case WEAPON_MP9:
+ return xors( "mp9" );
+ case WEAPON_NOVA:
+ return xors( "nova" );
+ case WEAPON_P250:
+ return xors( "p250" );
+ case WEAPON_SCAR20:
+ return xors( "scar20" );
+ case WEAPON_SG556:
+ return xors( "sg556" );
+ case WEAPON_SSG08:
+ return xors( "ssg08" );
+ case WEAPON_KNIFEGG:
+ return xors( "golden knife" ); // for the gun game hackers
+ case WEAPON_KNIFE:
+ return xors( "knife" );
+ case WEAPON_FLASHBANG:
+ return xors( "flash" );
+ case WEAPON_HEGRENADE:
+ return xors( "nade" );
+ case WEAPON_SMOKEGRENADE:
+ return xors( "smoke" );
+ case WEAPON_MOLOTOV:
+ return xors( "molotov" );
+ case WEAPON_DECOY:
+ return xors( "decoy" );
+ case WEAPON_INCGRENADE:
+ return xors( "incendiary" );
+ case WEAPON_C4:
+ return xors( "c4" );
+ case WEAPON_KNIFE_T:
+ return xors( "knife" );
+ case WEAPON_M4A1_SILENCER:
+ return xors( "M4A1" );
+ case WEAPON_USP_SILENCER:
+ return xors( "usp" );
+ case WEAPON_CZ75A:
+ return xors( "cz75" );
+ case WEAPON_R8REVOLVER:
+ return xors( "revolver" );
+ default:
+ return xors( "none" );
+ }
+}
diff --git a/internal_rewrite/util.hpp b/internal_rewrite/util.hpp new file mode 100644 index 0000000..c97f8c6 --- /dev/null +++ b/internal_rewrite/util.hpp @@ -0,0 +1,112 @@ +#pragma once
+#include <inttypes.h>
+#include <string>
+#include "strings.hpp"
+
+//#define COMIC_SANS
+
+#define NAMESPACE_REGION( x ) namespace x {
+#define END_REGION }
+
+extern int TIME_TO_TICKS( float dt );
+extern float TICKS_TO_TIME( int tick );
+extern float TICK_INTERVAL( );
+
+//WEE WOO WEE WOO ITS THE DWORD POLICE
+using ulong_t = unsigned long;
+using uword_t = unsigned short;
+
+class IClientEntity;
+class CTraceFilter;
+class CGameTrace;
+class vec3_t;
+class vec2_t;
+
+NAMESPACE_REGION( util )
+
+template < typename t >
+struct reverse_iterable {
+ reverse_iterable( t&& it ) :
+ iterable( it ) { }
+
+ t& iterable;
+ inline auto begin( ) {
+ return std::rbegin( iterable );
+ }
+
+ inline auto end( ) {
+ return std::rend( iterable );
+ }
+};
+
+struct hitchance_data_t {
+ float m_random[ 2 ];
+ float m_inaccuracy [ 2 ];
+ float m_spread[ 2 ];
+};
+
+template< typename t >
+reverse_iterable< t >
+reverse_iterator( t&& iter ) {
+ return reverse_iterable< t >{ iter };
+}
+
+template < typename fn > __forceinline fn get_vfunc( void* classbase, int index ) {
+ if ( !classbase ) return fn{ };
+ return ( fn )( *( uintptr_t** )classbase )[ index ];
+}
+
+template < size_t index, typename ret, class ... args_ >
+__forceinline ret get_vfunc( void* thisptr, args_... args ) {
+ using fn = ret( __thiscall* )( void*, args_... );
+
+ auto fn_ptr = ( fn )( *( uintptr_t** )thisptr )[ index ];
+ return fn_ptr( thisptr, args... );
+}
+
+__forceinline std::string unicode_to_ascii( const std::wstring& unicode ) {
+ std::string ascii_str( unicode.begin( ), unicode.end( ) );
+ return ascii_str;
+}
+
+__forceinline std::wstring ascii_to_unicode( const std::string& ascii ) {
+ std::wstring unicode_str( ascii.begin( ), ascii.end( ) );
+ return unicode_str;
+}
+
+template < typename integer >
+__forceinline auto to_hex_str( const integer& w,
+ size_t hex_len = sizeof( integer ) << 1 ) {
+ constexpr char* hex_digits = xors( "0123456789abcdef" );
+ std::string rc( hex_len, 0 );
+
+ for( size_t i{ }, j{ ( hex_len - 1 ) * 4 } ; i < hex_len; ++i, j -= 4 )
+ rc[ i ] = hex_digits[ ( w >> j ) & 0x0f ];
+
+ return rc;
+}
+
+extern void clip_trace_to_player( IClientEntity* player, const vec3_t& src, const vec3_t& end,
+ unsigned mask, CTraceFilter* filter, CGameTrace* trace );
+
+extern bool trace_ray( const vec3_t& start, const vec3_t& end, IClientEntity* a, IClientEntity* b );
+extern bool is_low_fps( );
+extern bool is_tick_valid( int tickcount );
+extern void set_random_seed( int seed );
+extern vec3_t get_spread_dir( void *weapon, float inaccuracy, float spread, vec3_t angles, int seed );
+extern float get_random_float( float min, float max );
+extern bool __vectorcall intersects_hitbox( vec3_t eye_pos, vec3_t end_pos, vec3_t min, vec3_t max, float radius );
+extern bool hitchance( int target, const vec3_t& angles, int percentage );
+extern bool hitchance( int target, const vec3_t& angle, int percentage, int hi );
+extern void calculate_spread_runtime( );
+
+extern float get_total_latency( );
+extern float get_lerptime( );
+extern int get_closest_player( );
+extern vec2_t screen_transform( vec3_t world );
+extern const char* definition_index_to_name( int index );
+extern void disable_pvs( );
+extern int hitbox_to_hitgroup( int hitbox );
+extern std::string hitgroup_to_string( int hitgroup );
+
+END_REGION
\ No newline at end of file diff --git a/internal_rewrite/vector.hpp b/internal_rewrite/vector.hpp new file mode 100644 index 0000000..4fef1b7 --- /dev/null +++ b/internal_rewrite/vector.hpp @@ -0,0 +1,334 @@ +#pragma once +#include <cmath> +#include <algorithm> + + +class vec2_t { +public: + vec2_t( ) { + x = y = 0.0f; + } + + vec2_t( float X, float Y ) { + x = X; y = Y; + } + + vec2_t( float* v ) { + x = v[ 0 ]; y = v[ 1 ]; + } + + vec2_t( const float* v ) { + x = v[ 0 ]; y = v[ 1 ]; + } + + vec2_t( const vec2_t& v ) { + x = v.x; y = v.y; + } + + vec2_t& operator=( const vec2_t& v ) { + x = v.x; y = v.y; return *this; + } + + float& operator[]( int i ) { + return ( ( float* )this )[ i ]; + } + + float operator[]( int i ) const { + return ( ( float* )this )[ i ]; + } + + vec2_t& operator+=( const vec2_t& v ) { + x += v.x; y += v.y; return *this; + } + + vec2_t& operator-=( const vec2_t& v ) { + x -= v.x; y -= v.y; return *this; + } + + vec2_t& operator*=( const vec2_t& v ) { + x *= v.x; y *= v.y; return *this; + } + + vec2_t& operator/=( const vec2_t& v ) { + x /= v.x; y /= v.y; return *this; + } + + vec2_t& operator+=( float v ) { + x += v; y += v; return *this; + } + + vec2_t& operator-=( float v ) { + x -= v; y -= v; return *this; + } + + vec2_t& operator*=( float v ) { + x *= v; y *= v; return *this; + } + + vec2_t& operator/=( float v ) { + x /= v; y /= v; return *this; + } + + vec2_t operator+( const vec2_t& v ) const { + return vec2_t( x + v.x, y + v.y ); + } + + vec2_t operator-( const vec2_t& v ) const { + return vec2_t( x - v.x, y - v.y ); + } + + vec2_t operator*( const vec2_t& v ) const { + return vec2_t( x * v.x, y * v.y ); + } + + vec2_t operator/( const vec2_t& v ) const { + return vec2_t( x / v.x, y / v.y ); + } + + vec2_t operator+( float v ) const { + return vec2_t( x + v, y + v ); + } + + vec2_t operator-( float v ) const { + return vec2_t( x - v, y - v ); + } + + vec2_t operator*( float v ) const { + return vec2_t( x * v, y * v ); + } + + vec2_t operator/( float v ) const { + return vec2_t( x / v, y / v ); + } + + void set( float X = 0.0f, float Y = 0.0f ) { + x = X; y = Y; + } + + float length( void ) const { + return sqrtf( x * x + y * y ); + } + + float lengthsqr( void ) const { + return ( x * x + y * y ); + } + + float dist_to( const vec2_t& v ) const { + return ( *this - v ).length( ); + } + + float dist_to_sqr( const vec2_t& v ) const { + return ( *this - v ).lengthsqr( ); + } + + float dot( const vec2_t& v ) const { + return ( x * v.x + y * v.y ); + } + + bool is_zero( void ) const { + return ( x > -FLT_EPSILON && x < FLT_EPSILON && + y > -FLT_EPSILON && y < FLT_EPSILON ); + } + + operator bool( ) const noexcept { + return !is_zero( ); + } + +public: + float x, y; +}; + +class vec3_t { +public: + vec3_t( ) { + x = y = z = 0.0f; + } + + vec3_t( float X, float Y, float Z ) { + x = X; y = Y; z = Z; + } + + vec3_t( float* v ) { + x = v[ 0 ]; y = v[ 1 ]; z = v[ 2 ]; + } + + vec3_t( const float* v ) { + x = v[ 0 ]; y = v[ 1 ]; z = v[ 2 ]; + } + + vec3_t( const vec3_t& v ) { + x = v.x; y = v.y; z = v.z; + } + + vec3_t( const vec2_t& v ) { + x = v.x; y = v.y; z = 0.0f; + } + + __forceinline vec3_t& operator=( const vec3_t& v ) { + x = v.x; y = v.y; z = v.z; return *this; + } + + __forceinline vec3_t& operator=( const vec2_t& v ) { + x = v.x; y = v.y; z = 0.0f; return *this; + } + + float& operator[]( int i ) { + return ( ( float* )this )[ i ]; + } + + __forceinline float operator[]( int i ) const { + return ( ( float* )this )[ i ]; + } + + vec3_t& operator+=( const vec3_t& v ) { + x += v.x; y += v.y; z += v.z; return *this; + } + + vec3_t& operator-=( const vec3_t& v ) { + x -= v.x; y -= v.y; z -= v.z; return *this; + } + + vec3_t& operator*=( const vec3_t& v ) { + x *= v.x; y *= v.y; z *= v.z; return *this; + } + + vec3_t& operator/=( const vec3_t& v ) { + x /= v.x; y /= v.y; z /= v.z; return *this; + } + + vec3_t& operator+=( float v ) { + x += v; y += v; z += v; return *this; + } + + vec3_t& operator-=( float v ) { + x -= v; y -= v; z -= v; return *this; + } + + vec3_t& operator*=( float v ) { + x *= v; y *= v; z *= v; return *this; + } + + vec3_t& operator/=( float v ) { + x /= v; y /= v; z /= v; return *this; + } + + __forceinline vec3_t operator+( const vec3_t& v ) const { + return vec3_t( x + v.x, y + v.y, z + v.z ); + } + + __forceinline vec3_t operator-( const vec3_t& v ) const { + return vec3_t( x - v.x, y - v.y, z - v.z ); + } + + __forceinline vec3_t operator*( const vec3_t& v ) const { + return vec3_t( x * v.x, y * v.y, z * v.z ); + } + + __forceinline vec3_t operator/( const vec3_t& v ) const { + return vec3_t( x / v.x, y / v.y, z / v.z ); + } + + __forceinline vec3_t operator+( float v ) const { + return vec3_t( x + v, y + v, z + v ); + } + + __forceinline vec3_t operator-( float v ) const { + return vec3_t( x - v, y - v, z - v ); + } + + __forceinline vec3_t operator*( float v ) const { + return vec3_t( x * v, y * v, z * v ); + } + + __forceinline vec3_t operator/( float v ) const { + return vec3_t( x / v, y / v, z / v ); + } + + __forceinline float length( ) const { + return sqrtf( x * x + y * y + z * z ); + } + + __forceinline float lengthsqr( ) const { + return ( x * x + y * y + z * z ); + } + + __forceinline float length2d( ) const { + return sqrtf( x * x + y * y ); + } + + __forceinline float length2dsqr( ) const { + return ( x * x + y * y ); + } + + __forceinline float dist_to( const vec3_t& v ) const { + return ( *this - v ).length( ); + } + + __forceinline float dist_to_sqr( const vec3_t& v ) const { + return ( *this - v ).lengthsqr( ); + } + + __forceinline float dot( const vec3_t& v ) const { + return ( x * v.x + y * v.y + z * v.z ); + } + + __forceinline float fov_to( const vec3_t& to ) { + const float from_length = length( ); + const float to_length = to.length( ); + + if( from_length && to_length ) { + return acos( dot( to ) / from_length * to_length ); + } + + return 0.f; + } + + vec3_t cross( const vec3_t& v ) const { + return vec3_t( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); + } + + bool is_zero( ) const { + return ( x > -FLT_EPSILON && x < FLT_EPSILON && + y > -FLT_EPSILON && y < FLT_EPSILON && + z > -FLT_EPSILON && z < FLT_EPSILON ); + } + + operator bool( ) const { + return !is_zero( ); + } + + inline void normalize_vector( ) { + vec3_t& v = *this; + + float iradius = 1.f / ( this->length( ) + FLT_EPSILON ); //FLT_EPSILON + + v.x *= iradius; + v.y *= iradius; + v.z *= iradius; + } + + vec3_t abs( ) const { + return vec3_t{ std::abs( x ), std::abs( y ), std::abs( z ) }; + } + + vec3_t clamp( ) { + for ( size_t axis{ }; axis < 2; axis++ ) { + auto &cur_axis = operator[]( axis ); + if ( !std::isfinite( cur_axis ) ) { + cur_axis = 0.f; + } + } + + x = std::clamp( x, -89.f, 89.f ); + y = std::clamp( std::remainder( y, 360.f ), -180.f, 180.f ); + z = 0.f; + return *this; + } + +public: + float x, y, z; +}; + +__forceinline vec3_t operator*( float f, const vec3_t& v ) { + return v * f; +} diff --git a/internal_rewrite/visual.hpp b/internal_rewrite/visual.hpp new file mode 100644 index 0000000..8df913e --- /dev/null +++ b/internal_rewrite/visual.hpp @@ -0,0 +1,109 @@ +#pragma once
+#include <vector>
+#include "vector.hpp"
+#include "color.hpp"
+#include <unordered_map>
+#include "strings.hpp"
+#include "IVRenderView.hpp"
+class c_base_player;
+
+enum HitFlag_t {
+ HIT_NONE = 0,
+ HIT_ALERT = 1,
+ HIT_1W = 2
+};
+
+namespace features
+{
+ class c_visuals {
+ private:
+ static const clr_t esp_green( uint8_t alpha = 255 ) {
+ return clr_t( 1, 216, 62, alpha );
+ }
+ static const clr_t esp_red( uint8_t alpha = 255 ) {
+ return clr_t( 240, 0, 0, alpha );
+ }
+ static const clr_t esp_blue( uint8_t alpha = 255 ) {
+ return clr_t( 84, 173, 247, alpha );
+ }
+
+ void draw_line( const vec2_t& a, const vec2_t& b, const clr_t& clr );
+ void draw_line( int x, int y, int x1, int y1, const clr_t& clr );
+ void draw_rect( int x, int y, int w, int h, const clr_t& clr );
+ void draw_filled_rect( int x, int y, int w, int h, const clr_t& clr );
+ void draw_circle( int x, int y, int r, const clr_t& clr, int res = 48 );
+
+ void draw_really_big_string( int x, int y, const clr_t& clr, const char* msg, ... );
+ void draw_string( int x, int y, int align, bool big, const clr_t& clr, const char* msg, ... );
+
+
+ void draw_local( );
+ void draw_players( );
+ void draw_world( );
+
+ void draw_hits( );
+ void spectator_list( );
+ void grenade_prediction( );
+ void draw_firegrenade( );
+
+ struct tracer_t {
+ float m_time;
+ vec3_t m_start;
+ vec3_t m_end;
+ bool m_local;
+ };
+
+ //you should always store the entity index rather than the ptr
+ struct sound_t {
+ float m_time;
+ vec3_t m_pos;
+ int m_ent;
+ };
+
+ struct firegrenade_t {
+ float m_time;
+ vec3_t m_pos;
+ int m_ent;
+ };
+
+ struct shot_t {
+ float time;
+ vec3_t pos;
+ bool hit;
+ };
+
+ std::vector< firegrenade_t > m_firegrenades;
+ std::vector< shot_t > m_shots;
+ std::vector< sound_t > m_sounds;
+ std::vector< tracer_t > m_tracers;
+
+ vec3_t m_stored_pos[ 65 ]{ };
+ float m_anim_progress[ 65 ]{ };
+ float m_last_hit{ };
+ int m_ent_dmg[ 65 ]{ };
+ int m_teamdmg{ 0 };
+ int m_hit_flag[ 65 ]{ };
+ float m_last_roundstart{ };
+ public:
+ void update_glow( );
+ void world_modulate( );
+ void update_position( int index, const vec3_t& pos );
+ void store_tracer( int ent_index, vec3_t shot );
+ void store_sound( int ent, vec3_t origin );
+ void store_firegrenades( int ent, vec3_t origin );
+ void draw_autowall( );
+ void draw_spread( );
+ void out_of_fov( c_base_player* ent, const vec3_t& pos, clr_t col );
+ void store_hit( );
+ void radar( );
+ void draw_tracers( );
+ void store_ent_dmg( int, int, int );
+ void store_shot( vec3_t pos, bool hit = false );
+ void draw_shots( );
+ void reset_local_dmg( );
+ void on_round_start( );
+ void draw_sound( );
+ void update_hit_flags( );
+ void operator()( );
+ };
+}
\ No newline at end of file diff --git a/internal_rewrite/visual_draw.cpp b/internal_rewrite/visual_draw.cpp new file mode 100644 index 0000000..3c40f29 --- /dev/null +++ b/internal_rewrite/visual_draw.cpp @@ -0,0 +1,94 @@ +#include "d3d.hpp" +#include "interface.hpp" +#include "renderer.hpp" +#include "visual.hpp" +#include "settings.hpp" + +namespace features +{ + void c_visuals::draw_line( const vec2_t& a, const vec2_t& b, const clr_t& clr ) { + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_line( clr, a.x, a.y, b.x, b.y ); + else + g_renderer.draw_line( a, b, clr ); + } + + void c_visuals::draw_line( int x, int y, int x1, int y1, const clr_t& clr ) { + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_line( clr, x, y, x1, y1 ); + else + g_renderer.draw_line( x, y, x1, y1, clr ); + } + + void c_visuals::draw_rect( int x, int y, int w, int h, const clr_t& clr ) { + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_rect( clr, x, y, w, h ); + else + g_renderer.draw_box( x, y, w, h, clr ); + } + + void c_visuals::draw_filled_rect( int x, int y, int w, int h, const clr_t& col ) { + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_filled_rect( col, x, y, w, h ); + else + g_renderer.draw_rect( x, y, w, h, col ); + } + + void c_visuals::draw_circle( int x, int y, int r, const clr_t& col, int res ) { + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_circle( col, x, y, r, res ); + else + g_renderer.draw_circle( x, y, r, col, res ); + } + + void c_visuals::draw_string( int x, int y, int align, bool big, const clr_t& col, const char* msg, ... ) { + char* buffer = ( char* )_alloca( 1024 ); + va_list list{ }; + + memset( buffer, 0, 1024 ); + + __crt_va_start( list, msg ); + vsprintf_s( buffer, 1024, msg, list ); + __crt_va_end( list ); + + switch( align ) { + case ALIGN_CENTER: + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_text< ALIGN_CENTER >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer ); + else + g_renderer.draw_string< ALIGN_CENTER >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer ); + + break; + case ALIGN_LEFT: + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_text< ALIGN_LEFT >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer ); + else + g_renderer.draw_string< ALIGN_LEFT >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer ); + + break; + case ALIGN_RIGHT: + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_text< ALIGN_RIGHT >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer ); + else + g_renderer.draw_string< ALIGN_RIGHT >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer ); + + break; + } + } + + void c_visuals::draw_really_big_string( int x, int y, const clr_t& col, const char* msg, ... ) { + char* buffer = ( char* )_alloca( 1024 ); + va_list list{ }; + + memset( buffer, 0, 1024 ); + + __crt_va_start( list, msg ); + vsprintf_s( buffer, 1024, msg, list ); + __crt_va_end( list ); + + if( g_settings.misc.hide_from_obs ) + g_d3d.draw_text< ALIGN_LEFT >( ::d3d::fonts.f_18, col, x, y, D3DFONTFLAG_OUTLINE, buffer ); + else + g_renderer.draw_string< ALIGN_LEFT >( g_fonts.f_bold, x, y, col, msg ); + } +}
\ No newline at end of file diff --git a/internal_rewrite/visual_local.cpp b/internal_rewrite/visual_local.cpp new file mode 100644 index 0000000..8a20aea --- /dev/null +++ b/internal_rewrite/visual_local.cpp @@ -0,0 +1,616 @@ +#include <algorithm>
+
+#include "visual.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+#include "renderer.hpp"
+#include "input_system.hpp"
+#include "math.hpp"
+
+namespace features
+{
+ void c_visuals::draw_local( ) {
+ int screen_w, screen_h;
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+
+ int cur_pos{ };
+
+ draw_shots( );
+ grenade_prediction( );
+ draw_spread( );
+ spectator_list( );
+
+ if( g_ctx.m_local->is_valid( ) ) {
+ //isvalveds
+
+ if( g_settings.misc.team_dmg( ) && *( bool* )( c_base_player::get_game_rules( ) + 0x75 ) ) {
+ const float kick = 300.f;
+ float percentage = m_teamdmg / kick;
+
+ clr_t col = clr_t::blend( esp_green( ), esp_red( ), std::clamp( percentage, 0.f, 1.f ) );
+
+ draw_really_big_string( 10, cur_pos += 15, col, xors( "DMG: %d" ), m_teamdmg );
+ }
+
+ static float incoming_latency;
+ if( g_settings.misc.net_fakelag ) {
+ float desired_latency = incoming_latency + g_settings.misc.net_fakeping_amount * 0.001f;
+ if( g_settings.misc.net_fakelag == 4 )
+ desired_latency = 1.0f;
+
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( nci ) {
+ float cur_latency = nci->GetLatency( 1 );
+ float percentage = cur_latency / desired_latency;
+ percentage = std::clamp( percentage + 0.1f, 0.f, 1.f );
+
+ clr_t col = clr_t::blend( esp_red( ), esp_green( ), percentage );
+
+ bool visible = g_settings.misc.net_fakeping_active;
+ if( g_settings.misc.net_fakelag == 4 )
+ visible = true;
+
+ if( percentage > 0.35f || visible ) {
+ draw_really_big_string( 10, cur_pos += 15, col, xors( "PING" ) );
+ }
+ }
+ }
+ else {
+ auto nci = g_csgo.m_engine( )->GetNetChannelInfo( );
+ if( nci ) {
+ incoming_latency = nci->GetLatency( 1 );
+ }
+ }
+
+ if( g_settings.rage.anti_aim( ) ) {
+ static float last_lby = 0.f;
+ static float last_update = 0.f;
+ float lby = g_ctx.m_local->m_flLowerBodyYawTarget( );
+ if( lby != last_lby ) {
+ last_update = g_csgo.m_globals->m_curtime;
+ last_lby = lby;
+ }
+
+ float lby_delta = std::abs( std::remainderf( lby - g_ctx.m_thirdperson_angle.y, 360.f ) );
+ float time_delta = g_csgo.m_globals->m_curtime - last_update;
+
+ bool breaking = lby_delta > 35.f && time_delta > 0.2f;
+
+ if( g_cheat.m_ragebot.m_antiaim->is_edging( ) ) {
+ draw_really_big_string( 10, cur_pos += 15, esp_green( ), xors( "EDGE" ) );
+ }
+
+ if( g_settings.rage.break_lby( ) ) {
+ draw_really_big_string( 10, cur_pos += 15, breaking ? esp_green( ) : esp_red( ), xors( "LBY" ) );
+
+ auto animstate = g_ctx.m_local->get_animstate( );
+ if( animstate && animstate->m_velocity < 0.1f && animstate->m_bOnGround ) {
+ draw_filled_rect( 11, ( cur_pos += 4 ) + 14, 31, 2, clr_t( 0, 0, 0, 170 ) );
+
+ float progress = ( float )g_cheat.m_ragebot.m_antiaim->get_next_update( ) / TIME_TO_TICKS( 1.1f );
+
+ if( progress <= 1.f )
+ draw_filled_rect( 11, cur_pos + 14, 30 * progress, 1, esp_green( ) );
+ }
+ }
+
+ if( g_settings.rage.preserve_fps && g_settings.rage.enabled && util::is_low_fps( ) ) {
+ draw_really_big_string( 10, cur_pos += 15, esp_red( ), xors( "FPS" ) );
+ }
+ }
+
+ if( g_settings.rage.fakelag.mode( ) &&
+ g_settings.rage.fakelag.ticks( ) &&
+ g_settings.rage.fakelag.in_air( ) ) {
+ int min_dist = 64;
+ int max_ticks = g_settings.rage.fakelag.ticks;
+ if( g_settings.rage.fakelag.mode == 2 ) {
+ max_ticks += max_ticks * g_settings.rage.fakelag.fluctuate * 0.01f;
+ max_ticks = math::min( max_ticks, 15 );
+ }
+
+ float speed = g_ctx.m_local->m_vecVelocity( ).length2d( );
+ if( speed > 255.f && speed * g_csgo.m_globals->m_interval_per_tick * max_ticks > 50 ) {
+ bool breaking = g_cheat.m_lagmgr.is_breaking_lc( );
+ draw_really_big_string( 10, cur_pos += 15, breaking ? esp_green( ) : esp_red( ), xors( "LC" ) );
+ }
+ }
+ }
+
+ if( g_settings.misc.no_scope( ) &&
+ g_ctx.m_local->m_bIsScoped( ) ) {
+ int w, h;
+ g_csgo.m_engine( )->GetScreenSize( w, h );
+
+ draw_line( 0, h / 2, w, h / 2, clr_t( 0, 0, 0 ) );
+ draw_line( w / 2, 0, w / 2, h, clr_t( 0, 0, 0 ) );
+ }
+
+ draw_autowall( );
+ }
+
+ void c_visuals::spectator_list( ) {
+ if( !g_settings.visuals.spec_list )
+ return;
+
+ std::vector< std::string > spec_list;
+
+ for( size_t i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+ if( ent && ent->is_player( ) && !ent->ce( )->IsDormant( ) ) {
+ auto spec_handle = ent->m_hObserverTarget( );
+ auto spec_ent = g_csgo.m_entlist( )->GetClientEntityFromHandle< >( spec_handle );
+
+ if( spec_ent == g_ctx.m_local ) {
+ char player_name[ 32 ];
+ ent->get_name_safe( player_name );
+ spec_list.push_back( player_name );
+ }
+ }
+ }
+
+ int screen_w, screen_h;
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+
+ int cur_pos{ };
+
+ if( g_settings.misc.watermark ) {
+ cur_pos = 20;
+ }
+
+ for( auto& it : spec_list ) {
+ draw_string( screen_w - 3, cur_pos, ALIGN_RIGHT, true, clr_t( 255, 255, 255 ), it.c_str( ) );
+ cur_pos += 10;
+ }
+ }
+
+ void c_visuals::grenade_prediction( ) {
+ static auto molotov_detonate_time = g_csgo.m_cvar( )->FindVar( xors( "molotov_throw_detonate_time" ) );
+ static auto molotov_detonate_slope = g_csgo.m_cvar( )->FindVar( xors( "weapon_molotov_maxdetonateslope" ) );
+ static auto sv_gravity = g_csgo.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+
+ if( !g_settings.visuals.grenade_prediction )
+ return;
+
+ auto is_grenade = [ ]( int defindex ) {
+ switch( defindex ) {
+ case WEAPON_FLASHBANG:
+ case WEAPON_HEGRENADE:
+ case WEAPON_SMOKEGRENADE:
+ case WEAPON_MOLOTOV:
+ case WEAPON_INCGRENADE:
+ case WEAPON_DECOY:
+ return true;
+ default: return false;
+ }
+ };
+
+ auto get_detonate_time = [ ]( int defindex ) {
+ switch( defindex ) {
+ case WEAPON_FLASHBANG:
+ case WEAPON_HEGRENADE:
+ return 1.5f;
+ case WEAPON_INCGRENADE:
+ case WEAPON_MOLOTOV:
+ return molotov_detonate_time->get_float( );
+ case WEAPON_DECOY:
+ return 5.f;
+ default: return 3.f;
+ }
+ };
+
+ auto draw_3d_line = [ this ]( const vec3_t& start, const vec3_t& end, clr_t col, bool circle = false ) {
+ vec2_t start_w2s = util::screen_transform( start );
+ vec2_t end_w2s = util::screen_transform( end );
+
+ draw_line( start_w2s, end_w2s, col );
+ if( circle )
+ draw_rect( end_w2s.x - 1, end_w2s.y - 1, 2, 2, clr_t( 230, 230, 230 ) );
+ };
+
+ auto clip_velocity = [ ]( const vec3_t& in, const vec3_t& normal, vec3_t& out, float overbounce ) {
+ int blocked = 0;
+ float angle = normal[ 2 ];
+
+ if( angle > 0.f )
+ blocked |= 1;
+
+ if( !angle )
+ blocked |= 2;
+
+ float backoff = in.dot( normal ) * overbounce;
+
+ for( int i{ }; i < 3; ++i ) {
+ out[ i ] = in[ i ] - ( normal[ i ] * backoff );
+
+ if( out[ i ] > -0.1f && out[ i ] < 0.1f ) {
+ out[ i ] = 0.f;
+ }
+ }
+
+ return blocked;
+ };
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon ) return;
+
+ int def_index = weapon->m_iItemDefinitionIndex( );
+ if( !is_grenade( def_index ) || !weapon->m_bPinPulled( ) )
+ return;
+
+ auto wpn_info = weapon->get_wpn_info( );
+
+ vec3_t throw_ang, forward;
+ g_csgo.m_engine( )->GetViewAngles( throw_ang );
+ throw_ang.x -= ( 90.f - abs( throw_ang.x ) ) * 0.11111111f;
+ throw_ang.x = std::remainderf( throw_ang.x, 360.f );
+
+ forward = math::angle_vectors( throw_ang );
+
+ float throw_strength = weapon->m_flThrowStrength( );
+ float throw_velocity = std::min( std::max( wpn_info->throw_velocity * 0.9f, 15.f ), 750.f );
+
+ float throw_height = ( throw_strength * 12.f ) - 12.f;
+ float v68 = throw_velocity * ( ( 0.7f * throw_strength ) + 0.3f );
+
+ vec3_t start_pos = g_ctx.m_local->get_eye_pos( ) + vec3_t( 0, 0, throw_height );
+ vec3_t end_pos = start_pos + ( forward * 22.f );
+
+ CTraceFilter filter;
+ filter.pSkip = g_ctx.m_local;
+
+ CGameTrace trace;
+ Ray_t ray;
+ ray.Init( start_pos, end_pos, vec3_t( -2.f, -2.f, -2.f ), vec3_t( 2.f, 2.f, 2.f ) );
+
+ g_csgo.m_trace( )->TraceRay( ray, CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_MOVEABLE | CONTENTS_CURRENT_90, &filter, &trace );
+ end_pos = trace.endpos - forward * 6.f;
+ vec3_t throw_pos = g_ctx.m_local->m_vecVelocity( ) * 1.25f + forward * v68;
+
+ //draw_3d_line( start_pos, end_pos, clr_t( 255, 255, 255 ) );
+ float gravity = sv_gravity->get_float( ) * 0.4f;
+
+ player_info_t info{ };
+
+ for( int ticks = TIME_TO_TICKS( get_detonate_time( def_index ) ); ticks >= 0; --ticks ) {
+ auto throw_dir = vec3_t( throw_pos.x, throw_pos.y, ( throw_pos.z + ( throw_pos.z - ( gravity * TICK_INTERVAL( ) ) ) ) * 0.5f );
+ auto temp = throw_dir * TICK_INTERVAL( );
+ throw_pos.z -= gravity * TICK_INTERVAL( );
+
+ vec3_t src = end_pos, end = end_pos + temp;
+ Ray_t ray;
+ ray.Init( src, end, vec3_t( -2.f, -2.f, -2.f ), vec3_t( 2.f, 2.f, 2.f ) );
+
+ g_csgo.m_trace( )->TraceRay( ray, CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_MONSTER | CONTENTS_CURRENT_90, &filter, &trace );
+ if( trace.allsolid )
+ throw_pos = vec3_t( );
+
+ end_pos = trace.endpos;
+ draw_3d_line( src, end_pos, clr_t( 66, 143, 244 ) );
+
+ if( trace.fraction != 1.f ) {
+ float surf_elasticity = 1.f;
+ vec3_t throw_pos2{ };
+ clip_velocity( throw_pos, trace.plane.normal, throw_pos2, 2.f );
+
+ if( trace.m_pEnt && g_csgo.m_engine( )->GetPlayerInfo( trace.m_pEnt->GetIndex( ), &info ) ) {
+ surf_elasticity = 0.3f;
+ }
+
+ throw_pos2 *= std::clamp( surf_elasticity * 0.45f, 0.f, 0.9f );
+ end = end_pos + throw_pos2 * ( ( 1.f - trace.fraction ) * TICK_INTERVAL( ) );
+
+ if( def_index == WEAPON_MOLOTOV || def_index == WEAPON_INCGRENADE ) {
+ if( trace.plane.normal.z >= cos( DEG2RAD( molotov_detonate_slope->get_float( ) ) ) ) {
+ return;
+ }
+ }
+
+ ray.Init( end_pos, end, vec3_t( -2.f, -2.f, -2.f ), vec3_t( 2.f, 2.f, 2.f ) );
+ g_csgo.m_trace( )->TraceRay( ray, CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_MONSTER | CONTENTS_CURRENT_90, &filter, &trace );
+
+ draw_3d_line( end_pos, end, clr_t( 66, 143, 244 ), true );
+ end_pos = trace.endpos;
+ throw_pos = throw_pos2;
+ }
+ }
+ }
+
+ void c_visuals::store_shot( vec3_t pos, bool hit ) {
+ if( !g_settings.visuals.target )
+ return;
+
+ m_shots.push_back( { g_csgo.m_globals->m_curtime, pos, hit } );
+ }
+
+ void c_visuals::draw_shots( ) {
+ if( !g_settings.visuals.target )
+ return;
+
+ for( size_t i{ }; i < m_shots.size( ) && !m_shots.empty( ); ++i ) {
+ if( m_shots[ i ].time + g_settings.visuals.target_time < g_csgo.m_globals->m_curtime ) {
+ m_shots.erase( m_shots.begin( ) + i );
+ }
+ }
+
+ for( auto& it : m_shots ) {
+ vec3_t min = it.pos - vec3_t( 3.5f, 3.5f, 3.5f );
+ vec3_t max = it.pos + vec3_t( 3.5f, 3.5f, 3.5f );
+
+ std::array< vec3_t, 8 > points = {
+ vec3_t{ min.x, min.y, min.z },
+ vec3_t{ min.x, max.y, min.z },
+ vec3_t{ max.x, max.y, min.z },
+ vec3_t{ max.x, min.y, min.z },
+ vec3_t{ max.x, max.y, max.z },
+ vec3_t{ min.x, max.y, max.z },
+ vec3_t{ min.x, min.y, max.z },
+ vec3_t{ max.x, min.y, max.z }
+ };
+
+ vec2_t
+ flb = util::screen_transform( points[ 3 ] ),
+ blb = util::screen_transform( points[ 0 ] ),
+ frb = util::screen_transform( points[ 2 ] ),
+ blt = util::screen_transform( points[ 6 ] ),
+ brt = util::screen_transform( points[ 5 ] ),
+ frt = util::screen_transform( points[ 4 ] ),
+ brb = util::screen_transform( points[ 1 ] ),
+ flt = util::screen_transform( points[ 7 ] );
+
+ vec2_t lines[ 12 ][ 2 ];
+
+ lines[ 0 ][ 0 ] = { flb.x, flb.y };
+ lines[ 0 ][ 1 ] = { frb.x, frb.y };
+ lines[ 1 ][ 0 ] = { frb.x, frb.y };
+ lines[ 1 ][ 1 ] = { brb.x, brb.y };
+ lines[ 2 ][ 0 ] = { brb.x, brb.y };
+ lines[ 2 ][ 1 ] = { blb.x, blb.y };
+ lines[ 3 ][ 0 ] = { blb.x, blb.y };
+ lines[ 3 ][ 1 ] = { flb.x, flb.y };
+
+ // top
+ lines[ 4 ][ 0 ] = { flt.x, flt.y };
+ lines[ 4 ][ 1 ] = { frt.x, frt.y };
+ lines[ 5 ][ 0 ] = { frt.x, frt.y };
+ lines[ 5 ][ 1 ] = { brt.x, brt.y };
+ lines[ 6 ][ 0 ] = { brt.x, brt.y };
+ lines[ 6 ][ 1 ] = { blt.x, blt.y };
+ lines[ 7 ][ 0 ] = { blt.x, blt.y };
+ lines[ 7 ][ 1 ] = { flt.x, flt.y };
+
+ //bottom to top
+ lines[ 8 ][ 0 ] = { flb.x, flb.y };
+ lines[ 8 ][ 1 ] = { flt.x, flt.y };
+ lines[ 9 ][ 0 ] = { frb.x, frb.y };
+ lines[ 9 ][ 1 ] = { frt.x, frt.y };
+ lines[ 10 ][ 0 ] = { brb.x, brb.y };
+ lines[ 10 ][ 1 ] = { brt.x, brt.y };
+ lines[ 11 ][ 0 ] = { blb.x, blb.y };
+ lines[ 11 ][ 1 ] = { blt.x, blt.y };
+
+ for( size_t i{ }; i < 12; ++i ) {
+ draw_line( lines[ i ][ 0 ], lines[ i ][ 1 ], it.hit ? esp_blue( 160 ) : esp_red( 160 ) );
+ }
+ }
+ }
+
+ void c_visuals::draw_autowall( ) {
+ if( !g_settings.visuals.autowall_crosshair )
+ return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( !weapon || weapon->is_knife( ) || weapon->is_grenade( ) )
+ return;
+
+ int screen_w, screen_h;
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+
+ auto wpn_data = weapon->get_wpn_info( );
+
+ vec3_t angles{ };
+ g_csgo.m_engine( )->GetViewAngles( angles );
+
+ fire_bullet_data_t data{ };
+ data.src = g_ctx.m_local->get_eye_pos( );
+ vec3_t end = data.src;
+ end += math::angle_vectors( angles ) * wpn_data->range;
+
+ data.filter.pSkip = g_ctx.m_local;
+ data.current_damage = wpn_data->damage;
+ data.penetrate_count = 1;
+ data.trace_length = 0.f;
+
+ //data.length_to_end = ( end - data.src ).length( );
+ data.trace_length_remaining = wpn_data->range - data.trace_length;
+ data.direction = math::angle_vectors( angles );
+
+ data.direction.normalize_vector( );
+
+ CTraceFilter filter;
+ Ray_t ray;
+
+ filter.pSkip = g_ctx.m_local;
+ ray.Init( data.src, end );
+ g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT | CONTENTS_GRATE, &filter, &data.enter_trace );
+
+ bool can_penetrate = g_cheat.m_autowall.handle_bullet_penetration( wpn_data, data );
+
+ draw_line( screen_w / 2 - 1, screen_h / 2, screen_w / 2 + 2, screen_h / 2,
+ can_penetrate ? clr_t( 0, 220, 0 ) : clr_t( 220, 0, 0 ) );
+
+ draw_line( screen_w / 2, screen_h / 2 - 1, screen_w / 2, screen_h / 2 + 2,
+ can_penetrate ? clr_t( 0, 220, 0 ) : clr_t( 220, 0, 0 ) );
+ }
+
+ void c_visuals::draw_spread( ) {
+ if( !g_settings.visuals.draw_spread )
+ return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+ if( weapon ) {
+ int screen_w, screen_h;
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+ int cross_x = screen_w / 2, cross_y = screen_h / 2;
+
+ float recoil_step = screen_h / g_ctx.m_fov;
+
+ cross_x -= ( int )( g_ctx.m_local->m_aimPunchAngle( ).y * recoil_step );
+ cross_y += ( int )( g_ctx.m_local->m_aimPunchAngle( ).x * recoil_step );
+
+ weapon->update_accuracy_penalty( );
+ float inaccuracy = weapon->get_inaccuracy( );
+ float spread = weapon->get_spread( );
+
+ float cone = inaccuracy * spread;
+ cone *= screen_h * 0.7f;
+ cone *= 90.f / g_ctx.m_fov;
+
+ for( int seed{ }; seed < 256; ++seed ) {
+ util::set_random_seed( math::random_number( 0, 255 ) + 1 );
+ float rand_a = util::get_random_float( 0.f, 1.0f );
+ float pi_rand_a = util::get_random_float( 0.f, 2.0f * M_PI );
+ float rand_b = util::get_random_float( 0.0f, 1.0f );
+ float pi_rand_b = util::get_random_float( 0.f, 2.f * M_PI );
+
+ float spread_x = cos( pi_rand_a ) * ( rand_a * inaccuracy ) + cos( pi_rand_b ) * ( rand_b * spread );
+ float spread_y = sin( pi_rand_a ) * ( rand_a * inaccuracy ) + sin( pi_rand_b ) * ( rand_b * spread );
+
+ float max_x = cos( pi_rand_a ) * cone + cos( pi_rand_b ) * cone;
+ float max_y = sin( pi_rand_a ) * cone + sin( pi_rand_b ) * cone;
+
+ float step = screen_h / g_ctx.m_fov * 90.f;
+ int screen_spread_x = ( int )( spread_x * step * 0.7f );
+ int screen_spread_y = ( int )( spread_y * step * 0.7f );
+
+ float percentage = ( rand_a * inaccuracy + rand_b * spread ) / ( inaccuracy + spread );
+
+ draw_filled_rect( cross_x + screen_spread_x, cross_y + screen_spread_y, 1, 1,
+ clr_t( 255, 255, 255, 255 * ( 0.4f + percentage * 0.6f ) ) * ( 0.1f + percentage * 0.9f ) );
+ }
+ }
+ }
+
+
+ void c_visuals::store_tracer( int index, vec3_t pos ) {
+ static float last_time[ 65 ]{ };
+ tracer_t new_tracer;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( index );
+ if( ent && ent->is_valid( ) ) {
+ bool valid = ent == g_ctx.m_local;
+ float time = g_csgo.m_globals->m_curtime;
+ auto ent_pos = ent->get_hitbox_pos( 0 );
+
+ if( ent != g_ctx.m_local && g_ctx.m_local->is_valid( ) &&
+ ( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) || g_settings.visuals.friendlies( ) ) ) {
+ vec3_t ang = math::vector_angles( ent_pos, pos );
+ vec3_t local_pos = g_ctx.m_local->get_hitbox_pos( 0 );
+ float dist = local_pos.dist_to( ent_pos );
+
+ vec3_t local_ang = math::vector_angles( ent_pos, local_pos );
+
+ constexpr float max_delta_sqr = 30.f * 30.f;
+
+ float pitch_delta = sin( DEG2RAD( std::abs( ( ang - local_ang ).clamp( ).x ) ) ) * dist;
+ float yaw_delta = sin( DEG2RAD( std::abs( ( ang - local_ang ).clamp( ).y ) ) ) * dist;
+ float delta_sqr = ( yaw_delta * yaw_delta + pitch_delta * pitch_delta );
+
+
+ if( delta_sqr > max_delta_sqr ) return;
+
+ vec3_t vec = math::angle_vectors( ang );
+ vec *= dist;
+ vec += ent_pos;
+
+ pos = vec;
+
+ valid = true;
+ }
+
+ if( valid ) {
+ float delta = std::abs( g_csgo.m_globals->m_curtime - last_time[ index ] );
+ if( delta > g_csgo.m_globals->m_interval_per_tick ) {
+ new_tracer.m_time = time;
+ new_tracer.m_start = ent_pos;
+ new_tracer.m_end = pos;
+ new_tracer.m_local = ent == g_ctx.m_local;
+ m_tracers.emplace_back( new_tracer );
+
+ last_time[ index ] = g_csgo.m_globals->m_curtime;
+ }
+ }
+ }
+ }
+
+ void c_visuals::draw_tracers( ) {
+ if( !g_settings.visuals.active ) return;
+ float time = g_csgo.m_globals->m_curtime;
+
+ if( m_tracers.empty( ) )
+ return;
+
+ for( size_t i{ }; i < m_tracers.size( ) && !m_tracers.empty( ); ++i ) {
+ auto& tr = m_tracers[ i ];
+
+ float delta = time - tr.m_time;
+ if( delta > 1.0f || std::abs( delta ) > 5.f ) m_tracers.erase( m_tracers.begin( ) + i );
+ }
+
+ if( !m_tracers.empty( ) ) {
+ for( auto& it : m_tracers ) {
+
+ float delta = time - it.m_time;
+ clr_t col = it.m_local ? clr_t::from_hsb( delta, 1.0f, 1.0f ) : clr_t( 255, 15, 46 );
+ col.a( ) = 1.0f - delta * 255;
+ auto w2s_begin = util::screen_transform( it.m_start );
+ auto w2s_end = util::screen_transform( it.m_end );
+
+
+ switch( g_settings.visuals.bullet_tracers( ) ) {
+ case 1:
+ draw_line( w2s_begin, w2s_end, col );
+ break;
+ case 2:
+ if( !g_ctx.precache_model( xors( "materials/sprites/laserbeam.vmt" ) ) ) {
+ g_con->log( "nigga cant get" );
+ break;
+ }
+
+ BeamInfo_t beam_info;
+
+ beam_info.m_nType = beam_normal;
+ beam_info.m_pszModelName = xors( "materials/sprites/laserbeam.vmt" );
+ beam_info.m_nModelIndex = g_csgo.m_model_info( )->GetModelIndex( xors( "materials/sprites/laserbeam.vmt" ) );
+ beam_info.m_flHaloScale = 0.0f;
+ beam_info.m_flLife = 0.09f; //0.09
+ beam_info.m_flWidth = .6f;
+ beam_info.m_flEndWidth = .75f;
+ beam_info.m_flFadeLength = 3.0f;
+ beam_info.m_flAmplitude = 0.f;
+ beam_info.m_flBrightness = ( col.a( ) - 255.f ) * 0.8f;
+ beam_info.m_flSpeed = 1.f;
+ beam_info.m_nStartFrame = 1;
+ beam_info.m_flFrameRate = 60;
+ beam_info.m_flRed = col.r( );
+ beam_info.m_flGreen = col.g( );
+ beam_info.m_flBlue = col.b( );
+ beam_info.m_nSegments = 4;
+ beam_info.m_bRenderable = true;
+ beam_info.m_nFlags = 0;
+
+ beam_info.m_vecStart = it.m_start;
+ beam_info.m_vecEnd = it.m_end;
+
+ Beam_t* beam = g_csgo.m_beams( )->CreateBeamPoints( beam_info );
+
+ if( beam ) {
+ g_csgo.m_beams( )->DrawBeam( beam );
+ }
+
+ break;
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/visual_player.cpp b/internal_rewrite/visual_player.cpp new file mode 100644 index 0000000..0752a5a --- /dev/null +++ b/internal_rewrite/visual_player.cpp @@ -0,0 +1,830 @@ +#include <algorithm>
+
+#include "visual.hpp"
+#include "context.hpp"
+#include "base_cheat.hpp"
+#include "renderer.hpp"
+#include "input_system.hpp"
+#include "math.hpp"
+
+#undef PlaySound
+
+//2k lines of code here
+int screen_w, screen_h;
+con_var< bool > dbg_anims{ &data::holder_, fnv( "dbg_anims" ), false };
+
+namespace features
+{
+ void c_visuals::update_position( int index, const vec3_t& pos ) {
+ m_stored_pos[ index ] = pos;
+ if( m_anim_progress[ index ] <= 0.3f && g_settings.visuals.dormant ) {
+ m_anim_progress[ index ] = 0.3f;
+ }
+ }
+
+ void c_visuals::store_hit( ) {
+ if( !g_settings.visuals.hitmarkers )
+ return;
+
+ g_csgo.m_surface( )->PlaySound( xors( "buttons\\arena_switch_press_02.wav" ) );
+ m_last_hit = g_csgo.m_globals->m_curtime;
+ }
+
+ void c_visuals::radar( ) {
+ if( !g_settings.visuals.radar( ) )
+ return;
+
+ for( int i = 0; i < 32; i++ ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+ if( !ent || !ent->is_valid( ) )
+ continue;
+
+ ent->m_bSpotted( ) = true;
+ }
+ }
+
+ void c_visuals::draw_hits( ) {
+ if( !g_settings.visuals.hitmarkers || !g_ctx.run_frame( ) )
+ return;
+
+ static const clr_t col_start = clr_t( 231, 75, 75, 255 );
+ static const clr_t col_end = clr_t( 0xf4, 0x7c, 0xa8, 255 );
+
+ float delta = ( g_csgo.m_globals->m_curtime - m_last_hit ) * 1.5f;
+ if( std::abs( delta ) > 1.0f ) return;
+
+ clr_t blend = clr_t::blend( col_start, col_end, delta );
+ if( delta > 0.75f ) {
+ blend.a( ) = 255 * ( 1.0f - delta ) * 4.f;
+ }
+
+ auto get_rotated_point = [ ]( vec2_t point, float rotation, float distance ) {
+ float rad = DEG2RAD( rotation );
+
+ point.x += sin( rad ) * distance;
+ point.y += cos( rad ) * distance;
+
+ return point;
+ };
+
+
+ for( size_t i{ }; i < 2; ++i ) {
+ float rotation = 135.f + i * 90.f;
+
+ vec2_t center = { screen_w * 0.5f, screen_h * 0.5f };
+ vec2_t start = get_rotated_point( center, rotation, 8.f );
+ vec2_t end = get_rotated_point( center, rotation, 17.f );
+
+ vec2_t rot_start = get_rotated_point( center, rotation - 180.f, 8.f );
+ vec2_t rot_end = get_rotated_point( center, rotation - 180.f, 17.f );
+
+ draw_line( start, end, blend );
+ draw_line( rot_start, rot_end, blend );
+ }
+ }
+
+ struct box_t {
+ int x, y, w, h;
+ };
+
+ box_t get_box( c_base_player* ent ) {
+ const matrix3x4& matrix = ent->m_CoordinateFrame( );
+
+ vec3_t min = ent->m_vecMins( );
+ vec3_t max = ent->m_vecMaxs( );
+
+ std::array< vec3_t, 8 > point_list = {
+ vec3_t{ min.x, min.y, min.z },
+ vec3_t{ min.x, max.y, min.z },
+ vec3_t{ max.x, max.y, min.z },
+ vec3_t{ max.x, min.y, min.z },
+ vec3_t{ max.x, max.y, max.z },
+ vec3_t{ min.x, max.y, max.z },
+ vec3_t{ min.x, min.y, max.z },
+ vec3_t{ max.x, min.y, max.z }
+ };
+
+ std::array< float, 8 > x_points;
+ std::array< float, 8 > y_points;
+
+ vec2_t origin = util::screen_transform( ent->m_vecOrigin( ) );
+
+ for( auto& it : point_list ) {
+ vec3_t backup = it;
+ for( int i{ }; i < 3; ++i ) {
+ it[ i ] = backup.dot( ( const vec3_t& )( matrix[ i ] ) ) + matrix[ i ][ 3 ];
+ }
+ }
+
+ for( size_t i{ }; i < 8; ++i ) {
+ vec2_t w2s = util::screen_transform( point_list[ i ] );
+ x_points[ i ] = w2s.x;
+ y_points[ i ] = w2s.y;
+ }
+
+ std::sort( x_points.begin( ), x_points.end( ) );
+ std::sort( y_points.begin( ), y_points.end( ) );
+
+ int x = ( int )x_points.front( );
+ int w = ( int )x_points.back( ) - x;
+
+ int y = ( int )y_points.front( );
+ int h = ( int )y_points.back( ) - y;
+
+ return { x - ( int )origin.x, y - ( int )origin.y, w, h };
+ }
+
+ void c_visuals::out_of_fov( c_base_player* ent, const vec3_t& pos, clr_t col ) {
+ vec2_t screen;
+ vec2_t circle;
+
+ auto find_point = [ ]( vec2_t& point, float deg_x, float deg_y ) {
+ float x2 = screen_w / 2.f;
+ float y2 = screen_h / 2.f;
+
+ float d = sqrt( pow( point.x - x2, 2 ) + pow( point.y - y2, 2 ) );
+ float r_x = deg_x / d;
+ float r_y = deg_y / d;
+
+ point.x = r_x * point.x + ( 1.f - r_x ) * x2;
+ point.y = r_y * point.y + ( 1.f - r_y ) * y2;
+ };
+
+ auto get_screen_point = [ ]( vec2_t& screen, const vec3_t& delta ) {
+ decltype( auto ) w2s_matrix = g_csgo.m_engine( )->WorldToScreenMatrix( );
+ float x;
+ float w;
+ float y;
+
+ screen.x = w2s_matrix[ 0 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 0 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 0 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 0 ][ 3 ];
+ screen.y = w2s_matrix[ 1 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 1 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 1 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 1 ][ 3 ];
+ w = w2s_matrix[ 3 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 3 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 3 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 3 ][ 3 ];
+
+ if( w < 0.001f ) {
+ float invw = -1.0f / w;
+ screen.x *= invw;
+ screen.y *= invw;
+ }
+ else {
+ float invw = 1.0f / w;
+ screen.x *= invw;
+ screen.y *= invw;
+ }
+
+ x = float( screen_w ) / 2.f;
+ y = float( screen_h ) / 2.f;
+ x += 0.5f * screen.x * screen_w + 0.5f;
+ y -= 0.5f * screen.y * screen_h + 0.5f;
+ screen.x = x;
+ screen.y = y;
+ };
+
+ screen = util::screen_transform( pos );//get_screen_point( screen, pos );
+ circle = util::screen_transform( pos );// get_screen_point( circle, pos );
+
+ float radius = g_settings.visuals.out_of_pov_radius * 0.49f;
+
+ float ratio = g_settings.visuals.out_of_pov_radius;
+
+ float w = screen_w * ratio + screen_h * ( 1.0f - ratio );
+
+ find_point( screen, w * radius,
+ float( screen_h ) * radius );
+
+ auto min = std::min< int >( screen_w, screen_h ) * radius;
+ find_point( circle, float( min ), float( min ) );
+
+ auto rot_around_center = [ ]( vec2_t start, float rot ) {
+ float rad = rot * ( M_PI / 180.f );
+
+ start.x += sin( rad ) * float( g_settings.visuals.out_of_pov_size );
+ start.y += cos( rad ) * float( g_settings.visuals.out_of_pov_size );
+
+ return start;
+ };
+
+ float delta_x = ( float( screen_w / 2 ) - circle.x );
+ float delta_y = ( float( screen_h / 2 ) - circle.y );
+
+ auto hyp = sqrt( delta_x * delta_x + delta_y * delta_y );
+
+ float cos_ = delta_x / hyp;
+
+ float deg = RAD2DEG( acos( cos_ ) );
+
+ if( screen.y < screen_h / 2 ) {
+ deg *= -1.f;
+ }
+
+ auto rotated_pos_1 = rot_around_center( screen, deg + 115 );
+ auto rotated_pos_2 = rot_around_center( screen, deg + 65 );
+
+ col.a( ) *= 0.8f;
+
+ vertex_t v[ ] = {
+ { screen },
+ { rotated_pos_1 },
+ { rotated_pos_2 }
+ };
+
+ if( !g_settings.misc.hide_from_obs )
+ g_renderer.draw_polygon( 3, v, col );
+ else {
+ draw_line( screen, rotated_pos_1, col );
+ draw_line( screen, rotated_pos_2, col );
+ draw_line( rotated_pos_1, rotated_pos_2, col );
+ }
+ }
+
+ void c_visuals::update_glow( ) {
+ if( !g_settings.visuals.active || g_settings.misc.hide_from_obs )
+ return;
+
+ static auto manager_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "0F 11 05 00 00 00 00 83 C8 01" ), 0x3 );
+
+ auto glow_object_manager = *( GlowObjectManager_t** )( manager_ptr );
+ auto glow_count = glow_object_manager->Count;
+ auto glow_objects = glow_object_manager->DataPtr;
+
+ if( glow_count > 500 || glow_count <= 0 )
+ return;
+
+ for( int i{ }; i < glow_count; ++i ) {
+ auto& object = glow_objects[ i ];
+
+ auto ent = object.m_pEntity->as< c_base_player >( );
+ if( !ent ) continue;
+
+ if( ent->is_player( ) ) {
+ if( g_settings.visuals.glow &&
+ ent->is_valid( ) && ( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) ||
+ g_settings.visuals.friendlies || g_settings.visuals.chams.friendlies ) ) {
+
+ clr_t clr = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ?
+ g_settings.visuals.glow_friendly : g_settings.visuals.glow_enemy;
+
+ object.color = clr.to_fclr( );
+ object.m_bRenderWhenOccluded = true;
+ object.m_bRenderWhenUnoccluded = false;
+ object.m_flBloomAmount = 0.85f;
+ }
+ }
+ else {
+ auto ce = ent->ce( );
+ auto client_class = ce->GetClientClass( );
+ if( !client_class ) continue;
+ int class_id = client_class->m_class_id;
+ if( class_id != CBaseWeaponWorldModel && ( strstr( client_class->m_name, xors( "Weapon" ) )
+ || class_id == CDEagle || class_id == CAK47 ) ) {
+ bool glow = g_settings.visuals.weapon_esp == 2 || g_settings.visuals.weapon_esp == 3;
+ object.color = g_settings.visuals.weapon_esp_clr( ).to_fclr( );
+ object.m_bRenderWhenOccluded = true;
+ object.m_bRenderWhenUnoccluded = false;
+ object.m_flBloomAmount = glow ? 0.85f : 0.0f;
+ }
+ else {
+ auto model = ce->GetModel( );
+ if( !model ) continue;
+
+ bool glow = g_settings.visuals.grenade_esp( ) == 2 || g_settings.visuals.grenade_esp( ) == 3;
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !strstr( hdr->name, xors( "thrown" ) ) && !strstr( hdr->name, xors( "dropped" ) ) )
+ continue;
+
+ object.color = g_settings.visuals.grenade_esp_clr( ).to_fclr( );
+ object.m_bRenderWhenOccluded = true;
+ object.m_bRenderWhenUnoccluded = false;
+ object.m_flBloomAmount = glow ? 0.85f : 0.0f;
+ }
+ }
+ }
+ }
+
+ inline clr_t blend_clr( clr_t in, float progress ) {
+ static const clr_t clr_gray = { 160, 160, 160, 255 };
+ int a = in.a( );
+
+ clr_t ret = clr_t::blend( clr_gray, in, 0.1f + progress * 0.9f );
+ ret.a( ) = a;
+ return ret;
+ }
+
+ void c_visuals::draw_players( ) {
+ static constexpr float anim_rate = 1.0f / 0.3f;
+ static float pov_progress[ 65 ]{ };
+
+ auto resource = c_base_player::get_player_resource( );
+
+ for( int i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( i );
+
+ if( !ent || !ent->is_player( ) || !ent->is_alive( ) || ent == g_ctx.m_local )
+ continue;
+
+ if( i == ( g_ctx.m_local->m_hObserverTarget( ) & 0xfff ) )
+ continue;
+
+ if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) &&
+ !g_settings.visuals.friendlies( ) )
+ continue;
+
+ float rate = g_csgo.m_globals->m_frametime * anim_rate;
+ float& anim = m_anim_progress[ i ];
+ float alpha = anim;
+ bool dormant = ent->ce( )->IsDormant( ) || !ent->has_valid_anim( );
+ int health = ent->m_iHealth( );
+ auto origin = ent->m_vecOrigin( );
+ auto box = get_box( ent );
+ int right_pos = 0;
+ int bottom_pos = 0;
+ bool too_distant = true;
+ if( g_ctx.m_local )
+ too_distant = ent->m_vecOrigin( ).dist_to( g_ctx.m_local->m_vecOrigin( ) ) > 2500.f;
+
+ if( !dormant ) {
+ update_position( i, origin );
+ anim = 1.0f;
+ }
+ else {
+ if( anim < 0.3f && g_settings.visuals.dormant && !too_distant ) {
+ rate *= 0.01f;
+ }
+ anim = std::clamp( anim -= rate, 0.f, 1.0f );
+ if( m_anim_progress[ i ] <= 0.f )
+ continue;
+ }
+
+ clr_t col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ?
+ g_settings.visuals.box_friendly : g_settings.visuals.box_enemy;
+
+ if( dormant ) {
+ col = blend_clr( col, anim );
+ col.a( ) *= anim;
+ }
+
+ auto w2s_cur_origin = util::screen_transform( m_stored_pos[ i ] );
+
+ box.x += w2s_cur_origin.x;
+ box.y += w2s_cur_origin.y;
+
+ if( box.x > screen_w || box.x + box.w < 0 ||
+ box.y > screen_h || box.y + box.h < 0 ) {
+ if( g_settings.visuals.out_of_pov ) {
+ auto& anim = pov_progress[ i ];
+ anim = std::clamp( anim += g_csgo.m_globals->m_frametime * anim_rate, 0.f, 1.0f );
+ if( dormant )
+ anim = std::clamp( anim -= g_csgo.m_globals->m_frametime * anim_rate, 0.f, 1.0f );
+ else
+ anim = std::clamp( anim += g_csgo.m_globals->m_frametime * anim_rate, 0.f, 1.0f );
+
+ col.a( ) *= anim;
+ out_of_fov( ent, ent->ce( )->GetRenderOrigin( ), col );
+ }
+ continue;
+ }
+
+ pov_progress[ i ] = 0.f;
+
+ if( g_settings.visuals.skeleton( ) && !dormant ) {
+ clr_t col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.skeleton_friendly : g_settings.visuals.skeleton_enemy;
+ col.a( ) *= alpha;
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( ent->ce( )->GetModel( ) );
+ if( hdr ) {
+ matrix3x4 matrix[ 128 ];
+ memcpy( matrix, ent->m_CachedBoneData( ).GetElements( ),
+ ent->m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) );
+
+ for( size_t bone{ }; bone < hdr->numbones; ++bone ) {
+ auto b = hdr->GetBone( bone );
+ if( b && b->flags & 0x100 && b->parent != -1 ) {
+ vec3_t child = vec3_t{ matrix[ bone ][ 0 ][ 3 ], matrix[ bone ][ 1 ][ 3 ], matrix[ bone ][ 2 ][ 3 ] };
+ vec3_t parent = vec3_t{ matrix[ b->parent ][ 0 ][ 3 ], matrix[ b->parent ][ 1 ][ 3 ], matrix[ b->parent ][ 2 ][ 3 ] };
+
+ auto child_screen = util::screen_transform( child );
+ auto parent_screen = util::screen_transform( parent );
+
+ draw_line( child_screen, parent_screen, col );
+ }
+ }
+ }
+ }
+
+ if( g_settings.visuals.box( ) ) {
+ auto alpha_ = col.a( );
+ float percent = float( alpha_ ) / 255.f;
+ draw_rect( box.x + 1, box.y + 1, box.w - 2, box.h - 2, clr_t( 0, 0, 0, 180 * alpha * percent ) );
+ draw_rect( box.x, box.y, box.w, box.h, col );
+ }
+
+ if( g_settings.visuals.health( ) ) {
+ auto fill = box.h - 1;
+ fill *= std::clamp( health, 0, 100 ) * 0.01f;
+
+ auto hp_col = clr_t(
+ std::min< int >( 510 * ( 100 - health ) / 100, 255 ),
+ std::min< int >( 510 * health / 100, 255 ),
+ 0,
+ 255 * alpha );
+
+ draw_filled_rect( box.x - 4, box.y, 3, box.h + 1, clr_t( 0, 0, 0, 170 * alpha ) );
+ draw_filled_rect( box.x - 3, box.y + box.h - fill, 1, fill, hp_col );
+
+ if( health != 100 )
+ draw_string( box.x - 2, box.y + 1 + box.h - fill - 3, ALIGN_CENTER, false, clr_t( 255, 255, 255, 255 * alpha ), "%d", health );
+ }
+
+ if( g_settings.visuals.name( ) ) {
+ clr_t col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.name_friendly( ) : g_settings.visuals.name_enemy( );
+ col.a( ) *= alpha;
+
+ char name[ 32 ];
+ ent->get_name_safe( name );
+
+ draw_string( box.x + box.w / 2, box.y - 12, ALIGN_CENTER, true,
+ blend_clr( col, anim ), name );
+ }
+
+ if( g_settings.visuals.money( ) ) {
+ int x_pos = box.x + box.w + 2;
+ int y_pos = box.y - 1 + right_pos;
+ draw_string( x_pos, y_pos, ALIGN_LEFT, false,
+ blend_clr( esp_green( 255 * alpha ), anim ),
+ xors( "%d$" ), ent->m_iAccount( ) );
+
+ right_pos += 9;
+ }
+
+ if( g_settings.visuals.resolver_indicator && g_settings.rage.resolver && g_cheat.m_player_mgr.is_cheater( i ) && !dormant && g_ctx.m_local->is_valid( ) ) {
+ bool can_backtrack_lby = g_cheat.m_ragebot.m_lagcomp->can_backtrack_entity( i ) == RECORD_LBY && !ent->is_breaking_lc( );
+ bool can_backtrack = !!g_cheat.m_ragebot.m_lagcomp->can_backtrack_entity( i ) && !ent->is_breaking_lc( );
+ int x_pos = box.x + box.w + 3;
+ int y_pos = box.y - 1 + right_pos;
+
+ bool is_fake = !can_backtrack_lby;
+ bool is_breaking_lc = g_cheat.m_prediction.is_breaking_lc( i );
+
+ if( is_breaking_lc ) {
+ draw_string( x_pos, y_pos, ALIGN_LEFT, false,
+ clr_t( 255, 255, 255, 255 * alpha ),
+ xors( "lc" ) );
+
+ right_pos += 9;
+ }
+ else if( is_fake ) {
+ draw_string( x_pos, y_pos, ALIGN_LEFT, false,
+ clr_t( 255, 255, 255, 255 * alpha ),
+ xors( "fake" ) );
+
+ right_pos += 9;
+ }
+
+ if( !!g_cheat.m_ragebot.m_resolver->get_breaking_state( i ) && !dormant && g_ctx.m_local->is_valid( ) ) {
+ float update = g_cheat.m_ragebot.m_lagcomp->get_flick_time( i );
+ float delta = ( ent->m_flSimulationTime( ) - update ) * 0.9f;
+ if( delta >= 0.f && delta <= 1.f ) {
+ float max = box.w - 2.f;
+ float fill = max * std::clamp( delta, 0.f, 1.f );
+
+ draw_filled_rect( box.x, box.y + box.h + 3 + bottom_pos,
+ box.w, 3, clr_t( 0, 0, 0, 180 * alpha ) );
+
+ clr_t col = g_settings.visuals.lby_bar_clr;
+ col.a( ) *= alpha;
+
+ draw_filled_rect( box.x + 1, box.y + box.h + 4 + bottom_pos,
+ fill, 1, blend_clr( col, anim ) );
+
+ bottom_pos += 4;
+ }
+ }
+ }
+
+ if( g_settings.visuals.ping( ) ) {
+ auto ping = ent->get_ping( );
+
+ if( ping > 310 ) {
+ int x_pos = box.x + box.w + 3;
+ int y_pos = box.y - 1 + right_pos;
+
+ draw_string( x_pos, y_pos, ALIGN_LEFT, false,
+ blend_clr( esp_blue( 255 * alpha ), anim ),
+ xors( "ping" ) );
+
+ right_pos += 9;
+ }
+ }
+
+ if( g_settings.visuals.weapon( ) ) {
+ auto weapon = ent->get_weapon( );
+ if( weapon ) { //magic font
+ auto weapon_info = weapon->get_wpn_info( );
+ int max = weapon_info->max_clip_ammo;
+
+ if( g_settings.visuals.ammo && max > 1 ) {
+ auto progress = float( weapon->m_iClip1( ) ) / max;
+ float fill = box.w - 2.f;
+ float percent = fill * progress;
+
+ draw_filled_rect( box.x, box.y + box.h + 3 + bottom_pos,
+ box.w, 3, clr_t( 0, 0, 0, 180 * alpha ) );
+
+ clr_t col = g_settings.visuals.ammo_bar_clr;
+ col.a( ) *= alpha;
+
+ draw_filled_rect( box.x + 1, box.y + box.h + 4 + bottom_pos,
+ percent, 1, blend_clr( col, anim ) );
+
+ if( progress < 0.25f ) {
+ draw_string(
+ box.x + percent, box.y + box.h + bottom_pos, ALIGN_LEFT, false,
+ clr_t( 255, 255, 255, 180 * alpha ), "%d", weapon->m_iClip1( ) );
+ }
+
+ bottom_pos += 4;
+ }
+
+
+ char wep_str[ 64 ];
+ sprintf_s< 64 >( wep_str, "%s", util::definition_index_to_name( weapon->m_iItemDefinitionIndex( ) ) );
+
+ draw_string( box.x + box.w / 2, box.y + box.h + 3 + bottom_pos, ALIGN_CENTER, false,
+ clr_t( 255, 255, 255, alpha * 255 ), wep_str );
+ }
+ }
+
+ if( g_settings.visuals.flags( ) ) {
+ int x_pos = box.x + box.w + 3;
+ int y_pos = box.y - 1;
+
+ if( ent->m_bIsScoped( ) && right_pos < box.h ) {
+ draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "scope" ) );
+ right_pos += 9;
+ }
+
+ if( ent->is_flashed( ) && right_pos < box.h ) {
+ draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, blend_clr( esp_blue( 255 * alpha ), anim ), xors( "flash" ) );
+ right_pos += 9;
+ }
+
+ if( !( util::is_low_fps( ) && g_settings.rage.preserve_fps( ) ) ) {
+ if( m_hit_flag[ i ] && g_ctx.m_local->is_valid( ) && i != g_cheat.m_ragebot.get_target( ) && g_settings.rage.enabled ) {
+ clr_t col = m_hit_flag[ i ] == HIT_1W ? clr_t( 255, 255, 255, 255 * alpha ) : esp_red( alpha * 255 );
+ draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, blend_clr( col, anim ), xors( "hit" ) );
+ right_pos += 9;
+ }
+ }
+
+ if( ent->is_reloading( ) && right_pos < box.h ) {
+ draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "rel" ) );
+ right_pos += 9;
+ }
+ }
+
+#ifdef _DEBUG
+ static con_var< bool > dbg_bt{ &data::holder_, fnv( "dbg_bt" ), false };
+ if( dbg_bt( ) && i == g_cheat.m_ragebot.get_shot_target( ) ) {
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( ent->ce( )->GetModel( ) );
+ if( hdr ) {
+ auto matrix = g_cheat.m_ragebot.get_shot_matrix( );
+ for( size_t bone{ }; bone < hdr->numbones; ++bone ) {
+ auto b = hdr->GetBone( bone );
+ if( b && b->flags & 0x100 && b->parent != -1 ) {
+ vec3_t child = vec3_t{ matrix[ bone ][ 0 ][ 3 ], matrix[ bone ][ 1 ][ 3 ], matrix[ bone ][ 2 ][ 3 ] };
+ vec3_t parent = vec3_t{ matrix[ b->parent ][ 0 ][ 3 ], matrix[ b->parent ][ 1 ][ 3 ], matrix[ b->parent ][ 2 ][ 3 ] };
+
+ auto child_screen = util::screen_transform( child );
+ auto parent_screen = util::screen_transform( parent );
+
+ draw_line( child_screen, parent_screen, clr_t( 255, 255, 255, 200 ) );
+ }
+ }
+ }
+ }
+
+ static con_var< bool > dbg_pose{ &data::holder_, fnv( "dbg_pose" ) };
+ if( dbg_pose( ) ) {
+ for( size_t i{ }; i < 24; ++i ) {
+ int x = box.x + box.w + 15;
+ int y = box.y + 11 * i;
+
+ draw_string( x, y, ALIGN_LEFT, false, clr_t( 255, 255, 255 ), "%d %f", i, ent->m_flPoseParameter( )[ i ] );
+ }
+ }
+
+ static con_var< bool > dbg_anim{ &data::holder_, fnv( "dbg_anim" ) };
+ if( dbg_anim( ) ) {
+ draw_string( box.x - 14, box.y - 15, ALIGN_RIGHT, false, clr_t( 255, 255, 255 ), "%f", ent->get_animdata( ).m_last_velocity.length2d( ) );
+ draw_string( box.x - 14, box.y, ALIGN_RIGHT, false, clr_t( 255, 255, 255 ), "%f", ent->get_animdata( ).m_anim_velocity.length2d( ) );
+ for( size_t i{ }; i < 13; ++i ) {
+ int x = box.x - 15;
+ int y = box.y + 11 * ( i + 2 );
+
+ draw_string( x, y, ALIGN_RIGHT, false, clr_t( 255, 255, 255 ), "%d %f", i, ent->m_AnimOverlay( ).GetElements( )[ i ].m_flCycle );
+ }
+ }
+#endif
+ }
+ }
+
+ void c_visuals::store_sound( int index, vec3_t origin ) {
+ if( !g_settings.visuals.sound )
+ return;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( index );
+ if( ent && ent->is_player( ) && ent->is_alive( ) && ent != g_ctx.m_local ) {
+ if( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) || ( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && g_settings.visuals.friendlies( ) ) ) {
+ sound_t new_sound;
+ new_sound.m_time = g_csgo.m_globals->m_curtime;
+ new_sound.m_ent = index;
+ new_sound.m_pos = origin;
+ new_sound.m_pos.z += 5.f;
+ m_sounds.emplace_back( new_sound );
+ }
+ }
+ }
+
+ void c_visuals::update_hit_flags( ) {
+ if( !g_settings.visuals.flags || !g_settings.rage.enabled )
+ return;
+
+ if( util::is_low_fps( ) && g_settings.rage.preserve_fps )
+ return;
+
+ auto weapon = g_ctx.m_local->get_weapon( );
+
+ for( size_t i{ }; i < 65; ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( i );
+
+ if( !ent || !ent->is_valid( ) || !ent->has_valid_anim( ) ||
+ ( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && !g_settings.rage.friendlies )
+ || ent->m_bGunGameImmunity( ) ) {
+ m_hit_flag[ i ] = HIT_NONE;
+ continue;
+ }
+
+ vec3_t local_pos = g_ctx.m_local->get_eye_pos( );
+ vec3_t enemy_pos = ent->get_hitbox_pos( 0 );
+
+ auto local_wep = g_ctx.m_local->get_weapon( );
+ auto enemy_wep = ent->get_weapon( );
+
+ if( !local_wep || !enemy_wep || local_wep->is_knife( ) || enemy_wep->is_knife( ) || local_wep->is_grenade( ) || enemy_wep->is_grenade( ) ) {
+ m_hit_flag[ i ] = HIT_NONE;
+ continue;
+ }
+
+ float local_dmg = g_cheat.m_autowall.run( g_ctx.m_local, ent, enemy_pos, false );
+ float enemy_dmg = g_cheat.m_autowall.run( ent, g_ctx.m_local, g_ctx.m_local->get_hitbox_pos( 0 ), false );
+
+ auto min_dmg = g_cheat.m_ragebot.get_min_dmg( ent );
+
+ if( enemy_dmg < 5.f && local_dmg > g_cheat.m_ragebot.get_min_dmg( ent ) )
+ m_hit_flag[ i ] = HIT_1W;
+ else if( enemy_dmg > 15.f && local_dmg < g_cheat.m_ragebot.get_min_dmg( ent ) )
+ m_hit_flag[ i ] = HIT_ALERT;
+ else
+ m_hit_flag[ i ] = HIT_NONE;
+ }
+ }
+
+ void c_visuals::store_ent_dmg( int attacker, int entindex, int dmg ) {
+ if( entindex == g_ctx.m_local->ce( )->GetIndex( ) )
+ return;
+
+ bool dead = false;
+ int hp = 100 - m_ent_dmg[ entindex ];
+
+ if( hp - dmg < 0 ) {
+ dmg = hp;
+ dead = true;
+ }
+
+ m_ent_dmg[ entindex ] += dmg;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( entindex );
+ if( attacker == g_csgo.m_engine( )->GetLocalPlayer( ) && ent && ent->is_player( ) && ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && g_ctx.m_local->is_valid( ) ) {
+ m_teamdmg += ( g_csgo.m_globals->m_curtime - m_last_roundstart > 10.f ) || dead ? dmg : dmg * 2;
+ }
+ }
+
+ void c_visuals::on_round_start( ) {
+ m_last_roundstart = g_csgo.m_globals->m_curtime;
+ for( size_t i{ }; i < 65; ++i ) {
+ m_ent_dmg[ i ] = 0;
+ }
+ }
+
+ void c_visuals::reset_local_dmg( ) {
+ m_teamdmg = 0;
+ }
+
+ void c_visuals::draw_sound( ) {
+ if( !g_settings.visuals.active ) return;
+ if( g_settings.misc.hide_from_obs ) return;
+
+ float time = g_csgo.m_globals->m_curtime;
+
+ if( m_sounds.empty( ) )
+ return;
+
+
+ for( size_t i{ }; i < m_sounds.size( ) && !m_sounds.empty( ); ++i ) {
+ auto& tr = m_sounds[ i ];
+
+ float delta = g_csgo.m_globals->m_curtime - tr.m_time;
+ if( delta > 0.001f || std::abs( delta ) > 0.001f ) m_sounds.erase( m_sounds.begin( ) + i );
+ }
+
+ if( !m_sounds.empty( ) ) {
+ for( auto& it : m_sounds ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( it.m_ent );
+ if( !ent || !ent->is_player( ) )
+ continue;
+
+ clr_t col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.box_friendly : g_settings.visuals.box_enemy;
+ float delta = time - it.m_time;
+ if( !g_ctx.precache_model( xors( "materials/sprites/laserbeam.vmt" ) ) ) {
+ g_con->log( "nigga cant get" );
+ continue;
+ }
+
+ BeamInfo_t beam_info;
+
+ beam_info.m_nType = beam_ring_point;
+ beam_info.m_pszModelName = xors( "materials/sprites/laserbeam.vmt" );
+ beam_info.m_nModelIndex = g_csgo.m_model_info( )->GetModelIndex( xors( "materials/sprites/laserbeam.vmt" ) );
+ beam_info.m_flHaloScale = 0.0f;
+ beam_info.m_flLife = 0.75f; //0.09
+ beam_info.m_flWidth = 1.5f;
+ beam_info.m_flEndWidth = 1.5f;
+ beam_info.m_flFadeLength = 1.0f;
+ beam_info.m_flAmplitude = 0.f;
+ beam_info.m_flBrightness = col.a( );
+ beam_info.m_flSpeed = 2.f;
+ beam_info.m_nStartFrame = 0;
+ beam_info.m_flFrameRate = 60;
+ beam_info.m_flRed = col.r( );
+ beam_info.m_flGreen = col.g( );
+ beam_info.m_flBlue = col.b( );
+ beam_info.m_nSegments = 1;
+ beam_info.m_bRenderable = true;
+ beam_info.m_nFlags = 0;
+
+ beam_info.m_vecCenter = it.m_pos;
+ beam_info.m_flStartRadius = 0.f;
+ beam_info.m_flEndRadius = ( float )g_settings.visuals.sound_range( );
+
+ Beam_t* beam = g_csgo.m_beams( )->CreateBeamRingPoint( beam_info );
+
+ if( beam ) {
+ g_csgo.m_beams( )->DrawBeam( beam );
+ }
+ }
+ }
+ }
+
+ void c_visuals::operator()( ) {
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+ if( g_ctx.run_frame( ) ) {
+ draw_local( );
+ }
+
+ if( !g_ctx.m_local )
+ return;
+
+ switch( g_settings.visuals.activation_type( ) ) {
+ case 0:
+ g_settings.visuals.active = false;
+ break;
+ case 1:
+ g_settings.visuals.active = true;
+ break;
+ case 2:
+ g_settings.visuals.active = g_input.is_key_pressed( g_settings.visuals.key );
+ break;
+ case 3: {
+ static bool held = false;
+ bool pressed = g_input.is_key_pressed( g_settings.visuals.key );
+ if( pressed ) {
+ if( !held )
+ g_settings.visuals.active ^= 1;
+ held = true;
+ }
+ else held = false;
+ }
+ break;
+ default:
+ g_settings.visuals.active = false;
+ break;
+ }
+
+ if( g_settings.visuals.active ) {
+ draw_players( );
+ }
+
+ draw_world( );
+ draw_tracers( );
+ draw_hits( );
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/visual_world.cpp b/internal_rewrite/visual_world.cpp new file mode 100644 index 0000000..b9b3430 --- /dev/null +++ b/internal_rewrite/visual_world.cpp @@ -0,0 +1,356 @@ +#include <unordered_map>
+#include <cmath>
+#include "context.hpp"
+#include "visual.hpp"
+#include "interface.hpp"
+#include "renderer.hpp"
+#include "base_cheat.hpp"
+namespace features
+{
+ void fix_static_props( ) {
+ static auto cvar = g_csgo.m_cvar( )->FindVar( xors( "r_drawspecificstaticprop" ) );
+ static bool fixed{ };
+ if( !fixed ) {
+ cvar->m_flags |= 0;
+ cvar->set_value( 1 );
+
+ fixed = true;
+ }
+ }
+
+ void c_visuals::store_firegrenades( int index, vec3_t pos ) {
+ firegrenade_t new_grenade;
+
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< >( index );
+ if( !ent || !ent->is_player( ) )
+ return;
+
+
+ new_grenade.m_time = g_csgo.m_globals->m_curtime;
+ new_grenade.m_ent = index;
+ new_grenade.m_pos = pos;
+ m_firegrenades.emplace_back( new_grenade );
+ }
+
+ void c_visuals::draw_world( ) {
+ if( !g_settings.visuals.active )
+ return;
+
+ static const auto m_bShouldGlow = g_netvars.get_netvar( fnv( "DT_DynamicProp" ), fnv( "m_bShouldGlow" ) );
+ static auto c4_time = g_csgo.m_cvar( )->FindVar( xors( "mp_c4timer" ) );
+
+ draw_firegrenade( );
+
+ for( int i{ 64 }; i < g_csgo.m_entlist( )->GetHighestEntityIndex( ); ++i ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity< IClientEntity >( i );
+ if( !ent ) continue;
+
+ auto client_class = ent->GetClientClass( );
+ if( !client_class ) continue;
+
+ int class_id = client_class->m_class_id;
+
+ if( g_settings.visuals.bomb_info && class_id == CPlantedC4 && ( strstr( client_class->m_name, xors( "Planted" ) ) ) ) {
+ //yea i know this is yuck i just want to get it out there for now, ill revisit it sometime in the week
+ //not bad at all tbh
+ int screen_w, screen_h;
+ g_csgo.m_engine( )->GetScreenSize( screen_w, screen_h );
+
+ auto pos = ent->GetRenderOrigin( );
+ auto w2s = util::screen_transform( pos );
+ auto bomb = ent->as< c_base_weapon >( );
+ auto to_target = pos - g_ctx.m_local->ce( )->GetRenderOrigin( );
+
+ float bomb_time = bomb->m_flC4Blow( ) - g_csgo.m_globals->m_curtime;
+ float bomb_percentage = bomb_time / c4_time->get_float( );
+ float time = ( bomb_time < 0 || bomb->m_bBombDefused( ) ) ? 0.f : bomb_time;
+
+ if( time <= 0.f )
+ return;
+
+ bool out_of_pov = w2s.x > screen_w || w2s.x < 0.f || w2s.y > screen_h || w2s.y < 0.f;
+ if( out_of_pov ) {
+ static auto safezoney = g_csgo.m_cvar( )->FindVar( xors( "safezoney" ) );
+ static auto hud_scaling = g_csgo.m_cvar( )->FindVar( xors( "hud_scaling" ) );
+
+ w2s.x = screen_w / 2;
+ w2s.y = ( 45 * hud_scaling->get_float( ) ) + ( screen_h - screen_h * safezoney->get_float( ) + 1 ) * 0.5f;
+ }
+
+ float bomb_damage = 500 * exp( -((to_target.length( ) * to_target.length( ) ) / ( ( ( 1750 * 0.33333334 ) * 2.f ) * ( 1750 * 0.33333334 ) ) ) );
+ float damage = bomb_damage;
+
+ if( g_ctx.m_local->m_ArmorValue( ) > 0 ) {
+ damage *= 0.5f;
+ float armor = ( bomb_damage - damage ) * 0.5f;
+ if( armor > g_ctx.m_local->m_ArmorValue( ) )
+ damage = bomb_damage - ( g_ctx.m_local->m_ArmorValue( ) * ( 1.f / 0.5f ) );
+ }
+
+ int health_remaining = g_ctx.m_local->m_iHealth( ) - round(damage);
+
+ float damage_percentage = std::clamp( round( damage ) / g_ctx.m_local->m_iHealth( ), 0.f, 1.0f );
+
+ clr_t bomb_col = clr_t::blend( esp_red( ), esp_green( ), bomb_percentage );
+ clr_t damage_col = clr_t::blend( esp_green( ), esp_red( ), damage_percentage );
+
+ char health_str[ 100 ];
+
+ strenc::w_sprintf_s( health_str, 100, xors( "health: %d" ), health_remaining );
+
+ if( health_remaining <= 0 ) {
+ strenc::w_sprintf_s( health_str, 100, xors( "dead" ) );
+ damage_percentage = 100.f;
+ }
+
+ draw_string( w2s.x, w2s.y + 20, ALIGN_CENTER, false, damage_col, health_str );
+
+ auto draw_timer = [ & ]( const char* text, float progress, bool red = false ) {
+ clr_t col = red ? esp_red( ) : clr_t::blend( esp_green( ), esp_red( ), progress );
+
+ const float full = 78.f;
+ float fill = full * progress;
+
+ draw_filled_rect( w2s.x - 40, w2s.y, 80, 18, clr_t( 0, 0, 0, 170 ) );
+ draw_filled_rect( w2s.x - 39, w2s.y + 1, fill, 16, col );
+
+ draw_string( w2s.x, w2s.y + 3, ALIGN_CENTER, false, clr_t( 255, 255, 255 ), text );
+ };
+
+ if( bomb->m_hBombDefuser( ) != ULONG_MAX ) {
+ auto defuser = g_csgo.m_entlist( )->GetClientEntity( bomb->m_hBombDefuser( ) & 0xfff );
+
+ float defuse_time = std::clamp( bomb->m_flDefuseCountDown( ) - g_csgo.m_globals->m_curtime, 0.f, 10.f );
+ float defuse_percentage = defuser->m_bHasDefuser( ) ? defuse_time / 5.f : defuse_time / 10.f;
+
+ char defuse_str[ 32 ];
+ strenc::w_sprintf_s( defuse_str, 32, xors( "defuse: %.1f" ), defuse_time );
+
+ draw_timer( defuse_str, 1.f - defuse_percentage, defuse_time > bomb_time );
+ }
+ else {
+ char bomb_str[ 32 ];
+ strenc::w_sprintf_s( bomb_str, 32, xors( "bomb: %.1f" ), bomb_time );
+
+ draw_timer( bomb_str, 1.f - bomb_percentage );
+ }
+ }
+
+ if( class_id != CBaseWeaponWorldModel && ( strstr( client_class->m_name, xors( "Weapon" ) )
+ || class_id == CDEagle || class_id == CAK47 ) ) {
+ auto owner = ( int )ent->as< c_base_weapon >( )->m_hOwner( ) & 0xfff;
+ if( owner <= 0 || owner > 64 ) {
+ auto origin = ent->GetRenderOrigin( );
+ if( origin ) {
+ bool draw = g_settings.visuals.weapon_esp( ) == 1;
+ bool glow = g_settings.visuals.weapon_esp( ) == 2;
+
+ if( draw || g_settings.visuals.weapon_esp == 3 ) {
+ if( !glow && !g_settings.misc.hide_from_obs ) {
+ *( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = false;
+ }
+
+ auto w2s = util::screen_transform( origin );
+ auto def_index = ent->as< c_base_weapon >( )->m_iItemDefinitionIndex( );
+ auto name = util::definition_index_to_name( def_index );
+
+ auto dist = g_ctx.m_local->m_vecOrigin( ).dist_to( origin );
+
+ clr_t col = g_settings.visuals.weapon_esp_clr;
+ if( dist > 250.f ) {
+ col.a( ) *= std::clamp( ( 750.f - ( dist - 250.f ) ) / 750.f, 0.f, 1.f );
+ };
+
+ draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+ col, name );
+ }
+ if( ( glow || g_settings.visuals.weapon_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+ *( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+ }
+ }
+ }
+ }
+ else {
+ if( g_settings.visuals.grenade_esp && strstr( client_class->m_name, xors( "Projectile" ) ) ) {
+ auto model = ent->GetModel( );
+ if( !model ) continue;
+
+ auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model );
+ if( !strstr( hdr->name, xors( "thrown" ) ) && !strstr( hdr->name, xors( "dropped" ) ) )
+ continue;
+
+ std::string name = xors( "nade" );
+ if( strstr( hdr->name, xors( "flash" ) ) ) {
+ name = xors( "flash" );
+ }
+ else if( strstr( hdr->name, xors( "smoke" ) ) ) {
+ name = xors( "smoke" );
+ }
+ else if( strstr( hdr->name, xors( "decoy" ) ) ) {
+ name = xors( "decoy" );
+ }
+ else if( strstr( hdr->name, xors( "incendiary" ) ) || strstr( hdr->name, xors( "molotov" ) ) ) {
+ name = xors( "molotov" );
+ }
+
+ if( ( g_settings.visuals.grenade_esp == 2 || g_settings.visuals.grenade_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+ *( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+ }
+
+ if( g_settings.visuals.grenade_esp == 1 || g_settings.visuals.grenade_esp == 3 ) {
+ auto pos = ent->GetRenderOrigin( );
+ auto w2s = util::screen_transform( pos );
+ auto cutie = g_csgo.m_entlist( )->GetClientEntityFromHandle( ent->as< c_base_weapon >( )->m_hOwnerEntity( ) );
+
+ auto dist = g_ctx.m_local->m_vecOrigin( ).dist_to( pos );
+
+ clr_t col = g_settings.visuals.grenade_esp_clr;
+ if( dist > 250.f && !strstr( hdr->name, xors( "thrown" ) ) ) {
+ col.a( ) *= ( 750.f - ( dist - 250.f ) ) / 750.f;
+ }
+
+ draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+ col, name.c_str( ) );
+
+ if( g_settings.visuals.grenade_owner( ) )
+ draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, col, cutie->get_info( ).name );
+ }
+ }
+ }
+ }
+ }
+ void c_visuals::draw_firegrenade( ) {
+ static auto life_span = g_csgo.m_cvar( )->FindVar( xors( "inferno_flame_lifetime" ) );
+ float time = g_csgo.m_globals->m_curtime;
+
+ if( m_firegrenades.empty( ) )
+ return;
+
+ for( size_t i{ }; i < m_firegrenades.size( ) && !m_firegrenades.empty( ); ++i ) {
+ auto& tr = m_firegrenades[ i ];
+
+ float delta = g_csgo.m_globals->m_curtime - tr.m_time;
+ if( std::abs( delta ) > life_span->get_float( ) ) m_firegrenades.erase( m_firegrenades.begin( ) + i );
+ }
+
+ if( !m_firegrenades.empty( ) ) {
+ for( auto& it : m_firegrenades ) {
+ auto ent = g_csgo.m_entlist( )->GetClientEntity( it.m_ent );
+ if( !ent || !ent->is_player( ) )
+ continue;
+
+ clr_t col = g_settings.visuals.grenade_esp_clr;
+ auto w2s = util::screen_transform( it.m_pos );
+
+ draw_string( w2s.x, w2s.y, ALIGN_CENTER, false, col, xors( "molotov" ) );
+ if( g_settings.visuals.grenade_owner )
+ draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, col, ent->get_info( ).name );
+ }
+ }
+ }
+
+ void c_visuals::world_modulate( ) {
+ static std::unordered_map< MaterialHandle_t, fclr_t > world_materials;
+ static std::unordered_map< MaterialHandle_t, fclr_t > world_materials2;
+ static c_base_player* local_player = nullptr;
+ static auto night_mode = false;
+ static bool modulated = false;
+ static bool alpha = false;
+
+ if( !g_settings.visuals.world_modulate || !g_csgo.m_engine( )->IsInGame( ) || g_settings.misc.hide_from_obs ) {
+ modulated = false;
+ if( !world_materials2.empty( ) ) {
+ for( auto& it : world_materials2 ) {
+ auto mat = g_csgo.m_mat_system( )->GetMaterial( it.first );
+ if( !mat ) continue;
+
+ auto original_col = it.second;
+ mat->ColorModulate( original_col.r( ), original_col.g( ), original_col.b( ) );
+ mat->AlphaModulate( original_col.a( ) );
+ }
+
+ world_materials.clear( );
+ world_materials2.clear( );
+ }
+
+ return;
+ }
+
+ if( g_ctx.m_stage == FRAME_NET_UPDATE_POSTDATAUPDATE_END ) {
+ fix_static_props( );
+
+ if( local_player == g_ctx.m_local &&
+ night_mode == g_settings.visuals.night_mode( ) &&
+ alpha == g_settings.visuals.transparent_props( ) &&
+ modulated == g_settings.visuals.world_modulate( ) )
+ return;
+
+
+ for( auto i = g_csgo.m_mat_system( )->FirstMaterial( );
+ i != g_csgo.m_mat_system( )->InvalidMaterial( );
+ i = g_csgo.m_mat_system( )->NextMaterial( i ) ) {
+
+ auto mat = g_csgo.m_mat_system( )->GetMaterial( i );
+ if( !mat ) continue;
+
+ const char* group = mat->GetTextureGroupName( );
+ bool is_world = strstr( group, xors( "World" ) );
+ bool is_sky = strstr( group, xors( "Sky" ) );
+ bool is_prop = strstr( group, xors( "StaticProp" ) );
+
+ if( is_world || is_sky || is_prop ) {
+ const char* name = mat->GetName( );
+ if( world_materials.find( i ) == world_materials.end( ) ) {
+ fclr_t clr;
+
+ mat->GetColorModulate( &clr.r( ), &clr.g( ), &clr.b( ) );
+ clr.a( ) = mat->GetAlphaModulation( );
+
+ world_materials.emplace( i, clr );
+ world_materials2.emplace( i, clr );
+ }
+
+ fclr_t new_color;
+
+ new_color = world_materials2.find( i )->second;
+ bool apply = g_settings.visuals.night_mode && g_settings.visuals.world_modulate;
+
+ if( is_world ) {
+ if( apply ) {
+ new_color.r( ) *= 0.15f;
+ new_color.g( ) *= 0.15f;
+ new_color.b( ) *= 0.15f;
+ }
+ }
+ else if( is_prop ) {
+ if( apply ) {
+ new_color.r( ) *= 0.3f;
+ new_color.g( ) *= 0.3f;
+ new_color.b( ) *= 0.3f;
+ }
+ if( g_settings.visuals.world_modulate && g_settings.visuals.transparent_props ) {
+ new_color.a( ) *= 0.6f;
+ }
+ }
+ else if( is_sky ) {
+ if( apply ) {
+ new_color = fclr_t( 0.f, 0.f, 0.f );
+ }
+ }
+
+ if( !( world_materials.at( i ) == new_color ) ) {
+ mat->ColorModulate( new_color.r( ), new_color.g( ), new_color.b( ) );
+ mat->AlphaModulate( new_color.a( ) );
+
+ world_materials.at( i ) = new_color;
+ }
+ }
+ }
+
+ modulated = g_settings.visuals.world_modulate;
+ night_mode = g_settings.visuals.night_mode;
+ alpha = g_settings.visuals.transparent_props;
+ local_player = g_ctx.m_local;
+ }
+ }
+}
\ No newline at end of file diff --git a/internal_rewrite/vmt.hpp b/internal_rewrite/vmt.hpp new file mode 100644 index 0000000..2ea9d72 --- /dev/null +++ b/internal_rewrite/vmt.hpp @@ -0,0 +1,81 @@ +#pragma once +#include <vector> +#include "util.hpp" + +// todo - dex; rewrite this, VirtualQuery (except for custom codeptr / readptr) and VirtualProtect shouldnt be used +// and we need to copy rtti over too or stuff will break later on + +// correct me if im wrong, but the vtable isnt replaced, instead the original is edited during hooking, rtti should be intact and accessable by game +// class could definetly do with a rewrite tho! + +// ^ you're corrct, but changing page rights and replacing ptrs direclty in rdata (or usually the heap, since thats where vmts go) is not a safe solution +// copying table + aligning it to compensate for rtti is safer +// vac loves scanning memory regions but it doesnt really do much outside of game servers (only loads some shit for checking DEP and stuff) + +// trash + +//llama is a fucking nigger +//true + +namespace hooks +{ + //we in 2017 still + + class c_vmt { + uintptr_t* m_table; + uintptr_t* m_original; + std::vector< uintptr_t > m_new; + public: + int count( ) { + int vfunc_count{ }; + + while ( m_original[ vfunc_count ] ) { + vfunc_count++; + }; + + return vfunc_count; + } + + c_vmt( void* table ) { + if ( !table ) { + return; + } + + this->m_table = reinterpret_cast< uintptr_t* >( table ); + this->m_original = *reinterpret_cast< uintptr_t** >( this->m_table ); + + for ( int i = -1; i < this->count( ); ++i ) { + this->m_new.push_back( this->m_original[ i ] ); + } + + auto data = this->m_new.data( ); + *this->m_table = uintptr_t( &data[ 1 ] ); + } + + ~c_vmt( ) { } + + template< typename T = uintptr_t > T get_function( int index ) { + return( ( T )( this->m_new.at( index + 1 ) ) ); + } + + template< typename T = uintptr_t > T get_old_function( int index ) { + return( ( T )( this->m_original[ index ] ) ); + } + + void hook( int index, uintptr_t new_func ) { + this->m_new.at( index + 1 ) = new_func; + } + + void unhook( int index ) { + this->m_new.at( index + 1 ) = this->m_original[ index ]; + } + + void hook( int index, void* new_func ) { + hook( index, reinterpret_cast< uintptr_t >( new_func ) ); + } + + void restore( ) const { + *this->m_table = uintptr_t( m_original ); + } + }; +}
\ No newline at end of file diff --git a/internal_rewrite/window_procedure.cpp b/internal_rewrite/window_procedure.cpp new file mode 100644 index 0000000..ffe9ccb --- /dev/null +++ b/internal_rewrite/window_procedure.cpp @@ -0,0 +1,58 @@ +#include "hooks.hpp"
+#include "input_system.hpp"
+#include "settings.hpp"
+
+decltype( &hooks::window_procedure ) hooks::window_procedure_o;
+long __stdcall hooks::window_procedure( HWND hwnd, uint32_t msg, uint32_t wparam, long lparam ) {
+ if ( g_csgo.m_panic ) {
+ return CallWindowProcA( ( WNDPROC )window_procedure_o, hwnd, msg, wparam, lparam );
+ }
+
+ if ( msg == WM_ACTIVATE && wparam == WA_INACTIVE ) {
+ g_input.clear_keys( );
+ }
+
+ if ( msg == WM_MOUSEMOVE ) {
+ g_input.capture_mouse_move( lparam );
+ g_con->get_input( )->capture_mouse_move( lparam );
+ }
+
+ static auto con_pressed = false;
+ if( g_con->get_input( )->is_key_pressed( KEYS_HOME ) ) {
+ if( !con_pressed ) {
+ if( !g_con->m_open ) {
+ g_con->m_consuming_input = true;
+ }
+
+ g_con->m_open ^= 1;
+ }
+
+ con_pressed = true;
+ }
+ else con_pressed = false;
+
+ if( g_con->get_input( )->register_key_press( VirtualKeyEvents_t( msg ), VirtualKeys_t( wparam ) ) ) {
+ if( g_con->m_open ) return false;
+ }
+
+ if( !g_con->m_open ) {
+ static bool was_pressed = false;
+ if( g_input.is_key_pressed( KEYS_INSERT ) ) {
+ if( !was_pressed ) {
+ g_settings.menu.open ^= 1;
+
+ was_pressed = true;
+ }
+ }
+ else {
+ was_pressed = false;
+ }
+
+ if( g_input.register_key_press( VirtualKeyEvents_t( msg ), VirtualKeys_t( wparam ) )
+ && g_settings.menu.open ) {
+ return false;
+ }
+ }
+
+ return CallWindowProcA( ( WNDPROC )window_procedure_o, hwnd, msg, wparam, lparam );
+}
\ No newline at end of file diff --git a/internal_rewrite/x86.hpp b/internal_rewrite/x86.hpp new file mode 100644 index 0000000..e737013 --- /dev/null +++ b/internal_rewrite/x86.hpp @@ -0,0 +1,47 @@ +#pragma once +#include <inttypes.h> + +namespace x86 +{ + enum class reg : size_t { + eax = 0, + ecx, + edx, + ebx, + esp, + ebp, + esi, + edi, + + /* + x64: + r8, + r9, + r10, + r11, + r12, + r13, + r14, + r15,*/ + }; + + enum instruction : uint8_t { + retn_imm16 = 0xc2, + retn = 0xc3, + fs = 0x64, + //its big nigga season + call = 0xff + }; + + __forceinline static uint32_t encode_mov_imm32( x86::reg dreg ) { + return ( 0xb8 + ( size_t( dreg ) ) ); + } + + __forceinline static uint32_t encode_push_reg( x86::reg dreg ) { + return ( 0x50 | ( ( size_t( dreg ) ) & 7 ) ); + } + + __forceinline static uint32_t encode_pop_reg( x86::reg dreg ) { + return ( 0x58 | ( ( size_t( dreg ) ) & 7 ) ); + } +};
\ No newline at end of file |