From 3d412a4b30a9f7c7f51ea6562e694315948bd3da Mon Sep 17 00:00:00 2001 From: boris Date: Wed, 28 Nov 2018 16:00:02 +1300 Subject: cleaned up in short, the cheat and loader are now separate solutions. unused stuff was moved into the legacy solution in case anyone wants to compile it or whatever. i can change this back if you want to. also, i configured the loader to compile in x64, and have separate build types for linux and win64 --- cheat/internal_rewrite/CHLClient.hpp | 83 + cheat/internal_rewrite/CInput.hpp | 55 + cheat/internal_rewrite/CUtlVector.hpp | 47 + cheat/internal_rewrite/ClientClass.hpp | 272 +++ cheat/internal_rewrite/GlobalVars_t.hpp | 21 + cheat/internal_rewrite/IAppSystem.hpp | 28 + cheat/internal_rewrite/IClientEntityList.hpp | 143 ++ cheat/internal_rewrite/IClientMode.hpp | 163 ++ cheat/internal_rewrite/ICvar.hpp | 206 +++ cheat/internal_rewrite/IEngineTrace.hpp | 384 ++++ cheat/internal_rewrite/IGameEventManager.hpp | 77 + cheat/internal_rewrite/IMaterialSystem.hpp | 281 +++ cheat/internal_rewrite/IMemAlloc.hpp | 79 + cheat/internal_rewrite/IPanel.hpp | 10 + cheat/internal_rewrite/IPhysicsSurfaceProps.hpp | 79 + cheat/internal_rewrite/IPrediction.hpp | 153 ++ cheat/internal_rewrite/ISteamClient.hpp | 43 + cheat/internal_rewrite/ISurface.hpp | 421 +++++ cheat/internal_rewrite/IVEngineClient.hpp | 287 +++ cheat/internal_rewrite/IVModelInfoClient.hpp | 268 +++ cheat/internal_rewrite/IVRenderView.hpp | 185 ++ cheat/internal_rewrite/KeyValues.cpp | 83 + cheat/internal_rewrite/KeyValues.hpp | 43 + cheat/internal_rewrite/Source.cpp | 88 + cheat/internal_rewrite/Valve/checksum_crc.cpp | 169 ++ cheat/internal_rewrite/Valve/checksum_crc.h | 30 + cheat/internal_rewrite/Valve/dt_common.h | 161 ++ cheat/internal_rewrite/Valve/dt_recv.h | 590 +++++++ cheat/internal_rewrite/autowall.cpp | 337 ++++ cheat/internal_rewrite/autowall.hpp | 35 + cheat/internal_rewrite/base_cheat.cpp | 3 + cheat/internal_rewrite/base_cheat.hpp | 39 + cheat/internal_rewrite/begin_lock.cpp | 67 + cheat/internal_rewrite/bf_write.hpp | 34 + cheat/internal_rewrite/c_base_player.cpp | 1144 ++++++++++++ cheat/internal_rewrite/c_base_player.hpp | 468 +++++ cheat/internal_rewrite/c_base_weapon.cpp | 51 + cheat/internal_rewrite/c_base_weapon.hpp | 324 ++++ cheat/internal_rewrite/chams.cpp | 341 ++++ cheat/internal_rewrite/chams.hpp | 49 + cheat/internal_rewrite/color.hpp | 278 +++ cheat/internal_rewrite/con_alias.hpp | 60 + cheat/internal_rewrite/con_fn.hpp | 172 ++ cheat/internal_rewrite/console.cpp | 324 ++++ cheat/internal_rewrite/console.hpp | 125 ++ cheat/internal_rewrite/context.cpp | 212 +++ cheat/internal_rewrite/context.hpp | 85 + cheat/internal_rewrite/create_move.cpp | 137 ++ cheat/internal_rewrite/csm_shadows.cpp | 10 + cheat/internal_rewrite/d3d.cpp | 387 +++++ cheat/internal_rewrite/d3d.hpp | 129 ++ cheat/internal_rewrite/d3d_sprite.cpp | 12 + cheat/internal_rewrite/d3d_sprite.hpp | 158 ++ cheat/internal_rewrite/debug_show_spread.cpp | 17 + cheat/internal_rewrite/detours.cpp | 292 ++++ cheat/internal_rewrite/detours.h | 164 ++ cheat/internal_rewrite/directx.cpp | 256 +++ .../do_post_screen_space_effects.cpp | 17 + cheat/internal_rewrite/draw_model_execute.cpp | 140 ++ cheat/internal_rewrite/draw_small_entities.cpp | 31 + cheat/internal_rewrite/emit_sound.cpp | 27 + cheat/internal_rewrite/end_lock.cpp | 22 + cheat/internal_rewrite/extra.cpp | 327 ++++ cheat/internal_rewrite/extra.hpp | 41 + cheat/internal_rewrite/factory.cpp | 110 ++ cheat/internal_rewrite/factory.hpp | 156 ++ cheat/internal_rewrite/fire_event_clientside.cpp | 14 + cheat/internal_rewrite/fnv.hpp | 64 + cheat/internal_rewrite/frame_stage_notify.cpp | 109 ++ cheat/internal_rewrite/get_player_info.cpp | 10 + cheat/internal_rewrite/get_screen_size.cpp | 36 + cheat/internal_rewrite/get_viewmodel_fov.cpp | 6 + cheat/internal_rewrite/hde32.cpp | 377 ++++ cheat/internal_rewrite/hde32.h | 109 ++ cheat/internal_rewrite/hooks.cpp | 108 ++ cheat/internal_rewrite/hooks.hpp | 125 ++ cheat/internal_rewrite/icons.hpp | 5 + cheat/internal_rewrite/icons/config.hpp | 1752 +++++++++++++++++++ cheat/internal_rewrite/icons/legit.hpp | 1798 +++++++++++++++++++ cheat/internal_rewrite/icons/misc.hpp | 1721 ++++++++++++++++++ cheat/internal_rewrite/icons/rage.hpp | 1630 +++++++++++++++++ cheat/internal_rewrite/icons/visuals.hpp | 1837 ++++++++++++++++++++ cheat/internal_rewrite/identity.cpp | 110 ++ cheat/internal_rewrite/identity.hpp | 16 + cheat/internal_rewrite/iface_dllmain_impl.hpp | 82 + cheat/internal_rewrite/in_prediction.cpp | 36 + cheat/internal_rewrite/input_system.cpp | 527 ++++++ cheat/internal_rewrite/input_system.hpp | 186 ++ cheat/internal_rewrite/interface.cpp | 271 +++ cheat/internal_rewrite/interface.hpp | 185 ++ cheat/internal_rewrite/internal_rewrite.vcxproj | 572 ++++++ .../internal_rewrite.vcxproj.filters | 571 ++++++ cheat/internal_rewrite/is_connected.cpp | 14 + cheat/internal_rewrite/lag_mgr.cpp | 219 +++ cheat/internal_rewrite/lag_mgr.hpp | 65 + cheat/internal_rewrite/legitbot.cpp | 331 ++++ cheat/internal_rewrite/legitbot.hpp | 75 + cheat/internal_rewrite/legitbot_lagcomp.cpp | 155 ++ cheat/internal_rewrite/level_init_pre_entity.cpp | 18 + cheat/internal_rewrite/listener.cpp | 239 +++ cheat/internal_rewrite/listener.hpp | 29 + cheat/internal_rewrite/lock_cursor.cpp | 10 + cheat/internal_rewrite/match_framework.h | 23 + cheat/internal_rewrite/materialsystem_config.cpp | 10 + cheat/internal_rewrite/math.cpp | 301 ++++ cheat/internal_rewrite/math.hpp | 164 ++ cheat/internal_rewrite/mem.hpp | 66 + cheat/internal_rewrite/modules.hpp | 35 + cheat/internal_rewrite/movement.cpp | 345 ++++ cheat/internal_rewrite/movement.hpp | 39 + cheat/internal_rewrite/movement_recorder.cpp | 79 + cheat/internal_rewrite/movement_recorder.hpp | 29 + cheat/internal_rewrite/net_showfragments.cpp | 50 + cheat/internal_rewrite/netvar_proxy.hpp | 36 + cheat/internal_rewrite/netvars.cpp | 93 + cheat/internal_rewrite/netvars.hpp | 44 + cheat/internal_rewrite/on_screen_size_changed.cpp | 9 + cheat/internal_rewrite/override_mouse_input.cpp | 14 + cheat/internal_rewrite/override_view.cpp | 35 + cheat/internal_rewrite/packet_start.cpp | 26 + cheat/internal_rewrite/paint_traverse.cpp | 65 + cheat/internal_rewrite/pattern.hpp | 68 + cheat/internal_rewrite/play_sound.cpp | 31 + cheat/internal_rewrite/player_manager.cpp | 44 + cheat/internal_rewrite/player_manager.hpp | 68 + cheat/internal_rewrite/prediction.cpp | 627 +++++++ cheat/internal_rewrite/prediction.hpp | 95 + cheat/internal_rewrite/proxies.cpp | 116 ++ cheat/internal_rewrite/ragebot.cpp | 1142 ++++++++++++ cheat/internal_rewrite/ragebot.hpp | 349 ++++ cheat/internal_rewrite/ragebot_antiaim.cpp | 889 ++++++++++ cheat/internal_rewrite/ragebot_lagcomp.cpp | 657 +++++++ cheat/internal_rewrite/ragebot_resolver.cpp | 626 +++++++ cheat/internal_rewrite/renderer.cpp | 93 + cheat/internal_rewrite/renderer.hpp | 126 ++ cheat/internal_rewrite/run_command.cpp | 11 + cheat/internal_rewrite/scene_end.cpp | 42 + cheat/internal_rewrite/sdk.hpp | 28 + cheat/internal_rewrite/send_datagram.cpp | 32 + cheat/internal_rewrite/settings.hpp | 460 +++++ cheat/internal_rewrite/shut_down.cpp | 20 + cheat/internal_rewrite/simple_settings.cpp | 32 + cheat/internal_rewrite/simple_settings.hpp | 283 +++ cheat/internal_rewrite/simulate.cpp | 46 + cheat/internal_rewrite/skins.cpp | 271 +++ cheat/internal_rewrite/skins.hpp | 33 + cheat/internal_rewrite/strings.hpp | 162 ++ cheat/internal_rewrite/suppress_lists.cpp | 43 + cheat/internal_rewrite/table32.h | 73 + cheat/internal_rewrite/ui.h | 885 ++++++++++ cheat/internal_rewrite/ui_base_item.h | 164 ++ cheat/internal_rewrite/ui_button.h | 56 + cheat/internal_rewrite/ui_checkbox.h | 68 + cheat/internal_rewrite/ui_color_picker.h | 201 +++ cheat/internal_rewrite/ui_draw.h | 161 ++ cheat/internal_rewrite/ui_dropdown.h | 219 +++ cheat/internal_rewrite/ui_dropdown_item.h | 861 +++++++++ cheat/internal_rewrite/ui_form.h | 187 ++ cheat/internal_rewrite/ui_itemlist.h | 127 ++ cheat/internal_rewrite/ui_itemlist_def.h | 61 + cheat/internal_rewrite/ui_key_picker.h | 164 ++ cheat/internal_rewrite/ui_label.h | 18 + cheat/internal_rewrite/ui_menu.h | 89 + cheat/internal_rewrite/ui_render.h | 63 + cheat/internal_rewrite/ui_slider.h | 175 ++ cheat/internal_rewrite/ui_tab_manager.h | 227 +++ cheat/internal_rewrite/ui_text_input.cpp | 83 + cheat/internal_rewrite/ui_text_input.h | 38 + .../update_clientside_animation.cpp | 48 + cheat/internal_rewrite/util.cpp | 575 ++++++ cheat/internal_rewrite/util.hpp | 111 ++ cheat/internal_rewrite/vector.hpp | 334 ++++ cheat/internal_rewrite/visual.hpp | 126 ++ cheat/internal_rewrite/visual_draw.cpp | 94 + cheat/internal_rewrite/visual_local.cpp | 661 +++++++ cheat/internal_rewrite/visual_player.cpp | 1174 +++++++++++++ cheat/internal_rewrite/visual_world.cpp | 415 +++++ cheat/internal_rewrite/vmt.hpp | 95 + cheat/internal_rewrite/window_procedure.cpp | 58 + cheat/internal_rewrite/wipe.hpp | 70 + cheat/internal_rewrite/x86.hpp | 47 + 181 files changed, 40027 insertions(+) create mode 100644 cheat/internal_rewrite/CHLClient.hpp create mode 100644 cheat/internal_rewrite/CInput.hpp create mode 100644 cheat/internal_rewrite/CUtlVector.hpp create mode 100644 cheat/internal_rewrite/ClientClass.hpp create mode 100644 cheat/internal_rewrite/GlobalVars_t.hpp create mode 100644 cheat/internal_rewrite/IAppSystem.hpp create mode 100644 cheat/internal_rewrite/IClientEntityList.hpp create mode 100644 cheat/internal_rewrite/IClientMode.hpp create mode 100644 cheat/internal_rewrite/ICvar.hpp create mode 100644 cheat/internal_rewrite/IEngineTrace.hpp create mode 100644 cheat/internal_rewrite/IGameEventManager.hpp create mode 100644 cheat/internal_rewrite/IMaterialSystem.hpp create mode 100644 cheat/internal_rewrite/IMemAlloc.hpp create mode 100644 cheat/internal_rewrite/IPanel.hpp create mode 100644 cheat/internal_rewrite/IPhysicsSurfaceProps.hpp create mode 100644 cheat/internal_rewrite/IPrediction.hpp create mode 100644 cheat/internal_rewrite/ISteamClient.hpp create mode 100644 cheat/internal_rewrite/ISurface.hpp create mode 100644 cheat/internal_rewrite/IVEngineClient.hpp create mode 100644 cheat/internal_rewrite/IVModelInfoClient.hpp create mode 100644 cheat/internal_rewrite/IVRenderView.hpp create mode 100644 cheat/internal_rewrite/KeyValues.cpp create mode 100644 cheat/internal_rewrite/KeyValues.hpp create mode 100644 cheat/internal_rewrite/Source.cpp create mode 100644 cheat/internal_rewrite/Valve/checksum_crc.cpp create mode 100644 cheat/internal_rewrite/Valve/checksum_crc.h create mode 100644 cheat/internal_rewrite/Valve/dt_common.h create mode 100644 cheat/internal_rewrite/Valve/dt_recv.h create mode 100644 cheat/internal_rewrite/autowall.cpp create mode 100644 cheat/internal_rewrite/autowall.hpp create mode 100644 cheat/internal_rewrite/base_cheat.cpp create mode 100644 cheat/internal_rewrite/base_cheat.hpp create mode 100644 cheat/internal_rewrite/begin_lock.cpp create mode 100644 cheat/internal_rewrite/bf_write.hpp create mode 100644 cheat/internal_rewrite/c_base_player.cpp create mode 100644 cheat/internal_rewrite/c_base_player.hpp create mode 100644 cheat/internal_rewrite/c_base_weapon.cpp create mode 100644 cheat/internal_rewrite/c_base_weapon.hpp create mode 100644 cheat/internal_rewrite/chams.cpp create mode 100644 cheat/internal_rewrite/chams.hpp create mode 100644 cheat/internal_rewrite/color.hpp create mode 100644 cheat/internal_rewrite/con_alias.hpp create mode 100644 cheat/internal_rewrite/con_fn.hpp create mode 100644 cheat/internal_rewrite/console.cpp create mode 100644 cheat/internal_rewrite/console.hpp create mode 100644 cheat/internal_rewrite/context.cpp create mode 100644 cheat/internal_rewrite/context.hpp create mode 100644 cheat/internal_rewrite/create_move.cpp create mode 100644 cheat/internal_rewrite/csm_shadows.cpp create mode 100644 cheat/internal_rewrite/d3d.cpp create mode 100644 cheat/internal_rewrite/d3d.hpp create mode 100644 cheat/internal_rewrite/d3d_sprite.cpp create mode 100644 cheat/internal_rewrite/d3d_sprite.hpp create mode 100644 cheat/internal_rewrite/debug_show_spread.cpp create mode 100644 cheat/internal_rewrite/detours.cpp create mode 100644 cheat/internal_rewrite/detours.h create mode 100644 cheat/internal_rewrite/directx.cpp create mode 100644 cheat/internal_rewrite/do_post_screen_space_effects.cpp create mode 100644 cheat/internal_rewrite/draw_model_execute.cpp create mode 100644 cheat/internal_rewrite/draw_small_entities.cpp create mode 100644 cheat/internal_rewrite/emit_sound.cpp create mode 100644 cheat/internal_rewrite/end_lock.cpp create mode 100644 cheat/internal_rewrite/extra.cpp create mode 100644 cheat/internal_rewrite/extra.hpp create mode 100644 cheat/internal_rewrite/factory.cpp create mode 100644 cheat/internal_rewrite/factory.hpp create mode 100644 cheat/internal_rewrite/fire_event_clientside.cpp create mode 100644 cheat/internal_rewrite/fnv.hpp create mode 100644 cheat/internal_rewrite/frame_stage_notify.cpp create mode 100644 cheat/internal_rewrite/get_player_info.cpp create mode 100644 cheat/internal_rewrite/get_screen_size.cpp create mode 100644 cheat/internal_rewrite/get_viewmodel_fov.cpp create mode 100644 cheat/internal_rewrite/hde32.cpp create mode 100644 cheat/internal_rewrite/hde32.h create mode 100644 cheat/internal_rewrite/hooks.cpp create mode 100644 cheat/internal_rewrite/hooks.hpp create mode 100644 cheat/internal_rewrite/icons.hpp create mode 100644 cheat/internal_rewrite/icons/config.hpp create mode 100644 cheat/internal_rewrite/icons/legit.hpp create mode 100644 cheat/internal_rewrite/icons/misc.hpp create mode 100644 cheat/internal_rewrite/icons/rage.hpp create mode 100644 cheat/internal_rewrite/icons/visuals.hpp create mode 100644 cheat/internal_rewrite/identity.cpp create mode 100644 cheat/internal_rewrite/identity.hpp create mode 100644 cheat/internal_rewrite/iface_dllmain_impl.hpp create mode 100644 cheat/internal_rewrite/in_prediction.cpp create mode 100644 cheat/internal_rewrite/input_system.cpp create mode 100644 cheat/internal_rewrite/input_system.hpp create mode 100644 cheat/internal_rewrite/interface.cpp create mode 100644 cheat/internal_rewrite/interface.hpp create mode 100644 cheat/internal_rewrite/internal_rewrite.vcxproj create mode 100644 cheat/internal_rewrite/internal_rewrite.vcxproj.filters create mode 100644 cheat/internal_rewrite/is_connected.cpp create mode 100644 cheat/internal_rewrite/lag_mgr.cpp create mode 100644 cheat/internal_rewrite/lag_mgr.hpp create mode 100644 cheat/internal_rewrite/legitbot.cpp create mode 100644 cheat/internal_rewrite/legitbot.hpp create mode 100644 cheat/internal_rewrite/legitbot_lagcomp.cpp create mode 100644 cheat/internal_rewrite/level_init_pre_entity.cpp create mode 100644 cheat/internal_rewrite/listener.cpp create mode 100644 cheat/internal_rewrite/listener.hpp create mode 100644 cheat/internal_rewrite/lock_cursor.cpp create mode 100644 cheat/internal_rewrite/match_framework.h create mode 100644 cheat/internal_rewrite/materialsystem_config.cpp create mode 100644 cheat/internal_rewrite/math.cpp create mode 100644 cheat/internal_rewrite/math.hpp create mode 100644 cheat/internal_rewrite/mem.hpp create mode 100644 cheat/internal_rewrite/modules.hpp create mode 100644 cheat/internal_rewrite/movement.cpp create mode 100644 cheat/internal_rewrite/movement.hpp create mode 100644 cheat/internal_rewrite/movement_recorder.cpp create mode 100644 cheat/internal_rewrite/movement_recorder.hpp create mode 100644 cheat/internal_rewrite/net_showfragments.cpp create mode 100644 cheat/internal_rewrite/netvar_proxy.hpp create mode 100644 cheat/internal_rewrite/netvars.cpp create mode 100644 cheat/internal_rewrite/netvars.hpp create mode 100644 cheat/internal_rewrite/on_screen_size_changed.cpp create mode 100644 cheat/internal_rewrite/override_mouse_input.cpp create mode 100644 cheat/internal_rewrite/override_view.cpp create mode 100644 cheat/internal_rewrite/packet_start.cpp create mode 100644 cheat/internal_rewrite/paint_traverse.cpp create mode 100644 cheat/internal_rewrite/pattern.hpp create mode 100644 cheat/internal_rewrite/play_sound.cpp create mode 100644 cheat/internal_rewrite/player_manager.cpp create mode 100644 cheat/internal_rewrite/player_manager.hpp create mode 100644 cheat/internal_rewrite/prediction.cpp create mode 100644 cheat/internal_rewrite/prediction.hpp create mode 100644 cheat/internal_rewrite/proxies.cpp create mode 100644 cheat/internal_rewrite/ragebot.cpp create mode 100644 cheat/internal_rewrite/ragebot.hpp create mode 100644 cheat/internal_rewrite/ragebot_antiaim.cpp create mode 100644 cheat/internal_rewrite/ragebot_lagcomp.cpp create mode 100644 cheat/internal_rewrite/ragebot_resolver.cpp create mode 100644 cheat/internal_rewrite/renderer.cpp create mode 100644 cheat/internal_rewrite/renderer.hpp create mode 100644 cheat/internal_rewrite/run_command.cpp create mode 100644 cheat/internal_rewrite/scene_end.cpp create mode 100644 cheat/internal_rewrite/sdk.hpp create mode 100644 cheat/internal_rewrite/send_datagram.cpp create mode 100644 cheat/internal_rewrite/settings.hpp create mode 100644 cheat/internal_rewrite/shut_down.cpp create mode 100644 cheat/internal_rewrite/simple_settings.cpp create mode 100644 cheat/internal_rewrite/simple_settings.hpp create mode 100644 cheat/internal_rewrite/simulate.cpp create mode 100644 cheat/internal_rewrite/skins.cpp create mode 100644 cheat/internal_rewrite/skins.hpp create mode 100644 cheat/internal_rewrite/strings.hpp create mode 100644 cheat/internal_rewrite/suppress_lists.cpp create mode 100644 cheat/internal_rewrite/table32.h create mode 100644 cheat/internal_rewrite/ui.h create mode 100644 cheat/internal_rewrite/ui_base_item.h create mode 100644 cheat/internal_rewrite/ui_button.h create mode 100644 cheat/internal_rewrite/ui_checkbox.h create mode 100644 cheat/internal_rewrite/ui_color_picker.h create mode 100644 cheat/internal_rewrite/ui_draw.h create mode 100644 cheat/internal_rewrite/ui_dropdown.h create mode 100644 cheat/internal_rewrite/ui_dropdown_item.h create mode 100644 cheat/internal_rewrite/ui_form.h create mode 100644 cheat/internal_rewrite/ui_itemlist.h create mode 100644 cheat/internal_rewrite/ui_itemlist_def.h create mode 100644 cheat/internal_rewrite/ui_key_picker.h create mode 100644 cheat/internal_rewrite/ui_label.h create mode 100644 cheat/internal_rewrite/ui_menu.h create mode 100644 cheat/internal_rewrite/ui_render.h create mode 100644 cheat/internal_rewrite/ui_slider.h create mode 100644 cheat/internal_rewrite/ui_tab_manager.h create mode 100644 cheat/internal_rewrite/ui_text_input.cpp create mode 100644 cheat/internal_rewrite/ui_text_input.h create mode 100644 cheat/internal_rewrite/update_clientside_animation.cpp create mode 100644 cheat/internal_rewrite/util.cpp create mode 100644 cheat/internal_rewrite/util.hpp create mode 100644 cheat/internal_rewrite/vector.hpp create mode 100644 cheat/internal_rewrite/visual.hpp create mode 100644 cheat/internal_rewrite/visual_draw.cpp create mode 100644 cheat/internal_rewrite/visual_local.cpp create mode 100644 cheat/internal_rewrite/visual_player.cpp create mode 100644 cheat/internal_rewrite/visual_world.cpp create mode 100644 cheat/internal_rewrite/vmt.hpp create mode 100644 cheat/internal_rewrite/window_procedure.cpp create mode 100644 cheat/internal_rewrite/wipe.hpp create mode 100644 cheat/internal_rewrite/x86.hpp (limited to 'cheat/internal_rewrite') diff --git a/cheat/internal_rewrite/CHLClient.hpp b/cheat/internal_rewrite/CHLClient.hpp new file mode 100644 index 0000000..94d209f --- /dev/null +++ b/cheat/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( this, 29 )( this, angle ); + } + + void HudProcessInput( bool enable ) + { + using fn = void( __thiscall* )( void*, bool ); + CallVFunction( this, 10 )( this, enable ); + } + + void HudUpdate( bool enable ) + { + using fn = void( __thiscall* )( void*, bool ); + CallVFunction( this, 11 )( this, enable ); + } + + void IN_ActivateMouse( ) + { + using fn = void( __thiscall* )( void* ); + CallVFunction( this, 15 )( this ); + } + + void IN_DeactivateMouse( ) + { + using fn = void( __thiscall* )( void* ); + CallVFunction( this, 16 )( this ); + }*/ +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/CInput.hpp b/cheat/internal_rewrite/CInput.hpp new file mode 100644 index 0000000..84802d3 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/CUtlVector.hpp b/cheat/internal_rewrite/CUtlVector.hpp new file mode 100644 index 0000000..6e43505 --- /dev/null +++ b/cheat/internal_rewrite/CUtlVector.hpp @@ -0,0 +1,47 @@ +#pragma once + +template +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 > +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/cheat/internal_rewrite/ClientClass.hpp b/cheat/internal_rewrite/ClientClass.hpp new file mode 100644 index 0000000..fc1f140 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/GlobalVars_t.hpp b/cheat/internal_rewrite/GlobalVars_t.hpp new file mode 100644 index 0000000..4cfcfb4 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IAppSystem.hpp b/cheat/internal_rewrite/IAppSystem.hpp new file mode 100644 index 0000000..61a6c8e --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IClientEntityList.hpp b/cheat/internal_rewrite/IClientEntityList.hpp new file mode 100644 index 0000000..d6a65e4 --- /dev/null +++ b/cheat/internal_rewrite/IClientEntityList.hpp @@ -0,0 +1,143 @@ +#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; + + // no vfunc :> + return *reinterpret_cast< int* >( this + 0x64 ); + + 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/cheat/internal_rewrite/IClientMode.hpp b/cheat/internal_rewrite/IClientMode.hpp new file mode 100644 index 0000000..dc7d15d --- /dev/null +++ b/cheat/internal_rewrite/IClientMode.hpp @@ -0,0 +1,163 @@ +#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; + int m_iEdgeBlur; +private: +}; + +class IClientMode { +public: + char _pad[ 28 ]; + + CHudChat* m_pChatElement; //0x2A +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/ICvar.hpp b/cheat/internal_rewrite/ICvar.hpp new file mode 100644 index 0000000..9e8040f --- /dev/null +++ b/cheat/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 + 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/cheat/internal_rewrite/IEngineTrace.hpp b/cheat/internal_rewrite/IEngineTrace.hpp new file mode 100644 index 0000000..681d64b --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IGameEventManager.hpp b/cheat/internal_rewrite/IGameEventManager.hpp new file mode 100644 index 0000000..ec37320 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IMaterialSystem.hpp b/cheat/internal_rewrite/IMaterialSystem.hpp new file mode 100644 index 0000000..7fc1bc1 --- /dev/null +++ b/cheat/internal_rewrite/IMaterialSystem.hpp @@ -0,0 +1,281 @@ +#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 IMaterialVar { +public: + virtual ITexture *GetTextureValue( void ) = 0; + + virtual char const * GetName( void ) const = 0; + virtual void* GetNameAsSymbol( ) const = 0; + + virtual void SetFloatValue( float val ) = 0; + + virtual void SetIntValue( int val ) = 0; + + virtual void SetStringValue( char const *val ) = 0; + virtual char const * GetStringValue( void ) const = 0; + + // Use FourCC values to pass app-defined data structures between + // the proxy and the shader. The shader should ignore the data if + // its FourCC type not correct. + virtual void SetFourCCValue( ) = 0; + virtual void GetFourCCValue( ) = 0; + + // Vec (dim 2-4) + virtual void SetVecValue( float const* val, int numcomps ) = 0; + virtual void SetVecValue( float x, float y ) = 0; + virtual void SetVecValue( float x, float y, float z ) = 0; + virtual void SetVecValue( float x, float y, float z, float w ) = 0; + virtual void GetLinearVecValue( float *val, int numcomps ) const = 0; + + // revisit: is this a good interface for textures? + virtual void SetTextureValue( ITexture * ) = 0; + + virtual IMaterial * GetMaterialValue( void ) = 0; + virtual void SetMaterialValue( IMaterial * ) = 0; + + virtual bool IsDefined( ) const = 0; + virtual void SetUndefined( ) = 0; + + // Matrix + virtual void SetMatrixValue( ) = 0; + virtual const void GetMatrixValue( ) = 0; + virtual bool MatrixIsIdentity( ) const = 0; + + // Copy.... + virtual void CopyFrom( IMaterialVar *pMaterialVar ) = 0; + + virtual void SetValueAutodetectType( char const *val ) = 0; + + virtual IMaterial * GetOwningMaterial( ) = 0; + + //set just 1 component + virtual void SetVecComponentValue( float fVal, int nComponent ) = 0; + +protected: + virtual int GetIntValueInternal( void ) const = 0; + virtual float GetFloatValueInternal( void ) const = 0; + virtual float const* GetVecValueInternal( ) const = 0; + virtual void GetVecValueInternal( float *val, int numcomps ) const = 0; + virtual int VectorSizeInternal( ) const = 0; +}; + +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( this, 115 )( this ); + }*/ +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/IMemAlloc.hpp b/cheat/internal_rewrite/IMemAlloc.hpp new file mode 100644 index 0000000..580104c --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IPanel.hpp b/cheat/internal_rewrite/IPanel.hpp new file mode 100644 index 0000000..bbae705 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IPhysicsSurfaceProps.hpp b/cheat/internal_rewrite/IPhysicsSurfaceProps.hpp new file mode 100644 index 0000000..8e4f10f --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IPrediction.hpp b/cheat/internal_rewrite/IPrediction.hpp new file mode 100644 index 0000000..35fb6b2 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ISteamClient.hpp b/cheat/internal_rewrite/ISteamClient.hpp new file mode 100644 index 0000000..190607f --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ISurface.hpp b/cheat/internal_rewrite/ISurface.hpp new file mode 100644 index 0000000..2845eaa --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/IVEngineClient.hpp b/cheat/internal_rewrite/IVEngineClient.hpp new file mode 100644 index 0000000..fb39e08 --- /dev/null +++ b/cheat/internal_rewrite/IVEngineClient.hpp @@ -0,0 +1,287 @@ +#pragma once +#include +#include + +#include "util.hpp" +#include "vector.hpp" +#include "CUtlVector.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 +class CNetMessagePB : public INetMessage, public T {}; + +class CCLCMsg_Move_ { +private: + char __PAD0[ 0x8 ]; +public: + int numBackupCommands; + int numNewCommands; +}; + +using CCLCMsg_Move_t = CNetMessagePB; + +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; + } +}; + +struct CSndInfo { + int guid; + void *file_handle; + int sound_source; + int channel; + int speaker_entity; + float volume; + float last_spatilized_volume; + float radius; + int pitch; + vec3_t *origin; + vec3_t *direction; + bool update_positions; + bool is_sentence; + bool disable_dsp_processing; + bool from_speaker_entity; + bool server_sound; +}; + +class IVEngineSound { +public: + void GetActiveSounds( CUtlVector< CSndInfo >& list ) { + using fn = void( __thiscall* )( void*, CUtlVector< CSndInfo >& ); + + return util::get_vfunc< fn >( this, 18 )( this, list ); + } +}; + +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/cheat/internal_rewrite/IVModelInfoClient.hpp b/cheat/internal_rewrite/IVModelInfoClient.hpp new file mode 100644 index 0000000..3cc418b --- /dev/null +++ b/cheat/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( reinterpret_cast( this ) + procindex ); }; + int surfacepropidx; + char* GetSurfaceProps( ) const { return reinterpret_cast( reinterpret_cast( 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( uintptr_t( this ) + boneindex ) + i; + }; + + mstudiohitboxset_t* pHitboxSet( int i ) const { + return reinterpret_cast( 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/cheat/internal_rewrite/IVRenderView.hpp b/cheat/internal_rewrite/IVRenderView.hpp new file mode 100644 index 0000000..a8396f5 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/KeyValues.cpp b/cheat/internal_rewrite/KeyValues.cpp new file mode 100644 index 0000000..300b6f1 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/KeyValues.hpp b/cheat/internal_rewrite/KeyValues.hpp new file mode 100644 index 0000000..94eb6ca --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/Source.cpp b/cheat/internal_rewrite/Source.cpp new file mode 100644 index 0000000..0b63051 --- /dev/null +++ b/cheat/internal_rewrite/Source.cpp @@ -0,0 +1,88 @@ +//this cheat was a mistake + +#include +#include + +#include "hooks.hpp" +#include "console.hpp" +#include "input_system.hpp" +#include "mem.hpp" +#include "wipe.hpp" + +HMODULE g_dll; +header_t g_header; + +void main_thread( HINSTANCE uh ) { + +#ifdef HEADER_MODULE + memcpy( &g_header, uh, sizeof( g_header ) ); + for ( size_t i = 1; i < sizeof( header_t ); ++i ) + *(uint8_t*)( uintptr_t( &g_header ) + i ) ^= g_header.xor_key; + +#endif + + g_csgo.initialize( ); + +#ifdef HEADER_MODULE + util::memset( (uint8_t*)uh, 0x90, 0x1000 ); +#endif + + 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 ); +#ifdef HEADER_MODULE + antidebug::fuck_skids( ); +#endif + + 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/cheat/internal_rewrite/Valve/checksum_crc.cpp b/cheat/internal_rewrite/Valve/checksum_crc.cpp new file mode 100644 index 0000000..bc7b433 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/Valve/checksum_crc.h b/cheat/internal_rewrite/Valve/checksum_crc.h new file mode 100644 index 0000000..356de67 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/Valve/dt_common.h b/cheat/internal_rewrite/Valve/dt_common.h new file mode 100644 index 0000000..ff0f7b7 --- /dev/null +++ b/cheat/internal_rewrite/Valve/dt_common.h @@ -0,0 +1,161 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#pragma warning( push, 0 ) + +#ifndef DATATABLE_COMMON_H +#define DATATABLE_COMMON_H + +#ifdef _WIN32 +#pragma once +#endif + +#include + +#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<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; + + +struct DVariant { + union { + float m_Float; + long m_Int; + char* m_pString; + void* m_pData; + float m_Vector[ 3 ]; + __int64 m_Int64; + }; + + int 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 + +#pragma warning( pop ) \ No newline at end of file diff --git a/cheat/internal_rewrite/Valve/dt_recv.h b/cheat/internal_rewrite/Valve/dt_recv.h new file mode 100644 index 0000000..6e73bdb --- /dev/null +++ b/cheat/internal_rewrite/Valve/dt_recv.h @@ -0,0 +1,590 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#pragma warning( push, 0 ) + +#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 int ClientClassInit(T *); \ + namespace tableName { \ + struct ignored; \ + } \ + template <> int ClientClassInit(tableName::ignored *); \ + namespace tableName { \ + RecvTable g_RecvTable; \ + int g_RecvTableInit = ClientClassInit((tableName::ignored *)NULL); \ + } \ + template <> int ClientClassInit(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( ( size_t )instance ); +} + +inline const void** GetVTable( const void* instance ) +{ + return *reinterpret_cast( ( size_t )instance ); +} + +template +inline T GetMethod( const void* instance, size_t index ) +{ + return reinterpret_cast( GetVTable( instance )[ index ] ); +} + +#endif // DATATABLE_RECV_H + +#pragma warning( pop ) \ No newline at end of file diff --git a/cheat/internal_rewrite/autowall.cpp b/cheat/internal_rewrite/autowall.cpp new file mode 100644 index 0000000..603f94e --- /dev/null +++ b/cheat/internal_rewrite/autowall.cpp @@ -0,0 +1,337 @@ +#include + +#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 ) { + #ifdef is_breakable_ptr + static auto is_breakable_ptr = g_header.patterns.is_breakable; + #else + 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" ) ); + #endif + + if ( !ent || ent->GetIndex( ) == 0 ) + return false; + + auto is_breakable_fn = reinterpret_cast< bool( __thiscall* )( void* ) >( is_breakable_ptr ); + + bool breakable = is_breakable_fn( ent ); + + if ( !breakable ) { + auto ent_class = ent->GetClientClass( ); + + if ( !ent_class ) + return false; + + // s/o 2 poiak + auto nazwa = ent_class->m_name; + + // s/o 2 estrosterik + if ( *reinterpret_cast< uint32_t* >( nazwa ) == 0x65724243 && *reinterpret_cast< uint32_t* >( nazwa + 0x7 ) == 0x53656C62 ) + return true; + } + + return 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; + int old_contents = 0; + + Ray_t ray; + + while ( dist <= 90.f ) { + dist += 4.0f; + + out_end = start + ( dir * dist ); + + if ( !old_contents ) + old_contents = g_csgo.m_trace( )->GetPointContents( out_end, MASK_SHOT_HULL | CONTENTS_HITBOX ); + + int contents = g_csgo.m_trace( )->GetPointContents( out_end, MASK_SHOT_HULL | CONTENTS_HITBOX ); + if ( contents & MASK_SHOT_HULL && ( !( contents & CONTENTS_HITBOX ) || old_contents == contents ) ) + continue; + + vec3_t end = out_end - ( dir * 4.0f ); + + ray.Init( out_end, end ); + + g_csgo.m_trace( )->TraceRay( ray, MASK_SHOT_HULL | CONTENTS_HITBOX, nullptr, exit_trace ); + + if ( exit_trace->startsolid && exit_trace->surface.flags & SURF_HITBOX ) { + CTraceFilter filter; + filter.pSkip = exit_trace->m_pEnt; + + ray.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; + } + + continue; + } + + // maps/cs_office/glass/urban_glass + const char* surface_name = tr.surface.name; + + if ( surface_name + && *( uint32_t* )( &surface_name[ 0 ] ) == 0x7370616d + && *( uint32_t* )( &surface_name[ 4 ] ) == 0x5f73632f + && *( uint32_t* )( &surface_name[ 8 ] ) == 0x6966666f + && *( uint32_t* )( &surface_name[ 12 ] ) == 0x672f6563 + && *( uint32_t* )( &surface_name[ 16 ] ) == 0x7373616c + && *( uint32_t* )( &surface_name[ 20 ] ) == 0x6272752f + && *( uint32_t* )( &surface_name[ 24 ] ) == 0x675f6e61 + && *( uint32_t* )( &surface_name[ 28 ] ) == 0x7373616c + ) { + *exit_trace = tr; + exit_trace->endpos = out_end + dir; + return true; + } + + if ( exit_trace->DidHit( ) && !exit_trace->startsolid ) { + if ( is_breakable( tr.m_pEnt ) && is_breakable( tr.m_pEnt ) ) + return true; + + if ( tr.surface.flags & SURF_NODRAW || !( exit_trace->surface.flags & SURF_NODRAW ) && ( exit_trace->plane.normal.dot( dir ) <= 1.f ) ) { + out_end -= dir * ( exit_trace->fraction * 4.f ); + return true; + } + + continue; + } + + if ( !exit_trace->DidHit( ) || exit_trace->startsolid ) { + if ( tr.m_pEnt && tr.m_pEnt != g_csgo.m_entlist( )->GetClientEntity< void >( 0 ) && is_breakable( exit_trace->m_pEnt ) ) { + *exit_trace = tr; + exit_trace->endpos = out_end + dir; + return true; + } + } + } + + return false; + } + + bool c_autowall::handle_bullet_penetration( weapon_info_t* wpn_data, fire_bullet_data_t& data ) { + + vec3_t pen_end; + CGameTrace exit_trace; + + + + if ( !trace_to_exit( data.enter_trace.endpos, data.direction, pen_end, data.enter_trace, &exit_trace ) ) { + // if( !( g_csgo.m_trace( )->GetPointContents( pen_end, MASK_SHOT_HULL ) & MASK_SHOT_HULL ) ) + return false; + } + + bool is_light_surf = ( data.enter_trace.contents >> 7 ) & 1; + bool is_solid_surf = ( data.enter_trace.contents >> 3 ) & 1; + + auto exit_surface = g_csgo.m_phys_props( )->GetSurfaceData( exit_trace.surface.surfaceProps ); + auto enter_surface = g_csgo.m_phys_props( )->GetSurfaceData( data.enter_trace.surface.surfaceProps ); + + if ( !exit_surface || !enter_surface ) + return false; + + int exit_material = exit_surface->game.material, enter_material = enter_surface->game.material; + + auto damage_mod = 0.16f; + auto pen_mod = ( enter_surface->game.penetrationmodifier + exit_surface->game.penetrationmodifier ) * 0.5f; + + constexpr uint32_t grate = 71, wood = 85, plastic = 76, glass = 89, cardboard = 87; + + if ( enter_material == grate /* metal vents */ || enter_material == glass /* windows */ ) { + pen_mod = 3.0f; + damage_mod = 0.05f; + } else if ( is_light_surf || is_solid_surf ) { + pen_mod = 1.0f; + damage_mod = 0.16f; + } + + if ( enter_material == exit_material ) { + if ( exit_material == cardboard || exit_material == wood ) + pen_mod = 3.0f; + else if ( exit_material == plastic ) + pen_mod = 2.0f; + } + + float thickness = exit_trace.endpos.dist_to_sqr( data.enter_trace.endpos ); + + auto modifier = math::max( 0.f, 1.0f / pen_mod ); + + auto lost_dmg = std::fmaxf( + ( ( modifier * thickness ) / 24.f ) + + ( ( data.current_damage * damage_mod ) + + ( std::fmaxf( 3.75f / wpn_data->penetration, 0.f ) * 3.f * modifier ) ), 0.f ); + + + if ( lost_dmg > 0.f ) + data.current_damage -= lost_dmg; + + if ( data.current_damage < 1.f ) + return false; + + data.src = exit_trace.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; + + if ( !wep_data ) + return false; + + data.current_damage = ( float )( wep_data->damage ); + + while ( data.penetrate_count > 0 && data.current_damage >= 1.0f ) { + // this little nigga all along. + // never trust the feds. + // or even fluffy people. + data.to_travel = data.travel_range - data.traveled; + vec3_t end = data.src + data.direction * data.to_travel; + + 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 ); + + data.traveled += data.to_travel * data.enter_trace.fraction; + data.current_damage *= std::pow( wep_data->range_modifier, data.traveled * 0.002f ); + + if ( data.enter_trace.fraction == 1.0f ) { + if ( !ent_check ) { + 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( ) ) { + auto enemy = ( c_base_player* )( data.enter_trace.m_pEnt ); + + if ( scale ) + scale_damage( enemy, data.enter_trace.hitgroup, wep_data->armor_ratio, data.current_damage ); + + return true; + } + + auto enter_surface = g_csgo.m_phys_props( )->GetSurfaceData( data.enter_trace.surface.surfaceProps ); + if ( data.traveled > 3000.f || enter_surface->game.penetrationmodifier < 0.1f ) + break; + + 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.direction = end - data.src; + data.travel_range = data.direction.length( ); + data.direction.normalize_vector( ); + data.traveled = 0.f; + data.to_travel = data.travel_range; + + + if ( fire_bullet( shooter, target, wep->get_wpn_info( ), data, ent_check ) ) { + return std::max( data.current_damage, 0.f ); + } + + return 0.f; + } +} diff --git a/cheat/internal_rewrite/autowall.hpp b/cheat/internal_rewrite/autowall.hpp new file mode 100644 index 0000000..5e433e0 --- /dev/null +++ b/cheat/internal_rewrite/autowall.hpp @@ -0,0 +1,35 @@ +#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 current_damage; + int penetrate_count; + + float travel_range{ }; + float traveled{ }; + float to_travel{ }; +}; + +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/cheat/internal_rewrite/base_cheat.cpp b/cheat/internal_rewrite/base_cheat.cpp new file mode 100644 index 0000000..d21888d --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/base_cheat.hpp b/cheat/internal_rewrite/base_cheat.hpp new file mode 100644 index 0000000..07d3588 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/begin_lock.cpp b/cheat/internal_rewrite/begin_lock.cpp new file mode 100644 index 0000000..5312eec --- /dev/null +++ b/cheat/internal_rewrite/begin_lock.cpp @@ -0,0 +1,67 @@ +#include + +#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 + // 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( ) == (void*)ret_addr ) { + g_ctx.m_stage = FRAME_NET_UPDATE_POSTDATAUPDATE_START; + g_cheat.m_visuals.world_modulate( ); + + static float last_time = 0.f; + + if( g_ctx.run_frame( ) && g_ctx.m_local->is_valid( ) ) { + auto state = g_ctx.m_local->get_animstate( ); + + auto& anims = g_ctx.m_local->get_animdata( ).m_animlayers; + + if( state && state->m_flLastClientSideAnimationUpdateTime != last_time ) { + for( size_t i{ }; i < 13; ++i ) { + auto& layer = g_ctx.m_local->m_AnimOverlay( ).GetElements( )[ i ]; + + if( layer.m_flWeight != anims.at( i ).m_flWeight || layer.m_flCycle != anims.at( i ).m_flCycle ) { + memcpy( &g_ctx.m_local->get_animdata( ).m_animlayers, + g_ctx.m_local->m_AnimOverlay( ).GetElements( ), + sizeof( C_AnimationLayer ) * 13 ); + + g_ctx.m_absyaw = state->m_flGoalFeetYaw; + + last_time = state->m_flLastClientSideAnimationUpdateTime; + break; + } + } + } + } + + + + /*if( g_settings.rage.anti_aim && g_ctx.run_frame( ) ) { + static float last_time = 0.f; + + if( last_time != g_ctx.m_local->get_animstate( )->m_flLastClientSideAnimationUpdateTime ) { + + } + }*/ + + + //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/cheat/internal_rewrite/bf_write.hpp b/cheat/internal_rewrite/bf_write.hpp new file mode 100644 index 0000000..7d759b2 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/c_base_player.cpp b/cheat/internal_rewrite/c_base_player.cpp new file mode 100644 index 0000000..11882ea --- /dev/null +++ b/cheat/internal_rewrite/c_base_player.cpp @@ -0,0 +1,1144 @@ +#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( ) { +#ifdef HEADER_MODULE + static auto fn_ptr = g_header.patterns.animstate_update; +#else + 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" ) ); +#endif + static auto var = *( bool** )( fn_ptr + 0xda + 2 ); + + return *var; +} + +void CCSGOPlayerAnimState::update( float yaw, float pitch ) { +#ifdef HEADER_MODULE + static auto fn_ptr = g_header.patterns.animstate_update; +#else + 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" ) ); +#endif + + uintptr_t alloc = ( uintptr_t )this; + if( !alloc ) + return; + + if( !this->pBaseEntity ) + 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.1f + && some_layer.m_flWeight < 0.1f + && 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; + + if( weapon->is_sniper( ) && g_cheat.m_lagmgr.has_fired( ) ) + 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 ) { + return g_ctx.m_revolver_shot; + } + + 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 ) { +#ifdef HEADER_MODULE + static uintptr_t fn_addr = g_header.patterns.set_abs_angles; +#else + 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" ) ); +#endif + + auto fn = ( void( __thiscall* )( void*, vec3_t& ) )( fn_addr ); + + return fn( this, angles ); +} + +void c_base_player::set_abs_origin( vec3_t origin ) { +#ifdef HEADER_MODULE + static uintptr_t fn_addr = g_header.patterns.set_abs_origin; +#else + 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" ) ); +#endif + + 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( bool layers ) { + int idx = ce( )->GetIndex( ); + auto& animdata = sm_animdata[ idx ]; + + memcpy( &animdata.m_poseparams, + m_flPoseParameter( ), + sizeof( float ) * 24 ); + + if( layers ) { + memcpy( &animdata.m_animlayers, + m_AnimOverlay( ).GetElements( ), + sizeof( C_AnimationLayer ) * 13 ); + } + + 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 ]; + + memcpy( m_flPoseParameter( ), + &animdata.m_poseparams, + sizeof( float ) * 24 ); + + if( layers ) { + memcpy( m_AnimOverlay( ).GetElements( ), + &animdata.m_animlayers, + sizeof( C_AnimationLayer ) * 13 ); + } + + memcpy( animdata.m_bones, + m_CachedBoneData( ).GetElements( ), + sizeof( matrix3x4 ) * m_CachedBoneData( ).GetSize( ) ); +} + +void c_base_player::do_ent_interpolation( bool reset ) { + 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( ); + if( !lerp ) + return; + + if( anim_data->m_last_interp_origin.dist_to( anim_data->m_interp_origin ) > 64.f ) + 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 < TICK_INTERVAL( ) ) + return; + + lerp = std::clamp( lerp, 0.f, update_delta ); + + float lerp_progress = ( anim_data->m_simtime + lerp - g_csgo.m_globals->m_curtime ) / lerp; + + vec3_t vec_lerp = math::lerp( origin, anim_data->m_last_interp_origin, 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( ); + + auto accelerate = [ & ]( vec3_t velocity, vec3_t direction, float speed, float accel ) { + float addspeed, accelspeed, currentspeed; + + velocity.z = 0.f; + currentspeed = velocity.dot( direction ); + + addspeed = speed - currentspeed; + + if( addspeed <= 0.f ) { + return velocity; + } + + //guess how many fucks i give, this works + accelspeed = std::min( accel * 10.f * TICK_INTERVAL( ) * std::max( speed, 250.f ), currentspeed ); + + for( size_t i{ }; i < 3; ++i ) { + velocity[ i ] += accelspeed * direction[ i ]; + } + + return velocity; + }; + + auto friction = [ & ]( 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.length2d( ); + if( speed < 0.1f ) + return vec3_t{ }; + + float friction = sv_friction->get_float( ); + 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; + } + + return velocity; + }; + + 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 { + static auto sv_accelerate = g_csgo.m_cvar( )->FindVar( xors( "sv_accelerate" ) ); + + float delta = m_flSimulationTime( ) - m_flOldSimulationTime( ); + delta = std::max( delta, TICK_INTERVAL( ) ); + + bool on_ground = m_fFlags( ) & FL_ONGROUND; + + 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_vel; + + if( on_ground ) { + vec3_t ang = math::vector_angles( vec3_t( ), velocity ); + + float move_yaw = math::vector_angles( velocity ).y; + float move_delta = math::vector_angles( last_velocity ).y; + move_delta -= move_yaw; + move_delta = std::remainderf( move_delta, 360.f ); + + vec3_t move_dir = math::angle_vectors( vec3_t( 0.f, move_delta, 0.f ) ) * 450.f; + + vec3_t forward, right, up; + math::angle_vectors( ang, &forward, &right, &up ); + + vec3_t wishdir; + for( size_t i{ }; i < 2; ++i ) + wishdir[ i ] = forward[ i ] * move_dir.x + right[ i ] * move_dir.y; + + anim_vel = friction( last_velocity ); + if( anim_vel.length2d( ) < 1.f ) + anim_vel = vec3_t( ); + + int ticks = TIME_TO_TICKS( delta * 0.5f ); + vec3_t est_tick_vel = math::lerp( last_velocity, velocity, .5f ); + for( int i{ }; i < ticks + 1; i++ ) { + if( est_tick_vel.length2d( ) < 5.f ) + break; + + est_tick_vel = friction( est_tick_vel ); + } + + if( velocity.length2d( ) > last_velocity.length2d( ) ) + anim_vel = accelerate( anim_vel, wishdir, 250.f, sv_accelerate->get_float( ) ); + + //assume fakewalk + if( anim_vel.length2d( ) >= sm_animdata[ idx ].m_anim_velocity.length2d( ) && est_tick_vel.length2d( ) < 5.f && delta > TICK_INTERVAL( ) ) + anim_vel = vec3_t( ); + } + else { + anim_vel = math::lerp( + last_velocity, + velocity, + TICK_INTERVAL( ) / delta + ); + } + + sm_animdata[ idx ].m_anim_velocity = anim_vel; + sm_animdata[ idx ].m_last_velocity = velocity; + sm_animdata[ idx ].m_last_origin = origin; + } +} + +void c_base_player::calc_abs_velocity( ) { +#ifdef HEADER_MODULE + static auto fn_ptr = g_header.patterns.calc_abs_velocity; +#else + 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 ); +#endif + + if( fn_ptr ) { + auto fn = ( void( __thiscall* )( void* ) )( fn_ptr ); + fn( this ); + } +} + +void c_base_player::fix_jump_fall( bool reset ) { + if( reset ) + return; + + int prev_flags = get_animdata( ).m_prev_flags; + int flags = m_fFlags( ); + + if( ( prev_flags & FL_ONGROUND ) && ( flags & FL_ONGROUND ) ) { + flags |= FL_ONGROUND; + } + else { + auto layer_weight = m_AnimOverlay( ).GetElements( )[ 4 ].m_flWeight; + auto last_weight = get_animdata( ).m_last_layers.at( 4 ).m_flWeight; + + if( layer_weight != 1.f && last_weight == 1.f && + m_AnimOverlay( ).GetElements( )[ 5 ].m_flWeight != 0.f ) + flags |= FL_ONGROUND; + + if( ( flags & FL_ONGROUND ) && !( prev_flags & FL_ONGROUND ) ) + flags &= ~FL_ONGROUND; + } + + m_fFlags( ) = flags; +} + +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; + } + + 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 ); + fix_jump_fall( 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( ); + + float prev_cycle = m_AnimOverlay( ).GetElements( )[ 6 ].m_flPrevCycle; + float prev_rate = m_AnimOverlay( ).GetElements( )[ 6 ].m_flPlaybackRate; + + if( !reset ) { + auto fraction = get_animstate( )->m_flStopToFullRunningFraction; + bool stopping = sm_animdata[ idx ].m_is_stopping; + + if( fraction > 0.1f && fraction < 1.f ) { + float delta_2x = get_animstate( )->m_flLastUpdateDelta * 2.f; + + if( stopping ) + fraction -= delta_2x; + else + fraction += delta_2x; + + fraction = std::clamp( fraction, 0.f, 1.f ); + } + + auto speed = get_anim_velocity( ).length2d( ); + + if( speed > 135.2f && stopping ) { + sm_animdata[ idx ].m_is_stopping = false; + fraction = std::max( fraction, 0.0099999998f ); + } + if( speed < 135.2f && !stopping ) { + sm_animdata[ idx ].m_is_stopping = true; + fraction = std::min( fraction, 0.99000001f ); + } + + get_animstate( )->m_flStopToFullRunningFraction = fraction; + } + + sm_animdata[ idx ].m_last_animtime = get_animstate( )->m_flLastClientSideAnimationUpdateTime; + get_animstate( )->update( eye_angles.y, eye_angles.x ); + m_AnimOverlay( ).GetElements( )[ 6 ].m_flPrevCycle = m_AnimOverlay( ).GetElements( )[ 6 ].m_flCycle; + + float lerp_rate = math::lerp( + prev_rate, + m_AnimOverlay( ).GetElements( )[ 6 ].m_flPlaybackRate, + TICK_INTERVAL( ) / ( m_flSimulationTime( ) - m_flOldSimulationTime( ) ) ); + + if( !reset ) { + m_AnimOverlay( ).GetElements( )[ 6 ].m_flCycle = prev_cycle + lerp_rate; + } + + get_animdata( ).m_prev_flags = flags; + memcpy( + get_animdata( ).m_last_layers.data( ), + m_AnimOverlay( ).GetElements( ), + sizeof( C_AnimationLayer ) * 13 + ); + + 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; + + //check for any possible mistakes + validate_animation_layers( ); + + sm_animdata[ idx ].m_adjust_rate = m_AnimOverlay( ).GetElements( )[ 3 ].m_flPlaybackRate; + sm_animdata[ idx ].m_adjust_cycle = m_AnimOverlay( ).GetElements( )[ 3 ].m_flCycle; + + if( m_flSimulationTime( ) - m_flOldSimulationTime( ) > TICK_INTERVAL( ) ) { + auto activity = get_seq_activity( m_AnimOverlay( ).GetElements( )[ 3 ].m_nSequence ); + + if( activity == 979 ) { + m_AnimOverlay( ).GetElements( )[ 3 ].m_flWeight = 0.f; + m_AnimOverlay( ).GetElements( )[ 3 ].m_flCycle = 0.f; + } + } + + bool moving = sm_animdata[ idx ].m_anim_velocity.length( ) > 0.1f; + //compute_move_cycle( reset, moving ); + + get_animdata( ).m_anim_flags = m_fFlags( ); + + if( !moving ) + m_AnimOverlay( ).GetElements( )[ 6 ].m_flWeight = 0.f; + + 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( ); + + 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/cheat/internal_rewrite/c_base_player.hpp b/cheat/internal_rewrite/c_base_player.hpp new file mode 100644 index 0000000..30bafde --- /dev/null +++ b/cheat/internal_rewrite/c_base_player.hpp @@ -0,0 +1,468 @@ +#pragma once +#include + +#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[ 4 ]; + 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; + int m_prev_flags; + int m_anim_flags; + float m_adjust_rate; + float m_adjust_cycle; + bool m_is_stopping; + float m_last_animtime; +}; + +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 ); + NETVAR( m_flConstraintRadius, "m_flConstraintRadius", "DT_CSPlayer", 0, float ); + + OFFSET( m_CachedBoneData, 0x28FC + sizeof( void* ), CUtlVector< matrix3x4 > ); + OFFSET( m_flSpawnTime, 0xA2C0, 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( bool layers = true ); + void restore_anim_data( bool layers = false ); + void handle_taser_animation( ); + void calc_anim_velocity( bool reset ); + void fix_jump_fall( bool reset ); + + bool is_breaking_lc( ); +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/c_base_weapon.cpp b/cheat/internal_rewrite/c_base_weapon.cpp new file mode 100644 index 0000000..ec6d420 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/c_base_weapon.hpp b/cheat/internal_rewrite/c_base_weapon.hpp new file mode 100644 index 0000000..f56770e --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/chams.cpp b/cheat/internal_rewrite/chams.cpp new file mode 100644 index 0000000..1d46bb2 --- /dev/null +++ b/cheat/internal_rewrite/chams.cpp @@ -0,0 +1,341 @@ +#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" "1" + "$envmapsaturation" "1.0" + "$phong" "1" + "$phongexponent" "15.0" + "$normalmapalphaenvmask" "1" + "$phongboost" "6.0" + "$phongfresnelranges" "[.5 .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.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 float last_luminance{ }; + static KeyValues* reflectivity; + static KeyValues* shine; + static KeyValues* luminance; + + 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( !luminance ) { + for( auto it = m_chams.m_keyvalues->m_pSub; !!it; it = it->m_pPeer ) { + if( it->m_flValue == 15.0f ) { + luminance = 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( ) * 3.f; + m_chams.m_mat->Refresh( ); + } + last_shine = g_settings.visuals.chams.shine( ); + } + + if( luminance ) { + if( last_luminance != g_settings.visuals.chams.luminance( ) ) { + if( g_settings.visuals.chams.luminance == 0.f ) + luminance->m_flValue = 0.f; + else + luminance->m_flValue = ( 1.05f - g_settings.visuals.chams.luminance( ) ) * 10.f; + m_chams.m_mat->Refresh( ); + } + last_luminance = g_settings.visuals.chams.luminance( ); + } + } + + 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/cheat/internal_rewrite/chams.hpp b/cheat/internal_rewrite/chams.hpp new file mode 100644 index 0000000..d7eb023 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/color.hpp b/cheat/internal_rewrite/color.hpp new file mode 100644 index 0000000..5ffd2a0 --- /dev/null +++ b/cheat/internal_rewrite/color.hpp @@ -0,0 +1,278 @@ +#pragma once +#include +#include + +//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( ) = default; + + 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( R < G ? R : G ); + min = static_cast( min < B ? min : B ); + + float max = static_cast( R > G ? R : G ); + max = static_cast( 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( G - B ) / delta; + else if ( G >= max ) + out.h = 2.0f + static_cast( B - R ) / delta; + else + out.h = 4.0f + static_cast( 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( R < G ? R : G ); + min = static_cast( min < B ? min : B ); + + float max = static_cast( R > G ? R : G ); + max = static_cast( 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( G - B ) / delta; + else if ( G >= max ) + out.h = 2.0f + static_cast( B - R ) / delta; + else + out.h = 4.0f + static_cast( 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/cheat/internal_rewrite/con_alias.hpp b/cheat/internal_rewrite/con_alias.hpp new file mode 100644 index 0000000..62812f1 --- /dev/null +++ b/cheat/internal_rewrite/con_alias.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include +#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/cheat/internal_rewrite/con_fn.hpp b/cheat/internal_rewrite/con_fn.hpp new file mode 100644 index 0000000..c71cc08 --- /dev/null +++ b/cheat/internal_rewrite/con_fn.hpp @@ -0,0 +1,172 @@ +#pragma once +#include + +#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/cheat/internal_rewrite/console.cpp b/cheat/internal_rewrite/console.cpp new file mode 100644 index 0000000..d922af3 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/console.hpp b/cheat/internal_rewrite/console.hpp new file mode 100644 index 0000000..5226607 --- /dev/null +++ b/cheat/internal_rewrite/console.hpp @@ -0,0 +1,125 @@ +#pragma once +#include +#include +#include +#include + +#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/cheat/internal_rewrite/context.cpp b/cheat/internal_rewrite/context.cpp new file mode 100644 index 0000000..26af64c --- /dev/null +++ b/cheat/internal_rewrite/context.cpp @@ -0,0 +1,212 @@ +#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( ) == 1 ) { + 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; + + m_has_incremented_shots = true; + } + + m_has_fired_this_frame = true; + } + } + + auto wep = m_local->get_weapon( ); + if( wep ) { + 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; +} + +//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/cheat/internal_rewrite/context.hpp b/cheat/internal_rewrite/context.hpp new file mode 100644 index 0000000..27f1a42 --- /dev/null +++ b/cheat/internal_rewrite/context.hpp @@ -0,0 +1,85 @@ +#pragma once +#include + +#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{ }; + matrix3x4 m_matrix[ 128 ]; +}; + +//replacement to the old global:: namespace +class c_context { +public: + //run localplayer check, pointer, is valid etc + bool run_frame( ); + float pred_time( ); + + 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_revolver_shot{ }; + + bool m_drawing_postscreenspace{ }; + bool m_has_incremented_shots{ }; + bool m_drawing_screneend{ }; + float m_weapon_spread{ }; + float m_weapon_inaccuracy{ }; + + bool m_has_fired_this_frame{ }; + + float m_absyaw{ }; + 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; + std::vector< int > m_cmd_numbers; +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/cheat/internal_rewrite/create_move.cpp b/cheat/internal_rewrite/create_move.cpp new file mode 100644 index 0000000..a59930e --- /dev/null +++ b/cheat/internal_rewrite/create_move.cpp @@ -0,0 +1,137 @@ +#include + +#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 ) { + 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; + } + + 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( ) ) { + 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 ); + + // u forgot to put this back in the right place after u removed + // my epic engine prediction that set seed to the player ptr + g_cheat.m_prediction.run_command(ucmd); + g_cheat.m_movement( ucmd ); + + //SUPER SECRET EXPLOIT DO NOT LEAK + if( g_settings.misc.no_crouch_cooldown ) + ucmd->m_buttons |= IN_BULLRUSH; + + g_cheat.m_extra.auto_revolver( 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.no_recoil( ucmd ); + + 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( ) > 16 ) { + g_cheat.m_lagmgr.set_state( true ); + } + + vec3_t real_angle = g_ctx.m_thirdperson_angle; + + g_cheat.m_lagmgr.on_cmove_end( ); + g_ctx.on_cmove_end( ucmd ); + + auto cl = g_csgo.m_global_state->get_client_state( ); + if( g_cheat.m_lagmgr.get_state( ) ) { + g_ctx.m_cmd_numbers.push_back( ucmd->m_cmd_nr ); + } + else { + int choked = cl->m_netchannel->m_nChokedPackets; + //printf( "choked: %d\n", choked ); + + cl->m_netchannel->m_nChokedPackets = 0; + + send_datagram_o( cl->m_netchannel, 0, 0 ); + + cl->m_netchannel->m_nOutSequenceNr--; + cl->m_netchannel->m_nChokedPackets = choked; + } + + g_cheat.m_ragebot.m_antiaim->on_runcommand( ); + + + } + 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/cheat/internal_rewrite/csm_shadows.cpp b/cheat/internal_rewrite/csm_shadows.cpp new file mode 100644 index 0000000..b0aa5ed --- /dev/null +++ b/cheat/internal_rewrite/csm_shadows.cpp @@ -0,0 +1,10 @@ +#include "hooks.hpp" + +int __fastcall hooks::cl_csm_shadows_get_int( void* ecx_, void* edx_ ) { + static auto old_fn = g_csgo.m_csm_shadows->get_old_function< decltype( &cl_csm_shadows_get_int ) >( 13 ); + + if( g_settings.visuals.no_cascade_shadows ) + return 0; + + return old_fn( ecx_, edx_ ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/d3d.cpp b/cheat/internal_rewrite/d3d.cpp new file mode 100644 index 0000000..e807776 --- /dev/null +++ b/cheat/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, 24, 700 ); + 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/cheat/internal_rewrite/d3d.hpp b/cheat/internal_rewrite/d3d.hpp new file mode 100644 index 0000000..36babe2 --- /dev/null +++ b/cheat/internal_rewrite/d3d.hpp @@ -0,0 +1,129 @@ +#ifndef D3D_HEADER //stackoverflow my niggas +#define D3D_HEADER + +#include +#include + +#pragma comment(lib, "d3d9.lib") +#pragma comment(lib, "d3dx9.lib") +#pragma warning(disable : 4838) + +#include +#include + +#include +#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/cheat/internal_rewrite/d3d_sprite.cpp b/cheat/internal_rewrite/d3d_sprite.cpp new file mode 100644 index 0000000..8c26c37 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/d3d_sprite.hpp b/cheat/internal_rewrite/d3d_sprite.hpp new file mode 100644 index 0000000..3cf46a6 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/debug_show_spread.cpp b/cheat/internal_rewrite/debug_show_spread.cpp new file mode 100644 index 0000000..54da769 --- /dev/null +++ b/cheat/internal_rewrite/debug_show_spread.cpp @@ -0,0 +1,17 @@ +#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/cheat/internal_rewrite/detours.cpp b/cheat/internal_rewrite/detours.cpp new file mode 100644 index 0000000..a12520c --- /dev/null +++ b/cheat/internal_rewrite/detours.cpp @@ -0,0 +1,292 @@ +#include "detours.h" +#include "hde32.h" + +// very MUCH comment i APPRECIATE cool + +memory::c_detours memory::detours; + +__forceinline static bool is_code_padding( uintptr_t address, size_t size ) +{ + uint8_t* code_ptr = (uint8_t*)address; + + if ( code_ptr[0] != 0x00 && code_ptr[0] != 0x90 && code_ptr[0] != 0xCC ) + return false; + + for ( int i = 1; i < size; ++i ) + { + if ( code_ptr[i] != code_ptr[0] ) + return false; + } + + return true; +} + +bool memory::c_detours::create_trampoline( detour_hook_t* hook ) +{ + if ( !hook->allocate_trampoline( ) ) + return false; + + instructions::long_jump_t call = { + 0xE8, + 0x00000000 + }; + + instructions::long_jump_t jmp = { + 0xE9, + 0x00000000 + }; + + instructions::JCC_REL jcc = { + 0x0F, 0x80, + 0x00000000 + }; + + uint8_t old_position = 0; + uint8_t new_position = 0; + uintptr_t jmp_dest = 0; + bool finished = false; + + hook->short_patch = false; + + const int max_instruction_boundaries = 8; + int instruction_boundaries = 0; + + do + { + hde32s hs; + uint8_t copy_size; + uintptr_t copy_src; + uintptr_t old_instruction = hook->m_original + old_position; + uintptr_t new_instruction = hook->m_trampoline + new_position; + + copy_size = hde32_disasm( (void*)old_instruction, &hs ); + if ( hs.flags & F_ERROR ) + return false; + + copy_src = old_instruction; + if ( old_position >= sizeof( instructions::long_jump_t ) ) + { + // the trampoline function is long enough. + // complete the function with the jump to the target function. + + jmp.opcode = 0xE9; + jmp.operand = (uint32_t)( old_instruction - ( new_instruction + sizeof( instructions::long_jump_t ) ) ); + copy_src = uintptr_t( &jmp ); + copy_size = sizeof( jmp ); + + finished = true; + } + else if ( hs.opcode == 0xE8 ) + { + // direct relative CALL + uintptr_t dest = old_instruction + hs.len + (int32_t)hs.imm.imm32; + + call.opcode = 0xE8; + call.operand = (uint32_t)( dest - ( new_instruction + sizeof( instructions::long_jump_t ) ) ); + + copy_src = uintptr_t( &call ); + copy_size = sizeof( call ); + } + else if ( ( hs.opcode & 0xFD ) == 0xE9 ) + { + // direct relative JMP (EB or E9) + uintptr_t dest = old_instruction + hs.len; + + if ( hs.opcode == 0xEB ) // short jmp + dest += (int8_t)hs.imm.imm8; + else + dest += (int32_t)hs.imm.imm32; + + // simply copy an internal jump. + if ( hook->m_original <= dest && dest < hook->m_original + sizeof( instructions::long_jump_t ) ) + { + if ( jmp_dest < dest ) + jmp_dest = dest; + } + else + { + jmp.operand = (uint32_t)( dest - ( new_instruction + sizeof( instructions::long_jump_t ) ) ); + + copy_src = uintptr_t( &jmp ); + copy_size = sizeof( instructions::long_jump_t ); + + // exit the function if it is not in the branch + finished = ( old_instruction >= jmp_dest ); + } + } + else if ( ( hs.opcode & 0xF0 ) == 0x70 || ( hs.opcode & 0xFC ) == 0xE0 || ( hs.opcode2 & 0xF0 ) == 0x80 ) + { + // direct relative JCC + uintptr_t dest = old_instruction + hs.len; + + if ( ( hs.opcode & 0xF0 ) == 0x70 // JCC + || ( hs.opcode & 0xFC ) == 0xE0 ) // LOOPNZ/LOOPZ/LOOP/JECXZ + dest += (int8_t)hs.imm.imm8; + else + dest += (int32_t)hs.imm.imm32; + + // simply copy an internal jump. + if ( (uintptr_t)hook->m_original <= dest && dest < ( (uintptr_t)hook->m_original + sizeof( instructions::long_jump_t ) ) ) + { + if ( jmp_dest < dest ) + jmp_dest = dest; + } + else if ( ( hs.opcode & 0xFC ) == 0xE0 ) + { + // LOOPNZ/LOOPZ/LOOP/JCXZ/JECXZ to the outside are not supported. + return false; + } + else + { + uint8_t cond = ( ( hs.opcode != 0x0F ? hs.opcode : hs.opcode2 ) & 0x0F ); + + jcc.opcode1 = 0x80 | cond; + jcc.operand = (uint32_t)( dest - ( new_instruction + sizeof( jcc ) ) ); + + copy_src = uintptr_t( &jcc ); + copy_size = sizeof( jcc ); + } + } + else if ( ( hs.opcode & 0xFE ) == 0xC2 ) + { + // RET (C2 or C3) + + // complete the function if not in a branch. + finished = ( old_instruction >= jmp_dest ); + } + + // can't alter the instruction length in a branch. + if ( old_instruction < jmp_dest && copy_size != hs.len ) + return false; + + // trampoline function is too large. + if ( new_position + copy_size > MEMORY_SLOT_SIZE ) + return false; + + // trampoline function has too many instructions. + if ( instruction_boundaries >= max_instruction_boundaries ) + return false; + + instruction_boundaries++; + + memcpy( (void*)( hook->m_trampoline + new_position ), (void*)copy_src, copy_size ); + + new_position += copy_size; + old_position += hs.len; + } + while ( !finished ); + + // can we do a regular 5 byte jmp patch? + if ( old_position < sizeof( instructions::long_jump_t ) && !is_code_padding( (uintptr_t)hook->m_original + old_position, sizeof( instructions::long_jump_t ) - old_position ) ) + { + // can we put 2 byte jmp patch? + if ( old_position < sizeof( instructions::short_jump_t ) && !is_code_padding( (uintptr_t)hook->m_original + old_position, sizeof( instructions::short_jump_t ) - old_position ) ) + return false; + + // can we put a 5 byte jmp patch above it? + if ( !is_code_padding( (uintptr_t)hook->m_original - sizeof( instructions::long_jump_t ), sizeof( instructions::long_jump_t ) ) ) + return false; + + hook->short_patch = true; + } + + return true; +} + +bool memory::c_detours::set_hook( detour_hook_t* hook, bool enable ) +{ + // hook is already in place silly + if ( hook->enabled == enable ) + return true; + + if ( enable ) + { + if ( hook->short_patch ) + { + uint8_t* target = (uint8_t*)( hook->m_original - sizeof( instructions::long_jump_t ) ); + + // prepare patch + instructions::short_patch_t jmp_patch; + jmp_patch.jmp.opcode = 0xE9; + jmp_patch.jmp.operand = (uint32_t)( hook->m_custom - hook->m_original - sizeof( instructions::long_jump_t ) ); + + jmp_patch.jmp_short.opcode = 0xEB; + jmp_patch.jmp_short.operand = (uint8_t)( 0 - sizeof( instructions::short_patch_t ) ); + + // overwrite protection + DWORD original_protection; + VirtualProtect( target, sizeof( instructions::short_patch_t ), PAGE_EXECUTE_READWRITE, &original_protection ); + + // place hook + memcpy( target, &jmp_patch, sizeof( instructions::short_patch_t ) ); + + // restore protection + VirtualProtect( target, sizeof( instructions::short_patch_t ), original_protection, &original_protection ); + + // let cpu know we altered code + FlushInstructionCache( GetCurrentProcess( ), target, sizeof( instructions::short_patch_t ) ); + } + else + { + // prepare patch + instructions::long_jump_t jmp_patch; + jmp_patch.opcode = 0xE9; + jmp_patch.operand = (uint32_t)( hook->m_custom - hook->m_original - sizeof( instructions::long_jump_t ) ); + + // overwrite protection + DWORD original_protection; + VirtualProtect( (void*)hook->m_original, sizeof( instructions::long_jump_t ), PAGE_EXECUTE_READWRITE, &original_protection ); + + // place hook + memcpy( (void*)hook->m_original, &jmp_patch, sizeof( instructions::long_jump_t ) ); + + // restore protection + VirtualProtect( (void*)hook->m_original, sizeof( instructions::long_jump_t ), original_protection, &original_protection ); + + // let cpu know we altered code + FlushInstructionCache( GetCurrentProcess( ), (void*)hook->m_original, sizeof( instructions::long_jump_t ) ); + } + + + } + else + { + if ( hook->short_patch ) + { + uint8_t* target = (uint8_t*)( hook->m_original - sizeof( instructions::long_jump_t ) ); + + // overwrite protection + DWORD original_protection; + VirtualProtect( target, sizeof( instructions::short_patch_t ), PAGE_EXECUTE_READWRITE, &original_protection ); + + // restore backup + memcpy( target, hook->m_original_bytes, sizeof( instructions::short_patch_t ) ); + + // restore protection + VirtualProtect( target, sizeof( instructions::short_patch_t ), original_protection, &original_protection ); + + // let cpu know we altered code + FlushInstructionCache( GetCurrentProcess( ), target, sizeof( instructions::short_patch_t ) ); + } + else + { + uint8_t* target = (uint8_t*)hook->m_original; + + // overwrite protection + DWORD original_protection; + VirtualProtect( target, sizeof( instructions::long_jump_t ), PAGE_EXECUTE_READWRITE, &original_protection ); + + // restore backup + memcpy( target, hook->m_original_bytes, sizeof( instructions::long_jump_t ) ); + + // restore protection + VirtualProtect( target, sizeof( instructions::long_jump_t ), original_protection, &original_protection ); + + // let cpu know we altered code + FlushInstructionCache( GetCurrentProcess( ), target, sizeof( instructions::long_jump_t ) ); + } + } + + hook->enabled = enable; + return true; +} \ No newline at end of file diff --git a/cheat/internal_rewrite/detours.h b/cheat/internal_rewrite/detours.h new file mode 100644 index 0000000..d4998b5 --- /dev/null +++ b/cheat/internal_rewrite/detours.h @@ -0,0 +1,164 @@ +#pragma once +#include +#include +#include + +#define MEMORY_SLOT_SIZE 64 + +namespace memory +{ + namespace instructions + { +// we're dealing with opcodes, align by 1 byte +#pragma pack(push, 1) + struct short_jump_t + { + uint8_t opcode{ }; + uint8_t operand{ }; + }; + + struct long_jump_t + { + uint8_t opcode{ }; + uint32_t operand{ }; + }; + + struct short_patch_t + { + long_jump_t jmp{ }; + short_jump_t jmp_short{ }; + }; + + struct JCC_REL + { + uint8_t opcode0{ }; + uint8_t opcode1{ }; + uint32_t operand{ }; + }; +#pragma pack(pop) + } + + struct detour_hook_t + { + bool enabled{ }; + bool short_patch{ }; + + uintptr_t m_original{ }; + uintptr_t m_custom{ }; + uintptr_t m_trampoline{ }; + + uint8_t m_original_bytes[8]{ }; + + bool allocate_trampoline( ) + { + if ( m_trampoline ) + return false; + + m_trampoline = (uintptr_t)VirtualAlloc( nullptr, MEMORY_SLOT_SIZE, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE ); + memset( (void*)m_trampoline, 0, MEMORY_SLOT_SIZE ); + + return m_trampoline; + } + + void restore( ) + { + if ( m_trampoline ) + { + VirtualFree( (void*)m_trampoline, MEMORY_SLOT_SIZE, MEM_RELEASE ); + m_trampoline = 0; + } + } + }; + + class c_detours + { + std::vector m_hooks; + + static bool create_trampoline( detour_hook_t* hook ); + + detour_hook_t* find_hook( uintptr_t custom_func ) + { + detour_hook_t* hook = nullptr; + + for ( auto& m_hook : m_hooks ) + { + if ( m_hook.m_custom == custom_func ) + { + return &m_hook; + } + } + + return nullptr; + } + + bool set_hook( detour_hook_t* hook, bool enable ); + + bool set_hook( uintptr_t custom_func, bool enable ) + { + detour_hook_t* hook = find_hook( custom_func ); + + if ( hook ) + return set_hook( hook, enable ); + + return false; + } + + public: + + template < typename fn = uintptr_t > + fn create_hook( fn custom_func, void* original_func ) + { + detour_hook_t hook; + hook.m_original = uintptr_t( original_func ); + hook.m_custom = intptr_t( custom_func ); + + if ( create_trampoline( &hook ) ) + { + if ( hook.short_patch ) + memcpy( hook.m_original_bytes, (void*)( hook.m_original - sizeof( instructions::long_jump_t ) ), sizeof( instructions::short_patch_t ) ); + else + memcpy( hook.m_original_bytes, (void*)( hook.m_original ), sizeof( instructions::long_jump_t ) ); + +#ifdef _DEBUG + printf( " $> prepared hook [ original: 0x%08x ] [ custom: 0x%08x ] [ short jmp: %d ] \n", uintptr_t( original_func ), uintptr_t( custom_func ), hook.short_patch ); +#endif + + m_hooks.push_back( hook ); + return (fn)hook.m_trampoline; + } +#ifdef _DEBUG + printf( " $> FAILED TO HOOK [ original: 0x%08x ] [ custom: hook 0x%08x ] \n", uintptr_t( original_func ), uintptr_t( custom_func ) ); +#endif + return (fn)0; + } + + void enable( ) + { + for ( auto& hook : m_hooks ) + set_hook( &hook, true ); + } + + void restore( ) + { + for ( auto& hook : m_hooks ) + { + set_hook( &hook, false ); + hook.restore( ); + } + + m_hooks.clear( ); + } + + template < typename fn = uintptr_t > + fn original( void* custom_func ) + { + auto hook = find_hook( (uintptr_t)custom_func ); + + if ( hook ) + return (fn)hook->m_trampoline; + + return (fn)0; + } + }; extern c_detours detours; +} + diff --git a/cheat/internal_rewrite/directx.cpp b/cheat/internal_rewrite/directx.cpp new file mode 100644 index 0000000..fa40fb3 --- /dev/null +++ b/cheat/internal_rewrite/directx.cpp @@ -0,0 +1,256 @@ +#include +#include + +#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 ) { + return 0; + /*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; + +#ifdef _DEBUG + static bool transformed = false; + if( !transformed ) { + date += __DATE__; + std::transform( date.begin( ), date.end( ), date.begin( ), + [ ]( char c ) { return ::tolower( c ); } ); + + transformed = true; + } +#endif + + 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 | " ); + } + +#ifdef _DEBUG + str += date; +#else + str += g_header.username; +#endif + + 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/cheat/internal_rewrite/do_post_screen_space_effects.cpp b/cheat/internal_rewrite/do_post_screen_space_effects.cpp new file mode 100644 index 0000000..1cdd00c --- /dev/null +++ b/cheat/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 = do_post_screen_space_effects_o; + + 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/cheat/internal_rewrite/draw_model_execute.cpp b/cheat/internal_rewrite/draw_model_execute.cpp new file mode 100644 index 0000000..49825f6 --- /dev/null +++ b/cheat/internal_rewrite/draw_model_execute.cpp @@ -0,0 +1,140 @@ +#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 = draw_model_execute_o; + + 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; + + //printf( "model: %s\n", model_name ); + + 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.3f ); + 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.rage.active && ( team != local_team || g_settings.rage.friendlies ) && !player->has_valid_anim( ) ) + return; + + 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( ) ) || !g_settings.visuals.chams.enabled( ) ) { + 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( 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( 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/cheat/internal_rewrite/draw_small_entities.cpp b/cheat/internal_rewrite/draw_small_entities.cpp new file mode 100644 index 0000000..2f88c74 --- /dev/null +++ b/cheat/internal_rewrite/draw_small_entities.cpp @@ -0,0 +1,31 @@ +#include + +#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 ) { + +#ifdef HEADER_MODULE + static auto ret_addr = g_header.patterns.draw_small_entities_retaddr + 6; +#else + static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_chl.dll( ), "FF 90 ? ? ? ? FF 15 ? ? ? ? 84 C0 74 28", 6 ); +#endif + + // please shoot me + // i have given up + // i want to leave + if( _ReturnAddress( ) == (void*)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/cheat/internal_rewrite/emit_sound.cpp b/cheat/internal_rewrite/emit_sound.cpp new file mode 100644 index 0000000..13ae28a --- /dev/null +++ b/cheat/internal_rewrite/emit_sound.cpp @@ -0,0 +1,27 @@ +#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/cheat/internal_rewrite/end_lock.cpp b/cheat/internal_rewrite/end_lock.cpp new file mode 100644 index 0000000..ee81d7a --- /dev/null +++ b/cheat/internal_rewrite/end_lock.cpp @@ -0,0 +1,22 @@ +#include + +#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 + + + // 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/cheat/internal_rewrite/extra.cpp b/cheat/internal_rewrite/extra.cpp new file mode 100644 index 0000000..2408e7f --- /dev/null +++ b/cheat/internal_rewrite/extra.cpp @@ -0,0 +1,327 @@ +#include "base_cheat.hpp" +#include "context.hpp" +#include "input_system.hpp" +#include "math.hpp" +#include "hooks.hpp" +#include "interface.hpp" +#include "detours.h" +#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( 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( ) { + + } + + void c_extra::add_latency( INetChannel* channel ) { + if ( g_ctx.m_local && g_ctx.m_local->is_valid( ) ) { + + auto nci = g_csgo.m_engine( )->GetNetChannelInfo( ); + float in_latency = nci->GetLatency( 0 ); + + //arbitrary number much + float latency = 0.15f - ( in_latency + g_csgo.m_globals->m_frametime ) - TICK_INTERVAL( ); + + if( g_settings.misc.net_fakeping_active && latency > 0.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; + + static float next_time = 0.f; + + auto time = g_ctx.pred_time( ); + auto primaryattack = weapon->m_flNextPrimaryAttack( ); + auto nextattack = g_ctx.m_local->m_flNextAttack( ); + + if( primaryattack < time && nextattack < time ) { + if( next_time >= time ) { + g_ctx.m_revolver_shot = false; + cmd->m_buttons |= IN_ATTACK; + } + else { + next_time = time + 0.234375f; + g_ctx.m_revolver_shot = true; + } + } + else { + g_ctx.m_revolver_shot = false; + next_time = time + 0.234375f; + } + } + + void c_extra::no_flash( ) { + static bool once = false; + + + if( !g_ctx.run_frame( ) || !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/cheat/internal_rewrite/extra.hpp b/cheat/internal_rewrite/extra.hpp new file mode 100644 index 0000000..7f0ac98 --- /dev/null +++ b/cheat/internal_rewrite/extra.hpp @@ -0,0 +1,41 @@ +#pragma once +#include +#include + +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/cheat/internal_rewrite/factory.cpp b/cheat/internal_rewrite/factory.cpp new file mode 100644 index 0000000..0e7bc03 --- /dev/null +++ b/cheat/internal_rewrite/factory.cpp @@ -0,0 +1,110 @@ +#include "factory.hpp" +#ifndef IFACE_DLLMAIN +#include "fnv.hpp" + +#include + +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/cheat/internal_rewrite/factory.hpp b/cheat/internal_rewrite/factory.hpp new file mode 100644 index 0000000..d197951 --- /dev/null +++ b/cheat/internal_rewrite/factory.hpp @@ -0,0 +1,156 @@ +#pragma once +#include +#include +#include +#include +#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 +//#define HEADER_MODULE +#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/cheat/internal_rewrite/fire_event_clientside.cpp b/cheat/internal_rewrite/fire_event_clientside.cpp new file mode 100644 index 0000000..10233a2 --- /dev/null +++ b/cheat/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 = fire_event_clientside_o; + + 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/cheat/internal_rewrite/fnv.hpp b/cheat/internal_rewrite/fnv.hpp new file mode 100644 index 0000000..08a478b --- /dev/null +++ b/cheat/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 +#include + +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/cheat/internal_rewrite/frame_stage_notify.cpp b/cheat/internal_rewrite/frame_stage_notify.cpp new file mode 100644 index 0000000..91cd7aa --- /dev/null +++ b/cheat/internal_rewrite/frame_stage_notify.cpp @@ -0,0 +1,109 @@ +#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 ) + { + // unload from game thread + static bool unloaded = false; + if ( !unloaded) + { + g_csgo.uninitialize( ); + unloaded = true; + } + + 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/cheat/internal_rewrite/get_player_info.cpp b/cheat/internal_rewrite/get_player_info.cpp new file mode 100644 index 0000000..0cd121a --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/get_screen_size.cpp b/cheat/internal_rewrite/get_screen_size.cpp new file mode 100644 index 0000000..be7e245 --- /dev/null +++ b/cheat/internal_rewrite/get_screen_size.cpp @@ -0,0 +1,36 @@ +#include "hooks.hpp" +#include "settings.hpp" + +#include +#include "context.hpp" +#include "mem.hpp" + +void __fastcall hooks::get_screen_size( void* ecx, void* edx, int& w, int& h ) { + 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/cheat/internal_rewrite/get_viewmodel_fov.cpp b/cheat/internal_rewrite/get_viewmodel_fov.cpp new file mode 100644 index 0000000..be48dd3 --- /dev/null +++ b/cheat/internal_rewrite/get_viewmodel_fov.cpp @@ -0,0 +1,6 @@ +#include "hooks.hpp" +#include "settings.hpp" + +float __fastcall hooks::get_viewmodel_fov( void* ecx, void* edx ) { + return get_viewmodel_fov_o( ecx, nullptr ) + float( g_settings.misc.viewmodel_fov ); +} diff --git a/cheat/internal_rewrite/hde32.cpp b/cheat/internal_rewrite/hde32.cpp new file mode 100644 index 0000000..8569287 --- /dev/null +++ b/cheat/internal_rewrite/hde32.cpp @@ -0,0 +1,377 @@ +/* +* Hacker Disassembler Engine 32 C +* Copyright (c) 2008-2009, Vyacheslav Patkov. +* All rights reserved. +* +*/ + +#include +#include "hde32.h" +#include "table32.h" + +unsigned int hde32_disasm( const void *code, hde32s *hs ) +{ + uint8_t x, c, *p = (uint8_t *)code, cflags, opcode, pref = 0; + uint8_t *ht = hde32_table, m_mod, m_reg, m_rm, disp_size = 0; + + memset( (uint8_t*)hs, 0, sizeof( hde32s ) ); + + for ( x = 16; x; x-- ) + switch ( c = *p++ ) + { + case 0xf3: + hs->p_rep = c; + pref |= PRE_F3; + break; + case 0xf2: + hs->p_rep = c; + pref |= PRE_F2; + break; + case 0xf0: + hs->p_lock = c; + pref |= PRE_LOCK; + break; + case 0x26: case 0x2e: case 0x36: + case 0x3e: case 0x64: case 0x65: + hs->p_seg = c; + pref |= PRE_SEG; + break; + case 0x66: + hs->p_66 = c; + pref |= PRE_66; + break; + case 0x67: + hs->p_67 = c; + pref |= PRE_67; + break; + default: + goto pref_done; + } +pref_done: + + hs->flags = (uint32_t)pref << 23; + + if ( !pref ) + pref |= PRE_NONE; + + if ( ( hs->opcode = c ) == 0x0f ) + { + hs->opcode2 = c = *p++; + ht += DELTA_OPCODES; + } + else if ( c >= 0xa0 && c <= 0xa3 ) + { + if ( pref & PRE_67 ) + pref |= PRE_66; + else + pref &= ~PRE_66; + } + + opcode = c; + cflags = ht[ht[opcode / 4] + ( opcode % 4 )]; + + if ( cflags == C_ERROR ) + { + hs->flags |= F_ERROR | F_ERROR_OPCODE; + cflags = 0; + if ( ( opcode & -3 ) == 0x24 ) + cflags++; + } + + x = 0; + if ( cflags & C_GROUP ) + { + uint16_t t; + t = *(uint16_t *)( ht + ( cflags & 0x7f ) ); + cflags = (uint8_t)t; + x = (uint8_t)( t >> 8 ); + } + + if ( hs->opcode2 ) + { + ht = hde32_table + DELTA_PREFIXES; + if ( ht[ht[opcode / 4] + ( opcode % 4 )] & pref ) + hs->flags |= F_ERROR | F_ERROR_OPCODE; + } + + if ( cflags & C_MODRM ) + { + hs->flags |= F_MODRM; + hs->modrm = c = *p++; + hs->modrm_mod = m_mod = c >> 6; + hs->modrm_rm = m_rm = c & 7; + hs->modrm_reg = m_reg = ( c & 0x3f ) >> 3; + + if ( x && ( ( x << m_reg ) & 0x80 ) ) + hs->flags |= F_ERROR | F_ERROR_OPCODE; + + if ( !hs->opcode2 && opcode >= 0xd9 && opcode <= 0xdf ) + { + uint8_t t = opcode - 0xd9; + if ( m_mod == 3 ) + { + ht = hde32_table + DELTA_FPU_MODRM + t * 8; + t = ht[m_reg] << m_rm; + } + else + { + ht = hde32_table + DELTA_FPU_REG; + t = ht[t] << m_reg; + } + if ( t & 0x80 ) + hs->flags |= F_ERROR | F_ERROR_OPCODE; + } + + if ( pref & PRE_LOCK ) + { + if ( m_mod == 3 ) + { + hs->flags |= F_ERROR | F_ERROR_LOCK; + } + else + { + uint8_t *table_end, op = opcode; + if ( hs->opcode2 ) + { + ht = hde32_table + DELTA_OP2_LOCK_OK; + table_end = ht + DELTA_OP_ONLY_MEM - DELTA_OP2_LOCK_OK; + } + else + { + ht = hde32_table + DELTA_OP_LOCK_OK; + table_end = ht + DELTA_OP2_LOCK_OK - DELTA_OP_LOCK_OK; + op &= -2; + } + for ( ; ht != table_end; ht++ ) + if ( *ht++ == op ) + { + if ( !( ( *ht << m_reg ) & 0x80 ) ) + goto no_lock_error; + else + break; + } + hs->flags |= F_ERROR | F_ERROR_LOCK; + no_lock_error: + ; + } + } + + if ( hs->opcode2 ) + { + switch ( opcode ) + { + case 0x20: case 0x22: + m_mod = 3; + if ( m_reg > 4 || m_reg == 1 ) + goto error_operand; + else + goto no_error_operand; + case 0x21: case 0x23: + m_mod = 3; + if ( m_reg == 4 || m_reg == 5 ) + goto error_operand; + else + goto no_error_operand; + } + } + else + { + switch ( opcode ) + { + case 0x8c: + if ( m_reg > 5 ) + goto error_operand; + else + goto no_error_operand; + case 0x8e: + if ( m_reg == 1 || m_reg > 5 ) + goto error_operand; + else + goto no_error_operand; + } + } + + if ( m_mod == 3 ) + { + uint8_t *table_end; + if ( hs->opcode2 ) + { + ht = hde32_table + DELTA_OP2_ONLY_MEM; + table_end = ht + sizeof( hde32_table ) - DELTA_OP2_ONLY_MEM; + } + else + { + ht = hde32_table + DELTA_OP_ONLY_MEM; + table_end = ht + DELTA_OP2_ONLY_MEM - DELTA_OP_ONLY_MEM; + } + for ( ; ht != table_end; ht += 2 ) + if ( *ht++ == opcode ) + { + if ( *ht++ & pref && !( ( *ht << m_reg ) & 0x80 ) ) + goto error_operand; + else + break; + } + goto no_error_operand; + } + else if ( hs->opcode2 ) + { + switch ( opcode ) + { + case 0x50: case 0xd7: case 0xf7: + if ( pref & ( PRE_NONE | PRE_66 ) ) + goto error_operand; + break; + case 0xd6: + if ( pref & ( PRE_F2 | PRE_F3 ) ) + goto error_operand; + break; + case 0xc5: + goto error_operand; + } + goto no_error_operand; + } + else + goto no_error_operand; + + error_operand: + hs->flags |= F_ERROR | F_ERROR_OPERAND; + no_error_operand: + + c = *p++; + if ( m_reg <= 1 ) + { + if ( opcode == 0xf6 ) + cflags |= C_IMM8; + else if ( opcode == 0xf7 ) + cflags |= C_IMM_P66; + } + + switch ( m_mod ) + { + case 0: + if ( pref & PRE_67 ) + { + if ( m_rm == 6 ) + disp_size = 2; + } + else + if ( m_rm == 5 ) + disp_size = 4; + break; + case 1: + disp_size = 1; + break; + case 2: + disp_size = 2; + if ( !( pref & PRE_67 ) ) + disp_size <<= 1; + } + + if ( m_mod != 3 && m_rm == 4 && !( pref & PRE_67 ) ) + { + hs->flags |= F_SIB; + p++; + hs->sib = c; + hs->sib_scale = c >> 6; + hs->sib_index = ( c & 0x3f ) >> 3; + if ( ( hs->sib_base = c & 7 ) == 5 && !( m_mod & 1 ) ) + disp_size = 4; + } + + p--; + switch ( disp_size ) + { + case 1: + hs->flags |= F_DISP8; + hs->disp.disp8 = *p; + break; + case 2: + hs->flags |= F_DISP16; + hs->disp.disp16 = *(uint16_t *)p; + break; + case 4: + hs->flags |= F_DISP32; + hs->disp.disp32 = *(uint32_t *)p; + } + p += disp_size; + } + else if ( pref & PRE_LOCK ) + hs->flags |= F_ERROR | F_ERROR_LOCK; + + if ( cflags & C_IMM_P66 ) + { + if ( cflags & C_REL32 ) + { + if ( pref & PRE_66 ) + { + hs->flags |= F_IMM16 | F_RELATIVE; + hs->imm.imm16 = *(uint16_t *)p; + p += 2; + goto disasm_done; + } + goto rel32_ok; + } + if ( pref & PRE_66 ) + { + hs->flags |= F_IMM16; + hs->imm.imm16 = *(uint16_t *)p; + p += 2; + } + else + { + hs->flags |= F_IMM32; + hs->imm.imm32 = *(uint32_t *)p; + p += 4; + } + } + + if ( cflags & C_IMM16 ) + { + if ( hs->flags & F_IMM32 ) + { + hs->flags |= F_IMM16; + hs->disp.disp16 = *(uint16_t *)p; + } + else if ( hs->flags & F_IMM16 ) + { + hs->flags |= F_2IMM16; + hs->disp.disp16 = *(uint16_t *)p; + } + else + { + hs->flags |= F_IMM16; + hs->imm.imm16 = *(uint16_t *)p; + } + p += 2; + } + if ( cflags & C_IMM8 ) + { + hs->flags |= F_IMM8; + hs->imm.imm8 = *p++; + } + + if ( cflags & C_REL32 ) + { + rel32_ok: + hs->flags |= F_IMM32 | F_RELATIVE; + hs->imm.imm32 = *(uint32_t *)p; + p += 4; + } + else if ( cflags & C_REL8 ) + { + hs->flags |= F_IMM8 | F_RELATIVE; + hs->imm.imm8 = *p++; + } + +disasm_done: + + if ( ( hs->len = (uint8_t)( p - (uint8_t *)code ) ) > 15 ) + { + hs->flags |= F_ERROR | F_ERROR_LENGTH; + hs->len = 15; + } + + return (unsigned int)hs->len; +} + diff --git a/cheat/internal_rewrite/hde32.h b/cheat/internal_rewrite/hde32.h new file mode 100644 index 0000000..dd2ef6d --- /dev/null +++ b/cheat/internal_rewrite/hde32.h @@ -0,0 +1,109 @@ +/* +* Hacker Disassembler Engine 32 +* Copyright (c) 2006-2009, Vyacheslav Patkov. +* All rights reserved. +* +* hde32.h: C/C++ header file +* +*/ + +#ifndef _HDE32_H_ +#define _HDE32_H_ + +/* stdint.h - C99 standard header +* http://en.wikipedia.org/wiki/stdint.h +* +* if your compiler doesn't contain "stdint.h" header (for +* example, Microsoft Visual C++), you can download file: +* http://www.azillionmonkeys.com/qed/pstdint.h +* and change next line to: +* #include "pstdint.h" +*/ + +#include + +#define F_MODRM 0x00000001 +#define F_SIB 0x00000002 +#define F_IMM8 0x00000004 +#define F_IMM16 0x00000008 +#define F_IMM32 0x00000010 +#define F_DISP8 0x00000020 +#define F_DISP16 0x00000040 +#define F_DISP32 0x00000080 +#define F_RELATIVE 0x00000100 +#define F_2IMM16 0x00000800 +#define F_ERROR 0x00001000 +#define F_ERROR_OPCODE 0x00002000 +#define F_ERROR_LENGTH 0x00004000 +#define F_ERROR_LOCK 0x00008000 +#define F_ERROR_OPERAND 0x00010000 +#define F_PREFIX_REPNZ 0x01000000 +#define F_PREFIX_REPX 0x02000000 +#define F_PREFIX_REP 0x03000000 +#define F_PREFIX_66 0x04000000 +#define F_PREFIX_67 0x08000000 +#define F_PREFIX_LOCK 0x10000000 +#define F_PREFIX_SEG 0x20000000 +#define F_PREFIX_ANY 0x3f000000 + +#define PREFIX_SEGMENT_CS 0x2e +#define PREFIX_SEGMENT_SS 0x36 +#define PREFIX_SEGMENT_DS 0x3e +#define PREFIX_SEGMENT_ES 0x26 +#define PREFIX_SEGMENT_FS 0x64 +#define PREFIX_SEGMENT_GS 0x65 +#define PREFIX_LOCK 0xf0 +#define PREFIX_REPNZ 0xf2 +#define PREFIX_REPX 0xf3 +#define PREFIX_OPERAND_SIZE 0x66 +#define PREFIX_ADDRESS_SIZE 0x67 + +#pragma pack(push,1) + +typedef struct +{ + uint8_t len; + uint8_t p_rep; + uint8_t p_lock; + uint8_t p_seg; + uint8_t p_66; + uint8_t p_67; + uint8_t opcode; + uint8_t opcode2; + uint8_t modrm; + uint8_t modrm_mod; + uint8_t modrm_reg; + uint8_t modrm_rm; + uint8_t sib; + uint8_t sib_scale; + uint8_t sib_index; + uint8_t sib_base; + union + { + uint8_t imm8; + uint16_t imm16; + uint32_t imm32; + } imm; + union + { + uint8_t disp8; + uint16_t disp16; + uint32_t disp32; + } disp; + uint32_t flags; +} hde32s; + +#pragma pack(pop) + +#ifdef __cplusplus +extern "C" { +#endif + + /* __cdecl */ + unsigned int hde32_disasm( const void *code, hde32s *hs ); + +#ifdef __cplusplus +} +#endif + +#endif /* _HDE32_H_ */ \ No newline at end of file diff --git a/cheat/internal_rewrite/hooks.cpp b/cheat/internal_rewrite/hooks.cpp new file mode 100644 index 0000000..e786a2b --- /dev/null +++ b/cheat/internal_rewrite/hooks.cpp @@ -0,0 +1,108 @@ +#include "hooks.hpp" +#include "interface.hpp" +#include "detours.h" +#include "wipe.hpp" + +//god i'm so cool +namespace hooks { + decltype( &paint_traverse ) paint_traverse_o; + decltype( &create_move ) create_move_o; + decltype( &frame_stage_notify ) fsn_o; + decltype( &suppress_lists ) suppress_lists_o; + decltype( &draw_small_entities ) draw_small_entities_o; + decltype( &begin_lock ) begin_lock_o; + decltype( &end_lock ) end_lock_o; + decltype( &simulate ) simulate_o; + decltype( &run_command ) run_command_o; + decltype( &override_mouse_input ) override_mouse_input_o; + decltype( &draw_model_execute ) draw_model_execute_o; + decltype( &scene_end ) scene_end_o; + decltype( &get_viewmodel_fov ) get_viewmodel_fov_o; + decltype( &get_screen_size ) get_screen_size_o; + decltype( &override_view ) override_view_o; + decltype( &shut_down ) shut_down_o; + decltype( &lock_cursor ) lock_cursor_o; + decltype( &is_connected ) is_connected_o; + decltype( &in_prediction ) in_prediction_o; + decltype( &update_clientside_animation ) update_clientside_animation_o; + decltype( &material_system ) material_system_o; + decltype( &fire_event_clientside ) fire_event_clientside_o; + decltype( &send_datagram ) send_datagram_o; + decltype( &do_post_screen_space_effects ) do_post_screen_space_effects_o; + decltype( &on_screen_size_changed ) on_screen_size_changed_o; + decltype( &play_sound ) play_sound_o; + decltype( &convar_getint ) convar_getint_o; + decltype( &packet_start ) packet_start_o; +} + +hooks::c_netvar_proxy hooks::lby_proxy; +hooks::c_netvar_proxy hooks::last_shot_proxy; +hooks::c_netvar_proxy hooks::simtime_proxy; + +bool hooks::commit( factory::c_csgo* instance ) { + DELETE_START( 5 ); + + 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 ); + simtime_proxy.init( g_netvars.get_prop( fnv( "DT_BaseEntity" ), fnv( "m_flSimulationTime" ) ), &simtime_proxy_fn ); + + // god i'm thriving the d + auto* d = &memory::detours; + + 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_debug_show_spread->hook( 13, &hooks::debug_show_spread_get_int ); + instance->m_netshowfragments->hook( 13, &hooks::net_showfragments_get_int ); + instance->m_csm_shadows->hook( 13, &hooks::cl_csm_shadows_get_int ); + + paint_traverse_o = d->create_hook( &hooks::paint_traverse, instance->m_panel->get_old_function< void* >( 41 ) ); + create_move_o = d->create_hook( &hooks::create_move, instance->m_clientmode->get_old_function< void* >( 24 ) ); + override_mouse_input_o = d->create_hook( &hooks::override_mouse_input, instance->m_clientmode->get_old_function< void* >( 23 ) ); + get_viewmodel_fov_o = d->create_hook( &hooks::get_viewmodel_fov, instance->m_clientmode->get_old_function< void* >( 35 ) ); + do_post_screen_space_effects_o = d->create_hook( &hooks::do_post_screen_space_effects, instance->m_clientmode->get_old_function< void* >( 44 ) ); + override_view_o = d->create_hook( &hooks::override_view, instance->m_clientmode->get_old_function< void* >( 18 ) ); + lock_cursor_o = d->create_hook( &hooks::lock_cursor, instance->m_surface->get_old_function< void* >( 67 ) ); + run_command_o = d->create_hook( &hooks::run_command, instance->m_prediction->get_old_function< void* >( 19 ) ); + in_prediction_o = d->create_hook( &hooks::in_prediction, instance->m_prediction->get_old_function< void* >( 14 ) ); + draw_model_execute_o = d->create_hook( &hooks::draw_model_execute, instance->m_model_render->get_old_function< void* >( 21 ) ); + scene_end_o = d->create_hook( &hooks::scene_end, instance->m_render_view->get_old_function< void* >( 9 ) ); + get_screen_size_o = d->create_hook( &hooks::get_screen_size, instance->m_surface->get_old_function< void* >( 44 ) ); + + on_screen_size_changed_o = d->create_hook( &hooks::on_screen_size_changed, instance->m_surface->get_old_function< void* >( 116 ) ); + play_sound_o = d->create_hook( &hooks::play_sound, instance->m_surface->get_old_function< void* >( 82 ) ); + material_system_o = d->create_hook( &hooks::material_system, instance->m_mat_system->get_old_function< void* >( 21 ) ); + suppress_lists_o = d->create_hook( &hooks::suppress_lists, instance->m_partition->get_old_function< void* >( 16 ) ); + draw_small_entities_o = d->create_hook( &hooks::draw_small_entities, instance->m_clientleaf->get_old_function< void* >( 39 ) ); + simulate_o = d->create_hook( &hooks::simulate, instance->m_engine_vgui->get_old_function< void* >( 39 ) ); + begin_lock_o = d->create_hook( &hooks::begin_lock, instance->m_mdl_cache->get_old_function< void* >( 33 ) ); + end_lock_o = d->create_hook( &hooks::end_lock, instance->m_mdl_cache->get_old_function< void* >( 34 ) ); + + auto packet_start = pattern::first_code_match< void* >( instance->m_engine.dll( ), xors( "55 8B EC 8B 45 08 89 81 ? ? ? ? 8B 45 0C 89 81 ? ? ? ? 5D C2 08 00 ? ? ? ? ? ? ? 56" ) ); + packet_start_o = d->create_hook( &::hooks::packet_start, packet_start ); + + auto update_clientside_anim = pattern::first_code_match< void* >( instance->m_chl.dll( ), xors( "55 8B EC 51 56 8B F1 80 BE ? ? ? ? ? 74 36" ) ); + update_clientside_animation_o = d->create_hook( &hooks::update_clientside_animation, update_clientside_anim ); + + auto send_datagram = pattern::first_code_match< void* >( instance->m_engine.dll( ), xors( "55 8B EC 83 E4 F0 B8 ? ? ? ? E8 ? ? ? ? 56 57 8B F9 89 7C 24 18" ) ); + send_datagram_o = d->create_hook( &hooks::send_datagram, send_datagram ); + + d->enable( ); + + return true; + + DELETE_END( 5 ); +} diff --git a/cheat/internal_rewrite/hooks.hpp b/cheat/internal_rewrite/hooks.hpp new file mode 100644 index 0000000..ab28545 --- /dev/null +++ b/cheat/internal_rewrite/hooks.hpp @@ -0,0 +1,125 @@ +#pragma once +#include + +#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 ); + extern decltype( &paint_traverse ) paint_traverse_o; + + bool __fastcall create_move( void*, void*, float, user_cmd_t* ); + extern decltype( &create_move ) create_move_o; + + //void __fastcall hl_create_move( void*, void*, int, float, bool ); + void __fastcall frame_stage_notify( void*, void*, ClientFrameStage_t ); + extern decltype( &frame_stage_notify ) fsn_o; + + void __fastcall suppress_lists( void*, void*, int, bool ); + extern decltype( &suppress_lists ) suppress_lists_o; + + void __fastcall draw_small_entities( void*, void*, bool ); + extern decltype( &draw_small_entities ) draw_small_entities_o; + + void __fastcall begin_lock( void*, void* ); + extern decltype( &begin_lock ) begin_lock_o; + + void __fastcall end_lock( void*, void* ); + extern decltype( &end_lock ) end_lock_o; + + void __fastcall simulate( void*, void* ); + extern decltype( &simulate ) simulate_o; + + void __fastcall run_command( void*, void*, IClientEntity*, user_cmd_t*, IMoveHelper* ); + extern decltype( &run_command ) run_command_o; + + void __fastcall override_mouse_input( void*, void*, float*, float* ); + extern decltype( &override_mouse_input ) override_mouse_input_o; + + void __fastcall draw_model_execute( IVModelRender*, void*, void*, const DrawModelState_t&, const ModelRenderInfo_t&, matrix3x4* ); + extern decltype( &draw_model_execute ) draw_model_execute_o; + + void __fastcall scene_end( void*, void* ); + extern decltype( &scene_end ) scene_end_o; + + float __fastcall get_viewmodel_fov( void*, void* ); + extern decltype( &get_viewmodel_fov ) get_viewmodel_fov_o; + + void __fastcall get_screen_size( void*, void*, int&, int& ); + extern decltype( &get_screen_size ) get_screen_size_o; + + void __fastcall override_view( void* ecx_, void* edx_, CViewSetup* setup ); + extern decltype( &override_view ) override_view_o; + + //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_ ); + extern decltype( &shut_down ) shut_down_o; + + void __fastcall lock_cursor( void* ecx_, void* edx_ ); + extern decltype( &lock_cursor ) lock_cursor_o; + + bool __fastcall is_connected( void* ecx_, void* edx_ ); + extern decltype( &is_connected ) is_connected_o; + + bool __fastcall in_prediction( void* ecx_, void* edx_ ); + extern decltype( &in_prediction ) in_prediction_o; + + void __fastcall update_clientside_animation( void* ecx_, void* edx_ ); + extern decltype( &update_clientside_animation ) update_clientside_animation_o; + + bool __fastcall material_system( void* ecx_, void* edx_, IMaterialSystem_Config_t* config, bool forceupdate ); + extern decltype( &material_system ) material_system_o; + + bool __fastcall fire_event_clientside( void* ecx_, void* edx, IGameEvent* event ); + extern decltype( &fire_event_clientside ) fire_event_clientside_o; + + 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 ); + void __cdecl simtime_proxy_fn( const CRecvProxyData* proxy_data_const, void* ent, void* output ); + + int __fastcall send_datagram( INetChannel* channel, void* edx, void* datagram ); + extern decltype( &send_datagram ) send_datagram_o; + + bool __fastcall do_post_screen_space_effects( void* ecx_, void* edx_, CViewSetup* setup ); + extern decltype( &do_post_screen_space_effects ) do_post_screen_space_effects_o; + + void __fastcall on_screen_size_changed( void* ecx_, void* edx_, int old_h, int old_w ); + extern decltype( &on_screen_size_changed ) on_screen_size_changed_o; + + void __fastcall play_sound( void* ecx_, void* edx_, const char* name ); + extern decltype( &play_sound ) play_sound_o; + + void __fastcall packet_start( void* ecx, void* edx, int in_seq, int out_ack ); + extern decltype( &packet_start ) packet_start_o; + + int __fastcall cl_csm_shadows_get_int( void* ecx_, void* edx_ ); + int __fastcall debug_show_spread_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; + extern c_netvar_proxy simtime_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 ); + } + + int __fastcall convar_getint( void* ecx_, void* edx_ ); + extern decltype( &convar_getint ) convar_getint_o; + + extern bool commit( factory::c_csgo* ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/icons.hpp b/cheat/internal_rewrite/icons.hpp new file mode 100644 index 0000000..840a413 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/icons/config.hpp b/cheat/internal_rewrite/icons/config.hpp new file mode 100644 index 0000000..d488e6a --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/icons/legit.hpp b/cheat/internal_rewrite/icons/legit.hpp new file mode 100644 index 0000000..13a06f4 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/icons/misc.hpp b/cheat/internal_rewrite/icons/misc.hpp new file mode 100644 index 0000000..a955fe0 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/icons/rage.hpp b/cheat/internal_rewrite/icons/rage.hpp new file mode 100644 index 0000000..0bc349b --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/icons/visuals.hpp b/cheat/internal_rewrite/icons/visuals.hpp new file mode 100644 index 0000000..3bd8c7b --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/identity.cpp b/cheat/internal_rewrite/identity.cpp new file mode 100644 index 0000000..b58e75b --- /dev/null +++ b/cheat/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( "dmt hook " ); + 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/cheat/internal_rewrite/identity.hpp b/cheat/internal_rewrite/identity.hpp new file mode 100644 index 0000000..aecba35 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/iface_dllmain_impl.hpp b/cheat/internal_rewrite/iface_dllmain_impl.hpp new file mode 100644 index 0000000..f8209ec --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/in_prediction.cpp b/cheat/internal_rewrite/in_prediction.cpp new file mode 100644 index 0000000..3123d06 --- /dev/null +++ b/cheat/internal_rewrite/in_prediction.cpp @@ -0,0 +1,36 @@ +#include "mem.hpp" +#include "hooks.hpp" +#include "context.hpp" + +#undef max + +bool __fastcall hooks::in_prediction( void* ecx_, void* edx_ ) { +#ifdef HEADER_MODULE + static auto ret_address = g_header.patterns.in_prediction_retaddr; +#else + static auto ret_address = pattern::first_code_match( g_csgo.m_chl.dll( ), + xors( "84 C0 75 08 57 8B CE E8 ? ? ? ? 8B 06" ) ); +#endif + + 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/cheat/internal_rewrite/input_system.cpp b/cheat/internal_rewrite/input_system.cpp new file mode 100644 index 0000000..6040cca --- /dev/null +++ b/cheat/internal_rewrite/input_system.cpp @@ -0,0 +1,527 @@ +#include + +#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( 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( 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/cheat/internal_rewrite/input_system.hpp b/cheat/internal_rewrite/input_system.hpp new file mode 100644 index 0000000..338c493 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/interface.cpp b/cheat/internal_rewrite/interface.cpp new file mode 100644 index 0000000..e424c0f --- /dev/null +++ b/cheat/internal_rewrite/interface.cpp @@ -0,0 +1,271 @@ +#include + +#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" +#include "modules.hpp" +#include "wipe.hpp" + +using namespace factory; + +interfaces::c_interface_manager g_factory; +factory::c_csgo g_csgo; + +bool factory::create_interfaces( c_csgo* instance, header_t* header ) { + DELETE_START( 0 ); + + +#ifndef HEADER_MODULE + header->client_panorama = ( uintptr_t )GetModuleHandleA( "client_panorama.dll" ); + header->vguimatsurface = ( uintptr_t )GetModuleHandleA( "vguimatsurface.dll" ); + header->shaderapidx9 = ( uintptr_t )GetModuleHandleA( "shaderapidx9.dll" ); + header->vstdlib = ( uintptr_t )GetModuleHandleA( "vstdlib.dll" ); + header->steam_api = ( uintptr_t )GetModuleHandleA( "steam_api.dll" ); +#endif + + 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( (HMODULE)header->shaderapidx9, + xors( "A1 ?? ?? ?? ?? 50 8B 08 FF 51 0C" ) ) + 0x1; + +#ifdef HEADER_MODULE + auto move_helper = header->patterns.move_helper + 0x2; +#else + auto move_helper = pattern::first_code_match( g_csgo.m_chl.dll( ), + xors( "8B 0D ?? ?? ?? ?? 8B 46 08 68" ) ) + 0x2; +#endif + +#ifdef HEADER_MODULE + auto beam_ptr = header->patterns.beam_ptr + 0x1; +#else + auto beam_ptr = pattern::first_code_match( g_csgo.m_chl.dll( ), xors( "B9 ? ? ? ? A1 ? ? ? ? FF 10 A1 ? ? ? ? B9" ), 0x1 ); +#endif + + 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( ( HMODULE )header->steam_api, xors( "SteamAPI_GetHSteamPipe" ) ) )( ); + instance->m_steam_user_handle = ( ( SteamUserHandle( __cdecl* )( ) )GetProcAddress( ( HMODULE )header->steam_api, xors( "SteamAPI_GetHSteamUser" ) ) )( ); + + uintptr_t steam_client_ptr = ( ( uintptr_t ( __cdecl* )( void ) )GetProcAddress( ( HMODULE )header->steam_api, 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( + ( HMODULE )header->vstdlib, + xors( "KeyValuesSystem" ) ) ); + + instance->m_keyvalues = ( IKeyValuesSystem* )kv_fn( ); + + 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 ); + + uintptr_t cl_csm_shadows = ( uintptr_t )( instance->m_cvar( )->FindVar( xors( "cl_csm_shadows" ) ) ); + instance->create( &instance->m_csm_shadows, cl_csm_shadows ); + + 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( ); + + DELETE_END( 0 ); + 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( ) { + DELETE_START( 0 ) + + m_panic = false; + + g_con->create( ); + auto now = std::chrono::high_resolution_clock::now( ); + g_con->print( xors( "hello\n" ) ); + + factory::create_interfaces( &g_csgo, &g_header ); + + 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( ) ); + + // open the menu so people actually know when the cheat loaded + g_settings.menu.open = true; + + DELETE_END( 0 ); +} + +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/cheat/internal_rewrite/interface.hpp b/cheat/internal_rewrite/interface.hpp new file mode 100644 index 0000000..332971a --- /dev/null +++ b/cheat/internal_rewrite/interface.hpp @@ -0,0 +1,185 @@ +#pragma once +#include + +#include "factory.hpp" +#include "sdk.hpp" +#include "listener.hpp" +#include "modules.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< IVEngineSound > 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< cvar_t > m_csm_shadows; + 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; + 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, header_t* ); + +END_REGION + +extern factory::c_csgo g_csgo; \ No newline at end of file diff --git a/cheat/internal_rewrite/internal_rewrite.vcxproj b/cheat/internal_rewrite/internal_rewrite.vcxproj new file mode 100644 index 0000000..a531095 --- /dev/null +++ b/cheat/internal_rewrite/internal_rewrite.vcxproj @@ -0,0 +1,572 @@ + + + + + Debug + Win32 + + + Online + Win32 + + + Online + x64 + + + optimize_test + Win32 + + + optimize_test + x64 + + + pHit + Win32 + + + pHit + x64 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 15.0 + {140DEC51-B0E7-4289-BB6F-79686422318E} + internal_rewrite + 10.0.17763.0 + csgo + + + + DynamicLibrary + true + v141 + MultiByte + + + DynamicLibrary + true + v141 + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + false + + + DynamicLibrary + true + v141 + MultiByte + + + DynamicLibrary + true + v141 + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + + + DynamicLibrary + false + v141 + true + MultiByte + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(ProjectDir)\protobuf_src;C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + $(SolutionDir)\bin + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + $(SolutionDir)\bin + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + $(SolutionDir)\online + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + $(SolutionDir)\pHit + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + $(SolutionDir)\bin + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + + + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) + C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) + + + + Level2 + Disabled + true + /std:c++latest /Zc:threadSafeInit- %(AdditionalOptions) + _DEBUG;_WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS;_SCL_SECURE_NO_WARNINGS + true + false + EnableFastChecks + NotUsing + precompiled.hpp + + + false + /FAs %(AdditionalOptions) + DebugFastLink + false + false + + + + + Level2 + Full + true + /std:c++latest /Zc:threadSafeInit- %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG;_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS + true + false + Default + AnySuitable + true + StreamingSIMDExtensions2 + Fast + true + MultiThreadedDLL + _DEBUG + NotUsing + precompiled.hpp + + + false + /FAs %(AdditionalOptions) + DebugFastLink + false + false + + + + + Level3 + Disabled + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG + + + + + Level3 + Disabled + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;_DEBUG + + + + + Level3 + Full + true + true + true + /std:c++latest /Zc:threadSafeInit- %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + true + StreamingSIMDExtensions2 + Precise + CompileAsCpp + false + AnySuitable + Neither + NotUsing + precompiled.hpp + + + true + true + + + + + Level3 + MaxSpeed + true + true + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + NotUsing + precompiled.hpp + false + true + + + true + true + false + + + + + Level3 + MaxSpeed + false + true + false + /std:c++latest /Zc:threadSafeInit- %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + NotUsing + precompiled.hpp + true + false + false + false + false + false + StreamingSIMDExtensions2 + false + false + false + stdcpplatest + None + MultiThreadedDLL + + + true + true + true + + + + + Level3 + MaxSpeed + true + true + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + + + true + true + + + + + Level3 + MaxSpeed + true + true + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + + + true + true + + + + + Level3 + MaxSpeed + true + true + true + /std:c++latest %(AdditionalOptions) + _WINDLL;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS + + + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/cheat/internal_rewrite/internal_rewrite.vcxproj.filters b/cheat/internal_rewrite/internal_rewrite.vcxproj.filters new file mode 100644 index 0000000..a871845 --- /dev/null +++ b/cheat/internal_rewrite/internal_rewrite.vcxproj.filters @@ -0,0 +1,571 @@ + + + + + {111ce6db-2b60-4a90-b3a8-f418abb6e441} + + + {46408dc1-0b1f-43a7-b32d-4b3f1a4e3393} + + + {e3e56c63-e162-43dc-af43-e40c4b463299} + + + {037f8374-e510-46a1-b5e3-f418537a7e61} + + + {c1fd811f-a868-4a60-9bf4-1c81c22c61ce} + + + {de79d40e-dbca-46ba-ac40-4adcd316d638} + + + {5b0550fa-f13e-4b35-83a2-2b8ae64dc7ee} + + + {1e1c2f2b-1cb9-4040-8a0f-f03ecfb56522} + + + {3a5a53ed-6526-48c1-ade4-05eaefe13c86} + + + {8bc3e769-d369-4e50-ad7d-20b9c4d6680b} + + + {37890891-fcc3-4432-9cdf-e586bded2aa1} + + + + + + factory + + + context + + + hooks + + + hooks + + + utility + + + factory + + + factory + + + hooks + + + utility + + + utility + + + hooks + + + context + + + hooks + + + features + + + hooks + + + features + + + features + + + hooks + + + features + + + sdk + + + sdk + + + features + + + sdk + + + hooks + + + hooks + + + utility + + + features + + + features + + + features + + + features + + + hooks + + + hooks + + + features + + + features + + + features + + + features + + + hooks + + + hooks + + + features + + + hooks + + + hooks\hookers + + + features + + + features + + + features + + + features + + + utility + + + hooks + + + utility + + + features + + + hooks + + + hooks + + + hooks + + + utility + + + hooks + + + hooks + + + hooks + + + features + + + hooks + + + hooks + + + sdk\valve + + + features + + + ui + + + ui + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks + + + hooks\hookers + + + hooks\hookers + + + hooks + + + hooks + + + + + factory + + + factory + + + sdk + + + sdk + + + utility + + + utility + + + context + + + sdk + + + sdk + + + features + + + utility + + + hooks + + + sdk + + + sdk + + + utility + + + sdk + + + utility + + + sdk + + + sdk + + + sdk + + + sdk + + + factory + + + sdk + + + sdk\valve + + + sdk\valve + + + sdk + + + utility + + + ui + + + utility + + + ui + + + ui + + + ui + + + ui + + + ui + + + ui + + + context + + + context + + + protection + + + protection + + + sdk + + + features + + + hooks\hookers + + + hooks\hookers + + + features + + + ui + + + ui + + + ui + + + ui + + + ui + + + ui + + + ui + + + features + + + sdk + + + sdk + + + sdk + + + sdk + + + sdk + + + features + + + features + + + sdk + + + sdk + + + ui + + + utility + + + features + + + features + + + sdk + + + sdk + + + features + + + features + + + sdk + + + features + + + sdk + + + sdk + + + hooks\hookers + + + features + + + ui + + + features + + + utility + + + resource + + + resource + + + resource + + + resource + + + resource + + + resource + + + utility + + + utility + + + utility + + + sdk + + + features + + + factory + + + sdk + + + sdk\valve + + + ui + + + sdk + + + hooks\hookers + + + hooks\hookers + + + hooks\hookers + + + factory + + + utility + + + \ No newline at end of file diff --git a/cheat/internal_rewrite/is_connected.cpp b/cheat/internal_rewrite/is_connected.cpp new file mode 100644 index 0000000..159d036 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/lag_mgr.cpp b/cheat/internal_rewrite/lag_mgr.cpp new file mode 100644 index 0000000..0233e4a --- /dev/null +++ b/cheat/internal_rewrite/lag_mgr.cpp @@ -0,0 +1,219 @@ +#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( float dist ) { + 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 ); + + //fuck getting pulled back on peek + position += velocity_dir * 20.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_cheat.m_ragebot.m_antiaim->is_fakewalking( ) ) { + return; + } + + bool moving = g_ctx.m_local->m_vecVelocity( ).length2d( ) > 0.f; + + 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; + + static bool changed = false; + static auto cl_sendmove = pattern::first_code_match( g_csgo.m_engine.dll( ), xors( "55 8B EC A1 ? ? ? ? 81 EC ? ? ? ? B9 ? ? ? ? 53 8B 98" ), 0 ); + + if( !changed ) { + ulong_t old; + VirtualProtect( ( void* )( cl_sendmove + 0xbd ), 1, PAGE_EXECUTE_READWRITE, &old ); + *( uint8_t* )( cl_sendmove + 0xbd ) = 50; + VirtualProtect( ( void* )( cl_sendmove + 0xbd ), 1, old, nullptr ); + } + + changed = true; + + max_ticks = math::min( max_ticks, 16 ); + + 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 = true; + static bool was_onground{ }; + + if( settings.in_move && ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) && moving ) { + send = false; + } + + if( settings.on_peek && moving ) { + static int choke_ticks = 0; + + bool peeking = predict_position( 20.f + g_ctx.m_local->m_vecVelocity( ) * TICK_INTERVAL( ) * 2.f ); + bool predicted = predict_position( 20.f ); + + if( !peeking && predicted ) { + choke_ticks = 0; + send = true; + } + else 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 ) { + static int choked = 0; + + if( !was_onground && ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + choked = settings.ticks; + } + + if( choked ) + send = !--choked; + } + + if( settings.jump_reset ) { + if( settings.avoid_ground ) { + if( was_onground && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + send = get_choked( ) > 0; + } + } + else { + if( !was_onground && ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + send = get_choked( ) > 0; + } + } + } + + was_onground = ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ); + + if( settings.on_duck && ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + float amt = g_ctx.m_local->m_flDuckAmount( ); + if( m_cmd->m_buttons & IN_DUCK ) { + if( amt < 1.0f ) + send = false; + } else if( amt > 0.f ) + send = false; + } + + static int wep_choke = 0; + if( wep_choke ) + send = !--wep_choke; + + if( m_cmd->m_weaponselect && settings.on_select ) { + wep_choke = max_ticks; + } + + 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 = get_choked( ) > 0; + } + } + + *m_sendpacket = ( send || force_send ) && !get_sent( ); + if( *m_sendpacket ) { + m_breaking_lc = delta.length2d( ) > 64.f; + last_rand = ( 1.f + math::random_number( -settings.fluctuate, settings.fluctuate( ) ) * 0.01f ); + } + } + + void c_lagmgr::on_cmove_end( ) { + if( !m_sendpacket ) return; + + if( *m_sendpacket ) { + ++m_sent_ticks; + m_held_ticks = 0; + m_has_fired = false; + } + else { + ++m_held_ticks; + m_sent_ticks = 0; + + if( ( m_cmd->m_buttons & IN_ATTACK ) && g_ctx.m_local->can_attack( ) ) { + m_has_fired = true; + } + } + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/lag_mgr.hpp b/cheat/internal_rewrite/lag_mgr.hpp new file mode 100644 index 0000000..d495210 --- /dev/null +++ b/cheat/internal_rewrite/lag_mgr.hpp @@ -0,0 +1,65 @@ +#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( ); + + void set_state( bool state ) { + *m_sendpacket = state; + } + + int get_choked( ) const { + return m_held_ticks; + } + + bool has_fired( ) const { + return m_has_fired; + } + + 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( float dist ); + void fakelag( ); + + user_cmd_t* m_cmd{ }; + byte* m_sendpacket{ }; + int m_sent_ticks{ }; + int m_held_ticks{ }; + bool m_breaking_lc{ }; + bool m_has_fired{ }; + }; +} \ No newline at end of file diff --git a/cheat/internal_rewrite/legitbot.cpp b/cheat/internal_rewrite/legitbot.cpp new file mode 100644 index 0000000..c3c0010 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/legitbot.hpp b/cheat/internal_rewrite/legitbot.hpp new file mode 100644 index 0000000..f543fd4 --- /dev/null +++ b/cheat/internal_rewrite/legitbot.hpp @@ -0,0 +1,75 @@ +#pragma once +#include +#include + +#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/cheat/internal_rewrite/legitbot_lagcomp.cpp b/cheat/internal_rewrite/legitbot_lagcomp.cpp new file mode 100644 index 0000000..c80bcbd --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/level_init_pre_entity.cpp b/cheat/internal_rewrite/level_init_pre_entity.cpp new file mode 100644 index 0000000..c4d8c38 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/listener.cpp b/cheat/internal_rewrite/listener.cpp new file mode 100644 index 0000000..eb5caf4 --- /dev/null +++ b/cheat/internal_rewrite/listener.cpp @@ -0,0 +1,239 @@ +#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 ) { + g_cheat.m_visuals.store_hit( &shot ); + //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/cheat/internal_rewrite/listener.hpp b/cheat/internal_rewrite/listener.hpp new file mode 100644 index 0000000..5e18879 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/lock_cursor.cpp b/cheat/internal_rewrite/lock_cursor.cpp new file mode 100644 index 0000000..6edb52a --- /dev/null +++ b/cheat/internal_rewrite/lock_cursor.cpp @@ -0,0 +1,10 @@ +#include "hooks.hpp" + +void __fastcall hooks::lock_cursor( void* ecx_, void* edx_ ) { + 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/cheat/internal_rewrite/match_framework.h b/cheat/internal_rewrite/match_framework.h new file mode 100644 index 0000000..f63efb1 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/materialsystem_config.cpp b/cheat/internal_rewrite/materialsystem_config.cpp new file mode 100644 index 0000000..102d09b --- /dev/null +++ b/cheat/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 = material_system_o; + + config->m_fullbright = g_settings.visuals.fullbright( ); + + return original_fn( ecx, edx, config, forceupdate ); +} diff --git a/cheat/internal_rewrite/math.cpp b/cheat/internal_rewrite/math.cpp new file mode 100644 index 0000000..79389a9 --- /dev/null +++ b/cheat/internal_rewrite/math.cpp @@ -0,0 +1,301 @@ +#include +#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/cheat/internal_rewrite/math.hpp b/cheat/internal_rewrite/math.hpp new file mode 100644 index 0000000..b965600 --- /dev/null +++ b/cheat/internal_rewrite/math.hpp @@ -0,0 +1,164 @@ +#pragma once +#include +#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/cheat/internal_rewrite/mem.hpp b/cheat/internal_rewrite/mem.hpp new file mode 100644 index 0000000..37db3ad --- /dev/null +++ b/cheat/internal_rewrite/mem.hpp @@ -0,0 +1,66 @@ +#pragma once +#include +#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/cheat/internal_rewrite/modules.hpp b/cheat/internal_rewrite/modules.hpp new file mode 100644 index 0000000..6e78bf3 --- /dev/null +++ b/cheat/internal_rewrite/modules.hpp @@ -0,0 +1,35 @@ +#pragma once +#include + +struct patterns_t +{ + uint32_t beam_ptr; // B9 ? ? ? ? A1 ? ? ? ? FF 10 A1 ? ? ? ? B9 + uint32_t move_helper; // 8B 0D ? ? ? ? 8B 46 08 68 + uint32_t calc_abs_velocity; // 55 8B EC 83 E4 F8 83 EC 1C 53 56 57 8B F9 F7 87 + uint32_t animstate_update; // 55 8B EC 83 E4 F8 83 EC 18 56 57 8B F9 F3 0F 11 54 24 + uint32_t draw_small_entities_retaddr; // FF 90 ? ? ? ? FF 15 ? ? ? ? 84 C0 74 28 + uint32_t is_breakable_ptr; // 55 8B EC 51 56 8B F1 85 F6 74 68 83 BE + uint32_t set_abs_angles; // 55 8B EC 83 E4 F8 83 EC 64 53 56 57 8B F1 E8 + uint32_t set_abs_origin; // 55 8B EC 83 E4 F8 51 53 56 57 8B F1 + uint32_t glow_manager; // 0F 11 05 00 00 00 00 83 C8 01 + uint32_t smoke_count; // 55 8B EC 83 EC 08 8B 15 ? ? ? ? 0F 57 C0 + uint32_t in_prediction_retaddr; // 84 C0 75 08 57 8B CE E8 ? ? ? ? 8B 06 + uint32_t net_update_retaddr; // 5F 5E 5D C2 04 00 83 3D ? ? ? ? ? +}; + + +struct header_t { + uint8_t xor_key{ }; + + char username[ 32 ]{ }; + + uintptr_t client_panorama{ }; + uintptr_t vguimatsurface{ }; + uintptr_t shaderapidx9{ }; + uintptr_t vstdlib{ }; + uintptr_t steam_api{ }; + + patterns_t patterns{ }; +}; + +extern header_t g_header; \ No newline at end of file diff --git a/cheat/internal_rewrite/movement.cpp b/cheat/internal_rewrite/movement.cpp new file mode 100644 index 0000000..3793e1b --- /dev/null +++ b/cheat/internal_rewrite/movement.cpp @@ -0,0 +1,345 @@ +#include "movement.hpp" +#include "interface.hpp" +#include "settings.hpp" +#include "context.hpp" + +#include +#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 ); + + return RAD2DEG( std::asinf( 30.f / speed ) ) * 0.5f; +} + +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( ); + + bool use_original = !g_settings.rage.enabled && !g_settings.rage.anti_aim; + + auto cmd = use_original ? m_ucmd : 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 ) { + float ideal_rotation = std::min( RAD2DEG( std::asinf( 30.f / std::max( speed, FLT_EPSILON ) ) ) * 0.5f, 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, ideal_rotation ); + } + else { + cmd->m_sidemove = m_ucmd->m_mousedx < 0.f ? -450.f : 450.f; + } + } + else if( g_settings.misc.auto_strafe == 2 ) { + if( !cmd->m_mousedx ) { + float ideal_rotation = std::min( RAD2DEG( std::asinf( 30.f / std::max( speed, FLT_EPSILON ) ) ) * 0.5f, 45.f ); + + float move_yaw = math::vector_angles( vec3_t( ), vec3_t( cmd->m_forwardmove, cmd->m_sidemove, 0.f ) ).y; + float vel_yaw = math::vector_angles( vec3_t( ), velocity ).y; + + float velocity_delta = std::remainderf( g_csgo.m_engine( )->GetViewAngles( ).y - vel_yaw, 360.f ); + + float move_delta = std::remainderf( move_yaw - velocity_delta, 360.f ); + float ideal_yaw = math::approach_angle( move_yaw, velocity_delta, ideal_rotation ); + + float delta_yaw = std::remainderf( move_yaw - ideal_yaw, 360.f ); + + if( std::abs( delta_yaw ) > ideal_rotation ) + ideal_rotation = 0.f; + else 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_yaw + ideal_rotation, 360.f ) ); + } + else { + float move_yaw = math::vector_angles( vec3_t( ), vec3_t( cmd->m_forwardmove, cmd->m_sidemove, 0.f ) ).y; + + float rotation = cmd->m_mousedx < 0.f ? -90.f : 90.f; + + cmd->m_forwardmove = 450.f; + cmd->m_sidemove = 0.f; + + rotate_movement( cmd, move_yaw + rotation ); + } + } + } +} + + +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/cheat/internal_rewrite/movement.hpp b/cheat/internal_rewrite/movement.hpp new file mode 100644 index 0000000..0c0b1a6 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/movement_recorder.cpp b/cheat/internal_rewrite/movement_recorder.cpp new file mode 100644 index 0000000..6e9245c --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/movement_recorder.hpp b/cheat/internal_rewrite/movement_recorder.hpp new file mode 100644 index 0000000..03bcf8c --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/net_showfragments.cpp b/cheat/internal_rewrite/net_showfragments.cpp new file mode 100644 index 0000000..93e5db0 --- /dev/null +++ b/cheat/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 && ( 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/cheat/internal_rewrite/netvar_proxy.hpp b/cheat/internal_rewrite/netvar_proxy.hpp new file mode 100644 index 0000000..113f212 --- /dev/null +++ b/cheat/internal_rewrite/netvar_proxy.hpp @@ -0,0 +1,36 @@ +#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: + RecvProp* m_target; + RecvVarProxyFn m_original; + }; +} \ No newline at end of file diff --git a/cheat/internal_rewrite/netvars.cpp b/cheat/internal_rewrite/netvars.cpp new file mode 100644 index 0000000..eb2d8fd --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/netvars.hpp b/cheat/internal_rewrite/netvars.hpp new file mode 100644 index 0000000..ca50ed9 --- /dev/null +++ b/cheat/internal_rewrite/netvars.hpp @@ -0,0 +1,44 @@ +#pragma once +#include + +#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/cheat/internal_rewrite/on_screen_size_changed.cpp b/cheat/internal_rewrite/on_screen_size_changed.cpp new file mode 100644 index 0000000..731835e --- /dev/null +++ b/cheat/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 = on_screen_size_changed_o; + + old_fn( ecx_, nullptr, old_w, old_h ); + + g_fonts.initialize( ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/override_mouse_input.cpp b/cheat/internal_rewrite/override_mouse_input.cpp new file mode 100644 index 0000000..84e3f57 --- /dev/null +++ b/cheat/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 = override_mouse_input_o; + 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/cheat/internal_rewrite/override_view.cpp b/cheat/internal_rewrite/override_view.cpp new file mode 100644 index 0000000..579f83f --- /dev/null +++ b/cheat/internal_rewrite/override_view.cpp @@ -0,0 +1,35 @@ +#include "base_cheat.hpp" +#include "context.hpp" +#include "hooks.hpp" +#include "settings.hpp" +void __fastcall hooks::override_view( void* ecx_, void* edx_, CViewSetup* setup ) { + if( g_csgo.m_panic ) { + return override_view_o( ecx_, nullptr, setup ); + } + + float fov = setup->m_flFov; + if ( g_ctx.run_frame( ) && g_ctx.m_local->is_valid( ) ) { + if( g_settings.misc.no_zoom ) + setup->m_flFov = g_settings.misc.fov_changer( ); + else + setup->m_flFov = g_settings.misc.fov_changer( ) * ( fov / 90.f ); + } + + g_ctx.m_fov = setup->m_flFov; + + g_cheat.m_extra.thirdperson( ); + + if( g_settings.misc.no_scope && g_ctx.run_frame( ) && g_ctx.m_local->is_valid( ) && g_ctx.m_local->m_bIsScoped( ) ) { + int backup = setup->m_iEdgeBlur; + + setup->m_iEdgeBlur = 0; + + override_view_o( ecx_, edx_, setup ); + + setup->m_iEdgeBlur = backup; + + return; + } + + override_view_o( ecx_, nullptr, setup ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/packet_start.cpp b/cheat/internal_rewrite/packet_start.cpp new file mode 100644 index 0000000..a5c9db4 --- /dev/null +++ b/cheat/internal_rewrite/packet_start.cpp @@ -0,0 +1,26 @@ +#include "hooks.hpp" +#include "context.hpp" + +void __fastcall hooks::packet_start( void* ecx, void* edx, int in_seq, int out_ack ) { + if( !g_ctx.run_frame( ) || !g_ctx.m_local->is_valid( ) ) { + *( int* )( uintptr_t( ecx ) + 0x114 ) = in_seq; + *( int* )( uintptr_t( ecx ) + 0x4cb4 ) = out_ack; + } + + // okay now this is epic + //printf("%08x -> %08x\n", &hooks::packet_start, hooks::packet_start_o); + + for( auto cmd_number = g_ctx.m_cmd_numbers.begin( ); cmd_number != g_ctx.m_cmd_numbers.end( ); ) { + if( *cmd_number == out_ack ) { + auto cl = ( uintptr_t )( ecx ); + + *( int* )( cl + 0x114 ) = in_seq; + *( int* )( cl + 0x4cb4 ) = out_ack; + + g_ctx.m_cmd_numbers.erase( cmd_number ); + return; + } + + cmd_number++; + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/paint_traverse.cpp b/cheat/internal_rewrite/paint_traverse.cpp new file mode 100644 index 0000000..8376cdd --- /dev/null +++ b/cheat/internal_rewrite/paint_traverse.cpp @@ -0,0 +1,65 @@ +#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 ) { + if( g_csgo.m_panic ) return paint_traverse_o( ecx_, 0, panel, force_repaint, allowforce ); + if( ecx_ != g_csgo.m_panel.get( ) ) + 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 ) ); + //g_renderer.draw_string( g_fonts.f_12, 100, 200, clr_t( 255, 255, 255, 255 ), "c: %d", g_csgo.m_global_state->get_client_state( )->m_chokedcommands ); + 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/cheat/internal_rewrite/pattern.hpp b/cheat/internal_rewrite/pattern.hpp new file mode 100644 index 0000000..8b4e17e --- /dev/null +++ b/cheat/internal_rewrite/pattern.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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/cheat/internal_rewrite/play_sound.cpp b/cheat/internal_rewrite/play_sound.cpp new file mode 100644 index 0000000..542be24 --- /dev/null +++ b/cheat/internal_rewrite/play_sound.cpp @@ -0,0 +1,31 @@ +#include "hooks.hpp" +#include "base_cheat.hpp" +void __fastcall hooks::play_sound( void* ecx_, void*, const char* file ) { +#ifdef HEADER_MODULE + // static auto is_ready = g_header.patterns.is_ready; + 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 ); +#else + 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 ); +#endif + 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/cheat/internal_rewrite/player_manager.cpp b/cheat/internal_rewrite/player_manager.cpp new file mode 100644 index 0000000..f76b363 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/player_manager.hpp b/cheat/internal_rewrite/player_manager.hpp new file mode 100644 index 0000000..440ddf3 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/prediction.cpp b/cheat/internal_rewrite/prediction.cpp new file mode 100644 index 0000000..2f6f606 --- /dev/null +++ b/cheat/internal_rewrite/prediction.cpp @@ -0,0 +1,627 @@ +#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 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; + + int backup_buttons = ucmd->m_buttons; + float backup_forwardmove = ucmd->m_forwardmove; + float backup_sidemove = ucmd->m_sidemove; + + ucmd->m_forwardmove = ucmd->m_sidemove = 0.f; + ucmd->m_buttons &= ~( IN_BACK | IN_FORWARD | IN_MOVELEFT | IN_MOVERIGHT ); + + 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; + + ucmd->m_forwardmove = backup_forwardmove; + ucmd->m_sidemove = backup_sidemove; + ucmd->m_buttons = backup_buttons; + + auto wep = g_ctx.m_local->get_weapon( ); + + if( wep ) { + wep->update_accuracy_penalty( ); + g_ctx.m_weapon_inaccuracy = wep->get_inaccuracy( ); + g_ctx.m_weapon_spread = wep->get_spread( ); + } + else { + g_ctx.m_weapon_inaccuracy = g_ctx.m_weapon_spread = 0.f; + } +} + +END_REGION diff --git a/cheat/internal_rewrite/prediction.hpp b/cheat/internal_rewrite/prediction.hpp new file mode 100644 index 0000000..d6adb44 --- /dev/null +++ b/cheat/internal_rewrite/prediction.hpp @@ -0,0 +1,95 @@ +#pragma once +#include "vector.hpp" +#include "util.hpp" + +#include +#include + +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 run_command( user_cmd_t *cmd ); + + 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/cheat/internal_rewrite/proxies.cpp b/cheat/internal_rewrite/proxies.cpp new file mode 100644 index 0000000..287970b --- /dev/null +++ b/cheat/internal_rewrite/proxies.cpp @@ -0,0 +1,116 @@ +#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 == anim_time && 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; + } + } + } + } +} + +void __cdecl hooks::simtime_proxy_fn( const CRecvProxyData* proxy_data_const, void* entity, void* output ) { + auto old_fn = simtime_proxy.get_old_function( ); + + auto ent = ( c_base_player* )( entity ); + if( ent && ent->is_valid( ) && ent->has_valid_anim( ) && ( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) || g_settings.rage.friendlies( ) ) && ent != g_ctx.m_local ) { + if( !proxy_data_const->m_Value.m_Int ) { + return; + } + } + + old_fn( proxy_data_const, entity, output ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/ragebot.cpp b/cheat/internal_rewrite/ragebot.cpp new file mode 100644 index 0000000..4a85078 --- /dev/null +++ b/cheat/internal_rewrite/ragebot.cpp @@ -0,0 +1,1142 @@ +#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 { + if( !g_settings.rage.multipoint_enable ) + return false; + + auto& setting = g_settings.rage.multipoint; + + switch( hitbox ) { + case HITBOX_HEAD: + return setting.head; + case HITBOX_PELVIS: + case HITBOX_BODY: + return setting.stomach; + //case HITBOX_CHEST: + case HITBOX_UPPER_CHEST: + case HITBOX_THORAX: + return setting.chest; + case HITBOX_RIGHT_THIGH: + case HITBOX_LEFT_THIGH: + if( moving && g_settings.rage.ignore_limbs_moving ) + return false; + + if( g_settings.rage.preserve_fps && util::is_low_fps( ) ) + return false; + + return setting.thighs; + + 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 setting.calves; + 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; + + static int point_index[ 65 ][ HITBOX_MAX ]; + + std::vector< vec3_t > points; + + if( g_settings.rage.multipoint_enable( ) == 1 || + hitbox == HITBOX_LEFT_CALF || hitbox == HITBOX_RIGHT_CALF || + hitbox == HITBOX_LEFT_THIGH || hitbox == HITBOX_RIGHT_THIGH ) { + points.push_back( vec3_t{ min.x, min.y, center.z } ); + points.push_back( vec3_t{ max.x, min.y, center.z } ); + points.push_back( vec3_t{ min.x, max.y, center.z } ); + points.push_back( vec3_t{ max.x, max.y, center.z } ); + } + else if( g_settings.rage.multipoint_enable( ) == 2 ) { + points.push_back( vec3_t{ max.x, max.y, max.z } ); + points.push_back( vec3_t{ min.x, max.y, max.z } ); + points.push_back( vec3_t{ max.x, min.y, max.z } ); + points.push_back( vec3_t{ min.x, min.y, max.z } ); + + points.push_back( vec3_t{ max.x, max.y, min.z } ); + points.push_back( vec3_t{ min.x, max.y, min.z } ); + points.push_back( vec3_t{ max.x, min.y, min.z } ); + points.push_back( vec3_t{ min.x, min.y, min.z } ); + } + else if( g_settings.rage.multipoint_enable( ) == 3 ) { + points.push_back( vec3_t{ min.x, min.y, center.z } ); + points.push_back( vec3_t{ max.x, min.y, center.z } ); + points.push_back( vec3_t{ min.x, max.y, center.z } ); + points.push_back( vec3_t{ max.x, max.y, center.z } ); + + points.push_back( vec3_t{ max.x, max.y, max.z } ); + points.push_back( vec3_t{ min.x, max.y, max.z } ); + points.push_back( vec3_t{ max.x, min.y, max.z } ); + points.push_back( vec3_t{ min.x, min.y, max.z } ); + + points.push_back( vec3_t{ max.x, max.y, min.z } ); + points.push_back( vec3_t{ min.x, max.y, min.z } ); + points.push_back( vec3_t{ max.x, min.y, min.z } ); + points.push_back( vec3_t{ min.x, min.y, min.z } ); + } + + float min_dmg = get_min_dmg( ent ); + auto& point_idx = point_index[ ent->ce( )->GetIndex( ) ][ hitbox ]; + + float percentage = g_settings.rage.multipoint_scale( ) * 0.01f; + int mul = ( int )( g_csgo.m_globals->m_frametime / TICK_INTERVAL( ) ); + + int count = math::min< int >( math::max< int >( mul * points.size( ) * percentage, + points.size( ) * percentage, + 1 ), points.size( ) ); + + for( int i{ }; i < count; ++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: + return g_settings.rage.hitscan.stomach; + case HITBOX_CHEST: + 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, 3 ), + + 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_NECK, 2 ), + + 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 ) { + 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( g_settings.rage.active->m_auto_stop == 1 || g_settings.rage.active->m_auto_stop == 4 ) { + auto wep = g_ctx.m_local->get_weapon( ); + auto wep_info = wep->get_wpn_info( ); + + bool scoped = g_ctx.m_local->m_bIsScoped( ); + float max_vel = scoped ? wep_info->max_speed_alt : wep_info->max_speed; + + if( speed < max_vel / 3 ) + return; + } + + if( speed < 0.1f ) { + 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; + } + + // thx ida + max_speed = std::min< float >( max_speed, 250.f ); + + 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 = g_csgo.m_engine( )->GetViewAngles( ).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 < 65.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; + } + + bool c_ragebot::can_hit_target( int it, aim_target_t* ret, bool zeus, bool hitchance ) { + vec3_t aim_ang; + vec3_t aim_pos; + vec3_t local_pos = g_ctx.m_local->get_eye_pos( ); + + auto entity = g_csgo.m_entlist( )->GetClientEntity< >( it ); + if( !entity || !entity->is_valid( ) || entity == g_ctx.m_local ) + return false; + if( entity->m_bGunGameImmunity( ) ) + return false; + if( !entity->has_valid_anim( ) ) + return false; + if( entity->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) && !g_settings.rage.friendlies ) + return false; + + 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 ) + return false; + + 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( it ); + 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( it ); + 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 + return false; + } + } + } + + 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( ); + return false; + } + + if( aim_pos.dist_to( local_pos ) > 150.f && zeus ) { + restore_player( ); + return false; + } + + aim_ang = math::vector_angles( local_pos, aim_pos ).clamp( ); + + if( g_settings.rage.active->m_auto_stop( ) == 2 ) + quick_stop( m_cmd ); + else if( g_settings.rage.active->m_auto_stop( ) == 3 ) { + m_antiaim->run_fakewalk( ); + } + + if( g_settings.rage.active->m_auto_stop( ) == 5 ) { + m_cmd->m_buttons |= IN_DUCK; + } + + if( hitchance && !util::hitchance( it, aim_ang, + g_settings.rage.active->m_hitchance, hitbox ) ) { + if( g_settings.rage.active->m_auto_stop( ) == 1 || g_settings.rage.active->m_auto_stop( ) == 4 ) + quick_stop( m_cmd ); + + if( g_settings.rage.active->m_auto_stop( ) == 5 ) { + if( g_ctx.m_local->m_flDuckAmount( ) < 1.f ) + quick_stop( m_cmd ); + } + + if( g_settings.rage.active->m_auto_stop( ) == 4 && g_cheat.m_lagmgr.get_choked( ) < 10 && !m_antiaim->is_fakewalking( ) ) + g_cheat.m_lagmgr.set_state( false ); + + 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( ); + return false; + } + + 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( ); + + return true; + } + + 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 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; + + auto players = get_sorted_targets( ); + auto data = players.data( ); + + for( size_t i{ }; i < players.size( ); ++i ) { + if( can_hit_target( data[ i ], &ret, is_zeus ) ) + 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; + + float inaccuracy = g_ctx.m_weapon_inaccuracy; + float spread = g_ctx.m_weapon_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; + } + else { + m_cmd->m_viewangles = angles; + } + + //if( g_settings.rage.silent == 2 ) { + // if( !m_antiaim->is_fakewalking( ) ) + // g_cheat.m_lagmgr.set_state( g_cheat.m_lagmgr.get_choked( ) ); + //} + + 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( ) ); + } + + 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; + } + } + } + + if( g_settings.rage.active->m_auto_stop && !m_antiaim->is_fakewalking( ) && !g_settings.rage.compensate_spread ) + m_cmd->m_forwardmove = m_cmd->m_sidemove = 0.f; + + 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; + } + + memcpy( g_ctx.m_shot_data[ g_ctx.m_last_shot ].m_matrix, + m_shot_matrix, + sizeof( matrix3x4 ) * ent->m_CachedBoneData( ).GetSize( ) ); + + set_angles( angle.clamp( ) ); + + if( g_settings.rage.active->m_auto_stop && !g_settings.rage.compensate_spread( ) ) + quick_stop( m_cmd ); + } + + 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 is_revolver = wep->m_iItemDefinitionIndex( ) == WEAPON_R8REVOLVER; + + bool in_attack = false; + + 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; + } + + if( !g_ctx.m_local->can_attack( ) ) { + aim_target_t t{ }; + bool is_zeus = wep->m_iItemDefinitionIndex( ) == WEAPON_TASER; + + if( m_target != -1 && !m_antiaim->is_fakewalking( ) ) { + bool can_hit = can_hit_target( m_target, &t, is_zeus, false ); + + if( !can_hit ) + m_target = -1; + + else if( g_settings.rage.active->m_auto_stop == 3 && can_hit ) { + m_antiaim->run_fakewalk( ); + //if( !g_cheat.m_lagmgr.get_choked( ) || g_cheat.m_lagmgr.get_state( ) ) + m_cmd->m_viewangles.y = m_antiaim->get_yaw( ); + } + } + return; + } + + // do not + if( g_settings.rage.silent == 2 && !g_cheat.m_lagmgr.get_choked( ) && !is_revolver ) { + if( !m_antiaim->is_fakewalking( ) ) + g_cheat.m_lagmgr.set_state( false ); + 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/cheat/internal_rewrite/ragebot.hpp b/cheat/internal_rewrite/ragebot.hpp new file mode 100644 index 0000000..7bc6c24 --- /dev/null +++ b/cheat/internal_rewrite/ragebot.hpp @@ -0,0 +1,349 @@ +#pragma once +#include +#include + +#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( ); + bool can_hit_target( int, aim_target_t* target, bool zeus, bool hitchance = true ); + 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( ); + + + public: + bool is_fakewalking( ) const { return m_is_fakewalking; } + void run_fakewalk( ); + + 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{ }; + int m_animFlags{ }; + float m_lastAnimTime; + + 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 ResolverState_t { + R_NONE, + R_NORMAL, + R_FREESTANDING, + R_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 ); + + 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; + } + + __forceinline int get_state( int ent_index ) { + return m_data[ ent_index ].m_state; + } + + __forceinline int& get_resolver_shots( int ent_index ) { + auto& data = m_data[ ent_index ]; + + return data.m_shots[ data.m_state ]; + } + + protected: + + struct resolve_log_t { + //todo: deque to log hits etc + void update( int ent_index ); + void reset( ); + + bool m_logged[ R_LAST ]{ }; + float m_logged_lby{ }; + int m_state{ }; + float m_last_lby{ }; + float m_last_moving_lby{ }; + float m_last_update{ }; + int m_shots[ R_LAST ]{ }; + bool m_was_invalid{ }; + bool m_has_valid_lby{ }; + int m_last_freestanding{ }; + int m_overriding{ }; + int m_missed_shots{ }; + int m_logged_shots[ R_LAST ]{ }; + 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/cheat/internal_rewrite/ragebot_antiaim.cpp b/cheat/internal_rewrite/ragebot_antiaim.cpp new file mode 100644 index 0000000..beff445 --- /dev/null +++ b/cheat/internal_rewrite/ragebot_antiaim.cpp @@ -0,0 +1,889 @@ +#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( ) { + if( !g_settings.rage.anti_aim( ) ) + return; + + if( !g_ctx.m_local->get_animstate( ) ) + return; + + auto cl = g_csgo.m_global_state->get_client_state( ); + if( !cl ) + return; + + if( g_cheat.m_lagmgr.get_choked( ) != 1 ) + return; + + 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( ); + + vec3_t real_angle = g_ctx.m_thirdperson_angle; + + float pitch; + if( g_ctx.m_local->get_animstate( )->m_bInHitGroundAnimation && ( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) { + bool dist = g_settings.rage.enabled( ) && g_settings.rage.selection_type( ) == 1; + int target = util::get_closest_player( dist ); + + if( target != -1 ) { + auto t = g_csgo.m_entlist( )->GetClientEntity( target ); + + pitch = math::vector_angles( g_ctx.m_local->get_eye_pos( ), t->get_hitbox_pos( 0 ) ).x; + } + else + pitch = 0.f; + + real_angle.x = pitch; + } + + g_ctx.m_local->get_animstate( )->m_iLastClientSideAnimationUpdateFramecount -= 1; + g_ctx.m_local->get_animstate( )->update( real_angle.y, real_angle.x ); + g_ctx.m_local->cache_anim_data( false ); + + g_csgo.m_globals->m_curtime = backup_curtime; + g_csgo.m_globals->m_frametime = backup_frametime; + + if( g_ctx.m_local->get_animstate( )->m_velocity < 0.1f ) + g_ctx.m_local->get_animstate( )->m_velocity = 0.f; + + bool moving = g_ctx.m_local->get_animstate( )->m_velocity > 0.1f; + bool onground = g_ctx.m_local->get_animstate( )->m_bOnGround; + + float time = g_ctx.pred_time( ); + + if( onground ) { + 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->get_animstate( )->m_bOnGround ) + 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( ) + 2 : 4; + if( update_ticks < min_tick && update_ticks >= 1 ) { + *angles = break_angle + ( offset < 0 ? 105 : -105 ); + return; + } + } + + if( breaking && update_ticks < 1 ) { + *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 && g_settings.rage.fix_legs( ) ) { + 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->get_animstate( )->m_bOnGround ) + 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.travel_range = ( end - data.src ).length( ); + data.traveled = 0.f; + data.to_travel = data.travel_range; + + 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; + } + + float get_min_dist( vec3_t origin ) { + const float max_dist = 150.f; + float dist = 0.f; + float ret = FLT_MAX; + + CTraceFilterWorldAndPropsOnly filter; + CGameTrace tr; + Ray_t ray; + + for( size_t f = 0.f; f < 360.f; f += 45.f ) { + vec3_t rotated = math::get_rotated_pos( origin, f, max_dist ); + + ray.Init( origin, rotated ); + + g_csgo.m_trace( )->TraceRay( ray, MASK_SOLID, &filter, &tr ); + dist = tr.endpos.dist_to( origin ); + + if( dist <= 75.f ) + return 75.f; + + if( dist < ret ) + ret = dist; + } + + return ret; + } + + bool c_ragebot::c_antiaim::run_freestanding( int player ) { + if( !g_settings.rage.edge_detection ) + return false; + + if( !g_ctx.m_local->get_animstate( )->m_bOnGround ) + 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 local_dist = get_min_dist( local_pos ); + float enemy_dist = get_min_dist( enemy_pos ); + + float start_dmg = get_damage( enemy_pos, local_pos, ent, g_ctx.m_local ); + + auto test_dmg = [ & ]( float dist, float enemy_dist, float delta = 50.f ) { + vec3_t enemy_left = math::get_rotated_pos( enemy_pos, aim_angle.y - 90.f, enemy_dist ); + vec3_t enemy_right = math::get_rotated_pos( enemy_pos, aim_angle.y + 90.f, enemy_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 ) < delta ) + return false; + + float max_dmg = math::max( dmg_left, dmg_right ); + direction = dmg_left > dmg_right; + + cur_damage = max_dmg; + return max_dmg > delta; + }; + + float radius = std::floorf( ( g_ctx.m_local->get_hitbox_pos( 0 ) - g_ctx.m_local->get_hitbox_pos( HITBOX_PELVIS ) ).length2d( ) ); + radius = radius >= 15.f ? 20.f : 10.f; + + float enemy_radius = std::floorf( ( ent->get_hitbox_pos( 0 ) - ent->get_hitbox_pos( HITBOX_PELVIS ) ).length2d( ) ); + enemy_radius = enemy_radius >= 15.f ? 20.f : 10.f; + + if( !test_dmg( radius + 1.f, enemy_radius + 1.f, 25.f ) ) { + if( cur_damage < start_dmg * 2.f ) + return false; + } + + bool found = false; + + for( size_t i = 5; i > 0; --i ) { + float cur_dist = local_dist / i; + float cur_enemy_dist = enemy_dist / i; + + if( cur_dist < radius ) + continue; + + if( cur_enemy_dist < enemy_radius ) + continue; + + if( test_dmg( cur_dist, cur_enemy_dist, 125.f / i ) ) { + found = true; + break; + } + else if( cur_damage > 125.f / i ) + break; + } + + if( !found ) + return false; + + m_direction = direction; + aim_angle.y += direction ? -90.f : 90.f; + + if( g_settings.rage.angle_step ) { + aim_angle.y = math::find_closest_step( aim_angle.y, g_settings.rage.angle_step_degrees ); + } + + 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; + } + else { + int jitter = g_settings.rage.edge_dtc_real_jitter; + if (jitter) { + aim_angle.y += math::random_number< float >(-jitter, jitter); + } + } + + 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 ) { + //if it works, it works + float friction = sv_friction->get_float( ) * 1.12f; + 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 < 0.1f ) { + 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 = g_csgo.m_engine( )->GetViewAngles( ).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_stop; + for( ticks_to_stop = 0; ticks_to_stop < 15; ++ticks_to_stop ) { + if( velocity.length2d( ) < 0.1f ) + break; + + predict_velocity( &velocity ); + } + + int update_ticks = m_breaker.get_next_update( ) - 1; + + const int max_ticks = math::min< int >( g_settings.rage.fakewalk_ticks, update_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( ticks_left <= ticks_to_stop || !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; + 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->get_animstate( )->m_bOnGround ) { + 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( ); + } + } + + on_ground = g_ctx.m_local->get_animstate( )->m_bOnGround; + + if( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) { + last_onground = g_ctx.pred_time( ); + } + + 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/cheat/internal_rewrite/ragebot_lagcomp.cpp b/cheat/internal_rewrite/ragebot_lagcomp.cpp new file mode 100644 index 0000000..5014143 --- /dev/null +++ b/cheat/internal_rewrite/ragebot_lagcomp.cpp @@ -0,0 +1,657 @@ +#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_lastAnimTime = m_ent->get_animdata( ).m_last_animtime; + 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_animFlags = m_ent->get_animdata( ).m_anim_flags; + + 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; + + 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_ent->m_fFlags( ) = m_animFlags; + + m_state.m_flLastClientSideAnimationUpdateTime = m_lastAnimTime; + m_state.update( m_ent->m_angEyeAngles( ).y, m_ent->m_angEyeAngles( ).x ); + + m_ent->m_fFlags( ) = m_fFlags; + + 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( ) ) { + data.clear( ); + continue; + } + + if( std::abs( last_simtime[ i ] - ent->m_flSimulationTime( ) ) && ent->has_valid_anim( ) ) { + 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 -= TICK_INTERVAL( ); + + new_record.m_validtime = 0.f; + + 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 ) { + if( !g_ctx.m_local || !g_ctx.m_local->is_valid( ) ) + return false; + + 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++ ) { + if( ( it + 1 ) == data.rend( ) || is_time_valid( it->m_simtime ) || ( it + 1 )->m_simtime == ent->m_flSimulationTime( ) + util::get_lerptime( ) ) { + if( it->m_origin.dist_to( ent->m_vecOrigin( ) ) < 1.f ) + return false; + + if( ent->is_breaking_lc( ) ) + return false; + + auto next_record = ( it + 1 ); + + if( std::abs( it->m_simtime - ent->m_flSimulationTime( ) ) > TIME_TO_TICKS( 16 ) ) + break; + + 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 choke = ent->m_flSimulationTime( ) - ent->m_flOldSimulationTime( ); + float lerptime = next_record == data.rend( ) ? choke : next_record->m_simtime - it->m_simtime; + + lerptime = std::max( lerptime, TICK_INTERVAL( ) ); + + float curtime = g_csgo.m_globals->m_curtime; + + float delta = ( curtime - it->m_validtime ) / lerptime; + + vec3_t next = ( it + 1 ) == data.rend( ) ? ent->m_vecOrigin( ) : ( it + 1 )->m_origin; + vec3_t lerp = math::lerp( it->m_origin, next, std::clamp( 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 ); + stored_lby[ i ] = ent->m_flLowerBodyYawTarget( ); + m_last_simtime[ i ] = ent->m_flSimulationTime( ); + m_flick_time[ i ] = FLT_MAX; + } + 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( ); + + if( !!std::abs( simtime - last_simtime ) ) { + g_cheat.m_ragebot.m_resolver->update_player( i ); + bool yaw_change = g_cheat.m_ragebot.m_resolver->yaw_change( i ); + + 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 ); + stored_lby[ i ] = lby; + } + + else if( ( lby != stored_lby[ i ] ) && !was_dormant[ i ] && g_settings.rage.resolver ) { + stored_lby[ i ] = lby; + ent->m_angEyeAngles( ).y = lby; + + update_anims( i ); + lag_record_t new_record( ent ); + + if( !m_first_update[ i ] ) { + m_data_lby[ i ].push_front( new_record ); + m_flick_time[ i ] = ent->m_flOldSimulationTime( ) + TICK_INTERVAL( ); + } + + m_first_update[ i ] = false; + } + else { + bool has_updated = false; + if( g_settings.rage.resolver( ) ) { + float anim_time = ent->m_flOldSimulationTime( ) + TICK_INTERVAL( ); + + if( anim_time - 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 ); + } + } + + + g_cheat.m_ragebot.m_resolver->yaw_change( i ) = false; + } + + ent->do_ent_interpolation( false ); + m_last_simtime[ i ] = simtime; + + 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/cheat/internal_rewrite/ragebot_resolver.cpp b/cheat/internal_rewrite/ragebot_resolver.cpp new file mode 100644 index 0000000..1b29305 --- /dev/null +++ b/cheat/internal_rewrite/ragebot_resolver.cpp @@ -0,0 +1,626 @@ +#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_normal = { + FLT_ANG_MOVING_LBY_UP, + FLT_ANG_180, + FLT_ANG_135, + FLT_ANG_MINUS_135 + }; + + static const std::vector< float > possible_angles_freestanding = { + 0.f, + 45.f, + 90.f, + 135.f, + 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->get_anim_velocity( ).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.travel_range = ( end - data.src ).length( ); + data.traveled = 0.f; + data.to_travel = data.travel_range; + + 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; + }; + + 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; + }; + + float local_dist = 75.f; + float enemy_dist = 75.f; + + float start_dmg = get_damage( enemy_pos, local_pos, g_ctx.m_local, ent ); + + auto test_dmg = [ & ]( float dist, float enemy_dist, float delta = 50.f ) { + vec3_t enemy_left = math::get_rotated_pos( enemy_pos, aim_angle.y - 90.f, enemy_dist ); + vec3_t enemy_right = math::get_rotated_pos( enemy_pos, aim_angle.y + 90.f, enemy_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, g_ctx.m_local, ent ) + + get_damage( local_right, enemy_left, g_ctx.m_local, ent ); + + float dmg_right = get_damage( local_left, enemy_right, g_ctx.m_local, ent ) + + get_damage( local_right, enemy_right, g_ctx.m_local, ent ); + + if( std::abs( dmg_left - dmg_right ) < delta ) + return false; + + float max_dmg = math::max( dmg_left, dmg_right ); + ret_dir = dmg_left > dmg_right; + + cur_damage = max_dmg; + return max_dmg > delta; + }; + + float radius = std::floorf( ( g_ctx.m_local->get_hitbox_pos( 0 ) - g_ctx.m_local->get_hitbox_pos( HITBOX_PELVIS ) ).length2d( ) ); + radius = radius >= 15.f ? 20.f : 10.f; + + float enemy_radius = std::floorf( ( ent->get_hitbox_pos( 0 ) - ent->get_hitbox_pos( HITBOX_PELVIS ) ).length2d( ) ); + enemy_radius = enemy_radius >= 15.f ? 20.f : 10.f; + + if( !test_dmg( enemy_radius + 1.f, radius + 1.f, 25.f ) ) { + if( cur_damage < start_dmg * 2.f ) + return -1; + } + + bool found = false; + + for( size_t i = 5; i > 0; --i ) { + float cur_dist = local_dist / i; + float cur_enemy_dist = enemy_dist / i; + + if( cur_dist < radius ) + continue; + + if( cur_enemy_dist < enemy_radius ) + continue; + + if( test_dmg( cur_enemy_dist, cur_dist, 125.f / i ) ) { + found = true; + break; + } else if( cur_damage > 125.f / i ) + break; + } + + if( !found ) + 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_state = R_NONE; + return; + } + + if( ent->get_anim_velocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( ) ) { + m_state = R_NONE; + m_has_valid_lby = true; + m_last_moving_lby = ent->m_flLowerBodyYawTarget( ); + return; + } + + m_last_pos = ent->m_vecOrigin( ); + + m_was_invalid = false; + + int freestanding = g_cheat.m_ragebot.m_resolver->try_freestanding( ent ); + + if( freestanding != -1 ) { + m_state = R_FREESTANDING; + } + else + m_state = R_NORMAL; + + if( m_last_freestanding != freestanding ) + m_angle_change = true; + + m_last_freestanding = freestanding; + 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_state = R_NONE; + m_last_update = 0.f; + m_last_lby = 0.f; + m_missed_shots = 0; + memset( m_shots, 0, sizeof( m_shots ) ); + memset( m_logged, 0, sizeof( m_logged ) ); + memset( m_logged_shots, 0, sizeof( m_logged ) ); + } + + std::vector< float > c_ragebot::c_resolver::get_shot_vec( int ent ) { + auto& data = m_data[ ent ]; + + if( data.m_state == R_NORMAL ) + return possible_angles_normal; + if( data.m_state == R_FREESTANDING ) + return possible_angles_freestanding; + + 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 ); + + auto vec = get_shot_vec( ent_index ); + + float new_ang = vec.at( shots % vec.size( ) ); + float new_yaw = 0.f; + + float ang = math::vector_angles( ent->m_vecOrigin( ), g_ctx.m_last_origin ).y; + + if( data.m_state == R_FREESTANDING ) { + ang += ( data.m_last_freestanding == 1 ? 90.f : -90.f ); + + float sign = data.m_last_freestanding == 1 ? 1.f : -1.f; + + return ang + new_ang * sign; + } + + 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 ) { + return get_shot_yaw( ++get_resolver_shots( ent_index ), ent_index ); + } + + 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 ) { + new_yaw = ang - 180.f; + } + 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( ent->m_flLowerBodyYawTarget( ) + new_ang, 360.f ); + + return new_yaw; + } + + 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->get_anim_velocity( ).length2d( ) > 0.1f && ( ent->m_fFlags( ) & FL_ONGROUND ); + + if( moving && !ent->is_fakewalking( ) ) { + return; + } + + if( !data.m_state ) { + 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 = get_resolver_shots( ent_index ); + 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[ data.m_state ] ) { + if( !--data.m_logged_shots[ data.m_state ] ) { + data.m_logged[ data.m_state ] = false; + } + } + else { + int shots = get_resolver_shots( ent_index ); + + increment_shots( ent_index ); + +#if _DEBUG + if( dbg_resolver( ) ) { + char str[ 128 ]; + sprintf_s< 128 >( str, "[\3moneybot\1] incrementing shots from %d to %d" + "[\3moneybot\1] resolver state: %d\n", shots, get_resolver_shots( ent_index ), data.m_state ); + + 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 cosine = offset.x / radius; + + float deg = RAD2DEG( acos( cosine ) ); + if( offset.y < 0 ) deg += 360.f; + + 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 = get_resolver_shots( ent_index ); + 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; + + data.m_snapshot[ g_ctx.m_last_shot ] = data; + + if( data.m_logged[ data.m_state ] ) { + if( !--data.m_logged_shots[ data.m_state ] ) { + data.m_logged[ data.m_state ] = false; + } + } + else { + int shots = get_resolver_shots( ent_index ); + increment_shots( ent_index ); + +#if _DEBUG + if( dbg_resolver( ) ) { + char str[ 128 ]; + sprintf_s< 128 >( str, "[\3moneybot\1] incrementing shots from %d to %d" + "[\3moneybot\1] resolver state: %d\n", shots, get_resolver_shots( ent_index ), data.m_state ); + + g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, str ); + } +#endif + } + } + } + } + + //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 ) { + get_resolver_shots( ent_index )++; + 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_state ] = snapshot.m_shots[ snapshot.m_state ]; + + if( snapshot.m_logged[ snapshot.m_state ] ) { + data.m_logged[ snapshot.m_state ] = true; + data.m_logged_shots[ snapshot.m_state ] = snapshot.m_logged_shots[ snapshot.m_state ]; + } + } + + 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_state ] = snapshot.m_shots[ snapshot.m_state ]; + data.m_logged[ snapshot.m_state ] = true; + + int latency_shots = ( nci->GetLatency( 0 ) + g_csgo.m_globals->m_frametime ) / rate + 1; + + data.m_logged_shots[ snapshot.m_state ] = 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[ data.m_state ], ent_index, get_resolver_shots( ent_index ) ); + + g_csgo.m_clientmode( )->m_pChatElement->ChatPrintf( 0, 0, str ); + } +#endif + } + + void c_ragebot::c_resolver::update_player( int i ) { + if( !g_settings.rage.enabled( ) || !g_settings.rage.resolver( ) ) + return; + + if( !g_cheat.m_player_mgr.is_cheater( i ) ) + return; + + 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->get_animdata( ).m_anim_velocity.length2d( ) > 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->get_anim_velocity( ).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( ); + int s = get_resolver_shots( i ); + auto vec = get_shot_vec( i ); + + if( vec.at( s % vec.size( ) ) == FLT_ANG_MOVING_LBY_UP && g_settings.rage.pitch_resolver ) + ent->m_angEyeAngles( ).x = -89.f; + + float new_yaw = get_shot_yaw( get_resolver_shots( i ), i ); + + force_yaw( ent, new_yaw ); + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/renderer.cpp b/cheat/internal_rewrite/renderer.cpp new file mode 100644 index 0000000..3d22805 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/renderer.hpp b/cheat/internal_rewrite/renderer.hpp new file mode 100644 index 0000000..59e4dd1 --- /dev/null +++ b/cheat/internal_rewrite/renderer.hpp @@ -0,0 +1,126 @@ +#pragma once +#include +#include +#include + +#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_DROPSHADOW }; + font_t f_bold{ xors( "Verdana" ), 24, 700, 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/cheat/internal_rewrite/run_command.cpp b/cheat/internal_rewrite/run_command.cpp new file mode 100644 index 0000000..d8df083 --- /dev/null +++ b/cheat/internal_rewrite/run_command.cpp @@ -0,0 +1,11 @@ +#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 ) { + if( !g_csgo.m_panic && g_settings.rage.anti_aim( ) && entity == g_ctx.m_local->ce( ) ) { + + } + + run_command_o( ecx_, edx_, entity, ucmd, move_helper ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/scene_end.cpp b/cheat/internal_rewrite/scene_end.cpp new file mode 100644 index 0000000..997ed21 --- /dev/null +++ b/cheat/internal_rewrite/scene_end.cpp @@ -0,0 +1,42 @@ +#include "hooks.hpp" +#include "settings.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::scene_end( void* ecx_, void* edx_ ) { + 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_settings.misc.hide_from_obs ) { + 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/cheat/internal_rewrite/sdk.hpp b/cheat/internal_rewrite/sdk.hpp new file mode 100644 index 0000000..91f9bba --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/send_datagram.cpp b/cheat/internal_rewrite/send_datagram.cpp new file mode 100644 index 0000000..7a86842 --- /dev/null +++ b/cheat/internal_rewrite/send_datagram.cpp @@ -0,0 +1,32 @@ +#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 ) { + 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/cheat/internal_rewrite/settings.hpp b/cheat/internal_rewrite/settings.hpp new file mode 100644 index 0000000..6880bff --- /dev/null +++ b/cheat/internal_rewrite/settings.hpp @@ -0,0 +1,460 @@ +#pragma once +#include "simple_settings.hpp" +#include "strings.hpp" +#include "color.hpp" +#include +//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< 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< int > 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( ) ) ); + } + + __declspec( noinline ) void load( ) { + switch( menu.cur_setting ) { + case 0: + holder_.load( "", xors( "money_legit.cfg" ) ); + break; + case 1: + holder_.load( "", xors( "money_closet.cfg" ) ); + break; + case 2: + holder_.load( "", xors( "money_rage1.cfg" ) ); + break; + case 3: + holder_.load( "", xors( "money_rage2.cfg" ) ); + break; + case 4: + holder_.load( "", xors( "money_test.cfg" ) ); + break; + } + + menu.anti_untrusted = true; + misc.skins.current_skin = -1; + } + + __declspec( noinline ) void save( ) { + switch( menu.cur_setting ) { + case 0: + holder_.save( "", xors( "money_legit.cfg" ) ); + break; + case 1: + holder_.save( "", xors( "money_closet.cfg" ) ); + break; + case 2: + holder_.save( "", xors( "money_rage1.cfg" ) ); + break; + case 3: + holder_.save( "", xors( "money_rage2.cfg" ) ); + break; + case 4: + holder_.save( "", xors( "money_test.cfg" ) ); + break; + } + } + + __declspec( noinline ) void reset( ) { + holder_.reset( ); + } + + 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< int > multipoint_enable{ &holder_, fnv( "rage_multipoint" ), false }; + con_var< int > multipoint_scale{ &holder_, fnv( "rage_multipoint_scale" ), 10 }; + + struct { + con_var< bool > head{ &holder_, fnv( "rage_multipoint_head" ), true }; + con_var< bool > stomach{ &holder_, fnv( "rage_multipoint_stomach" ), true }; + con_var< bool > chest{ &holder_, fnv( "rage_multipoint_chest" ), false }; + con_var< bool > thighs{ &holder_, fnv( "rage_multipoint_thighs" ), false }; + con_var< bool > calves{ &holder_, fnv( "rage_multipoint_calves" ), false }; + } multipoint; + + + 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< bool > compensate_spread{ &holder_, fnv( "rage_compensate_spread" ) }; + + 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 > on_select{ &holder_, fnv( "fakelag_on_select" ), 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 }; + con_var< bool > jump_reset{ &holder_, fnv( "fakelag_jump_reset" ), false }; + con_var< bool > on_duck{ &holder_, fnv( "fakelag_on_duck" ), 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< int > edge_dtc_real_jitter{ &holder_, fnv("rage_edge_dtc_real_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 > 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 > fix_legs{ &holder_, true }; + + 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" ) }; + con_var< float > luminance{ &holder_, fnv( "visuals_chams_luminance" ), 1.f }; + } 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< bool > hits{ &holder_, fnv( "visuals_hits" ), false }; + + 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 > no_cascade_shadows{ &holder_, fnv( "visuals_no_cascade_shadows" ), 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< clr_t > grenade_pred_clr{ &holder_, fnv( "visuals_grenade_pred_clr" ), clr_t( 84, 173, 247 ) }; + + 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< int > 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< bool > net_fakelag{ &holder_, fnv( "misc_net_fakelag" ), false }; + 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 > no_crouch_cooldown{ &holder_, fnv("no_crouch_cooldown") }; + 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< clr_t > menu_color{ &holder_, fnv( "menu_color" ), clr_t( 231, 105, 105 ) }; + + 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/cheat/internal_rewrite/shut_down.cpp b/cheat/internal_rewrite/shut_down.cpp new file mode 100644 index 0000000..c3d2a95 --- /dev/null +++ b/cheat/internal_rewrite/shut_down.cpp @@ -0,0 +1,20 @@ +#include "hooks.hpp" +#include "chams.hpp" +#include "base_cheat.hpp" +#include "detours.h" + +void __fastcall hooks::shut_down( void* ecx_, void* edx_ ) { + static auto original_fn = shut_down_o; + + g_csgo.m_engine( )->ClientCmd_Unrestricted( xors( "host_writeconfig" ) ); + //fuck you + + memory::detours.restore( ); + + g_con->destroy( ); + + abort( ); + + g_cheat.m_chams.m_materials.destroy_materials( ); + return original_fn( ecx_, edx_ ); +} \ No newline at end of file diff --git a/cheat/internal_rewrite/simple_settings.cpp b/cheat/internal_rewrite/simple_settings.cpp new file mode 100644 index 0000000..b6b3281 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/simple_settings.hpp b/cheat/internal_rewrite/simple_settings.hpp new file mode 100644 index 0000000..e3187ba --- /dev/null +++ b/cheat/internal_rewrite/simple_settings.hpp @@ -0,0 +1,283 @@ +#pragma once +#include +#include +#include +#include +#include + +#include "util.hpp" +#include "fnv.hpp" + +#pragma comment( lib, "Shlwapi.lib" ) + +//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 reset( ) 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 ); + } + + __declspec( noinline ) void load( const char* path, const char* file ) override + { + static char full_path[1024]; + memset( full_path, 0, 1024 ); + + strcpy_s( full_path, path ); + strcat_s( full_path, "_" ); + strcat_s( full_path, name_.c_str( ) ); + + for( auto x : setting_nodes_ ) { + if( !x ) + continue; + + x->load( full_path, file ); + } + } + + __declspec( noinline ) void save( const char* path, const char* file ) const override + { + static char full_path[1024]; + memset( full_path, 0, 1024 ); + + strcpy_s( full_path, path ); + strcat_s( full_path, "_" ); + strcat_s( full_path, name_.c_str( ) ); + for ( auto x : setting_nodes_ ) + x->save( full_path, file ); + } + + __declspec( noinline ) void reset( ) const override { + for( auto x : setting_nodes_ ) + x->reset( ); + } + + auto& get_nodes( ) { + return setting_nodes_; + } + + virtual bool has_nodes( ) { + return true; + } + +private: + std::string name_; + bool has_nodes_; + std::vector 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 ); + }; + + __declspec( noinline ) void load( const char* path, const char* file ) override { + static char str[ MAX_PATH ]; + + GetModuleFileNameA( nullptr, str, MAX_PATH - 1 ); + PathRemoveFileSpecA( str ); + strcat_s< MAX_PATH >( str, path ); + strcat_s< MAX_PATH >( str, "\\" ); + + GetPrivateProfileStringA( path, std::to_string( m_name ).c_str( ), "", m_value, L, file ); + } + + __declspec( noinline ) void save( const char* path, const char* file ) const override { + static char str[ MAX_PATH ]; + + GetModuleFileNameA( nullptr, str, MAX_PATH - 1 ); + PathRemoveFileSpecA( str ); + strcat_s< MAX_PATH >( str, path ); + strcat_s< MAX_PATH >( str, "\\" ); + + 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: + __declspec( noinline ) con_var( SettingHolder* holder_ptr, hash_t name ) : + name_( name ), + original_{ }, + is_float_( std::is_floating_point_v< T > ), + is_integral_( std::is_integral_v< T > ) { + holder_ptr->register_( this ); + } + __declspec( noinline ) con_var( SettingHolder* holder_ptr, hash_t name, const T& rhs ) : + value_( rhs ), + name_( name ), + original_( value_ ), + is_float_( std::is_floating_point_v< T > ), + is_integral_( std::is_integral_v< T > ) { + holder_ptr->register_( this ); + } + + __declspec( noinline ) void load( const char* path, const char* file ) override { + static char str[ MAX_PATH ]; + static char full_path[ MAX_PATH ]; + static bool taken = false; + + if( !taken ) { + GetModuleFileNameA( nullptr, str, MAX_PATH - 1 ); + PathRemoveFileSpecA( str ); + strcat_s< MAX_PATH >( str, "\\csgo\\cfg\\" ); + + taken = true; + } + + memset( full_path, 0, MAX_PATH ); + memcpy( full_path, str, MAX_PATH ); + strcat_s< MAX_PATH >( full_path, file ); + + simple_load( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), full_path ); + } + + __declspec( noinline ) void save( const char* path, const char* file ) const override { + static char str[ MAX_PATH ]; + static char full_path[ MAX_PATH ]; + static bool taken = false; + + if( !taken ) { + GetModuleFileNameA( nullptr, str, MAX_PATH - 1 ); + PathRemoveFileSpecA( str ); + strcat_s< MAX_PATH >( str, "\\csgo\\cfg\\" ); + + taken = true; + } + + memset( full_path, 0, MAX_PATH ); + memcpy( full_path, str, MAX_PATH ); + strcat_s< MAX_PATH >( full_path, file ); + + simple_save( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), full_path ); + } + + __declspec( noinline ) void reset( ) const override { + // now this is really epic. + memcpy( ( void* )&value_, ( void* )&original_, sizeof( original_ ) ); + } + + __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_; + T original_; +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/simulate.cpp b/cheat/internal_rewrite/simulate.cpp new file mode 100644 index 0000000..28ec687 --- /dev/null +++ b/cheat/internal_rewrite/simulate.cpp @@ -0,0 +1,46 @@ +#include + +#include "hooks.hpp" +#include "base_cheat.hpp" +#include "context.hpp" + +void __fastcall hooks::simulate( void* ecx, void* edx ) { + static auto ret_addr = pattern::first_code_match< void* >( g_csgo.m_engine.dll( ), "8B CE 6A FF 8B 06", -0x81 ); + + if( _ReturnAddress( ) == (void*)ret_addr ) { + g_ctx.run_frame( ); + + 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 ) { +#ifdef HEADER_MODULE + static auto smoke_count = g_header.patterns.smoke_count; +#else + 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" ) ); +#endif + **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/cheat/internal_rewrite/skins.cpp b/cheat/internal_rewrite/skins.cpp new file mode 100644 index 0000000..4abef06 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/skins.hpp b/cheat/internal_rewrite/skins.hpp new file mode 100644 index 0000000..f60deef --- /dev/null +++ b/cheat/internal_rewrite/skins.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include + +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/cheat/internal_rewrite/strings.hpp b/cheat/internal_rewrite/strings.hpp new file mode 100644 index 0000000..f34c082 --- /dev/null +++ b/cheat/internal_rewrite/strings.hpp @@ -0,0 +1,162 @@ +//-------------------------------------------------------------------------------- +//-- XorCompileTime.hpp +// +// Author: frk +// Date: 12.12.2015 +// +//-------------------------------------------------------------------------------- + +#pragma once +#include +#include +#include + +#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/cheat/internal_rewrite/suppress_lists.cpp b/cheat/internal_rewrite/suppress_lists.cpp new file mode 100644 index 0000000..01036ea --- /dev/null +++ b/cheat/internal_rewrite/suppress_lists.cpp @@ -0,0 +1,43 @@ +#include + +#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 ) { +#ifdef HEADER_MODULE + static auto net_update_ret = g_header.patterns.net_update_retaddr; +#else + static auto net_update_ret = pattern::first_code_match< void* >( g_csgo.m_chl.dll( ), "5F 5E 5D C2 04 00 83 3D ? ? ? ? ?" ); +#endif + + if( _ReturnAddress( ) == (void*)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/cheat/internal_rewrite/table32.h b/cheat/internal_rewrite/table32.h new file mode 100644 index 0000000..2bd19d8 --- /dev/null +++ b/cheat/internal_rewrite/table32.h @@ -0,0 +1,73 @@ +/* +* Hacker Disassembler Engine 32 C +* Copyright (c) 2008-2009, Vyacheslav Patkov. +* All rights reserved. +* +*/ + +#define C_NONE 0x00 +#define C_MODRM 0x01 +#define C_IMM8 0x02 +#define C_IMM16 0x04 +#define C_IMM_P66 0x10 +#define C_REL8 0x20 +#define C_REL32 0x40 +#define C_GROUP 0x80 +#define C_ERROR 0xff + +#define PRE_ANY 0x00 +#define PRE_NONE 0x01 +#define PRE_F2 0x02 +#define PRE_F3 0x04 +#define PRE_66 0x08 +#define PRE_67 0x10 +#define PRE_LOCK 0x20 +#define PRE_SEG 0x40 +#define PRE_ALL 0xff + +#define DELTA_OPCODES 0x4a +#define DELTA_FPU_REG 0xf1 +#define DELTA_FPU_MODRM 0xf8 +#define DELTA_PREFIXES 0x130 +#define DELTA_OP_LOCK_OK 0x1a1 +#define DELTA_OP2_LOCK_OK 0x1b9 +#define DELTA_OP_ONLY_MEM 0x1cb +#define DELTA_OP2_ONLY_MEM 0x1da + +static unsigned char hde32_table[] = { + 0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3, + 0xa8,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xac,0xaa,0xb2,0xaa,0x9f,0x9f, + 0x9f,0x9f,0xb5,0xa3,0xa3,0xa4,0xaa,0xaa,0xba,0xaa,0x96,0xaa,0xa8,0xaa,0xc3, + 0xc3,0x96,0x96,0xb7,0xae,0xd6,0xbd,0xa3,0xc5,0xa3,0xa3,0x9f,0xc3,0x9c,0xaa, + 0xaa,0xac,0xaa,0xbf,0x03,0x7f,0x11,0x7f,0x01,0x7f,0x01,0x3f,0x01,0x01,0x90, + 0x82,0x7d,0x97,0x59,0x59,0x59,0x59,0x59,0x7f,0x59,0x59,0x60,0x7d,0x7f,0x7f, + 0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x9a,0x88,0x7d, + 0x59,0x50,0x50,0x50,0x50,0x59,0x59,0x59,0x59,0x61,0x94,0x61,0x9e,0x59,0x59, + 0x85,0x59,0x92,0xa3,0x60,0x60,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59, + 0x59,0x59,0x9f,0x01,0x03,0x01,0x04,0x03,0xd5,0x03,0xcc,0x01,0xbc,0x03,0xf0, + 0x10,0x10,0x10,0x10,0x50,0x50,0x50,0x50,0x14,0x20,0x20,0x20,0x20,0x01,0x01, + 0x01,0x01,0xc4,0x02,0x10,0x00,0x00,0x00,0x00,0x01,0x01,0xc0,0xc2,0x10,0x11, + 0x02,0x03,0x11,0x03,0x03,0x04,0x00,0x00,0x14,0x00,0x02,0x00,0x00,0xc6,0xc8, + 0x02,0x02,0x02,0x02,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0xca, + 0x01,0x01,0x01,0x00,0x06,0x00,0x04,0x00,0xc0,0xc2,0x01,0x01,0x03,0x01,0xff, + 0xff,0x01,0x00,0x03,0xc4,0xc4,0xc6,0x03,0x01,0x01,0x01,0xff,0x03,0x03,0x03, + 0xc8,0x40,0x00,0x0a,0x00,0x04,0x00,0x00,0x00,0x00,0x7f,0x00,0x33,0x01,0x00, + 0x00,0x00,0x00,0x00,0x00,0xff,0xbf,0xff,0xff,0x00,0x00,0x00,0x00,0x07,0x00, + 0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0xff,0xff,0x00,0x00,0x00,0xbf,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x7f,0x00,0x00,0xff,0x4a,0x4a,0x4a,0x4a,0x4b,0x52,0x4a,0x4a,0x4a,0x4a,0x4f, + 0x4c,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x55,0x45,0x40,0x4a,0x4a,0x4a, + 0x45,0x59,0x4d,0x46,0x4a,0x5d,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a, + 0x4a,0x4a,0x4a,0x4a,0x4a,0x61,0x63,0x67,0x4e,0x4a,0x4a,0x6b,0x6d,0x4a,0x4a, + 0x45,0x6d,0x4a,0x4a,0x44,0x45,0x4a,0x4a,0x00,0x00,0x00,0x02,0x0d,0x06,0x06, + 0x06,0x06,0x0e,0x00,0x00,0x00,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x02,0x06, + 0x00,0x0a,0x0a,0x07,0x07,0x06,0x02,0x05,0x05,0x02,0x02,0x00,0x00,0x04,0x04, + 0x04,0x04,0x00,0x00,0x00,0x0e,0x05,0x06,0x06,0x06,0x01,0x06,0x00,0x00,0x08, + 0x00,0x10,0x00,0x18,0x00,0x20,0x00,0x28,0x00,0x30,0x00,0x80,0x01,0x82,0x01, + 0x86,0x00,0xf6,0xcf,0xfe,0x3f,0xab,0x00,0xb0,0x00,0xb1,0x00,0xb3,0x00,0xba, + 0xf8,0xbb,0x00,0xc0,0x00,0xc1,0x00,0xc7,0xbf,0x62,0xff,0x00,0x8d,0xff,0x00, + 0xc4,0xff,0x00,0xc5,0xff,0x00,0xff,0xff,0xeb,0x01,0xff,0x0e,0x12,0x08,0x00, + 0x13,0x09,0x00,0x16,0x08,0x00,0x17,0x09,0x00,0x2b,0x09,0x00,0xae,0xff,0x07, + 0xb2,0xff,0x00,0xb4,0xff,0x00,0xb5,0xff,0x00,0xc3,0x01,0x00,0xc7,0xff,0xbf, + 0xe7,0x08,0x00,0xf0,0x02,0x00 +}; \ No newline at end of file diff --git a/cheat/internal_rewrite/ui.h b/cheat/internal_rewrite/ui.h new file mode 100644 index 0000000..968a969 --- /dev/null +++ b/cheat/internal_rewrite/ui.h @@ -0,0 +1,885 @@ +#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" + +#include "modules.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" ), + "" ); + + 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 + date_str = g_header.username; + + + menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "automated currency" ), + //don't ask + date_str.c_str( ) ); +#else + menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "dmt hook" ), + 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_enable, &dropdowns::multipoint_types ) ); + main_form->add_item( std::make_shared< ui::c_slider< int > >( 0, 0, 120, 10, 100, &g_settings.rage.multipoint_scale( ) ) ); + auto multipoint_form = main_form->add_item( std::make_shared< ui::c_form >( 0, 5, 119, 0, xors( "multipoint" ), 0, true ) ); + multipoint_form->set_cond( [ ]( ) { return g_settings.rage.multipoint_enable( ); } ); + + multipoint_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "head" ), &g_settings.rage.multipoint.head ) ); + multipoint_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "chest" ), &g_settings.rage.multipoint.chest ) ); + multipoint_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "stomach" ), &g_settings.rage.multipoint.stomach ) ); + multipoint_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "thighs" ), &g_settings.rage.multipoint.thighs ) ); + multipoint_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "calves" ), &g_settings.rage.multipoint.calves ) ); + + + main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "preserve fps" ), &g_settings.rage.preserve_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_dropdown< > >( 0, 0, 120, xors( "auto stop" ), &g_settings.rage.general.m_auto_stop, &dropdowns::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_enable( ); } ); + + 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_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_dropdown< > >( 0, 0, 120, xors( "auto stop" ), &g_settings.rage.heavy_pistols.m_auto_stop, &dropdowns::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_enable( ); } ); + 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_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_dropdown< > >( 0, 0, 120, xors( "auto stop" ), &g_settings.rage.snipers.m_auto_stop, &dropdowns::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_enable( ); } ); + 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_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_dropdown< > >( 0, 0, 120, xors( "auto stop" ), &g_settings.rage.auto_snipers.m_auto_stop, &dropdowns::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_enable( ); } ); + 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_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, 131, xors( "main" ), 131 ); { + 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( ); } ); + + main_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "fix leg movement" ), &g_settings.rage.fix_legs ) ); + } + + 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, 190, xors( "yaw" ), 190 ); { + 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_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 ) ); + edge_form->add_item(std::make_shared< ui::c_slider< int > >(0, 0, 140, 0, 90, xors("real jitter"), &g_settings.rage.edge_dtc_real_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, 16 + , &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, 2, 16, &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( "on duck" ), &g_settings.rage.fakelag.on_duck ) ); + flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "on weapon select" ), &g_settings.rage.fakelag.on_select ) ); + 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 ) ); + flags_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "reset on jump" ), &g_settings.rage.fakelag.jump_reset ) ); + } + + 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( "hit ghost" ), &g_settings.visuals.hits ) ); + 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 || g_settings.visuals.hits; } ); + } + + 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; } ); + + chams_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "luminance" ), &g_settings.visuals.chams.luminance ) + )->set_cond( [ ]( ) { return !g_settings.visuals.chams.flat; } ); + + 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; } ); + + 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( ) ) )->add_item( + std::make_shared< ui::c_color_picker >( 180, 4, 15, &g_settings.visuals.grenade_pred_clr ) + ); + + 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 ) ); + removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no cascade shadows" ), &g_settings.visuals.no_cascade_shadows ) ); + } + + 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_dropdown< > >( 0, 0, 120, xors( "auto strafe" ), &g_settings.misc.auto_strafe, &dropdowns::autostrafe_types ) ); + 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( "no duck cooldown" ), &g_settings.misc.no_crouch_cooldown ) ); + + 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" ) ); { + static auto sv_maxunlag = g_csgo.m_cvar( )->FindVar( "sv_maxunlag" ); + + fake_ping->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "extended backtracking" ), &g_settings.misc.net_fakelag ) ); + } + + 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, 134, 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( "reset" ), []( ) { g_settings.reset( ); g_settings.save( ); } ) ); + cfg_form->add_item( std::make_shared< ui::c_button >( 95, -50, 85, 20, xors( "unload" ), []( ) { g_settings.reset( ); } ) ); + //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( ); } ) ); + auto label = cfg_form->add_item( std::make_shared< ui::c_label >( 0, -50, xors( "menu color" ) ) ); + label->add_item( std::make_shared< ui::c_color_picker >( 165, 4, 15, &g_settings.menu.menu_color ) ); + + cfg_form->add_item( std::make_shared< ui::c_checkbox >( 0, -50, 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" ) ); + + static auto fakeping_form = menu->find_item( xors( "fake latency" ) ); + + auto game_rules = c_base_player::get_game_rules( ); + if( game_rules ) { + fakeping_form->set_visible( !*( bool* )( game_rules + 0x75 ) ); + } + + 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/cheat/internal_rewrite/ui_base_item.h b/cheat/internal_rewrite/ui_base_item.h new file mode 100644 index 0000000..482481a --- /dev/null +++ b/cheat/internal_rewrite/ui_base_item.h @@ -0,0 +1,164 @@ +#pragma once +#include +#include +#include + +#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/cheat/internal_rewrite/ui_button.h b/cheat/internal_rewrite/ui_button.h new file mode 100644 index 0000000..0472360 --- /dev/null +++ b/cheat/internal_rewrite/ui_button.h @@ -0,0 +1,56 @@ +#pragma once + +#include + +#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/cheat/internal_rewrite/ui_checkbox.h b/cheat/internal_rewrite/ui_checkbox.h new file mode 100644 index 0000000..3b0c251 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_color_picker.h b/cheat/internal_rewrite/ui_color_picker.h new file mode 100644 index 0000000..8404e19 --- /dev/null +++ b/cheat/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 + 0 && 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, -1, 122 ); + 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/cheat/internal_rewrite/ui_draw.h b/cheat/internal_rewrite/ui_draw.h new file mode 100644 index 0000000..d95b1c2 --- /dev/null +++ b/cheat/internal_rewrite/ui_draw.h @@ -0,0 +1,161 @@ +#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; + + float brightness = col_start.brightness( ) / 255.f; + float saturation = col_start.saturation( ); + + float new_brightness = brightness > .5f ? brightness - 0.2f : brightness + 0.2f; + float new_saturation = saturation > .5f ? saturation - 0.2f : saturation + 0.2f; + + clr_t col_end = clr_t::from_hsb( col_start.hue( ), new_saturation, new_brightness ); + col_end.a( ) = col_start.a( ); + + 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/cheat/internal_rewrite/ui_dropdown.h b/cheat/internal_rewrite/ui_dropdown.h new file mode 100644 index 0000000..12a9e98 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_dropdown_item.h b/cheat/internal_rewrite/ui_dropdown_item.h new file mode 100644 index 0000000..2774013 --- /dev/null +++ b/cheat/internal_rewrite/ui_dropdown_item.h @@ -0,0 +1,861 @@ +#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< > > auto_stop = { + { xors( "none" ), 0 }, + { xors( "hitchance" ), 1 }, + { xors( "hitchance + lag" ), 4 }, + { xors( "duck" ), 5 }, + { xors( "slide" ), 3 }, + { xors( "full" ), 2 } + }; + + static std::vector< dropdown_item_t< > > antiaim_edge = { + { xors( "off" ), 0 }, + { xors( "peek" ), 1 }, + { xors( "full" ), 2 }, + }; + + static std::vector< dropdown_item_t< > > autostrafe_types = { + { xors( "none" ), 0 }, + { xors( "view" ), 1 }, + { xors( "view + movement" ), 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 }, +#ifdef _DEBUG + { xors( "auto" ), 4 } +#endif + }; + + 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( "center" ), 1 }, + { xors( "edges" ), 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/cheat/internal_rewrite/ui_form.h b/cheat/internal_rewrite/ui_form.h new file mode 100644 index 0000000..9dbe68e --- /dev/null +++ b/cheat/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::min< int >( std::max< int >( 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/cheat/internal_rewrite/ui_itemlist.h b/cheat/internal_rewrite/ui_itemlist.h new file mode 100644 index 0000000..e692746 --- /dev/null +++ b/cheat/internal_rewrite/ui_itemlist.h @@ -0,0 +1,127 @@ +#pragma once +#include "ui_base_item.h" +#include "ui_dropdown_item.h" + +#include + +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/cheat/internal_rewrite/ui_itemlist_def.h b/cheat/internal_rewrite/ui_itemlist_def.h new file mode 100644 index 0000000..fd64f12 --- /dev/null +++ b/cheat/internal_rewrite/ui_itemlist_def.h @@ -0,0 +1,61 @@ +#include "ui_itemlist.h" +#include + +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/cheat/internal_rewrite/ui_key_picker.h b/cheat/internal_rewrite/ui_key_picker.h new file mode 100644 index 0000000..dea681c --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_label.h b/cheat/internal_rewrite/ui_label.h new file mode 100644 index 0000000..712b547 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_menu.h b/cheat/internal_rewrite/ui_menu.h new file mode 100644 index 0000000..37b16f9 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_render.h b/cheat/internal_rewrite/ui_render.h new file mode 100644 index 0000000..1f10223 --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_slider.h b/cheat/internal_rewrite/ui_slider.h new file mode 100644 index 0000000..8f54b3c --- /dev/null +++ b/cheat/internal_rewrite/ui_slider.h @@ -0,0 +1,175 @@ +#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 ); + } + } + + void set_min( float min ) { + m_min = min; + } + + void set_max( float max ) { + m_max = max; + } + + + 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/cheat/internal_rewrite/ui_tab_manager.h b/cheat/internal_rewrite/ui_tab_manager.h new file mode 100644 index 0000000..293d48b --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/ui_text_input.cpp b/cheat/internal_rewrite/ui_text_input.cpp new file mode 100644 index 0000000..f2c3530 --- /dev/null +++ b/cheat/internal_rewrite/ui_text_input.cpp @@ -0,0 +1,83 @@ +#include "ui_text_input.h" +#include + +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; + } + + if( i == KEYS_RETURN ) { + m_active = false; + break; + } + + 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( ) ); + + if( !m_hidden ) + ui_draw_string( x + 2, y + 3, false, ui_get_text_col( ), m_active ? "%s_" : "%s", m_text_ptr ); + else { + std::string str; + str.append( "*", strlen( m_text_ptr ) ); + if( m_active ) + str += '_'; + + ui_draw_string( x + 2, y + 3, false, ui_get_text_col( ), str.c_str( ) ); + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/ui_text_input.h b/cheat/internal_rewrite/ui_text_input.h new file mode 100644 index 0000000..243c40b --- /dev/null +++ b/cheat/internal_rewrite/ui_text_input.h @@ -0,0 +1,38 @@ +#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, bool hidden = false ) : + base_item( x, y, w, 16, name ), m_text_len( max_chars ), m_text_ptr( str ), m_hidden( hidden ) { + } + + 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 ]{ }; + bool m_hidden{ }; + }; +} \ No newline at end of file diff --git a/cheat/internal_rewrite/update_clientside_animation.cpp b/cheat/internal_rewrite/update_clientside_animation.cpp new file mode 100644 index 0000000..201d100 --- /dev/null +++ b/cheat/internal_rewrite/update_clientside_animation.cpp @@ -0,0 +1,48 @@ +#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 = update_clientside_animation_o; + + if( ecx_ != g_ctx.m_local ) + return old_func( ecx_, 0 ); + + auto ent = ( c_base_player* )( ecx_ ); + + static float last_update; + static float last_spawntime = 0.f; + + // 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_spawntime != ent->m_flSpawnTime( ) ) { + last_update = g_csgo.m_globals->m_curtime; + first_update = true; + + if( last_spawntime != ent->m_flSpawnTime( ) ) + last_spawntime = ent->m_flSpawnTime( ); + + return old_func( ecx_, edx_ ); + } + + last_update = g_csgo.m_globals->m_curtime; + + ent->get_animstate( )->m_iLastClientSideAnimationUpdateFramecount = g_csgo.m_globals->m_framecount; + old_func( ecx_, edx_ ); + + if( !first_update ) { + g_ctx.m_local->restore_anim_data( true ); + + ent->set_abs_angles( vec3_t( 0, g_ctx.m_absyaw, 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/cheat/internal_rewrite/util.cpp b/cheat/internal_rewrite/util.cpp new file mode 100644 index 0000000..1d19f9a --- /dev/null +++ b/cheat/internal_rewrite/util.cpp @@ -0,0 +1,575 @@ +#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( bool dist ) { + float cur_fov = FLT_MAX; + 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; + } + + float distance = 0.f; + if( dist ) { + distance = g_ctx.m_local->m_vecOrigin( ).dist_to( ent->m_vecOrigin( ) ); + } + else { + auto ang = math::vector_angles( local_pos, ent->get_hitbox_pos( 0 ) ); + ang.clamp( ); + distance = ( viewangles - ang ).clamp( ).length2d( ); + } + + if( distance < cur_fov ) { + ret = i; + cur_fov = distance; + } + } + + 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_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 * g_ctx.m_weapon_inaccuracy; + const float rand_spread = rand_b * g_ctx.m_weapon_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, int hitbox ) { + 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; + + float inaccuracy = g_ctx.m_weapon_inaccuracy; + float spread = g_ctx.m_weapon_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 ]; + memcpy( bone_matrix, + ent->m_CachedBoneData( ).GetElements( ), + ent->m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) ); + + auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) ); + if( !set ) return false; + + if( hitbox == -1 ) { + 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 ) ); + } + } + else { + auto box = set->pHitbox( hitbox ); + if( !box ) return false; + + 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, *( bool* )( c_base_player::get_game_rules( ) + 0x75 ) ? 0.2f : 1.0f ); + float delta = correct - ( g_ctx.pred_time( ) - TICKS_TO_TIME( tickcount ) ); + + if( g_settings.rage.enabled ) { + return delta > -0.2f + TICK_INTERVAL( ) * 2.f && delta < 0.2f; + } + + 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/cheat/internal_rewrite/util.hpp b/cheat/internal_rewrite/util.hpp new file mode 100644 index 0000000..ba7c779 --- /dev/null +++ b/cheat/internal_rewrite/util.hpp @@ -0,0 +1,111 @@ +#pragma once +#include +#include +#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, int hitbox = -1 ); +extern void calculate_spread_runtime( ); + +extern float get_total_latency( ); +extern float get_lerptime( ); +extern int get_closest_player( bool distance = false ); +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/cheat/internal_rewrite/vector.hpp b/cheat/internal_rewrite/vector.hpp new file mode 100644 index 0000000..4fef1b7 --- /dev/null +++ b/cheat/internal_rewrite/vector.hpp @@ -0,0 +1,334 @@ +#pragma once +#include +#include + + +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/cheat/internal_rewrite/visual.hpp b/cheat/internal_rewrite/visual.hpp new file mode 100644 index 0000000..4d0e996 --- /dev/null +++ b/cheat/internal_rewrite/visual.hpp @@ -0,0 +1,126 @@ +#pragma once +#include +#include "vector.hpp" +#include "color.hpp" +#include +#include "strings.hpp" +#include "IVRenderView.hpp" +#include "context.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( 110, 200, 20, 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; + }; + + struct hit_t { + int m_ent; + char m_name[ 32 ]; + matrix3x4 m_matrix[ 128 ]; + vec3_t m_pos; + bool m_dead; + float m_time; + }; + + //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; + std::vector< hit_t > m_hits; + + vec3_t m_stored_pos[ 65 ]{ }; + float m_anim_progress[ 65 ]{ }; + bool m_has_seen[ 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 reset_position( ); + 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 update_positions( ); + 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 draw_skeletons( ); + void on_round_start( ); + void draw_sound( ); + void update_hit_flags( ); + void store_hit( context::shot_data_t* shot ); + void operator()( ); + }; +} \ No newline at end of file diff --git a/cheat/internal_rewrite/visual_draw.cpp b/cheat/internal_rewrite/visual_draw.cpp new file mode 100644 index 0000000..8636af2 --- /dev/null +++ b/cheat/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, D3DFONTFLAG_DROPSHADOW, 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, D3DFONTFLAG_DROPSHADOW, 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, D3DFONTFLAG_DROPSHADOW, 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/cheat/internal_rewrite/visual_local.cpp b/cheat/internal_rewrite/visual_local.cpp new file mode 100644 index 0000000..119c352 --- /dev/null +++ b/cheat/internal_rewrite/visual_local.cpp @@ -0,0 +1,661 @@ +#include + +#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( ); + + const int offset = 21; + + + 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 += offset, col, xors( "DMG: %d" ), m_teamdmg ); + } + + static float incoming_latency; + if( g_settings.misc.net_fakelag ) { + float desired_latency = incoming_latency + 0.15f; + 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 ) { + draw_really_big_string( 9, ( cur_pos += offset ), clr_t( 110, 110, 110, 255 ), xors( "PING" ) ); + draw_really_big_string( 11, cur_pos + 2, clr_t( 0, 0, 0, 255 ), xors( "PING" ) ); + draw_really_big_string( 10, cur_pos, 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( 9, ( cur_pos += offset ), clr_t( 110, 110, 110, 255 ), xors( "EDGE" ) ); + draw_really_big_string( 11, cur_pos + 2, clr_t( 0, 0, 0, 255 ), xors( "EDGE" ) ); + draw_really_big_string( 10, cur_pos, esp_green( ), xors( "EDGE" ) ); + } + + if( g_settings.rage.break_lby( ) ) { + draw_really_big_string( 9, ( cur_pos += offset ), clr_t( 110, 110, 110, 255 ), xors( "LBY" ) ); + draw_really_big_string( 11, cur_pos + 2, clr_t( 0, 0, 0, 255 ), xors( "LBY" ) ); + draw_really_big_string( 10, cur_pos, 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 ) + 18, 36, 3, 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 + 19, 34 * progress, 1, esp_green( ) ); + } + } + + if( g_settings.rage.preserve_fps && g_settings.rage.enabled && util::is_low_fps( ) ) { + draw_really_big_string( 9, ( cur_pos += offset ), clr_t( 110, 110, 110, 255 ), xors( "FPS" ) ); + draw_really_big_string( 11, cur_pos + 2, clr_t( 0, 0, 0, 255 ), xors( "FPS" ) ); + draw_really_big_string( 10, cur_pos, esp_red( ), xors( "FPS" ) ); + } + } + + bool onground = g_ctx.m_local->m_fFlags( ) & FL_ONGROUND; + bool air_lag = g_settings.rage.fakelag.in_air; + bool move_lag = g_settings.rage.fakelag.in_move; + + bool should_lag = ( air_lag && !onground ) || ( move_lag && onground ); + + if( g_settings.rage.fakelag.mode( ) && + g_settings.rage.fakelag.ticks( ) && + should_lag ) { + int min_dist = 64; + int max_ticks = g_settings.rage.fakelag.ticks; + max_ticks += g_settings.rage.fakelag.fluctuate * max_ticks * 0.01f; + max_ticks = std::min( max_ticks, 16 ); + + float speed = g_ctx.m_local->m_vecVelocity( ).length2d( ); + bool breaking = g_cheat.m_lagmgr.is_breaking_lc( ); + if( speed * g_csgo.m_globals->m_interval_per_tick * max_ticks > 55 && speed >= 245.f || breaking ) { + draw_really_big_string( 9, ( cur_pos += offset ), clr_t( 110, 110, 110, 255 ), xors( "LC" ) ); + draw_really_big_string( 11, cur_pos + 2, clr_t( 0, 0, 0, 255 ), xors( "LC" ) ); + draw_really_big_string( 10, cur_pos, 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 ); + + auto wep = g_ctx.m_local->get_weapon( ); + if( wep ) { + float inacc = g_ctx.m_weapon_inaccuracy; + + int pixels = inacc * 75; + + if( pixels < 2 ) { + 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 ) ); + } + else { + for( int i = -pixels; i < pixels; ++i ) { + float a = 1.f - ( float )( std::abs( i ) ) / ( float )( pixels ); + + float inacc_alpha = 1.f - ( inacc * 3.f ); + inacc_alpha = std::clamp( inacc_alpha, 0.4f, 1.f ); + + draw_line( 0, h / 2 + i, w, h / 2 + i, clr_t( 0, 0, 0, 255 * a * inacc_alpha ) ); + draw_line( w / 2 + i, 0, w / 2 + i, h, clr_t( 0, 0, 0, 255 * a * inacc_alpha ) ); + } + } + } + } + + 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, g_settings.visuals.grenade_pred_clr ); + + 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, g_settings.visuals.grenade_pred_clr, 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.travel_range = ( end - data.src ).length( ); + data.traveled = 0.f; + data.to_travel = data.travel_range; + + 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 ) ); + +#ifdef _DEBUG + static con_var< bool > dbg_awall{ &data::holder_, fnv( "dbg_awall" ) }; + + if( dbg_awall( ) ) { + draw_string( screen_w / 2 + 5, screen_h / 2 + 5, ALIGN_LEFT, true, + can_penetrate ? clr_t( 0, 220, 0 ) : clr_t( 220, 0, 0 ), "%d", ( int )data.current_damage ); + } +#endif + } + + 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/cheat/internal_rewrite/visual_player.cpp b/cheat/internal_rewrite/visual_player.cpp new file mode 100644 index 0000000..f14a0d7 --- /dev/null +++ b/cheat/internal_rewrite/visual_player.cpp @@ -0,0 +1,1174 @@ +#include + +#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.f && m_anim_progress[ index ] <= 0.3f + && m_has_seen[ index ] && g_settings.visuals.dormant ) { + m_anim_progress[ index ] = 0.3f; + } + } + + void c_visuals::reset_position( ) { + for( size_t i{ }; i < 65; ++i ) { + m_anim_progress[ i ] = 0.f; + m_has_seen[ i ] = false; + } + } + + 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; + + float delta = ( g_csgo.m_globals->m_curtime - m_last_hit ) * 1.5f; + if( std::abs( delta ) > 1.0f ) return; + + clr_t col = g_settings.menu.menu_color; + if( delta > 0.75f ) { + col.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 }; + + for( size_t dist = 7; dist < 14; ++dist ) { + vec2_t start = get_rotated_point( center, rotation, dist ); + vec2_t end = get_rotated_point( center, rotation, dist + 1 ); + + vec2_t rot_start = get_rotated_point( center, rotation - 180.f, dist ); + vec2_t rot_end = get_rotated_point( center, rotation - 180.f, dist + 1 ); + + int point = dist - 6; + float percentage = point / 7; + + percentage = 1.f - percentage; + percentage *= std::clamp( delta + 0.75f, 0.f, 1.f ); + + clr_t draw = col; + draw.a( ) *= percentage; + + draw_line( start, end, draw ); + draw_line( rot_start, rot_end, draw ); + } + } + } + + struct box_t { + int x, y, w, h; + }; + + box_t get_box( c_base_player* ent, vec3_t stored_origin ) { + const matrix3x4& matrix = ent->m_CoordinateFrame( ); + + vec2_t min_corner{ FLT_MAX, FLT_MAX }; + vec2_t max_corner{ FLT_MIN, FLT_MIN }; + + vec3_t min_pos; + vec3_t max_pos; + + matrix3x4 bone_matrix[ 128 ]; + memcpy( bone_matrix, ent->m_CachedBoneData( ).GetElements( ), ent->m_CachedBoneData( ).GetSize( ) * sizeof( matrix3x4 ) ); + + auto hdr = g_csgo.m_model_info( )->GetStudiomodel( ent->ce( )->GetModel( ) ); + + for( size_t i{ }; i < hdr->numbones; ++i ) { + auto bone = hdr->GetBone( i ); + + if( bone && bone->parent != -1 && bone->flags & 0x100 ) { + auto& matrix = bone_matrix[ i ]; + vec3_t hitbox = vec3_t( matrix[ 0 ][ 3 ], matrix[ 1 ][ 3 ], matrix[ 2 ][ 3 ] ); + hitbox -= ent->ce( )->GetRenderOrigin( ); + hitbox += stored_origin; + + + vec2_t pos = util::screen_transform( hitbox ); + + if( pos.x < min_corner.x ) + min_corner.x = pos.x; + + if( pos.x > max_corner.x ) + max_corner.x = pos.x; + + if( pos.y < min_corner.y ) + min_corner.y = pos.y; + + if( pos.y > max_corner.y ) + max_corner.y = pos.y; + } + } + + vec2_t origin = util::screen_transform( stored_origin ); + if( max_corner.y > 1 && max_corner.x > 1 && min_corner.y < screen_h && min_corner.x < screen_w ) { + vec3_t origin_zoffset = stored_origin; + origin_zoffset.z += 10; + + vec2_t delta = util::screen_transform( origin_zoffset ) - origin; + + min_corner.x += delta.y; + max_corner.x -= delta.y; + + min_corner.y += delta.y; + max_corner.y -= delta.y; + } + else { + return { -100, -100, 0, 0 }; + } + + int x = ( int )min_corner.x; + int w = ( int )( max_corner.x - min_corner.x ); + + int y = ( int )min_corner.y; + int h = ( int )( max_corner.y - min_corner.y ); + + return { x, 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; + +#ifdef HEADER_MODULE + static auto manager_ptr = g_header.patterns.glow_manager + 0x3; +#else + 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 ); +#endif + + 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->has_valid_anim( ) && ( 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::update_positions( ) { + CUtlVector< CSndInfo > sound_info{ }; + + g_csgo.m_engine_sound( )->GetActiveSounds( sound_info ); + + for( size_t i{ }; i < sound_info.GetSize( ); ++i ) { + auto& snd = sound_info.GetElements( )[ i ]; + + if( snd.origin ) { + int idx = snd.sound_source; + auto ent = g_csgo.m_entlist( )->GetClientEntity( idx ); + + if( ent && ent->is_player( ) && ent->ce( )->IsDormant( ) ) + update_position( idx, snd.origin[ 0 ] ); + } + } + } + + void c_visuals::draw_players( ) { + static constexpr float anim_rate = 1.0f / 0.5f; + 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 ) { + m_has_seen[ i ] = false; + m_anim_progress[ i ] = 0.f; + continue; + } + + if( !ent->has_valid_anim( ) ) + 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( ); + int health = ent->m_iHealth( ); + auto origin = ent->ce( )->GetRenderOrigin( ); + 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( ) ) > 2000.f; + + if( !dormant ) { + update_position( i, origin ); + if( anim > 0.f ) + anim = std::clamp( anim + rate, 0.f, 1.f ); + else + anim = 0.5f; + + m_has_seen[ i ] = true; + } + else { + if( anim < 0.3f && g_settings.visuals.dormant && !too_distant ) { + rate *= 0.02f; + } + anim = std::clamp( anim -= rate, 0.f, 1.0f ); + if( m_anim_progress[ i ] <= 0.f ) { + m_has_seen[ i ] = false; + continue; + } + } + + auto box = get_box( ent, m_stored_pos[ i ] ); + + 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; + } + + 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 ]; + + 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 && g_ctx.m_local->is_valid( ) ) { + if( ent->m_fFlags( ) & FL_ONGROUND && ent->get_anim_velocity( ).length2d( ) < 0.1f && !dormant && !g_settings.misc.hide_from_obs ) { + 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 ) { + + //don't allocate 20000000 bytes on the stack thx + static vertex_t v[ 48 ]; + + float radius = box.w / 5.f; + + radius = std::clamp( radius, 4.f, 8.f ); + + right_pos += radius * 2; + + v[ 0 ].init( x_pos + radius / 2 + 2, y_pos + radius / 2 + 2 ); + + int progress = ( 1.f - delta ) * 48; + + + const float step = ( M_PI * 2.f ) / 48.f; + + for( int r = 1; r < progress; ++r ) { + float s = sin( step * r ) * radius; + float c = cos( step * r ) * radius; + + + v[ r ].init( x_pos + radius / 2 + c + 2, y_pos + s + radius / 2 + 2 ); + } + + g_renderer.draw_filled_circle( x_pos + radius / 2 + 2, y_pos + radius / 2 + 2, radius + 1, clr_t( 0, 0, 0, 170 * alpha ) ); + g_renderer.draw_polygon( progress, v, g_settings.visuals.lby_bar_clr ); + } + } + else { + 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_state( i ) && !dormant && g_ctx.m_local->is_valid( ) && g_settings.misc.hide_from_obs( ) ) { + 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 ) { + const float step = M_PI * 2.f / 6; + + float radius = std::clamp( box.w / 5.f, 4.f, 8.f ); + + for( int i = 0; i < 6; ++i ) { + float c = cos( step * i + DEG2RAD( 30.f ) ); + float s = sin( step * i + DEG2RAD( 30.f ) ); + + float off = 0; + + if( i == 5 || i == 0 ) + off = 0.25f; + + draw_line( x_pos + c * radius / 2 + radius / 2 + 2, y_pos + right_pos + s * radius / 2 + radius / 2 + 3, + x_pos + c * ( radius + off ) + radius / 2 + off + 2, y_pos + s * ( radius + off ) + right_pos + radius / 2 + 3, + blend_clr( esp_blue( 255 * alpha ), anim ) ); + } + + //draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, blend_clr( esp_blue( 255 * alpha ), anim ), xors( "flash" ) ); + right_pos += radius * 2.3f; + } + + 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; + } + } + + + + static con_var< bool > dbg_multipoint{ &data::holder_, fnv( "dbg_multipoint" ), false }; + if( dbg_multipoint( ) ) { + auto should_multipoint = [ ]( int hitbox, bool moving ) -> bool { + auto& setting = g_settings.rage.multipoint; + + switch( hitbox ) { + case HITBOX_HEAD: + return setting.head; + case HITBOX_PELVIS: + case HITBOX_BODY: + return setting.stomach; + //case HITBOX_CHEST: + case HITBOX_UPPER_CHEST: + case HITBOX_THORAX: + return setting.chest; + case HITBOX_RIGHT_THIGH: + case HITBOX_LEFT_THIGH: + if( moving && g_settings.rage.ignore_limbs_moving ) + return false; + + if( g_settings.rage.preserve_fps && util::is_low_fps( ) ) + return false; + + return setting.thighs; + + 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 setting.calves; + default: + return false; + } + }; + + bool moving = ent->m_vecVelocity( ).length2d( ) > 0.1f && !ent->is_fakewalking( ); + + matrix3x4 bone_matrix[ 128 ]; + ent->ce( )->SetupBones( bone_matrix, 128, BONE_USED_BY_HITBOX, 0.f ); + + for( int hitbox = 0; hitbox < HITBOX_MAX; ++hitbox ) { + if( should_multipoint( hitbox, moving ) ) { + const auto model = ent->ce( )->GetModel( ); + if( !model ) continue; + + auto hdr = g_csgo.m_model_info( )->GetStudiomodel( model ); + if( !hdr ) continue; + + auto set = hdr->pHitboxSet( ent->m_nHitboxSet( ) ); + if( !set ) continue; + + //literally 20000 iq, the best multipoint + //im an actual fucking retard jesus christ + auto box = set->pHitbox( hitbox ); + if( !box ) continue; + + 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; + + std::vector< vec3_t > points; + + points.push_back( center ); + + if( g_settings.rage.multipoint_enable( ) == 1 || + hitbox == HITBOX_LEFT_CALF || hitbox == HITBOX_RIGHT_CALF || + hitbox == HITBOX_LEFT_THIGH || hitbox == HITBOX_RIGHT_THIGH ) { + points.push_back( vec3_t{ min.x, min.y, center.z } ); + points.push_back( vec3_t{ max.x, min.y, center.z } ); + points.push_back( vec3_t{ min.x, max.y, center.z } ); + points.push_back( vec3_t{ max.x, max.y, center.z } ); + } + else if( g_settings.rage.multipoint_enable( ) == 2 ) { + points.push_back( vec3_t{ max.x, max.y, max.z } ); + points.push_back( vec3_t{ min.x, max.y, max.z } ); + points.push_back( vec3_t{ max.x, min.y, max.z } ); + points.push_back( vec3_t{ min.x, min.y, max.z } ); + + points.push_back( vec3_t{ max.x, max.y, min.z } ); + points.push_back( vec3_t{ min.x, max.y, min.z } ); + points.push_back( vec3_t{ max.x, min.y, min.z } ); + points.push_back( vec3_t{ min.x, min.y, min.z } ); + } + else if( g_settings.rage.multipoint_enable( ) == 3 ) { + points.push_back( vec3_t{ min.x, min.y, center.z } ); + points.push_back( vec3_t{ max.x, min.y, center.z } ); + points.push_back( vec3_t{ min.x, max.y, center.z } ); + points.push_back( vec3_t{ max.x, max.y, center.z } ); + + points.push_back( vec3_t{ max.x, max.y, max.z } ); + points.push_back( vec3_t{ min.x, max.y, max.z } ); + points.push_back( vec3_t{ max.x, min.y, max.z } ); + points.push_back( vec3_t{ min.x, min.y, max.z } ); + + points.push_back( vec3_t{ max.x, max.y, min.z } ); + points.push_back( vec3_t{ min.x, max.y, min.z } ); + points.push_back( vec3_t{ max.x, min.y, min.z } ); + points.push_back( vec3_t{ min.x, min.y, min.z } ); + } + + for( size_t i1 = 0; i1 < points.size( ); i1++ ) { + auto& it = points.at( i1 ); + + auto trans = math::vector_transform( it, bone_matrix[ box->bone ] ); + auto w2s_box = util::screen_transform( trans ); + + draw_circle( ( int )w2s_box.x, ( int )w2s_box.y, 3, esp_blue( ), 16 ); + } + } + } + } + +#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 ); + } + + auto ent_origin = ent->m_vecOrigin( ); + auto ent_origin_vel = origin + ent->get_animdata( ).m_anim_velocity; + ent_origin_vel.z = ent_origin.z; + + draw_line( util::screen_transform( ent_origin ), util::screen_transform( ent_origin_vel ), esp_blue( ) ); + } +#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::store_hit( context::shot_data_t* shot ) { + if( !g_settings.visuals.hits ) + return; + + hit_t new_hit; + + auto ent = g_csgo.m_entlist( )->GetClientEntity( shot->m_enemy_index ); + + new_hit.m_ent = shot->m_enemy_index; + ent->get_name_safe( new_hit.m_name ); + + memcpy( new_hit.m_matrix, + shot->m_matrix, + sizeof( matrix3x4 ) * 128 ); + + new_hit.m_pos = shot->m_enemy_pos; + new_hit.m_time = g_csgo.m_globals->m_curtime; + + m_hits.push_back( new_hit ); + } + + void c_visuals::draw_skeletons( ) { + if( !g_settings.visuals.hits ) + return; + + for( size_t i{ }; i < m_hits.size( ) && !m_hits.empty( ); ++i ) { + auto& hit = m_hits[ i ]; + + float delta = g_csgo.m_globals->m_curtime - hit.m_time; + if( std::abs( delta ) > g_settings.visuals.target_time ) + m_hits.erase( m_hits.begin( ) + i ); + } + + for( auto& it : m_hits ) { + auto ent = g_csgo.m_entlist( )->GetClientEntity( it.m_ent ); + + if( !ent || !ent->is_player( ) ) + continue; + + if( !ent->is_alive( ) ) + it.m_dead = true; + + auto hdr = g_csgo.m_model_info( )->GetStudiomodel( ent->ce( )->GetModel( ) ); + + auto matrix = it.m_matrix; + vec3_t pos = it.m_pos; + float delta = g_csgo.m_globals->m_curtime - it.m_time; + + float total = g_settings.visuals.target_time; + float threshold = total * 0.5f; + + float fade = total - delta < threshold ? ( total - delta ) / ( total * 0.5f ) : 1.f; + + float dist_fade = 1.f; + if( ent->is_valid( ) && !it.m_dead ) { + dist_fade = 300.f - std::clamp( ent->ce( )->GetRenderOrigin( ).dist_to( pos ), 1.f, 300.f ) / 300.f; + } + + clr_t col = clr_t( 255, 255, 255, 100 * dist_fade * fade ); + + clr_t outer_col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ? + g_settings.visuals.glow_friendly : + g_settings.visuals.glow_enemy; + + outer_col.a( ) *= 0.65f; + outer_col.a( ) *= ( fade * dist_fade ); + + 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 - vec2_t( 1, 1 ), parent_screen - vec2_t( 1, 1 ), outer_col ); + draw_line( child_screen, parent_screen, col ); + + draw_line( child_screen + vec2_t( 1, 1 ), parent_screen + vec2_t( 1, 1 ), outer_col ); + } + } + } + } + + 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( ) { + reset_position( ); + + m_last_roundstart = g_csgo.m_globals->m_curtime; + for( size_t i{ }; i < 65; ++i ) { + m_ent_dmg[ i ] = 0.f; + } + } + + 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 ) { + update_positions( ); + draw_players( ); + draw_skeletons( ); + } + + draw_world( ); + draw_tracers( ); + draw_hits( ); + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/visual_world.cpp b/cheat/internal_rewrite/visual_world.cpp new file mode 100644 index 0000000..ea3d31d --- /dev/null +++ b/cheat/internal_rewrite/visual_world.cpp @@ -0,0 +1,415 @@ +#include +#include +#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; + + bool fade = false; + + std::string name = xors( "nade" ); + if( strstr( hdr->name, xors( "flash" ) ) ) { + name = xors( "flash" ); + fade = true; + } + else if( strstr( hdr->name, xors( "smoke" ) ) ) { + name = xors( "smoke" ); + fade = true; + } + else if( strstr( hdr->name, xors( "decoy" ) ) ) { + name = xors( "decoy" ); + fade = true; + } + 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 && fade ) { + col.a( ) *= std::max( ( 1000.f - ( dist - 250.f ) ) / 1000.f, 0.f ); + } + + draw_string( w2s.x, w2s.y, ALIGN_CENTER, false, + col, name.c_str( ) ); + + char name[ 32 ]; + cutie->get_name_safe( name ); + + if( g_settings.visuals.grenade_owner( ) ) + draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, col, 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; + + vec3_t text_pos = it.m_pos; + text_pos.z += 5.f; + + auto w2s = util::screen_transform( text_pos ); + + float delta = g_csgo.m_globals->m_curtime - it.m_time; + + if( g_ctx.m_local->is_valid( ) && ( ent->m_iTeamNum( ) != g_ctx.m_local->m_iTeamNum( ) || ent == g_ctx.m_local ) ) { + vec3_t last_pos; + + const float fill = ( life_span->get_float( ) - delta ) / ( life_span->get_float( ) ) * 180.f; + + for( float rot = -fill; rot <= fill; rot += 3.f ) { + auto rotation = rot + delta * 90.f; + + while( rotation > 360.f ) + rotation -= 360.f; + + vec3_t rotated_pos = it.m_pos; + + rotated_pos.z -= 5.f; + + const auto radius = 50.f; + rotated_pos.x += cos( DEG2RAD( rotation ) ) * radius; + rotated_pos.y += sin( DEG2RAD( rotation ) ) * radius; + + if( rot != -fill ) { + auto w2s_new = util::screen_transform( rotated_pos ); + auto w2s_old = util::screen_transform( last_pos ); + auto alpha = 1.f - ( std::abs( rot ) / fill ); + + float threshold = life_span->get_float( ) * 0.2f; + + if( life_span->get_float( ) - delta < threshold ) { + float diff = ( life_span->get_float( ) - delta ) / ( life_span->get_float( ) ) * 5.f; + + alpha *= diff; + } + + clr_t col = g_settings.visuals.grenade_esp_clr; + + col.a( ) *= alpha; + + draw_line( w2s_old, w2s_new, col ); + } + + last_pos = rotated_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/cheat/internal_rewrite/vmt.hpp b/cheat/internal_rewrite/vmt.hpp new file mode 100644 index 0000000..03409ce --- /dev/null +++ b/cheat/internal_rewrite/vmt.hpp @@ -0,0 +1,95 @@ +#pragma once +#include +#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; + bool m_copied; + 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 ] ); + } + + m_copied = false; + } + + ~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 ) { + if( !m_copied ) { + auto data = this->m_new.data( ); + *this->m_table = uintptr_t( &data[ 1 ] ); + + m_copied = true; + } + + 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 ) { + if( !m_copied ) { + auto data = this->m_new.data( ); + *this->m_table = uintptr_t( &data[ 1 ] ); + + m_copied = true; + } + + 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/cheat/internal_rewrite/window_procedure.cpp b/cheat/internal_rewrite/window_procedure.cpp new file mode 100644 index 0000000..ffe9ccb --- /dev/null +++ b/cheat/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/cheat/internal_rewrite/wipe.hpp b/cheat/internal_rewrite/wipe.hpp new file mode 100644 index 0000000..dfb72a8 --- /dev/null +++ b/cheat/internal_rewrite/wipe.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "util.hpp" +#include + +#ifdef HEADER_MODULE + #define EXPAND( x,y )x##y + + #define BEGIN___( MARKER_BEGIN )MARKER_BEGIN: + + #define DEL_END___( MARKER_BEGIN, MARKER_END )__asm { __asm PUSH MARKER_END __asm PUSH MARKER_BEGIN __asm CALL antidebug::erase } \ + MARKER_END: + + #define BEGIN__( x, y ) BEGIN___( EXPAND2( MARKER_BEGIN_, x, y ) ) + #define END__( x, y ) DEL_END___( EXPAND2( MARKER_BEGIN_, x, y ), EXPAND2( MARKER_END_, x, y ) ) + + #define DELETE_START( x ) BEGIN___( EXPAND( MARKER_BEGIN_, x ) ) + #define DELETE_END( x ) DEL_END___( EXPAND( MARKER_BEGIN_, x ), EXPAND( MARKER_END_, x ) ) +#else + #define DELETE_START( x ) + #define DELETE_END( x ) +#endif + +namespace antidebug +{ + static void __stdcall erase( uintptr_t start, uintptr_t end ) { + uintptr_t size = end - start; + + DWORD protection_flag{ }; + VirtualProtect( ( void* )start, size, PAGE_EXECUTE_READWRITE, &protection_flag ); + + for( unsigned int i = 0; i < size; i++ ) { + int random = rand( ) % 0x90; + memset( ( void* )( start + i ), random, 1 ); + } + + VirtualProtect( ( void* )start, size, protection_flag, &protection_flag ); + } + + static void fuck_skids( ) { + DELETE_START( 0 ); + // stop most debuggers from working as breakpoint is patched to exit process call + + ulong_t old_protection = 0; + + uintptr_t exit_process = ( uintptr_t )GetProcAddress( GetModuleHandleA( xors( "kernel32.dll" ) ), xors( "ExitProcess" ) ); + uintptr_t dbg_ui_remote_breakin = ( uintptr_t )GetProcAddress( GetModuleHandleA( xors( "ntdll.dll" ) ), xors( "DbgUiRemoteBreakin" ) ); + uintptr_t dbg_break_point = ( uintptr_t )GetProcAddress( GetModuleHandleA( xors( "ntdll.dll" ) ), xors( "DbgBreakPoint" ) ); + + // fuck DbgUiRemoteBreakin + VirtualProtect( ( void* )dbg_ui_remote_breakin, 6, PAGE_EXECUTE_READWRITE, &old_protection ); + + *( uint8_t* )( dbg_ui_remote_breakin ) = 0x68; // push + *( uintptr_t* )( dbg_ui_remote_breakin + 1 ) = exit_process; + *( uint8_t* )( dbg_ui_remote_breakin + 5 ) = 0xC3; // ret + + VirtualProtect( ( void* )dbg_ui_remote_breakin, 6, old_protection, &old_protection ); + + // fuck DbgBreakPoint + VirtualProtect( ( void* )dbg_break_point, 6, PAGE_EXECUTE_READWRITE, &old_protection ); + + *( uint8_t* )( dbg_break_point ) = 0x68; // push + *( uintptr_t* )( dbg_break_point + 1 ) = exit_process; + *( uint8_t* )( dbg_break_point + 5 ) = 0xC3; // ret + + VirtualProtect( ( void* )dbg_break_point, 6, old_protection, &old_protection ); + + DELETE_END( 0 ); + } +} \ No newline at end of file diff --git a/cheat/internal_rewrite/x86.hpp b/cheat/internal_rewrite/x86.hpp new file mode 100644 index 0000000..e737013 --- /dev/null +++ b/cheat/internal_rewrite/x86.hpp @@ -0,0 +1,47 @@ +#pragma once +#include + +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 -- cgit v1.2.3