first

author: JustSomePwner <crotchyalt@gmail.com> 2018-08-30 14:01:54 +0200
committer: JustSomePwner <crotchyalt@gmail.com> 2018-08-30 14:01:54 +0200
commit: 7ccb819f867493f8ec202ea3b39c94c198c64584 (patch)
tree: 94622e61af0ff359e3d6689cf274d74f60b2492a /tf2
parent: 564d979b79e8a5aaa5014eba0ecd36c61575934f (diff)
149 files changed, 25691 insertions, 0 deletions
diff --git a/tf2/ButtonCode_t.h b/tf2/ButtonCode_t.h
new file mode 100644
index 0000000..1d11c19
--- /dev/null
+++ b/tf2/ButtonCode_t.h
@@ -0,0 +1,253 @@
+#pragma once
+
+#define MAX_SPLITSCREEN_CLIENT_BITS 2
+#define MAX_SPLITSCREEN_CLIENTS	( 1 << MAX_SPLITSCREEN_CLIENT_BITS ) // 4
+
+#define JOYSTICK_BUTTON_INTERNAL( _joystick, _button ) ( JOYSTICK_FIRST_BUTTON + ((_joystick) * JOYSTICK_MAX_BUTTON_COUNT) + (_button) )
+#define JOYSTICK_POV_BUTTON_INTERNAL( _joystick, _button ) ( JOYSTICK_FIRST_POV_BUTTON + ((_joystick) * JOYSTICK_POV_BUTTON_COUNT) + (_button) )
+#define JOYSTICK_AXIS_BUTTON_INTERNAL( _joystick, _button ) ( JOYSTICK_FIRST_AXIS_BUTTON + ((_joystick) * JOYSTICK_AXIS_BUTTON_COUNT) + (_button) )
+
+#define JOYSTICK_BUTTON( _joystick, _button ) ( (ButtonCode_t)JOYSTICK_BUTTON_INTERNAL( _joystick, _button ) )
+#define JOYSTICK_POV_BUTTON( _joystick, _button ) ( (ButtonCode_t)JOYSTICK_POV_BUTTON_INTERNAL( _joystick, _button ) )
+#define JOYSTICK_AXIS_BUTTON( _joystick, _button ) ( (ButtonCode_t)JOYSTICK_AXIS_BUTTON_INTERNAL( _joystick, _button ) )
+
+enum {
+	MAX_JOYSTICKS = MAX_SPLITSCREEN_CLIENTS,
+	MOUSE_BUTTON_COUNT = 5,
+};
+
+enum JoystickAxis_t {
+	JOY_AXIS_X = 0,
+	JOY_AXIS_Y,
+	JOY_AXIS_Z,
+	JOY_AXIS_R,
+	JOY_AXIS_U,
+	JOY_AXIS_V,
+	MAX_JOYSTICK_AXES,
+};
+
+enum {
+	JOYSTICK_MAX_BUTTON_COUNT = 32,
+	JOYSTICK_POV_BUTTON_COUNT = 4,
+	JOYSTICK_AXIS_BUTTON_COUNT = MAX_JOYSTICK_AXES * 2,
+};
+
+enum ButtonCode_t {
+	BUTTON_CODE_INVALID = -1,
+	BUTTON_CODE_NONE = 0,
+
+	KEY_FIRST = 0,
+
+	KEY_NONE = KEY_FIRST,
+	KEY_0,
+	KEY_1,
+	KEY_2,
+	KEY_3,
+	KEY_4,
+	KEY_5,
+	KEY_6,
+	KEY_7,
+	KEY_8,
+	KEY_9,
+	KEY_A,
+	KEY_B,
+	KEY_C,
+	KEY_D,
+	KEY_E,
+	KEY_F,
+	KEY_G,
+	KEY_H,
+	KEY_I,
+	KEY_J,
+	KEY_K,
+	KEY_L,
+	KEY_M,
+	KEY_N,
+	KEY_O,
+	KEY_P,
+	KEY_Q,
+	KEY_R,
+	KEY_S,
+	KEY_T,
+	KEY_U,
+	KEY_V,
+	KEY_W,
+	KEY_X,
+	KEY_Y,
+	KEY_Z,
+	KEY_PAD_0,
+	KEY_PAD_1,
+	KEY_PAD_2,
+	KEY_PAD_3,
+	KEY_PAD_4,
+	KEY_PAD_5,
+	KEY_PAD_6,
+	KEY_PAD_7,
+	KEY_PAD_8,
+	KEY_PAD_9,
+	KEY_PAD_DIVIDE,
+	KEY_PAD_MULTIPLY,
+	KEY_PAD_MINUS,
+	KEY_PAD_PLUS,
+	KEY_PAD_ENTER,
+	KEY_PAD_DECIMAL,
+	KEY_LBRACKET,
+	KEY_RBRACKET,
+	KEY_SEMICOLON,
+	KEY_APOSTROPHE,
+	KEY_BACKQUOTE,
+	KEY_COMMA,
+	KEY_PERIOD,
+	KEY_SLASH,
+	KEY_BACKSLASH,
+	KEY_MINUS,
+	KEY_EQUAL,
+	KEY_ENTER,
+	KEY_SPACE,
+	KEY_BACKSPACE,
+	KEY_TAB,
+	KEY_CAPSLOCK,
+	KEY_NUMLOCK,
+	KEY_ESCAPE,
+	KEY_SCROLLLOCK,
+	KEY_INSERT,
+	KEY_DELETE,
+	KEY_HOME,
+	KEY_END,
+	KEY_PAGEUP,
+	KEY_PAGEDOWN,
+	KEY_BREAK,
+	KEY_LSHIFT,
+	KEY_RSHIFT,
+	KEY_LALT,
+	KEY_RALT,
+	KEY_LCONTROL,
+	KEY_RCONTROL,
+	KEY_LWIN,
+	KEY_RWIN,
+	KEY_APP,
+	KEY_UP,
+	KEY_LEFT,
+	KEY_DOWN,
+	KEY_RIGHT,
+	KEY_F1,
+	KEY_F2,
+	KEY_F3,
+	KEY_F4,
+	KEY_F5,
+	KEY_F6,
+	KEY_F7,
+	KEY_F8,
+	KEY_F9,
+	KEY_F10,
+	KEY_F11,
+	KEY_F12,
+	KEY_CAPSLOCKTOGGLE,
+	KEY_NUMLOCKTOGGLE,
+	KEY_SCROLLLOCKTOGGLE,
+
+	KEY_LAST = KEY_SCROLLLOCKTOGGLE,
+	KEY_COUNT = KEY_LAST - KEY_FIRST + 1,
+
+	// Mouse
+	MOUSE_FIRST = KEY_LAST + 1,
+
+	MOUSE_LEFT = MOUSE_FIRST,
+	MOUSE_RIGHT,
+	MOUSE_MIDDLE,
+	MOUSE_4,
+	MOUSE_5,
+	MOUSE_WHEEL_UP,		// A fake button which is 'pressed' and 'released' when the wheel is moved up 
+	MOUSE_WHEEL_DOWN,	// A fake button which is 'pressed' and 'released' when the wheel is moved down
+
+	MOUSE_LAST = MOUSE_WHEEL_DOWN,
+	MOUSE_COUNT = MOUSE_LAST - MOUSE_FIRST + 1,
+
+	// Joystick
+	JOYSTICK_FIRST = MOUSE_LAST + 1,
+
+	JOYSTICK_FIRST_BUTTON = JOYSTICK_FIRST,
+	JOYSTICK_LAST_BUTTON = JOYSTICK_BUTTON_INTERNAL( MAX_JOYSTICKS - 1, JOYSTICK_MAX_BUTTON_COUNT - 1 ),
+	JOYSTICK_FIRST_POV_BUTTON,
+	JOYSTICK_LAST_POV_BUTTON = JOYSTICK_POV_BUTTON_INTERNAL( MAX_JOYSTICKS - 1, JOYSTICK_POV_BUTTON_COUNT - 1 ),
+	JOYSTICK_FIRST_AXIS_BUTTON,
+	JOYSTICK_LAST_AXIS_BUTTON = JOYSTICK_AXIS_BUTTON_INTERNAL( MAX_JOYSTICKS - 1, JOYSTICK_AXIS_BUTTON_COUNT - 1 ),
+
+	JOYSTICK_LAST = JOYSTICK_LAST_AXIS_BUTTON,
+
+	BUTTON_CODE_LAST,
+	BUTTON_CODE_COUNT = BUTTON_CODE_LAST - KEY_FIRST + 1,
+
+	// Helpers for XBox 360
+	KEY_XBUTTON_UP = JOYSTICK_FIRST_POV_BUTTON,	// POV buttons
+	KEY_XBUTTON_RIGHT,
+	KEY_XBUTTON_DOWN,
+	KEY_XBUTTON_LEFT,
+
+	KEY_XBUTTON_A = JOYSTICK_FIRST_BUTTON,		// Buttons
+	KEY_XBUTTON_B,
+	KEY_XBUTTON_X,
+	KEY_XBUTTON_Y,
+	KEY_XBUTTON_LEFT_SHOULDER,
+	KEY_XBUTTON_RIGHT_SHOULDER,
+	KEY_XBUTTON_BACK,
+	KEY_XBUTTON_START,
+	KEY_XBUTTON_STICK1,
+	KEY_XBUTTON_STICK2,
+	KEY_XBUTTON_INACTIVE_START,
+
+	KEY_XSTICK1_RIGHT = JOYSTICK_FIRST_AXIS_BUTTON,	// XAXIS POSITIVE
+	KEY_XSTICK1_LEFT,							// XAXIS NEGATIVE
+	KEY_XSTICK1_DOWN,							// YAXIS POSITIVE
+	KEY_XSTICK1_UP,								// YAXIS NEGATIVE
+	KEY_XBUTTON_LTRIGGER,						// ZAXIS POSITIVE
+	KEY_XBUTTON_RTRIGGER,						// ZAXIS NEGATIVE
+	KEY_XSTICK2_RIGHT,							// UAXIS POSITIVE
+	KEY_XSTICK2_LEFT,							// UAXIS NEGATIVE
+	KEY_XSTICK2_DOWN,							// VAXIS POSITIVE
+	KEY_XSTICK2_UP,								// VAXIS NEGATIVE
+	KEY_MAX,
+};
+
+enum AnalogCode_t {
+	ANALOG_CODE_INVALID = -1,
+	MOUSE_X = 0,
+	MOUSE_Y,
+	MOUSE_XY,		// Invoked when either x or y changes
+	MOUSE_WHEEL,
+
+	JOYSTICK_FIRST_AXIS,
+	JOYSTICK_LAST_AXIS = 5,
+
+	ANALOG_CODE_LAST,
+};
+
+enum InputStandardCursor_t {
+	INPUT_CURSOR_NONE = 0,
+	INPUT_CURSOR_ARROW,
+	INPUT_CURSOR_IBEAM,
+	INPUT_CURSOR_HOURGLASS,
+	INPUT_CURSOR_CROSSHAIR,
+	INPUT_CURSOR_WAITARROW,
+	INPUT_CURSOR_UP,
+	INPUT_CURSOR_SIZE_NW_SE,
+	INPUT_CURSOR_SIZE_NE_SW,
+	INPUT_CURSOR_SIZE_W_E,
+	INPUT_CURSOR_SIZE_N_S,
+	INPUT_CURSOR_SIZE_ALL,
+	INPUT_CURSOR_NO,
+	INPUT_CURSOR_HAND,
+
+	INPUT_CURSOR_COUNT
+};
+
+using PlatWindow_t = void*;
+using InputCursorHandle_t = void*;
+
+struct InputEvent_t {
+	int m_nType; // Type of the event (see InputEventType_t)
+	int m_nTick; // Tick on which the event occurred
+	int m_nData; // Generic 32-bit data, what it contains depends on the event
+	int m_nData2; // Generic 32-bit data, what it contains depends on the event
+	int m_nData3; // Generic 32-bit data, what it contains depends on the event
+};
+\ No newline at end of file
diff --git a/tf2/CAttribute.h b/tf2/CAttribute.h
new file mode 100644
index 0000000..a7dd944
--- /dev/null
+++ b/tf2/CAttribute.h
@@ -0,0 +1,41 @@
+#pragma once
+#include "UtlMem.h"
+
+class c_attribute {
+private:
+	void* vtable;
+public:
+	uint16_t m_attribute_definition_index;
+	float m_value;
+private:
+	uint32_t unk;
+
+public:
+	__forceinline c_attribute( unsigned short index, float value ) {
+		m_attribute_definition_index = index;
+		m_value = value;
+	}
+};
+
+class c_attribute_list {
+private:
+	uint32_t unk;
+public:
+	CUtlVector< c_attribute, CUtlMemory< c_attribute > > m_attributes;
+
+	__forceinline void add_attribute( int index, float value ) {
+		if ( m_attributes.Count( ) >= 15 ) return; //setting this above 15 will crash
+		if ( has_attrib( index ) ) return;
+
+		c_attribute attribute( index, value );
+		m_attributes.AddToTail( attribute );
+	}
+
+	__forceinline bool has_attrib( int index ) {
+		for ( int i{ }; i < m_attributes.Count( ); i++ ) {
+			if ( !m_attributes ) continue;
+			if ( m_attributes[ i ].m_attribute_definition_index == index ) return true;
+		}
+		return false;
+	}
+};
+\ No newline at end of file
diff --git a/tf2/CBasePlayer.cpp b/tf2/CBasePlayer.cpp
new file mode 100644
index 0000000..a5860ac
--- /dev/null
+++ b/tf2/CBasePlayer.cpp
@@ -0,0 +1,264 @@
+#include "CBasePlayer.h"
+#include "sdk.h"
+#include <string>
+#include "math.h"
+#include "graphics.h"
+#include "CBaseWeapon.h"
+#include "ClientClass.h"
+#include "IVEngineClient.h"
+
+vec3_t c_base_player::get_eye_pos( ) {
+	vec3_t offset = get_view_offset( );
+	vec3_t origin = get_origin( );
+	return offset + origin;
+}
+
+uintptr_t c_base_player::get_player_resource( ) {
+	for( int i{ 1 }; i < cl.m_entlist( )->get_highest_entity_index( ); ++i ) {
+		auto ent = cl.m_entlist( )->get_client_entity< IClientEntity >( i );
+		if( !ent ) continue;
+		auto class_ = ent->GetClientClass( );
+		if( class_ ) {
+			if( class_->m_class_id == CTFPlayerResource ) {
+				return uintptr_t( ent );
+			}
+		}
+	}
+
+	return 0;
+}
+
+player_info_t c_base_player::get_info( ) {
+	player_info_t info;
+	cl.m_engine( )->GetPlayerInfo( ce( )->index( ), &info );
+
+	return info;
+}
+
+void c_base_player::get_name_safe( char* buf ) {
+	player_info_t info;
+	if( cl.m_engine( )->GetPlayerInfo( this->ce( )->index( ), &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;
+	}
+}
+
+uintptr_t c_base_player::get_game_rules( ) {
+	static uintptr_t** game_rules = pattern::first_code_match< uintptr_t** >( cl.m_chl.dll( ), xors( "A1 ? ? ? ? 85 C0 0F 84 ? ? ? ? 80 B8 ? ? ? ? ? 0F 84 ? ? ? ? 0F 10 05" ), 0x1 );
+	return **game_rules;
+}
+
+bool c_base_player::is_valid( ) {
+	auto local = cl.m_entlist( )->get_local_player( );
+	return ( this != local && !is_dormant( ) && is_alive( ) && GetClientClass( )->m_class_id == CTFPlayer );
+}
+
+vec3_t c_base_player::get_origin( ) {
+	return m_vecOrigin( );
+}
+
+vec3_t c_base_player::get_view_offset( ) {
+	return m_vecViewOffset( );
+}
+
+vec3_t c_base_player::get_eye_angles( ) {
+	return m_angEyeAngles( );
+}
+
+vec3_t c_base_player::get_velocity( ) {
+	return m_vecVelocity( );
+}
+
+vec3_t c_base_player::get_bone_position( int bone ) {
+	matrix3x4 matrix[ 128 ];
+
+	setup_bones( matrix, 128, 0x100, cl.m_globals->curtime );
+
+	return vec3_t( matrix[ bone ][ 0 ][ 3 ], matrix[ bone ][ 1 ][ 3 ], matrix[ bone ][ 2 ][ 3 ] );
+}
+
+// bye fps lol
+vec3_t c_base_player::get_hitbox_position( int hitbox ) {
+	const auto model = get_model( );
+	if ( !model ) return vec3_t{ };
+
+	auto hdr = cl.m_modelinfo( )->GetStudioModel( model );
+	if ( !hdr ) return vec3_t{ };
+
+	matrix3x4 matrix[ 128 ];
+	if ( !setup_bones( matrix, 128, 0x100, cl.m_globals->curtime ) ) return vec3_t{ };
+
+	auto set = hdr->pHitboxSet( m_nHitboxSet( ) );
+	if ( !set ) return vec3_t{ };
+
+	auto box = set->pHitbox( hitbox );
+
+	vec3_t hitbox_center = ( box->bbmin + box->bbmax ) * 0.5f;
+
+	vec3_t transformed = math::vector_transform( hitbox_center, matrix[ box->bone ] );
+
+	return transformed;
+}
+
+int c_base_player::get_team( ) {
+	return m_iTeamNum( );
+}
+
+bool c_base_player::is_enemy( ) {
+	auto local = g_ctx.m_local;
+	if ( !local ) return false;
+	return get_team( ) != local->get_team( );
+}
+
+int c_base_player::get_class( ) {
+	int class_num = m_iClass( );
+	return std::clamp( class_num, 0, 10 ); //to prevent crashes if its out of bounds
+}
+
+const char* c_base_player::get_class_name( ) {
+	static const char* tf2_class_names[ ] = {
+		"none",
+		"scout",
+		"sniper",
+		"soldier",
+		"demoman",
+		"medic",
+		"heavy",
+		"pyro",
+		"spy",
+		"engineer",
+		"invalid"
+	};
+	return tf2_class_names[ get_class( ) ];
+}
+
+byte c_base_player::get_life_state( ) {
+	return m_lifeState( );
+}
+
+int c_base_player::get_flags( ) {
+	return m_fFlags( );
+}
+
+int c_base_player::get_health( ) {
+	return m_iHealth( );
+}
+
+int c_base_player::get_max_health( ) {
+	IClientEntity* player_resource{ };
+	for ( int i{ }; i < cl.m_entlist( )->get_highest_entity_index( ); i++ ) {
+		auto ent = cl.m_entlist( )->get_client_entity( i );
+		if ( ent && ent->GetClientClass( )->m_class_id == CTFPlayerResource ) {
+			player_resource = ent;
+			break;
+		}
+	}
+	if ( !player_resource ) return 0;
+
+	return *reinterpret_cast< int* >( uintptr_t( player_resource ) + m_iMaxHealth( ) + ( 4 * this->index( ) ) );
+}
+
+bool c_base_player::is_buffed( ) {
+	return get_health( ) > get_max_health( );
+}
+
+bool c_base_player::is_alive( ) {
+	return m_iHealth( ) > 0 && get_life_state( ) == LIFE_ALIVE;
+}
+
+int c_base_player::get_tick_base( ) {
+	return m_nTickBase( );
+}
+
+bool c_base_player::is_visible( ) {
+	auto local = cl.m_entlist( )->get_local_player( );
+	if ( !local ) return true;
+	trace_t tr;
+	Ray_t ray;
+	CTraceFilter filter;
+
+	filter.pSkip = local;
+
+	ray.Init( local->get_eye_pos( ), get_eye_pos( ) );
+
+	cl.m_trace( )->trace_ray( ray, MASK_AIM, &filter, &tr );
+
+	return ( tr.m_pEnt == this || tr.fraction > 0.99f );
+}
+
+bool c_base_player::is_visible( int hitbox ) {
+	auto local = cl.m_entlist( )->get_local_player( );
+	if ( !local ) return true;
+	trace_t tr;
+	Ray_t ray;
+	CTraceFilter filter;
+
+	filter.pSkip = local;
+
+	ray.Init( local->get_eye_pos( ), get_hitbox_position( hitbox ) );
+
+	cl.m_trace( )->trace_ray( ray, MASK_AIM, &filter, &tr );
+
+	return ( tr.m_pEnt == this || tr.fraction > 0.99f );
+}
+
+dynamic_box_t c_base_player::get_dynamic_box( ) {
+	const matrix3x4& trans = m_CollisionGroup( );
+
+	vec3_t min = *reinterpret_cast< vec3_t* >( this + m_Collision( ) + 0x8 );
+	vec3_t max = *reinterpret_cast< vec3_t* >( this + m_Collision( ) + 0x14 );
+
+	vec3_t point_list[ ] = {
+		vec3_t( min.x, min.y, min.z ),
+		vec3_t( min.x, max.y, min.z ),
+		vec3_t( max.x, max.y, min.z ),
+		vec3_t( max.x, min.y, min.z ),
+		vec3_t( max.x, max.y, max.z ),
+		vec3_t( min.x, max.y, max.z ),
+		vec3_t( min.x, min.y, max.z ),
+		vec3_t( max.x, min.y, max.z )
+	};
+
+	vec3_t transformed[ 8 ];
+
+	for ( int i{ }; i < 8; i++ ) {
+		transformed[ i ] = math::vector_transform( point_list[ i ], trans );
+	}
+
+	vec2_t screen_pos[ 8 ]{ vec2_t( 0.f, 0.f ) };
+
+	for ( int i = 0; i < 8; i++ ) {
+		screen_pos[ i ] = graphics.world_to_screen( transformed[ i ] );
+	}
+
+	float left = FLT_MAX, top = FLT_MIN, right = FLT_MIN, bottom = FLT_MAX;
+
+	for ( int i{ }; i < 8; i++ ) {
+		left = std::min< float >( left, screen_pos[ i ].x );
+		top = std::max< float >( top, screen_pos[ i ].y );
+		right = std::max< float >( right, screen_pos[ i ].x );
+		bottom = std::min< float >( bottom, screen_pos[ i ].y );
+	}
+
+	if ( right - left > 4000.f || top - bottom > 4000.f ) return{ 10000, 10000, 0, 0 }; //sanity check
+	return{ ( int )left, ( int )bottom, ( int )( right - left ), ( int )( top - bottom ) + 4 };
+}
+
+c_base_weapon* c_base_player::get_active_weapon( ) {
+	auto wep_handle = m_hActiveWeapon( );
+	auto weapon = reinterpret_cast< c_base_weapon* >( cl.m_entlist( )->get_entity_from_handle( wep_handle ) );
+	return weapon;
+}
diff --git a/tf2/CBasePlayer.h b/tf2/CBasePlayer.h
new file mode 100644
index 0000000..dbce5cd
--- /dev/null
+++ b/tf2/CBasePlayer.h
@@ -0,0 +1,241 @@
+#pragma once
+#include "vector.hpp"
+#include "CBaseWeapon.h"
+#include "IVEngineClient.h"
+
+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 TFClasses_t {
+	TF2_None = 0,
+	TF2_Scout,
+	TF2_Sniper,
+	TF2_Soldier,
+	TF2_Demoman,
+	TF2_Medic,
+	TF2_Heavy,
+	TF2_Pyro,
+	TF2_Spy,
+	TF2_Engineer
+};
+
+enum LifeStates_t {
+	LIFE_ALIVE = 0,
+	LIFE_DYING,
+	LIFE_DEAD,
+	LIFE_RESPAWNABLE,
+	LIFE_DISCARDBODY
+};
+
+enum PlayerStates_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 ),
+};
+
+struct dynamic_box_t {
+	int x, y, w, h;
+};
+
+enum PlayerConds_t
+{
+	TFCond_Slowed = ( 1 << 0 ), //Toggled when a player is slowed down. 
+	TFCond_Zoomed = ( 1 << 1 ), //Toggled when a player is zoomed. 
+	TFCond_Disguising = ( 1 << 2 ), //Toggled when a Spy is disguising.  
+	TFCond_Disguised = ( 1 << 3 ), //Toggled when a Spy is disguised. 
+	TFCond_Cloaked = ( 1 << 4 ), //Toggled when a Spy is invisible. 
+	TFCond_Ubercharged = ( 1 << 5 ), //Toggled when a player is �berCharged. 
+	TFCond_TeleportedGlow = ( 1 << 6 ), //Toggled when someone leaves a teleporter and has glow beneath their feet. 
+	TFCond_Taunting = ( 1 << 7 ), //Toggled when a player is taunting. 
+	TFCond_UberchargeFading = ( 1 << 8 ), //Toggled when the �berCharge is fading. 
+	TFCond_CloakFlicker = ( 1 << 9 ), //Toggled when a Spy is visible during cloak. 
+	TFCond_Teleporting = ( 1 << 10 ), //Only activates for a brief second when the player is being teleported; not very useful. 
+	TFCond_Kritzkrieged = ( 1 << 11 ), //Toggled when a player is being crit buffed by the KritzKrieg. 
+	TFCond_TmpDamageBonus = ( 1 << 12 ), //Unknown what this is for. Name taken from the AlliedModders SDK. 
+	TFCond_DeadRingered = ( 1 << 13 ), //Toggled when a player is taking reduced damage from the Deadringer. 
+	TFCond_Bonked = ( 1 << 14 ), //Toggled when a player is under the effects of The Bonk! Atomic Punch. 
+	TFCond_Stunned = ( 1 << 15 ), //Toggled when a player's speed is reduced from airblast or a Sandman ball. 
+	TFCond_Buffed = ( 1 << 16 ), //Toggled when a player is within range of an activated Buff Banner. 
+	TFCond_Charging = ( 1 << 17 ), //Toggled when a Demoman charges with the shield. 
+	TFCond_DemoBuff = ( 1 << 18 ), //Toggled when a Demoman has heads from the Eyelander. 
+	TFCond_CritCola = ( 1 << 19 ), //Toggled when the player is under the effect of The Crit-a-Cola. 
+	TFCond_InHealRadius = ( 1 << 20 ), //Unused condition, name taken from AlliedModders SDK. 
+	TFCond_Healing = ( 1 << 21 ), //Toggled when someone is being healed by a medic or a dispenser. 
+	TFCond_OnFire = ( 1 << 22 ), //Toggled when a player is on fire. 
+	TFCond_Overhealed = ( 1 << 23 ), //Toggled when a player has >100% health. 
+	TFCond_Jarated = ( 1 << 24 ), //Toggled when a player is hit with a Sniper's Jarate. 
+	TFCond_Bleeding = ( 1 << 25 ), //Toggled when a player is taking bleeding damage. 
+	TFCond_DefenseBuffed = ( 1 << 26 ), //Toggled when a player is within range of an activated Battalion's Backup. 
+	TFCond_Milked = ( 1 << 27 ), //Player was hit with a jar of Mad Milk. 
+	TFCond_MegaHeal = ( 1 << 28 ), //Player is under the effect of Quick-Fix charge. 
+	TFCond_RegenBuffed = ( 1 << 29 ), //Toggled when a player is within a Concheror's range. 
+	TFCond_MarkedForDeath = ( 1 << 30 ), //Player is marked for death by a Fan O'War hit. Effects are similar to TFCond_Jarated. 
+	TFCond_NoHealingDamageBuff = ( 1 << 31 ), //Unknown what this is used for.
+
+	TFCondEx_SpeedBuffAlly = ( 1 << 0 ), //Toggled when a player gets hit with the disciplinary action. 
+	TFCondEx_HalloweenCritCandy = ( 1 << 1 ), //Only for Scream Fortress event maps that drop crit candy. 
+	TFCondEx_CritCanteen = ( 1 << 2 ), //Player is getting a crit boost from a MVM canteen.
+	TFCondEx_CritDemoCharge = ( 1 << 3 ), //From demo's shield
+	TFCondEx_CritHype = ( 1 << 4 ), //Soda Popper crits. 
+	TFCondEx_CritOnFirstBlood = ( 1 << 5 ), //Arena first blood crit buff. 
+	TFCondEx_CritOnWin = ( 1 << 6 ), //End of round crits. 
+	TFCondEx_CritOnFlagCapture = ( 1 << 7 ), //CTF intelligence capture crits. 
+	TFCondEx_CritOnKill = ( 1 << 8 ), //Unknown what this is for. 
+	TFCondEx_RestrictToMelee = ( 1 << 9 ), //Unknown what this is for. 
+	TFCondEx_DefenseBuffNoCritBlock = ( 1 << 10 ), //MvM Buff.
+	TFCondEx_Reprogrammed = ( 1 << 11 ), //MvM Bot has been reprogrammed.
+	TFCondEx_PyroCrits = ( 1 << 12 ), //Player is getting crits from the Mmmph charge. 
+	TFCondEx_PyroHeal = ( 1 << 13 ), //Player is being healed from the Mmmph charge. 
+	TFCondEx_FocusBuff = ( 1 << 14 ), //Player is getting a focus buff.
+	TFCondEx_DisguisedRemoved = ( 1 << 15 ), //Disguised remove from a bot.
+	TFCondEx_MarkedForDeathSilent = ( 1 << 16 ), //Player is under the effects of the Escape Plan/Equalizer or GRU.
+	TFCondEx_DisguisedAsDispenser = ( 1 << 17 ), //Bot is disguised as dispenser.
+	TFCondEx_Sapped = ( 1 << 18 ), //MvM bot is being sapped.
+	TFCondEx_UberchargedHidden = ( 1 << 19 ), //MvM Related
+	TFCondEx_UberchargedCanteen = ( 1 << 20 ), //Player is receiving �berCharge from a canteen.
+	TFCondEx_HalloweenBombHead = ( 1 << 21 ), //Player has a bomb on their head from Merasmus.
+	TFCondEx_HalloweenThriller = ( 1 << 22 ), //Players are forced to dance from Merasmus.
+	TFCondEx_BulletCharge = ( 1 << 26 ), //Player is receiving 75% reduced damage from bullets.
+	TFCondEx_ExplosiveCharge = ( 1 << 27 ), //Player is receiving 75% reduced damage from explosives.
+	TFCondEx_FireCharge = ( 1 << 28 ), //Player is receiving 75% reduced damage from fire.
+	TFCondEx_BulletResistance = ( 1 << 29 ), //Player is receiving 10% reduced damage from bullets.
+	TFCondEx_ExplosiveResistance = ( 1 << 30 ), //Player is receiving 10% reduced damage from explosives.
+	TFCondEx_FireResistance = ( 1 << 31 ), //Player is receiving 10% reduced damage from fire.
+
+	TFCondEx2_Stealthed = ( 1 << 0 ),
+	TFCondEx2_MedigunDebuff = ( 1 << 1 ),
+	TFCondEx2_StealthedUserBuffFade = ( 1 << 2 ),
+	TFCondEx2_BulletImmune = ( 1 << 3 ),
+	TFCondEx2_BlastImmune = ( 1 << 4 ),
+	TFCondEx2_FireImmune = ( 1 << 5 ),
+	TFCondEx2_PreventDeath = ( 1 << 6 ),
+	TFCondEx2_MVMBotRadiowave = ( 1 << 7 ),
+	TFCondEx2_HalloweenSpeedBoost = ( 1 << 8 ), //Wheel has granted player speed boost.
+	TFCondEx2_HalloweenQuickHeal = ( 1 << 9 ), //Wheel has granted player quick heal.
+	TFCondEx2_HalloweenGiant = ( 1 << 10 ), //Wheel has granted player giant mode.
+	TFCondEx2_HalloweenTiny = ( 1 << 11 ), //Wheel has granted player tiny mode.
+	TFCondEx2_HalloweenInHell = ( 1 << 12 ), //Wheel has granted player in hell mode.
+	TFCondEx2_HalloweenGhostMode = ( 1 << 13 ), //Wheel has granted player ghost mode.
+	TFCondEx2_Parachute = ( 1 << 16 ), //Player has deployed the BASE Jumper.
+	TFCondEx2_BlastJumping = ( 1 << 17 ), //Player has sticky or rocket jumped.
+
+	TFCond_MiniCrits = ( TFCond_Buffed | TFCond_CritCola ),
+	TFCond_IgnoreStates = ( TFCond_Ubercharged | TFCond_Bonked ),
+	TFCondEx_IgnoreStates = ( TFCondEx_PyroHeal )
+};
+
+enum tf_hitbox : int {
+	head = 0,
+	pelvis = 1,
+	spine_0 = 2,
+	spine_1 = 3,
+	spine_2 = 4,
+	spine_3 = 5,
+	upperArm_L = 6,
+	lowerArm_L = 7,
+	hand_L = 8,
+	upperArm_R = 9,
+	lowerArm_R = 10,
+	hand_R = 11,
+	hip_L = 12,
+	knee_L = 13,
+	foot_L = 14,
+	hip_R = 15,
+	knee_R = 16,
+	foot_R = 17,
+};
+
+class c_base_player : public IClientEntity {
+public:
+
+	NETVAR( m_nMoveType, "m_nRenderMode", "DT_BaseEntity", 1, MoveType_t );
+	NETVAR( m_fFlags, "m_fFlags", "DT_BasePlayer", 0, int );
+	NETVAR( m_vecVelocity, "m_vecVelocity[0]", "DT_BasePlayer", 0, vec3_t );
+	NETVAR( m_flSimulationTime, "m_flSimulationTime", "DT_BaseEntity", 0, float );
+	NETVAR( m_vecOrigin, "m_vecOrigin", "DT_BaseEntity", 0, vec3_t );
+	NETVAR( m_angRotation, "m_angRotation", "DT_BaseEntity", 0, vec3_t );
+	NETVAR( m_CollisionGroup, "m_CollisionGroup", "DT_BaseEntity", -0x4c, matrix3x4 );
+	NETVAR( m_Collision, "m_Collision", "DT_BaseEntity", 0, std::ptrdiff_t );
+	NETVAR( m_vecViewOffset, "m_vecViewOffset[0]", "DT_BasePlayer", 0, vec3_t );
+	NETVAR( m_nTickBase, "m_nTickBase", "DT_BasePlayer", 0, int );
+	NETVAR( m_lifeState, "m_lifeState", "DT_BasePlayer", 0, byte );
+	NETVAR( m_iHealth, "m_iHealth", "DT_BasePlayer", 0, int );
+	NETVAR( m_iTeamNum, "m_iTeamNum", "DT_BasePlayer", 0, int );
+	NETVAR( m_nHitboxSet, "m_nHitboxSet", "DT_BaseAnimating", 0, int );
+	NETVAR( m_PlayerClass, "m_PlayerClass", "DT_TFPlayer", 0, int );
+	NETVAR( m_iClass, "m_iClass", "DT_TFPlayer", 0, int );
+	NETVAR( m_angEyeAngles, "m_angEyeAngles[0]", "DT_TFPlayer", 0, vec3_t );
+	NETVAR( m_hActiveWeapon, "m_hActiveWeapon", "DT_BaseCombatCharacter", 0, uintptr_t );
+	NETVAR( m_iMaxHealth, "m_iMaxHealth", "DT_TFPlayerResource", 0, std::ptrdiff_t );
+	NETVAR( m_hObserverTarget, "m_hObserverTarget", "DT_BasePlayer", 0, uint32_t );
+	NETVAR( m_bIsScoped, "m_bIsScoped", "DT_TFPlayer", 0, bool );
+	NETVAR( m_vecMins, "m_vecMins", "DT_BaseEntity", 0, vec3_t );
+	NETVAR( m_vecMaxs, "m_vecMaxs", "DT_BaseEntity", 0, vec3_t );
+	NETVAR( m_iObserverMode, "m_iObserverMode", "DT_Base_player", 0, int );
+	NETVAR( m_bGlowEnabled, "m_bGlowEnabled", "DT_TFPlayer", 0, bool );
+	NETVAR( m_nPlayerCond, "m_nPlayerCond", "DT_TFPlayer", 0, int );
+
+	//fuck you this is for ragdolls
+	NETVAR( m_vecRagdollVelocity, "m_vecRagdollVelocity", "DT_TFRagdoll", 0, vec3_t );
+
+
+
+	static uintptr_t get_player_resource( );
+	static uintptr_t get_game_rules( );
+
+	__forceinline IClientEntity* ce( ) {
+		return reinterpret_cast< IClientEntity* >( this );
+	}
+
+	__forceinline bool is_player( ) {
+		client_class_t* client_class = ce( )->GetClientClass( );
+		return client_class && client_class->m_class_id == CTFPlayer;
+	}
+
+	player_info_t get_info( );
+	void get_name_safe( char* buf );
+	bool is_valid( );
+	vec3_t get_eye_pos( );
+	vec3_t get_origin( );
+	vec3_t get_view_offset( );
+	vec3_t get_bone_position( int );
+	vec3_t get_hitbox_position( int );
+	vec3_t get_eye_angles( );
+	vec3_t get_velocity( );
+	int get_team( );
+	bool is_enemy( );
+	const char* get_class_name( );
+	int get_class( );
+	byte get_life_state( );
+	int get_flags( );
+	bool is_alive( );
+	bool is_visible( );
+	bool is_visible( int );
+	dynamic_box_t get_dynamic_box( );
+	int get_health( );
+	int get_max_health( );
+	bool is_buffed( );
+	int get_tick_base( );
+	c_base_weapon* get_active_weapon( );
+};
+\ No newline at end of file
diff --git a/tf2/CBaseWeapon.cpp b/tf2/CBaseWeapon.cpp
new file mode 100644
index 0000000..b9881d1
--- /dev/null
+++ b/tf2/CBaseWeapon.cpp
@@ -0,0 +1,69 @@
+#include "CBaseWeapon.h"
+#include "interfaces.h"
+
+int c_base_weapon::get_max_clip_1( ) {
+	return call_vfunc< int( __thiscall* )( void* ) >( this, 318 )( this );
+}
+
+int c_base_weapon::get_max_clip_2( ) {
+	return call_vfunc< int( __thiscall* )( void* ) >( this, 319 )( this );
+}
+
+int c_base_weapon::get_slot( ) {
+	return call_vfunc< int( __thiscall* )( void* ) >( this, 327 )( this );
+}
+
+char* c_base_weapon::get_name( ) {
+	return call_vfunc< char *( __thiscall* )( void* ) >( this, 329 )( this );
+}
+
+char* c_base_weapon::get_print_name( ) {
+	return call_vfunc<  char *( __thiscall* )( void* ) >( this, 330 )( this );
+}
+
+vec3_t& c_base_weapon::get_bullet_spread( ) {
+	return call_vfunc< vec3_t& ( __thiscall* )( void* ) >( this, 286 )( this );
+}
+
+float c_base_weapon::get_spread( ) {
+	return call_vfunc< float( __thiscall* )( void* ) >( this, 455 )( this );
+}
+
+int c_base_weapon::get_weaponid( ) {
+	return call_vfunc< int( __thiscall* )( void* ) >( this, 422 )( this );
+}
+
+bool c_base_weapon::can_fire( ) {
+	auto cur_time = g_ctx.m_local->get_tick_base( ) * cl.m_globals->interval_per_tick;
+	auto next_primary_attack = m_flNextPrimaryAttack( );
+	return cur_time >= next_primary_attack;
+}
+
+bool c_base_weapon::is_non_aim( ) {
+	if ( get_slot( ) >= 2 ) return true;
+	//more checks to be added
+	return false;
+}
+
+int& c_base_weapon::get_inspect_stage( ) {
+	return m_nInspectStage( );
+}
+
+float& c_base_weapon::get_inspect_time( ) {
+	return m_flInspectAnimTime( );
+}
+
+c_attribute_list* c_base_weapon::get_attribute_list( ) {
+	return reinterpret_cast< c_attribute_list* >( this + 0xA8 );
+}
+
+float c_base_weapon::get_distance( ) {
+
+	if( is_melee( ) )
+		return 100.f;
+
+	if( is_flame_thrower( ) )
+		return 185.f;
+
+	return 8012.f;
+}
diff --git a/tf2/CBaseWeapon.h b/tf2/CBaseWeapon.h
new file mode 100644
index 0000000..213a576
--- /dev/null
+++ b/tf2/CBaseWeapon.h
@@ -0,0 +1,1389 @@
+#pragma once
+#include "IClientEntity.h"
+#include "CAttribute.h"
+#include "netvars.h"
+enum class weapon_attributes {
+	weapon_allow_inspect = 731,
+};
+
+enum scoutweapons
+{
+	//Primary
+	WPN_Scattergun = 13,
+	WPN_NewScattergun = 200,
+	WPN_FAN = 45,
+	WPN_Shortstop = 220,
+	WPN_SodaPopper = 448,
+	WPN_BabyFaceBlaster = 772,
+	WPN_BotScattergunS = 799,
+	WPN_BotScattergunG = 808,
+	WPN_BotScattergunR = 888,
+	WPN_BotScattergunB = 897,
+	WPN_BotScattergunC = 906,
+	WPN_BotScattergunD = 915,
+	WPN_BotScattergunES = 964,
+	WPN_BotScattergunEG = 973,
+	WPN_FestiveFaN = 1078,
+	WPN_BackScatter = 1103,
+	//Secondary
+	WPN_ScoutPistol = 23,
+	WPN_NewPistol = 209,
+	WPN_Bonk = 46,
+	WPN_CritCola = 163,
+	WPN_Lugermorph = 160,
+	WPN_Milk = 222,
+	WPN_Lugermorph2 = 294,
+	WPN_Winger = 449,
+	WPN_PocketPistol = 773,
+	WPN_MutatedMilk = 1121,
+	WPN_CAPPER = 30666,
+	//Melee
+	WPN_Bat = 0,
+	WPN_NewBat = 190,
+	WPN_Sandman = 44,
+	WPN_Fish = 221,
+	WPN_Cane = 317,
+	WPN_BostonBasher = 325,
+	WPN_SunStick = 349,
+	WPN_FanOWar = 355,
+	WPN_RuneBlade = 452,
+	WPN_Saxxy = 423,
+	WPN_Atomizer = 450,
+	WPN_ConscientiousObjector = 474,
+	WPN_UnarmedCombat = 572,
+	WPN_WrapAssassin = 648,
+	WPN_FestiveBat = 660,
+	WPN_FestiveScattergun = 669,
+	WPN_FlyingGuillotine1 = 812,
+	WPN_FlyingGuillotine2 = 833,
+	WPN_FreedomStaff = 880,
+	WPN_BatOuttaHell = 939,
+	WPN_MemoryMaker = 954,
+	WPN_FestiveFish = 999,
+	WPN_TheHamShank = 1013,
+	WPN_CrossingGuard = 1127,
+	WPN_NecroSmasher = 1123,
+	WPN_Batsaber = 30667,
+};
+enum soldierweapons
+{
+	//Primary
+	WPN_RocketLauncher = 18,
+	WPN_NewRocketLauncher = 205,
+	WPN_DirectHit = 127,
+	WPN_BlackBox = 228,
+	WPN_RocketJumper = 237,
+	WPN_LibertyLauncher = 414,
+	WPN_CowMangler = 441,
+	WPN_Original = 513,
+	WPN_FestiveRocketLauncher = 658,
+	WPN_BeggersBazooka = 730,
+	WPN_BotRocketlauncherS = 800,
+	WPN_BotRocketlauncherG = 809,
+	WPN_BotRocketlauncherR = 889,
+	WPN_BotRocketlauncherB = 898,
+	WPN_BotRocketlauncherC = 907,
+	WPN_BotRocketlauncherD = 916,
+	WPN_BotRocketlauncherES = 965,
+	WPN_BotRocketlauncherEG = 974,
+	WPN_FestiveBlackbox = 1085,
+	WPN_Airstrike = 1104,
+	//Secondary
+	WPN_SoldierShotgun = 10,
+	WPN_NewShotgun = 199,
+	WPN_BuffBanner = 129,
+	WPN_BattalionBackup = 226,
+	WPN_Concheror = 354,
+	WPN_ReserveShooter = 415,
+	WPN_RighteousBison = 442,
+	WPN_FestiveBuffBanner = 1001,
+	WPN_PanicAttack = 1153,
+	WPN_ManTreads = 444,
+	WPN_GunBoats = 133,
+	WPN_BASEJumper = 1101,
+	//Melee
+	WPN_Shovel = 6,
+	WPN_NewShovel = 196,
+	WPN_Equalizer = 128,
+	WPN_PainTrain = 154,
+	WPN_Katana = 357,
+	WPN_MarketGardener = 416,
+	WPN_DisciplinaryAction = 447,
+	WPN_EscapePlan = 775,
+};
+enum pyroweapons
+{
+	//Primary
+	WPN_Flamethrower = 21,
+	WPN_NewFlamethrower = 208,
+	WPN_Backburner = 40,
+	WPN_Degreaser = 215,
+	WPN_FestiveFlamethrower = 659,
+	WPN_Phlogistinator = 594,
+	WPN_Rainblower = 741,
+	WPN_BotFlamethrowerS = 798,
+	WPN_BotFlamethrowerG = 807,
+	WPN_BotFlamethrowerR = 887,
+	WPN_BotFlamethrowerB = 896,
+	WPN_BotFlamethrowerC = 905,
+	WPN_BotFlamethrowerD = 914,
+	WPN_BotFlamethrowerES = 963,
+	WPN_BotFlamethrowerEG = 972,
+	WPN_FestiveBackburner = 1146,
+	//Secondary
+	WPN_PyroShotgun = 12,
+	WPN_Flaregun = 39,
+	WPN_Detonator = 351,
+	WPN_ManMelter = 595,
+	WPN_ScorchShot = 740,
+	WPN_FestiveFlaregun = 1081,
+	WPN_ThermalThruster = 1179,
+	WPN_GasPasser = 1180,
+	//Melee
+	WPN_Fireaxe = 2,
+	WPN_NewAxe = 192,
+	WPN_Axtingusher = 38,
+	WPN_HomeWrecker = 153,
+	WPN_PowerJack = 214,
+	WPN_Backscratcher = 326,
+	WPN_VolcanoFragment = 348,
+	WPN_Maul = 466,
+	WPN_Mailbox = 457,
+	WPN_ThirdDegree = 593,
+	WPN_Lollychop = 739,
+	WPN_NeonAnnihilator1 = 813,
+	WPN_NeonAnnihilator2 = 834,
+	WPN_FestiveAxtingisher = 1000,
+};
+enum demomanweapons
+{
+	//Primary
+	WPN_GrenadeLauncher = 19,
+	WPN_NewGrenadeLauncher = 206,
+	WPN_LochNLoad = 308,
+	WPN_LoooseCannon = 996,
+	WPN_FestiveGrenadeLauncher = 1007,
+	WPN_IronBomber = 1151,
+	//Secondary
+	WPN_StickyLauncher = 20,
+	WPN_NewStickyLauncher = 207,
+	WPN_ScottishResistance = 130,
+	WPN_StickyJumper = 265,
+	WPN_FestiveStickyLauncher = 661,
+	WPN_BotStickyS = 797,
+	WPN_BotStickyG = 806,
+	WPN_BotStickyR = 886,
+	WPN_BotStickyB = 895,
+	WPN_BotStickyC = 904,
+	WPN_BotStickyD = 913,
+	WPN_BotStickyES = 962,
+	WPN_BotStickyEG = 971,
+	WPN_QuickieBombLauncher = 1150,
+	WPN_SplendidScreen = 406,
+	WPN_CharginTarge = 131,
+	WPN_FestiveCharginTarge = 1144,
+	WPN_TideTurner = 1099,
+	//Melee
+	WPN_Bottle = 1,
+	WPN_NewBottle = 191,
+	WPN_Sword = 132,
+	WPN_ScottsSkullctter = 172,
+	WPN_Fryingpan = 264,
+	WPN_Headless = 266,
+	WPN_Ullapool = 307,
+	WPN_Claidheamhmor = 327,
+	WPN_PersainPersuader = 404,
+	WPN_Golfclub = 482,
+	WPN_ScottishHandshake = 609,
+	WPN_GoldenFryingPan = 1071,
+	WPN_FestiveEyelander = 1082,
+};
+enum heavyweapons
+{
+	//Primary
+	WPN_Minigun = 15,
+	WPN_NewMinigun = 202,
+	WPN_Natascha = 41,
+	WPN_IronCurtain = 298,
+	WPN_BrassBeast = 312,
+	WPN_Tomislav = 424,
+	WPN_FestiveMinigun = 654,
+	WPN_HuoLongHeatmaker1 = 811,
+	WPN_HuoLongHeatmaker2 = 832,
+	WPN_BotMinigunS = 793,
+	WPN_BotMinigunG = 802,
+	WPN_BotMinigunR = 882,
+	WPN_BotMinigunB = 891,
+	WPN_BotMinigunC = 900,
+	WPN_BotMinigunD = 909,
+	WPN_Deflector = 850,
+	WPN_BotMinigunES = 958,
+	WPN_BotMinigunEG = 967,
+	//Secondary
+	WPN_HeavyShotgun = 11,
+	WPN_Sandvich = 42,
+	WPN_CandyBar = 159,
+	WPN_Steak = 311,
+	WPN_Fishcake = 433,
+	WPN_FamilyBuisness = 425,
+	WPN_RobotSandvich = 863,
+	WPN_FestiveSandvich = 1002,
+	//Melee
+	WPN_Fists = 5,
+	WPN_NewFists = 195,
+	WPN_KGB = 43,
+	WPN_GRU = 239,
+	WPN_WarriorSpirit = 310,
+	WPN_FistsOfSteel = 331,
+	WPN_EvictionNotice = 426,
+	WPN_ApocoFists = 587,
+	WPN_HolidayPunch = 656,
+	WPN_FestiveGRU = 1084,
+	WPN_BreadBite = 1100,
+};
+enum engineerweapons
+{
+	//Primary
+	WPN_EngineerShotgun = 9,
+	WPN_FrontierJustice = 141,
+	WPN_Widowmaker = 527,
+	WPN_Pomson = 588,
+	WPN_RescueRanger = 997,
+	WPN_FestiveFrontierJustice = 1004,
+	//Secondary
+	WPN_EngineerPistol = 22,
+	WPN_Wrangler = 140,
+	WPN_ShortCircut = 528,
+	WPN_FestiveWrangler = 1086,
+	WPN_GeigerCounter = 30668,
+	//Melee
+	WPN_Wrench = 7,
+	WPN_NewWrench = 197,
+	WPN_Goldenwrench = 169,
+	WPN_SouthernHospitality = 155,
+	WPN_Gunslinger = 142,
+	WPN_Jag = 329,
+	WPN_FestiveWrench = 662,
+	WPN_EurekaEffect = 589,
+	WPN_BotWrenchS = 795,
+	WPN_BotWrenchG = 804,
+	WPN_BotWrenchR = 884,
+	WPN_BotWrenchB = 893,
+	WPN_BotWrenchC = 902,
+	WPN_BotWrenchD = 911,
+	WPN_BotWrenchES = 960,
+	WPN_BotWrenchEG = 969,
+	//Misc
+	WPN_Builder = 25,
+	WPN_Builder2 = 737,
+	WPN_Destructor = 26,
+	WPN_Toolbox = 28,
+};
+enum medicweapons
+{
+	//Primary
+	WPN_SyringeGun = 17,
+	WPN_NewSyringeGun = 204,
+	WPN_Blutsauger = 36,
+	WPN_Crossbow = 305,
+	WPN_Overdose = 412,
+	WPN_FestiveCrossbow = 1079,
+	//Secondary
+	WPN_Medigun = 29,
+	WPN_NewMedigun = 211,
+	WPN_Kritzkrieg = 35,
+	WPN_QuickFix = 411,
+	WPN_FestiveMedigun = 663,
+	WPN_MedigunS = 796,
+	WPN_MedigunG = 805,
+	WPN_MedigunR = 885,
+	WPN_MedigunB = 894,
+	WPN_MedigunC = 903,
+	WPN_MedigunD = 912,
+	WPN_Vaccinator = 998,
+	WPN_MedigunES = 961,
+	WPN_MedigunEG = 970,
+	//Melee
+	WPN_Bonesaw = 8,
+	WPN_NewBonesaw = 198,
+	WPN_Ubersaw = 37,
+	WPN_Vitasaw = 173,
+	WPN_Amputator = 304,
+	WPN_Solemnvow = 413,
+	WPN_FestiveUbersaw = 1003,
+};
+enum sniperweapons
+{
+	//Primary
+	WPN_SniperRifle = 14,
+	WPN_NewSniperRifle = 201,
+	WPN_Huntsman = 56,
+	WPN_SydneySleeper = 230,
+	WPN_Bazaarbargain = 402,
+	WPN_Machina = 526,
+	WPN_FestiveSniperRifle = 664,
+	WPN_HitmanHeatmaker = 752,
+	WPN_BotSniperRifleS = 792,
+	WPN_BotSniperRifleG = 801,
+	WPN_BotSniperRifleR = 881,
+	WPN_BotSniperRifleB = 890,
+	WPN_BotSniperRifleC = 899,
+	WPN_BotSniperRifleD = 908,
+	WPN_AWP = 851,
+	WPN_BotSniperRifleES = 957,
+	WPN_BotSniperRifleEG = 966,
+	WPN_FestiveHuntsman = 1005,
+	WPN_CompoundBow = 1092,
+	WPN_ClassicSniperRifle = 1098,
+	WPN_ShootingStar = 30665,
+	//Secondary
+	WPN_SMG = 16,
+	WPN_NewSMG = 203,
+	WPN_Jarate = 58,
+	WPN_DarwinDangerShield = 231,
+	WPN_CleanersCarbine = 751,
+	WPN_FestiveJarate = 1083,
+	WPN_SelfAwareBeautyMark = 1105,
+	WPN_RAZORBACK = 57,
+	WPN_COZYCAMPER = 642,
+	//Melee
+	WPN_Kukri = 3,
+	WPN_NewKukri = 193,
+	WPN_TribalmansShiv = 171,
+	WPN_Bushwacka = 232,
+	WPN_Shahanshah = 401,
+};
+enum spyweapons
+{
+	//Primary
+	WPN_Revolver = 24,
+	WPN_NewRevolver = 210,
+	WPN_Ambassador = 61,
+	WPN_BigKill = 161,
+	WPN_Letranger = 224,
+	WPN_Enforcer = 460,
+	WPN_Diamondback = 525,
+	WPN_FestiveAmbassador = 1006,
+	//Melee
+	WPN_Knife = 4,
+	WPN_NewKnife = 194,
+	WPN_EternalReward = 225,
+	WPN_DisguiseKit = 27,
+	WPN_Kunai = 356,
+	WPN_BigEarner = 461,
+	WPN_WangaPrick = 574,
+	WPN_SharpDresser = 638,
+	WPN_Spycicle = 649,
+	WPN_FestiveKnife = 665,
+	WPN_BlackRose = 727,
+	WPN_BotKnifeS = 794,
+	WPN_BotKnifeG = 803,
+	WPN_BotKnifeR = 883,
+	WPN_BotKnifeB = 892,
+	WPN_BotKnifeC = 901,
+	WPN_BotKnifeD = 910,
+	WPN_BotKnifeES = 959,
+	WPN_BotKnifeEG = 968,
+	//Watches
+	WPN_InivisWatch = 30,
+	WPN_DeadRinger = 59,
+	WPN_CloakAndDagger = 60,
+	WPN_TimePiece = 297,
+	//Sapper
+	WPN_Sapper = 735,
+	WPN_Sapper2 = 736,
+	WPN_RedTape1 = 810,
+	WPN_RedTape2 = 831,
+	WPN_ApSap = 933,
+	WPN_FestiveSapper = 1080,
+	WPN_SnackAttack = 1102,
+};
+
+
+class c_base_weapon : public IClientEntity
+{
+public:
+
+	NETVAR( m_iItemDefinitionIndex, "m_iItemDefinitionIndex", "DT_BaseAttributableItem", 0, int );
+	NETVAR( m_flNextPrimaryAttack, "m_flNextPrimaryAttack", "DT_TFWeaponBase", 0, float );
+	NETVAR( m_nInspectStage, "m_nInspectStage", "DT_TFWeaponBase", 0, int );
+	NETVAR( m_flInspectAnimTime, "m_flInspectAnimTime", "DT_TFWeaponBase", 0, float );
+	NETVAR( m_AttributeList, "m_AttributeList", "DT_BaseAttributableItem", 0, c_attribute_list* )
+	NETVAR( m_hOwnerEntity, "m_hOwnerEntity", "DT_BaseEntity", 0, uint32_t );
+	NETVAR( m_iClip1, "m_iClip1", "DT_BaseCombatWeapon", 0, int );
+	NETVAR( m_hBuilder, "m_hBuilder", "DT_BaseObject", 0, uint32_t );
+	void get_weapon_class( );
+
+	bool is_sniper( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_SniperRifle:
+		case WPN_NewSniperRifle:
+		case WPN_Huntsman:
+		case WPN_SydneySleeper:
+		case WPN_Bazaarbargain:
+		case WPN_Machina:
+		case WPN_FestiveSniperRifle:
+		case WPN_HitmanHeatmaker:
+		case WPN_BotSniperRifleS:
+		case WPN_BotSniperRifleG:
+		case WPN_BotSniperRifleR:
+		case WPN_BotSniperRifleB:
+		case WPN_BotSniperRifleC:
+		case WPN_BotSniperRifleD:
+		case WPN_AWP:
+		case WPN_BotSniperRifleES:
+		case WPN_BotSniperRifleEG:
+		case WPN_FestiveHuntsman:
+		case WPN_CompoundBow:
+		case WPN_ClassicSniperRifle:
+		case WPN_ShootingStar:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+
+	bool has_trajectory( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Sandman:
+		case WPN_WrapAssassin:
+		case WPN_FlyingGuillotine1:
+		case WPN_FlyingGuillotine2:
+		case WPN_Flaregun:
+		case WPN_Detonator:
+		case WPN_ScorchShot:
+		case WPN_FestiveFlaregun:
+		case WPN_GrenadeLauncher:
+		case WPN_NewGrenadeLauncher:
+		case WPN_LochNLoad:
+		case WPN_LoooseCannon:
+		case WPN_FestiveGrenadeLauncher:
+		case WPN_IronBomber:
+		case WPN_Ullapool:
+		case WPN_QuickieBombLauncher:
+		case WPN_StickyJumper:
+		case WPN_NewStickyLauncher:
+		case WPN_StickyLauncher:
+		case WPN_ScottishResistance:
+		case WPN_FestiveHuntsman:
+		case WPN_Huntsman:
+		case WPN_FestiveJarate:
+		case WPN_Jarate:
+		case WPN_SelfAwareBeautyMark:
+		case WPN_GasPasser:
+		case WPN_CompoundBow:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_primary( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Scattergun:
+		case WPN_NewScattergun:
+		case WPN_FAN:
+		case WPN_Shortstop:
+		case WPN_SodaPopper:
+		case WPN_BabyFaceBlaster:
+		case WPN_BotScattergunS:
+		case WPN_BotScattergunG:
+		case WPN_BotScattergunR:
+		case WPN_BotScattergunB:
+		case WPN_BotScattergunC:
+		case WPN_BotScattergunD:
+		case WPN_BotScattergunES:
+		case WPN_BotScattergunEG:
+		case WPN_FestiveFaN:
+		case WPN_BackScatter:
+		case WPN_RocketLauncher:
+		case WPN_NewRocketLauncher:
+		case WPN_DirectHit:
+		case WPN_BlackBox:
+		case WPN_RocketJumper:
+		case WPN_LibertyLauncher:
+		case WPN_CowMangler:
+		case WPN_Original:
+		case WPN_FestiveRocketLauncher:
+		case WPN_BeggersBazooka:
+		case WPN_BotRocketlauncherS:
+		case WPN_BotRocketlauncherG:
+		case WPN_BotRocketlauncherR:
+		case WPN_BotRocketlauncherB:
+		case WPN_BotRocketlauncherC:
+		case WPN_BotRocketlauncherD:
+		case WPN_BotRocketlauncherES:
+		case WPN_BotRocketlauncherEG:
+		case WPN_FestiveBlackbox:
+		case WPN_Airstrike:
+		case WPN_Flamethrower:
+		case WPN_NewFlamethrower:
+		case WPN_Backburner:
+		case WPN_Degreaser:
+		case WPN_FestiveFlamethrower:
+		case WPN_Phlogistinator:
+		case WPN_Rainblower:
+		case WPN_BotFlamethrowerS:
+		case WPN_BotFlamethrowerG:
+		case WPN_BotFlamethrowerR:
+		case WPN_BotFlamethrowerB:
+		case WPN_BotFlamethrowerC:
+		case WPN_BotFlamethrowerD:
+		case WPN_BotFlamethrowerES:
+		case WPN_BotFlamethrowerEG:
+		case WPN_FestiveBackburner:
+		case WPN_GrenadeLauncher:
+		case WPN_NewGrenadeLauncher:
+		case WPN_LochNLoad:
+		case WPN_LoooseCannon:
+		case WPN_FestiveGrenadeLauncher:
+		case WPN_IronBomber:
+		case WPN_Minigun:
+		case WPN_NewMinigun:
+		case WPN_Natascha:
+		case WPN_IronCurtain:
+		case WPN_BrassBeast:
+		case WPN_Tomislav:
+		case WPN_FestiveMinigun:
+		case WPN_HuoLongHeatmaker1:
+		case WPN_HuoLongHeatmaker2:
+		case WPN_BotMinigunS:
+		case WPN_BotMinigunG:
+		case WPN_BotMinigunR:
+		case WPN_BotMinigunB:
+		case WPN_BotMinigunC:
+		case WPN_BotMinigunD:
+		case WPN_Deflector:
+		case WPN_BotMinigunES:
+		case WPN_BotMinigunEG:
+		case WPN_EngineerShotgun:
+		case WPN_FrontierJustice:
+		case WPN_Widowmaker:
+		case WPN_Pomson:
+		case WPN_RescueRanger:
+		case WPN_FestiveFrontierJustice:
+		case WPN_SyringeGun:
+		case WPN_NewSyringeGun:
+		case WPN_Blutsauger:
+		case WPN_Crossbow:
+		case WPN_Overdose:
+		case WPN_FestiveCrossbow:
+		case WPN_SniperRifle:
+		case WPN_NewSniperRifle:
+		case WPN_Huntsman:
+		case WPN_SydneySleeper:
+		case WPN_Bazaarbargain:
+		case WPN_Machina:
+		case WPN_FestiveSniperRifle:
+		case WPN_HitmanHeatmaker:
+		case WPN_BotSniperRifleS:
+		case WPN_BotSniperRifleG:
+		case WPN_BotSniperRifleR:
+		case WPN_BotSniperRifleB:
+		case WPN_BotSniperRifleC:
+		case WPN_BotSniperRifleD:
+		case WPN_AWP:
+		case WPN_BotSniperRifleES:
+		case WPN_BotSniperRifleEG:
+		case WPN_FestiveHuntsman:
+		case WPN_CompoundBow:
+		case WPN_ClassicSniperRifle:
+		case WPN_ShootingStar:
+		case WPN_Revolver:
+		case WPN_NewRevolver:
+		case WPN_Ambassador:
+		case WPN_BigKill:
+		case WPN_Letranger:
+		case WPN_Enforcer:
+		case WPN_Diamondback:
+		case WPN_FestiveAmbassador:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_secondary( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_ScoutPistol:
+		case WPN_NewPistol:
+		case WPN_Bonk:
+		case WPN_CritCola:
+		case WPN_Lugermorph:
+		case WPN_Milk:
+		case WPN_Lugermorph2:
+		case WPN_Winger:
+		case WPN_PocketPistol:
+		case WPN_MutatedMilk:
+		case WPN_CAPPER:
+		case WPN_SoldierShotgun:
+		case WPN_NewShotgun:
+		case WPN_BuffBanner:
+		case WPN_BattalionBackup:
+		case WPN_Concheror:
+		case WPN_ReserveShooter:
+		case WPN_RighteousBison:
+		case WPN_FestiveBuffBanner:
+		case WPN_PanicAttack:
+		case WPN_ManTreads:
+		case WPN_GunBoats:
+		case WPN_BASEJumper:
+		case WPN_PyroShotgun:
+		case WPN_Flaregun:
+		case WPN_Detonator:
+		case WPN_ManMelter:
+		case WPN_ScorchShot:
+		case WPN_FestiveFlaregun:
+		case WPN_ThermalThruster:
+		case WPN_GasPasser:
+		case WPN_StickyLauncher:
+		case WPN_NewStickyLauncher:
+		case WPN_ScottishResistance:
+		case WPN_StickyJumper:
+		case WPN_FestiveStickyLauncher:
+		case WPN_BotStickyS:
+		case WPN_BotStickyG:
+		case WPN_BotStickyR:
+		case WPN_BotStickyB:
+		case WPN_BotStickyC:
+		case WPN_BotStickyD:
+		case WPN_BotStickyES:
+		case WPN_BotStickyEG:
+		case WPN_QuickieBombLauncher:
+		case WPN_SplendidScreen:
+		case WPN_CharginTarge:
+		case WPN_FestiveCharginTarge:
+		case WPN_TideTurner:
+		case WPN_HeavyShotgun:
+		case WPN_Sandvich:
+		case WPN_CandyBar:
+		case WPN_Steak:
+		case WPN_Fishcake:
+		case WPN_FamilyBuisness:
+		case WPN_RobotSandvich:
+		case WPN_FestiveSandvich:
+		case WPN_EngineerPistol:
+		case WPN_Wrangler:
+		case WPN_ShortCircut:
+		case WPN_FestiveWrangler:
+		case WPN_GeigerCounter:
+		case WPN_Medigun:
+		case WPN_NewMedigun:
+		case WPN_Kritzkrieg:
+		case WPN_QuickFix:
+		case WPN_FestiveMedigun:
+		case WPN_MedigunS:
+		case WPN_MedigunG:
+		case WPN_MedigunR:
+		case WPN_MedigunB:
+		case WPN_MedigunC:
+		case WPN_MedigunD:
+		case WPN_Vaccinator:
+		case WPN_MedigunES:
+		case WPN_MedigunEG:
+		case WPN_SMG:
+		case WPN_NewSMG:
+		case WPN_Jarate:
+		case WPN_DarwinDangerShield:
+		case WPN_CleanersCarbine:
+		case WPN_FestiveJarate:
+		case WPN_SelfAwareBeautyMark:
+		case WPN_RAZORBACK:
+		case WPN_COZYCAMPER:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_third( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Bat:
+		case WPN_NewBat:
+		case WPN_Sandman:
+		case WPN_Fish:
+		case WPN_Cane:
+		case WPN_BostonBasher:
+		case WPN_SunStick:
+		case WPN_FanOWar:
+		case WPN_RuneBlade:
+		case WPN_Saxxy:
+		case WPN_Atomizer:
+		case WPN_ConscientiousObjector:
+		case WPN_UnarmedCombat:
+		case WPN_WrapAssassin:
+		case WPN_FestiveBat:
+		case WPN_FestiveScattergun:
+		case WPN_FlyingGuillotine1:
+		case WPN_FlyingGuillotine2:
+		case WPN_FreedomStaff:
+		case WPN_BatOuttaHell:
+		case WPN_MemoryMaker:
+		case WPN_FestiveFish:
+		case WPN_TheHamShank:
+		case WPN_CrossingGuard:
+		case WPN_NecroSmasher:
+		case WPN_Batsaber:
+		case WPN_Shovel:
+		case WPN_NewShovel:
+		case WPN_Equalizer:
+		case WPN_PainTrain:
+		case WPN_Katana:
+		case WPN_MarketGardener:
+		case WPN_DisciplinaryAction:
+		case WPN_EscapePlan:
+		case WPN_Fireaxe:
+		case WPN_NewAxe:
+		case WPN_Axtingusher:
+		case WPN_HomeWrecker:
+		case WPN_PowerJack:
+		case WPN_Backscratcher:
+		case WPN_VolcanoFragment:
+		case WPN_Maul:
+		case WPN_Mailbox:
+		case WPN_ThirdDegree:
+		case WPN_Lollychop:
+		case WPN_NeonAnnihilator1:
+		case WPN_NeonAnnihilator2:
+		case WPN_FestiveAxtingisher:
+		case WPN_Bottle:
+		case WPN_NewBottle:
+		case WPN_Sword:
+		case WPN_ScottsSkullctter:
+		case WPN_Fryingpan:
+		case WPN_Headless:
+		case WPN_Ullapool:
+		case WPN_Claidheamhmor:
+		case WPN_PersainPersuader:
+		case WPN_Golfclub:
+		case WPN_ScottishHandshake:
+		case WPN_GoldenFryingPan:
+		case WPN_FestiveEyelander:
+		case WPN_Fists:
+		case WPN_NewFists:
+		case WPN_KGB:
+		case WPN_GRU:
+		case WPN_WarriorSpirit:
+		case WPN_FistsOfSteel:
+		case WPN_EvictionNotice:
+		case WPN_ApocoFists:
+		case WPN_HolidayPunch:
+		case WPN_FestiveGRU:
+		case WPN_BreadBite:
+		case WPN_Wrench:
+		case WPN_NewWrench:
+		case WPN_Goldenwrench:
+		case WPN_SouthernHospitality:
+		case WPN_Gunslinger:
+		case WPN_Jag:
+		case WPN_FestiveWrench:
+		case WPN_EurekaEffect:
+		case WPN_BotWrenchS:
+		case WPN_BotWrenchG:
+		case WPN_BotWrenchR:
+		case WPN_BotWrenchB:
+		case WPN_BotWrenchC:
+		case WPN_BotWrenchD:
+		case WPN_BotWrenchES:
+		case WPN_BotWrenchEG:
+		case WPN_Bonesaw:
+		case WPN_NewBonesaw:
+		case WPN_Ubersaw:
+		case WPN_Vitasaw:
+		case WPN_Amputator:
+		case WPN_Solemnvow:
+		case WPN_FestiveUbersaw:
+		case WPN_Kukri:
+		case WPN_NewKukri:
+		case WPN_TribalmansShiv:
+		case WPN_Bushwacka:
+		case WPN_Shahanshah:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_shield( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_CharginTarge:
+		case WPN_SplendidScreen:
+		case WPN_TideTurner:
+		case WPN_FestiveCharginTarge:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+
+	bool is_shotgun( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Scattergun:
+		case WPN_NewScattergun:
+		case WPN_FAN:
+		case WPN_SodaPopper:
+		case WPN_FestiveFaN:
+		case WPN_BackScatter:
+		case WPN_SoldierShotgun:
+		case WPN_NewShotgun:
+		case WPN_ReserveShooter:
+		case WPN_PanicAttack:
+		case WPN_PyroShotgun:
+		case WPN_HeavyShotgun:
+		case WPN_FamilyBuisness:
+		case WPN_EngineerShotgun:
+		case WPN_FrontierJustice:
+		case WPN_Widowmaker:
+		case WPN_Pomson:
+		case WPN_RescueRanger:
+		case WPN_FestiveFrontierJustice:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_melee( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Bat:
+		case WPN_NewBat:
+		case WPN_Sandman:
+		case WPN_Fish:
+		case WPN_Cane:
+		case WPN_BostonBasher:
+		case WPN_SunStick:
+		case WPN_FanOWar:
+		case WPN_RuneBlade:
+		case WPN_Saxxy:
+		case WPN_Atomizer:
+		case WPN_ConscientiousObjector:
+		case WPN_UnarmedCombat:
+		case WPN_WrapAssassin:
+		case WPN_FestiveBat:
+		case WPN_FreedomStaff:
+		case WPN_BatOuttaHell:
+		case WPN_MemoryMaker:
+		case WPN_FestiveFish:
+		case WPN_TheHamShank:
+		case WPN_CrossingGuard:
+		case WPN_NecroSmasher:
+		case WPN_Batsaber:
+		case WPN_Shovel:
+		case WPN_NewShovel:
+		case WPN_Equalizer:
+		case WPN_PainTrain:
+		case WPN_Katana:
+		case WPN_MarketGardener:
+		case WPN_DisciplinaryAction:
+		case WPN_EscapePlan:
+		case WPN_Fireaxe:
+		case WPN_NewAxe:
+		case WPN_Axtingusher:
+		case WPN_HomeWrecker:
+		case WPN_PowerJack:
+		case WPN_Backscratcher:
+		case WPN_VolcanoFragment:
+		case WPN_Maul:
+		case WPN_Mailbox:
+		case WPN_ThirdDegree:
+		case WPN_Lollychop:
+		case WPN_NeonAnnihilator1:
+		case WPN_NeonAnnihilator2:
+		case WPN_FestiveAxtingisher:
+		case WPN_Bottle:
+		case WPN_NewBottle:
+		case WPN_Sword:
+		case WPN_ScottsSkullctter:
+		case WPN_Fryingpan:
+		case WPN_Headless:
+		case WPN_Ullapool:
+		case WPN_Claidheamhmor:
+		case WPN_PersainPersuader:
+		case WPN_Golfclub:
+		case WPN_ScottishHandshake:
+		case WPN_GoldenFryingPan:
+		case WPN_FestiveEyelander:
+		case WPN_Fists:
+		case WPN_NewFists:
+		case WPN_KGB:
+		case WPN_GRU:
+		case WPN_WarriorSpirit:
+		case WPN_FistsOfSteel:
+		case WPN_EvictionNotice:
+		case WPN_ApocoFists:
+		case WPN_HolidayPunch:
+		case WPN_FestiveGRU:
+		case WPN_BreadBite:
+		case WPN_Wrench:
+		case WPN_NewWrench:
+		case WPN_Goldenwrench:
+		case WPN_SouthernHospitality:
+		case WPN_Gunslinger:
+		case WPN_Jag:
+		case WPN_Bonesaw:
+		case WPN_NewBonesaw:
+		case WPN_Ubersaw:
+		case WPN_Vitasaw:
+		case WPN_Amputator:
+		case WPN_Solemnvow:
+		case WPN_FestiveUbersaw:
+		case WPN_Kukri:
+		case WPN_NewKukri:
+		case WPN_TribalmansShiv:
+		case WPN_Bushwacka:
+		case WPN_Shahanshah:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_pistol( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_EngineerPistol:
+		case WPN_ScoutPistol:
+		case WPN_NewPistol:
+		case WPN_Lugermorph:
+		case WPN_Lugermorph2:
+		case WPN_Winger:
+		case WPN_PocketPistol:
+		case WPN_CAPPER:
+		case WPN_ShortCircut:
+		case WPN_Flaregun:
+		case WPN_FestiveFlaregun:
+		case WPN_Detonator:
+		case WPN_ManMelter:
+		case WPN_ScorchShot:
+		case WPN_Shortstop:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_grenade( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Milk:
+		case WPN_MutatedMilk:
+		case WPN_Jarate:
+		case WPN_FestiveJarate:
+		case WPN_SelfAwareBeautyMark:
+		case WPN_GasPasser:
+		case WPN_FlyingGuillotine1:
+		case WPN_FlyingGuillotine2:
+			return true;
+			break;
+		default:
+			return false;
+		
+		}
+	}
+	
+
+	bool is_util( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Milk:
+		case WPN_MutatedMilk:
+		case WPN_Jarate:
+		case WPN_FestiveJarate:
+		case WPN_DarwinDangerShield:
+		case WPN_RAZORBACK:
+		case WPN_COZYCAMPER:
+		case WPN_BuffBanner:
+		case WPN_BattalionBackup:
+		case WPN_Concheror:
+		case WPN_BASEJumper:
+		case WPN_ManTreads:
+		case WPN_GunBoats:
+		case WPN_ThermalThruster:
+		case WPN_DisguiseKit:
+		case WPN_Builder:
+		case WPN_Builder2:
+		case WPN_Destructor:
+		case WPN_Toolbox:
+			return true;
+			break;
+		default:
+			return false;
+
+		}
+	}
+	
+	bool is_flame_thrower( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Flamethrower:
+		case WPN_NewFlamethrower:
+		case WPN_Backburner:
+		case WPN_Degreaser:
+		case WPN_FestiveFlamethrower:
+		case WPN_Phlogistinator:
+		case WPN_Rainblower:
+		case WPN_BotFlamethrowerS:
+		case WPN_BotFlamethrowerG:
+		case WPN_BotFlamethrowerR:
+		case WPN_BotFlamethrowerB:
+		case WPN_BotFlamethrowerC:
+		case WPN_BotFlamethrowerD:
+		case WPN_BotFlamethrowerES:
+		case WPN_BotFlamethrowerEG:
+		case WPN_FestiveBackburner:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_sticky( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_StickyLauncher:
+		case WPN_NewStickyLauncher:
+		case WPN_ScottishResistance:
+		case WPN_StickyJumper:
+		case WPN_FestiveStickyLauncher:
+		case WPN_BotStickyS:
+		case WPN_BotStickyG:
+		case WPN_BotStickyR:
+		case WPN_BotStickyB:
+		case WPN_BotStickyC:
+		case WPN_BotStickyD:
+		case WPN_BotStickyES:
+		case WPN_BotStickyEG:
+		case WPN_QuickieBombLauncher:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_grenade_launcher( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_GrenadeLauncher:
+		case WPN_NewGrenadeLauncher:
+		case WPN_LochNLoad:
+		case WPN_LoooseCannon:
+		case WPN_FestiveGrenadeLauncher:
+		case WPN_IronBomber:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_rocket_launcher( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_RocketLauncher:
+		case WPN_NewRocketLauncher:
+		case WPN_DirectHit:
+		case WPN_BlackBox:
+		case WPN_RocketJumper:
+		case WPN_LibertyLauncher:
+		case WPN_CowMangler:
+		case WPN_Original:
+		case WPN_FestiveRocketLauncher:
+		case WPN_BeggersBazooka:
+		case WPN_BotRocketlauncherS:
+		case WPN_BotRocketlauncherG:
+		case WPN_BotRocketlauncherR:
+		case WPN_BotRocketlauncherB:
+		case WPN_BotRocketlauncherC:
+		case WPN_BotRocketlauncherD:
+		case WPN_BotRocketlauncherES:
+		case WPN_BotRocketlauncherEG:
+		case WPN_FestiveBlackbox:
+		case WPN_Airstrike:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_minigun( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Minigun:
+		case WPN_NewMinigun:
+		case WPN_Natascha:
+		case WPN_IronCurtain:
+		case WPN_BrassBeast:
+		case WPN_Tomislav:
+		case WPN_FestiveMinigun:
+		case WPN_HuoLongHeatmaker1:
+		case WPN_HuoLongHeatmaker2:
+		case WPN_BotMinigunS:
+		case WPN_BotMinigunG:
+		case WPN_BotMinigunR:
+		case WPN_BotMinigunB:
+		case WPN_BotMinigunC:
+		case WPN_BotMinigunD:
+		case WPN_Deflector:
+		case WPN_BotMinigunES:
+		case WPN_BotMinigunEG:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_edible( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Bonk:
+		case WPN_CritCola:
+		case WPN_CandyBar:
+		case WPN_Steak:
+		case WPN_Fishcake:
+		case WPN_Sandvich:
+		case WPN_RobotSandvich:
+		case WPN_FestiveSandvich:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_wrench( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Wrench:
+		case WPN_NewWrench:
+		case WPN_Goldenwrench:
+		case WPN_SouthernHospitality:
+		case WPN_Gunslinger:
+		case WPN_Jag:
+		case WPN_FestiveWrench:
+		case WPN_EurekaEffect:
+		case WPN_BotWrenchS:
+		case WPN_BotWrenchG:
+		case WPN_BotWrenchR:
+		case WPN_BotWrenchB:
+		case WPN_BotWrenchC:
+		case WPN_BotWrenchD:
+		case WPN_BotWrenchES:
+		case WPN_BotWrenchEG:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_engineer( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Builder:
+		case WPN_Builder2:
+		case WPN_Destructor:
+		case WPN_Toolbox:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	bool is_needle_gun( ) {
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_SyringeGun:
+		case WPN_NewSyringeGun:
+		case WPN_Blutsauger:
+		case WPN_Crossbow:
+		case WPN_Overdose:
+		case WPN_FestiveCrossbow:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_healing( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Medigun:
+		case WPN_NewMedigun:
+		case WPN_Kritzkrieg:
+		case WPN_QuickFix:
+		case WPN_FestiveMedigun:
+		case WPN_MedigunS:
+		case WPN_MedigunG:
+		case WPN_MedigunR:
+		case WPN_MedigunB:
+		case WPN_MedigunC:
+		case WPN_MedigunD:
+		case WPN_Vaccinator:
+		case WPN_MedigunES:
+		case WPN_MedigunEG:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_revolver( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Revolver:
+		case WPN_NewRevolver:
+		case WPN_Ambassador:
+		case WPN_BigKill:
+		case WPN_Letranger:
+		case WPN_Enforcer:
+		case WPN_Diamondback:
+		case WPN_FestiveAmbassador:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_spy_knife( ) { 
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Knife:
+		case WPN_NewKnife:
+		case WPN_EternalReward:
+		case WPN_DisguiseKit:
+		case WPN_Kunai:
+		case WPN_BigEarner:
+		case WPN_WangaPrick:
+		case WPN_SharpDresser:
+		case WPN_Spycicle:
+		case WPN_FestiveKnife:
+		case WPN_BlackRose:
+		case WPN_BotKnifeS:
+		case WPN_BotKnifeG:
+		case WPN_BotKnifeR:
+		case WPN_BotKnifeB:
+		case WPN_BotKnifeC:
+		case WPN_BotKnifeD:
+		case WPN_BotKnifeES:
+		case WPN_BotKnifeEG:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_watch( ) { 
+		switch( m_iItemDefinitionIndex( ) ) { 
+		case WPN_InivisWatch:
+		case WPN_DeadRinger:
+		case WPN_CloakAndDagger:
+		case WPN_TimePiece:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+	
+	bool is_sapper( ) { 
+		switch( m_iItemDefinitionIndex( ) ) { 
+		case WPN_Sapper:
+		case WPN_Sapper2:
+		case WPN_RedTape1:
+		case WPN_RedTape2:
+		case WPN_ApSap:
+		case WPN_FestiveSapper:
+		case WPN_SnackAttack:
+			return true;
+			break;
+		default:
+			return false;
+		}
+	}
+
+	/*bool get_projectile_speed( float& speed ) {
+		speed = 0;
+		switch( m_iItemDefinitionIndex( ) ) {
+		case WPN_Milk:
+		case WPN_MutatedMilk:
+			speed = 1019.9;
+			break;
+		case WPN_FlyingGuillotine1:
+		case WPN_FlyingGuillotine2:
+		case WPN_Sandman:
+		case WPN_WrapAssassin:
+		case WPN_ManMelter:
+			speed = 3000;
+			break;
+		case WPN_RocketJumper:
+		case WPN_BlackBox:
+		case WPN_Original:
+		case WPN_BeggersBazooka:
+		case WPN_CowMangler:
+			speed = 1100;
+			break;
+
+		case WPN_DirectHit:
+			speed = 1980;
+			break;
+
+		case WPN_LibertyLauncher:
+			speed = 1540;
+			break;
+
+		case WPN_RighteousBison:
+		case WPN_Pomson:
+			speed = 1200;
+			break;
+
+		case WPN_Flaregun:
+		case WPN_FestiveFlaregun:
+		case WPN_ScorchShot:
+		case WPN_Detonator:
+			speed = 2000;
+			break;
+
+		case WPN_GrenadeLauncher:
+		case WPN_NewGrenadeLauncher:
+		case WPN_FestiveGrenadeLauncher:
+		case WPN_IronBomber:
+			speed = 1216.6;
+			break;
+
+
+
+		/*
+		get dynamically
+		
+		stickybomb launcher
+		scottish resistance
+		sticky jumper
+		quickiebomb launcher
+		huntman fortified compound
+
+		
+
+		}
+		return ( speed );
+	}*/
+
+	int get_max_clip_1( );
+	int get_max_clip_2( );
+	int get_slot( );
+	char* get_name( );
+	char* get_print_name( );
+	vec3_t& get_bullet_spread( );
+	float get_spread( );
+	int get_weaponid( );
+	bool can_fire( );
+	bool is_non_aim( );
+	int& get_inspect_stage( );
+	float& get_inspect_time( );
+	c_attribute_list* get_attribute_list( );
+	float get_distance( );
+};
+\ No newline at end of file
diff --git a/tf2/CGlobalVarsBase.h b/tf2/CGlobalVarsBase.h
new file mode 100644
index 0000000..9b0d79f
--- /dev/null
+++ b/tf2/CGlobalVarsBase.h
@@ -0,0 +1,14 @@
+#pragma once
+
+class CGlobalVarsBase {
+public:
+	float realtime;
+	int framecount;
+	float absoluteframetime;
+	float curtime;
+	float frametime;
+	int maxclients;
+	int tickcount;
+	float interval_per_tick;
+	float interpolation_amount;
+};
+\ No newline at end of file
diff --git a/tf2/CHLClient.h b/tf2/CHLClient.h
new file mode 100644
index 0000000..7eadb50
--- /dev/null
+++ b/tf2/CHLClient.h
@@ -0,0 +1,32 @@
+#pragma once
+#include "dt_common.h"
+#include "dt_recv.h"
+#include "VFunc.h"
+#include "ClientClass.h"
+
+enum frame_stages_t {
+	FRAME_UNDEFINED = -1,			// (haven't run any frames yet)
+	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
+};
+
+class chl_client {
+public:
+	client_class_t* GetAllClasses( ) {
+		return call_vfunc< client_class_t*( __thiscall* )( void* ) >( this, 8 )( this );
+	}
+
+	void in_activatemouse( ) {
+		call_vfunc< void( __thiscall* )( void* ) >( this, 15 )( this );
+	}
+
+	void in_deactivatemouse( ) {
+		call_vfunc< void( __thiscall* )( void* ) >( this, 16 )( this );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/CInput.hpp b/tf2/CInput.hpp
new file mode 100644
index 0000000..3fb8bff
--- /dev/null
+++ b/tf2/CInput.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "vector.hpp"
+#include "IClientMode.h"
+
+#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/tf2/CUserCmd.h b/tf2/CUserCmd.h
new file mode 100644
index 0000000..f9dd746
--- /dev/null
+++ b/tf2/CUserCmd.h
@@ -0,0 +1,51 @@
+#pragma once
+#include "vector.hpp"
+
+enum PlayerControls_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 command_number; //0
+	int tick_count; //4
+	vec3_t viewangles; //16
+	float forwardmove; //20
+	float sidemove; //24
+	float upmove; //28
+	int	buttons; //32
+	byte impulse; //33
+	int weaponselect; //
+	int weaponsubtype;
+	int random_seed;
+	short mousedx;
+	short mousedy;
+	bool hasbeenpredicted;
+	int SetValue;
+};
+\ No newline at end of file
diff --git a/tf2/ClientClass.h b/tf2/ClientClass.h
new file mode 100644
index 0000000..56a1103
--- /dev/null
+++ b/tf2/ClientClass.h
@@ -0,0 +1,382 @@
+#pragma once
+#include <inttypes.h>
+#include "dt_recv.h"
+typedef unsigned char byte;
+
+enum ClientClassIDs {
+	SporeExplosion = 359,
+	RocketTrail = 357,
+	SmokeTrail = 358,
+	CPropVehicleDriveable = 107,
+	ParticleSmokeGrenade = 356,
+	CParticleFire = 90,
+	MovieExplosion = 354,
+	CTEGaussExplosion = 154,
+	CEnvQuadraticBeam = 43,
+	CEmbers = 36,
+	CEnvWind = 47,
+	CPrecipitation = 106,
+	CBaseTempEntity = 17,
+	CWeaponIFMSteadyCam = 349,
+	CWeaponIFMBaseCamera = 348,
+	CWeaponIFMBase = 347,
+	CTFWearableVM = 341,
+	CTFWearable = 334,
+	CTFWearableItem = 337,
+	CEconWearable = 35,
+	CBaseAttributableItem = 3,
+	CEconEntity = 34,
+	CHandleTest = 72,
+	CTeamplayRoundBasedRulesProxy = 125,
+	CTeamRoundTimer = 126,
+	CSpriteTrail = 121,
+	CSpriteOriented = 120,
+	CSprite = 119,
+	CRagdollPropAttached = 110,
+	CRagdollProp = 109,
+	CPoseController = 105,
+	CGameRulesProxy = 68,
+	CInfoLadderDismount = 75,
+	CFuncLadder = 58,
+	CEnvDetailController = 40,
+	CWorld = 351,
+	CWaterLODControl = 346,
+	CWaterBullet = 345,
+	CVoteController = 344,
+	CVGuiScreen = 343,
+	CPropJeep = 0,
+	CPropVehicleChoreoGeneric = 0,
+	CTest_ProxyToggle_Networkable = 174,
+	CTesla = 169,
+	CTeamTrainWatcher = 127,
+	CBaseTeamObjectiveResource = 16,
+	CTeam = 124,
+	CSun = 123,
+	CParticlePerformanceMonitor = 91,
+	CSpotlightEnd = 118,
+	CSlideshowDisplay = 115,
+	CShadowControl = 114,
+	CSceneEntity = 113,
+	CRopeKeyframe = 112,
+	CRagdollManager = 108,
+	CPhysicsPropMultiplayer = 98,
+	CPhysBoxMultiplayer = 96,
+	CBasePropDoor = 15,
+	CDynamicProp = 33,
+	CPointCommentaryNode = 104,
+	CPointCamera = 103,
+	CPlayerResource = 102,
+	CPlasma = 100,
+	CPhysMagnet = 99,
+	CPhysicsProp = 97,
+	CPhysBox = 95,
+	CParticleSystem = 92,
+	CMaterialModifyControl = 81,
+	CLightGlow = 79,
+	CInfoOverlayAccessor = 77,
+	CFuncTrackTrain = 67,
+	CFuncSmokeVolume = 66,
+	CFuncRotating = 65,
+	CFuncReflectiveGlass = 62,
+	CFuncOccluder = 60,
+	CFuncMonitor = 59,
+	CFunc_LOD = 54,
+	CTEDust = 146,
+	CFunc_Dust = 53,
+	CFuncConveyor = 56,
+	CBreakableSurface = 25,
+	CFuncAreaPortalWindow = 55,
+	CFish = 51,
+	CEntityFlame = 38,
+	CFireSmoke = 49,
+	CEnvTonemapController = 46,
+	CEnvScreenEffect = 44,
+	CEnvScreenOverlay = 45,
+	CEnvProjectedTexture = 42,
+	CEnvParticleScript = 41,
+	CFogController = 52,
+	CEntityParticleTrail = 39,
+	CEntityDissolve = 37,
+	CDynamicLight = 32,
+	CColorCorrectionVolume = 30,
+	CColorCorrection = 29,
+	CBreakableProp = 24,
+	CBasePlayer = 13,
+	CBaseFlex = 8,
+	CBaseEntity_ = 7,
+	CBaseDoor = 6,
+	CBaseCombatCharacter = 4,
+	CBaseAnimatingOverlay = 2,
+	CBoneFollower = 20,
+	CBaseAnimating = 1,
+	CInfoLightingRelative = 76,
+	CAI_BaseNPC = 0,
+	CBeam = 19,
+	CBaseViewModel = 18,
+	CBaseProjectile = 14,
+	CBaseParticleEntity = 12,
+	CBaseGrenade = 9,
+	CBaseCombatWeapon = 5,
+	CTFWearableRazorback = 339,
+	CTFWearableDemoShield = 336,
+	CTFWearableLevelableItem = 338,
+	CTFWearableCampaignItem = 335,
+	CTFBaseRocket = 184,
+	CTFWeaponBaseMerasmusGrenade = 323,
+	CTFWeaponBaseMelee = 322,
+	CTFWeaponBaseGun = 321,
+	CTFWeaponBaseGrenadeProj = 320,
+	CTFWeaponBase = 319,
+	CTFWearableRobotArm = 340,
+	CTFRobotArm = 285,
+	CTFWrench = 342,
+	CTFProjectile_ThrowableBreadMonster = 277,
+	CTFProjectile_ThrowableBrick = 278,
+	CTFProjectile_ThrowableRepel = 279,
+	CTFProjectile_Throwable = 276,
+	CTFThrowable = 317,
+	CTFSyringeGun = 313,
+	CTFKatana = 224,
+	CTFSword = 312,
+	CSniperDot = 117,
+	CTFSniperRifleClassic = 306,
+	CTFSniperRifleDecap = 307,
+	CTFSniperRifle = 305,
+	CTFChargedSMG = 196,
+	CTFSMG = 304,
+	CTFSlap = 303,
+	CTFShovel = 302,
+	CTFShotgunBuildingRescue = 301,
+	CTFPEPBrawlerBlaster = 240,
+	CTFSodaPopper = 308,
+	CTFShotgun_Revenge = 299,
+	CTFScatterGun = 295,
+	CTFShotgun_Pyro = 298,
+	CTFShotgun_HWG = 297,
+	CTFShotgun_Soldier = 300,
+	CTFShotgun = 296,
+	CTFRocketPack = 294,
+	CTFCrossbow = 200,
+	CTFRocketLauncher_Mortar = 293,
+	CTFRocketLauncher_AirStrike = 291,
+	CTFRocketLauncher_DirectHit = 292,
+	CTFRocketLauncher = 290,
+	CTFRevolver = 284,
+	CTFDRGPomson = 201,
+	CTFRaygun = 282,
+	CTFPistol_ScoutSecondary = 245,
+	CTFPistol_ScoutPrimary = 244,
+	CTFPistol_Scout = 243,
+	CTFPistol = 242,
+	CTFPipebombLauncher = 241,
+	CTFWeaponPDA_Spy = 330,
+	CTFWeaponPDA_Engineer_Destroy = 329,
+	CTFWeaponPDA_Engineer_Build = 328,
+	CTFWeaponPDAExpansion_Teleporter = 332,
+	CTFWeaponPDAExpansion_Dispenser = 331,
+	CTFWeaponPDA = 327,
+	CTFParticleCannon = 238,
+	CTFParachute_Secondary = 237,
+	CTFParachute_Primary = 236,
+	CTFParachute = 235,
+	CTFMinigun = 233,
+	CTFMedigunShield = 230,
+	CWeaponMedigun = 350,
+	CTFMechanicalArm = 229,
+	CTFLunchBox_Drink = 228,
+	CTFLunchBox = 227,
+	CLaserDot = 78,
+	CTFLaserPointer = 226,
+	CTFKnife = 225,
+	CTFGasManager = 211,
+	CTFProjectile_JarGas = 260,
+	CTFJarGas = 222,
+	CTFProjectile_Cleaver = 253,
+	CTFProjectile_JarMilk = 261,
+	CTFProjectile_Jar = 259,
+	CTFCleaver = 197,
+	CTFJarMilk = 223,
+	CTFJar = 221,
+	CTFWeaponInvis = 326,
+	CTFCannon = 195,
+	CTFGrenadeLauncher = 215,
+	CTFGrenadePipebombProjectile = 216,
+	CTFGrapplingHook = 214,
+	CTFFlareGun_Revenge = 209,
+	CTFFlareGun = 208,
+	CTFFlameRocket = 206,
+	CTFFlameThrower = 207,
+	CTFFists = 204,
+	CTFFireAxe = 203,
+	CTFWeaponFlameBall = 325,
+	CTFCompoundBow = 199,
+	CTFClub = 198,
+	CTFBuffItem = 194,
+	CTFStickBomb = 310,
+	CTFBreakableSign = 193,
+	CTFBottle = 191,
+	CTFBreakableMelee = 192,
+	CTFBonesaw = 189,
+	CTFBall_Ornament = 181,
+	CTFStunBall = 311,
+	CTFBat_Giftwrap = 187,
+	CTFBat_Wood = 188,
+	CTFBat_Fish = 186,
+	CTFBat = 185,
+	CTFProjectile_EnergyRing = 255,
+	CTFDroppedWeapon = 202,
+	CTFWeaponSapper = 333,
+	CTFWeaponBuilder = 324,
+	C_TFWeaponBuilder = 0,
+	CTFProjectile_Rocket = 262,
+	CTFProjectile_Flare = 256,
+	CTFProjectile_EnergyBall = 254,
+	CTFProjectile_GrapplingHook = 257,
+	CTFProjectile_HealingBolt = 258,
+	CTFProjectile_Arrow = 251,
+	CTFTankBoss = 314,
+	CTFBaseBoss = 182,
+	CBossAlpha = 0,
+	NextBotCombatCharacter = 355,
+	CTFProjectile_SpellKartBats = 266,
+	CTFProjectile_SpellKartOrb = 267,
+	CTFHellZap = 219,
+	CTFProjectile_SpellLightningOrb = 268,
+	CTFProjectile_SpellTransposeTeleport = 275,
+	CTFProjectile_SpellMeteorShower = 269,
+	CTFProjectile_SpellSpawnBoss = 272,
+	CTFProjectile_SpellMirv = 270,
+	CTFProjectile_SpellPumpkin = 271,
+	CTFProjectile_SpellSpawnHorde = 273,
+	CTFProjectile_SpellSpawnZombie = 274,
+	CTFProjectile_SpellBats = 264,
+	CTFProjectile_SpellFireball = 265,
+	CTFSpellBook = 309,
+	CHightower_TeleportVortex = 74,
+	CTeleportVortex = 159,
+	CZombie = 352,
+	CMerasmusDancer = 83,
+	CMerasmus = 82,
+	CHeadlessHatman = 73,
+	CEyeballBoss = 48,
+	CTFBotHintEngineerNest = 190,
+	CBotNPCMinion = 0,
+	CBotNPC = 0,
+	CPasstimeGun = 94,
+	CTFViewModel = 318,
+	CRobotDispenser = 111,
+	CTFRobotDestruction_Robot = 286,
+	CTFReviveMarker = 283,
+	CTFPumpkinBomb = 280,
+	CTFProjectile_BallOfFire = 252,
+	CTFBaseProjectile = 183,
+	CTFPointManager = 249,
+	CBaseObjectUpgrade = 11,
+	CTFRobotDestructionLogic = 289,
+	CTFRobotDestruction_RobotGroup = 287,
+	CTFRobotDestruction_RobotSpawn = 288,
+	CTFPlayerDestructionLogic = 247,
+	CPlayerDestructionDispenser = 101,
+	CTFMinigameLogic = 232,
+	CTFHalloweenMinigame_FallingPlatforms = 218,
+	CTFHalloweenMinigame = 217,
+	CTFMiniGame = 231,
+	CTFPowerupBottle = 250,
+	CTFItem = 220,
+	CHalloweenSoulPack = 71,
+	CTFGenericBomb = 212,
+	CBonusRoundLogic = 23,
+	CTFGameRulesProxy = 210,
+	CTETFParticleEffect = 178,
+	CTETFExplosion = 177,
+	CTETFBlood = 176,
+	CTFFlameManager = 205,
+	CHalloweenGiftPickup = 69,
+	CBonusDuckPickup = 21,
+	CHalloweenPickup = 70,
+	CCaptureFlagReturnIcon = 27,
+	CCaptureFlag = 26,
+	CBonusPack = 22,
+	CTFTeam = 316,
+	CTFTauntProp = 315,
+	CTFPlayerResource = 248,
+	CTFPlayer = 246,
+	CTFRagdoll = 281,
+	CTEPlayerAnimEvent = 164,
+	CTFPasstimeLogic = 239,
+	CPasstimeBall = 93,
+	CTFObjectiveResource = 234,
+	CTFGlow = 213,
+	CTEFireBullets = 151,
+	CTFBuffBanner = 0,
+	CTFAmmoPack = 180,
+	CObjectTeleporter = 89,
+	CObjectSentrygun = 88,
+	CTFProjectile_SentryRocket = 263,
+	CObjectSapper = 87,
+	CObjectCartDispenser = 85,
+	CObjectDispenser = 86,
+	CMonsterResource = 84,
+	CFuncRespawnRoomVisualizer = 64,
+	CFuncRespawnRoom = 63,
+	CFuncPasstimeGoal = 61,
+	CFuncForceField = 57,
+	CCaptureZone = 28,
+	CCurrencyPack = 31,
+	CBaseObject = 10,
+	CTestTraceline = 175,
+	CTEWorldDecal = 179,
+	CTESpriteSpray = 173,
+	CTESprite = 172,
+	CTESparks = 171,
+	CTESmoke = 170,
+	CTEShowLine = 168,
+	CTEProjectedDecal = 166,
+	CTEPlayerDecal = 165,
+	CTEPhysicsProp = 163,
+	CTEParticleSystem = 162,
+	CTEMuzzleFlash = 161,
+	CTELargeFunnel = 158,
+	CTEKillPlayerAttachments = 157,
+	CTEImpact = 156,
+	CTEGlowSprite = 155,
+	CTEShatterSurface = 167,
+	CTEFootprintDecal = 153,
+	CTEFizz = 152,
+	CTEExplosion = 150,
+	CTEEnergySplash = 149,
+	CTEEffectDispatch = 148,
+	CTEDynamicLight = 147,
+	CTEDecal = 145,
+	CTEClientProjectile = 144,
+	CTEBubbleTrail = 143,
+	CTEBubbles = 142,
+	CTEBSPDecal = 141,
+	CTEBreakModel = 140,
+	CTEBloodStream = 139,
+	CTEBloodSprite = 138,
+	CTEBeamSpline = 137,
+	CTEBeamRingPoint = 136,
+	CTEBeamRing = 135,
+	CTEBeamPoints = 134,
+	CTEBeamLaser = 133,
+	CTEBeamFollow = 132,
+	CTEBeamEnts = 131,
+	CTEBeamEntPoint = 130,
+	CTEBaseBeam = 129,
+	CTEArmorRicochet = 128,
+	CTEMetalSparks = 160,
+	CSteamJet = 122,
+	CSmokeStack = 116,
+	DustTrail = 353,
+	CFireTrail = 50,
+};
+
+class client_class_t {
+	byte _chpadding[ 8 ];
+public:
+	char* m_name;
+	RecvTable* m_rt_table;
+	client_class_t* m_next;
+	int m_class_id;
+};
+\ No newline at end of file
diff --git a/tf2/GlowObject.h b/tf2/GlowObject.h
new file mode 100644
index 0000000..00dce81
--- /dev/null
+++ b/tf2/GlowObject.h
@@ -0,0 +1,43 @@
+#pragma once
+#include "UtlMem.h"
+#include <inttypes.h>
+#include "color.hpp"
+
+static const int END_OF_FREE_LIST = -1;
+static const int ENTRY_IN_USE = -2;
+
+struct GlowObject_t {
+	uintptr_t ent_ptr;
+	fclr_t glow_color;
+
+	bool render_when_occluded;
+	bool render_when_unoccluded;
+	int pad;
+
+	int next_free_slot;
+};
+
+struct GlowObjectManager_t {
+	CUtlVector< GlowObject_t > data;
+	int first_slot;
+
+	int RegisterGlowObject( IClientEntity* ent ) {
+		for( int i{ }; i < data.Count( ); i++ ) {
+			if( data[ i ].ent_ptr == ent->get_ehandle( ) ) return 0;
+		}
+		int index{ };
+		if( first_slot == -1 ) index = data.AddToTail( );
+		else {
+			index = first_slot;
+			first_slot = data[ index ].next_free_slot;
+		}
+		data[ index ].ent_ptr = ent->get_ehandle( );
+		data[ index ].glow_color = clr_t( 255, 255, 255, 255 ).to_fclr( );
+		data[ index ].render_when_occluded = true;
+		data[ index ].render_when_unoccluded = true;
+		data[ index ].pad = -1;
+		data[ index ].next_free_slot = -2;
+
+		return index;
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IAppSystem.h b/tf2/IAppSystem.h
new file mode 100644
index 0000000..84af8c2
--- /dev/null
+++ b/tf2/IAppSystem.h
@@ -0,0 +1,31 @@
+#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,
+};
+
+using CreateInterfaceFn = void*( *)( const char*, int* );
+
+class IAppSystem {
+public:
+	// Here's where the app systems get to learn about each other 
+	virtual bool Connect( CreateInterfaceFn factory ) = 0;
+	virtual void Disconnect( ) = 0;
+
+	// Here's where systems can access other interfaces implemented by this object
+	// Returns NULL if it doesn't implement the requested interface
+	virtual void *QueryInterface( const char *pInterfaceName ) = 0;
+
+	// Init, shutdown
+	virtual InitReturnVal_t Init( ) = 0;
+	virtual void Shutdown( ) = 0;
+};
+\ No newline at end of file
diff --git a/tf2/IClientEntity.h b/tf2/IClientEntity.h
new file mode 100644
index 0000000..0ba0807
--- /dev/null
+++ b/tf2/IClientEntity.h
@@ -0,0 +1,154 @@
+#pragma once
+#include "vector.hpp"
+#include "VFunc.h"
+#include "dt_common.h"
+#include "dt_recv.h"
+#include "search.h"
+#include "util.hpp"
+#include "ClientClass.h"
+
+using matrix3x4 = float[ 3 ][ 4 ];
+class bf_read;
+
+class ICollideable;
+class IClientNetworkable;
+class IClientRenderable;
+class IClientThinkable;
+class IClientEntity;
+class IClientAlphaProperty;
+
+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 client_class_t* 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* get_client_renderable( ) {
+		return reinterpret_cast< void* >( this + 0x4 );
+	}
+
+	IClientNetworkable* get_client_networkable( ) {
+		return reinterpret_cast< IClientNetworkable* >( this + 0x8 );
+	}
+
+public:
+	uintptr_t get_ehandle( ) {
+		return call_vfunc< uintptr_t( __thiscall* )( void* ) >( this, 1 )( this );
+	}
+
+	bool setup_bones( matrix3x4* bonetoworld, int maxbones, long bonemask, float curtime ) {
+		return call_vfunc< bool( __thiscall* )( void*, matrix3x4*, int, long, float ) >( get_client_renderable( ), 16 )( get_client_renderable( ), bonetoworld, maxbones, bonemask, curtime );
+	}
+
+	int DrawModel( int flags, uint8_t alpha ) {
+		using fn = int( __thiscall* )( void*, int, uint8_t );
+		return util::get_vfunc< fn >( this->get_client_renderable( ), 9 )( this->get_client_renderable( ), flags, alpha );
+	}
+
+	vec3_t& get_render_origin( ) {
+		using fn = vec3_t & ( __thiscall* )( void* );
+		return util::get_vfunc< fn >( this, 10 )( this );
+	}
+
+	vec3_t& get_abs_origin( ) {
+		return call_vfunc< vec3_t&( __thiscall* )( void* ) >( this, 9 )( this );
+	}
+
+	vec3_t& get_abs_angles( ) {
+		return call_vfunc< vec3_t&( __thiscall* )( void* ) >( this, 10 )( this );
+	}
+
+	void* get_model( ) {
+		return call_vfunc< void*( __thiscall* )( void* ) >( get_client_renderable( ), 9 )( get_client_renderable( ) );
+	}
+
+	client_class_t* get_client_class( ) {
+		return call_vfunc< client_class_t*( __thiscall* )( void* ) >( get_client_networkable( ), 2 )( get_client_networkable( ) );
+	}
+
+	bool is_dormant( ) {
+		return call_vfunc< bool( __thiscall * )( void * ) >( get_client_networkable( ), 8 )( get_client_networkable( ) );
+	}
+
+	int index( ) {
+		return call_vfunc< int( __thiscall* )( void* ) >( get_client_networkable( ), 9 )( get_client_networkable( ) );
+	}
+
+	void update_glow_effect( ) {
+		//static auto fn = pattern::first_code_match< void( __thiscall* )( void* ) >( GetModuleHandleA( "client.dll" ), "8B 06 8D 4D F4 57 51 8D 4D F8", -0x2c );
+		//if ( fn ) fn( this );
+		return call_vfunc< void( __thiscall* )( void* ) >( this, 226 )( this );
+	}
+
+	void destroy_glow_effect( ) {
+		//static auto fn_offset = pattern::first_code_match< intptr_t >( GetModuleHandleA( "client.dll" ), "E8 ? ? ? ? 8B 9F ? ? ? ? 85 DB 74 3D 8B 33" );
+		//static auto fn = reinterpret_cast< void( __thiscall* )( void* ) >( fn_offset + 5 + *( intptr_t* )( fn_offset + 1 ) );
+		//if ( fn ) fn( this );
+		return call_vfunc< void( __thiscall* )( void* ) >( this, 227 )( this );
+	}
+
+	client_class_t* GetClientClass( ) {
+		using fn = client_class_t* ( __thiscall* )( void* );
+		return util::get_vfunc< fn >( get_client_networkable( ), 2 )( this );
+		/*
+		try {
+			return get_client_networkable( )->GetClientClass( );
+		}
+		catch( ... ) {
+			return 0;
+		}*/
+	}
+
+public:
+	template< typename T = uintptr_t >
+	__forceinline T& get( std::ptrdiff_t offset = 0 ) {
+		return( *reinterpret_cast< T* >( ( uintptr_t )this + offset ) );
+	}
+
+	template< std::ptrdiff_t offset, typename T = uintptr_t >
+	__forceinline T& get( ) {
+		return( *reinterpret_cast< T* >( ( uintptr_t )this + offset ) );
+	}
+
+	template< typename T = uintptr_t >
+	__forceinline T at( std::ptrdiff_t offset = 0 ) {
+		return( reinterpret_cast< T >( uintptr_t( this ) + offset ) );
+	}
+
+	template< std::ptrdiff_t offset, typename T = uintptr_t >
+	__forceinline T at( ) {
+		return( reinterpret_cast< T >( uintptr_t( this ) + offset ) );
+	}
+
+	template < typename t >
+	t* as( ) {
+		return reinterpret_cast< t* >( this );
+	}
+
+};
+\ No newline at end of file
diff --git a/tf2/IClientEntityList.h b/tf2/IClientEntityList.h
new file mode 100644
index 0000000..18b4371
--- /dev/null
+++ b/tf2/IClientEntityList.h
@@ -0,0 +1,24 @@
+#pragma once
+#include "VFunc.h"
+
+class IClientEntity;
+class c_base_player;
+using model_t = uintptr_t;
+class client_ent_list {
+public:
+	template< typename T = IClientEntity > T* get_client_entity( int index ) {
+		return call_vfunc< T* ( __thiscall* )( void*, int ) >( this, 3 )( this, index );
+	}
+
+	template< typename T = IClientEntity > T* get_entity_from_handle( uintptr_t handle ) {
+		return call_vfunc< T*( __thiscall* )( void*, uintptr_t ) >( this, 4 )( this, handle );
+	}
+
+	int get_highest_entity_index( ) {
+		return call_vfunc< int( __thiscall* )( void* ) >( this, 6 )( this );
+	}
+
+	template< typename T = c_base_player > __forceinline T* get_local_player( ) {
+		return get_client_entity< T >( cl.m_engine( )->GetLocalPlayer( ) );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IClientMode.h b/tf2/IClientMode.h
new file mode 100644
index 0000000..f528f3d
--- /dev/null
+++ b/tf2/IClientMode.h
@@ -0,0 +1,174 @@
+#pragma once
+
+#include "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.
+	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_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, 26 )( this, iPlayerIndex, iFilter, fmt );
+	}
+};
+
+class CViewSetup {
+public:
+	int m_x;
+	int m_oldX;
+	int m_y;
+	int m_oldY;
+	int m_width;
+	int m_oldWidth;
+	int m_height;
+	int m_oldHeight;
+
+	bool m_bOrtho;
+	float m_OrthoLeft;
+	float m_OrthoTop;
+	float m_OrthoRight;
+	float m_OrthoBottom;
+
+private:
+	char pad1[ 0x7C ];
+
+public:
+	float m_flFov;
+	float m_flFovViewmodel;
+	vec3_t m_vecOrigin;
+	vec3_t m_vecAngles;
+
+	float zNear;
+	float zFar;
+	float zNearViewmodel;
+	float zFarViewmodel;
+
+	float m_flAspectRatio;
+	float m_flNearBlurDepth;
+	float m_flNearFocusDepth;
+	float m_flFarFocusDepth;
+	float m_flFarBlurDepth;
+	float m_flNearBlurRadius;
+	float m_flFarBlurRadius;
+	int m_nDoFQuality;
+	int m_nMotionBlurMode;
+
+	float m_flShutterTime;
+	vec3_t m_vShutterOpenPosition;
+	vec3_t m_shutterOpenAngles;
+	vec3_t m_vShutterClosePosition;
+	vec3_t m_shutterCloseAngles;
+
+	float m_flOffCenterTop;
+	float m_flOffCenterBottom;
+	float m_flOffCenterLeft;
+	float m_flOffCenterRight;
+
+	bool m_bOffCenter : 1;
+	bool m_bRenderToSubrectOfLargerScreen : 1;
+	bool m_bDoBloomAndToneMapping : 1;
+	bool m_bDoDepthOfField : 1;
+	bool m_bHDRTarget : 1;
+	bool m_bDrawWorldNormal : 1;
+	bool m_bCullFrontFaces : 1;
+	bool m_bCacheFullSceneState : 1;
+	bool m_bRenderFlashlightDepthTranslucents : 1;
+private:
+	char pad2[ 0x40 ];
+};
+
+class IClientMode {
+public:
+	char _pad[ 28 ];
+
+	CHudChat* m_pChatElement; //0x2A
+};
+\ No newline at end of file
diff --git a/tf2/ICvar.h b/tf2/ICvar.h
new file mode 100644
index 0000000..19cb55f
--- /dev/null
+++ b/tf2/ICvar.h
@@ -0,0 +1,201 @@
+#pragma once
+#include "IAppSystem.h"
+#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 );
+	}
+
+	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( ) {
+		//return call_vfunc< float( __thiscall* )( void* ) >( this, 12 )( this );
+		return m_parent->m_flvalue;
+	} //crash no idea why
+
+	int get_int( ) {
+		using fn = int( __thiscall* )( void* );
+		return util::get_vfunc< fn >( this, 13 )( this );
+	}
+
+private:
+	char pad_0x0000[ 0x4 ]; //0x0000
+public:
+	cvar_t * m_next; //0x0004 
+	__int32 m_registered; //0x0008 
+	char* m_name; //0x000C 
+	char* m_help_str; //0x0010 
+	__int32 m_flags; //0x0014 
+private:
+	char pad_0x0018[ 0x4 ]; //0x0018
+public:
+	cvar_t * m_parent; //0x001C 
+	char* m_default; //0x0020 
+	char* m_string; //0x0024 
+	__int32 m_str_len; //0x0028 
+	float m_flvalue; //0x002C 
+	__int32 m_nvalue; //0x0030 
+	__int32 m_has_min; //0x0034 
+	float m_min; //0x0038 
+	__int32 m_hax_max; //0x003C 
+	float m_max; //0x0040 
+	void* m_change_callback; //0x0044 
+};//Size=0x0048
+
+class ICVar : public IAppSystem
+{
+public:
+	// Allocate a unique DLL identifier
+	virtual CVarDLLIdentifier_t AllocateDLLIdentifier( ) = 0;
+
+	// Register, unregister commands
+	virtual void			RegisterConCommand( ConCommandBase *pCommandBase ) = 0;
+	virtual void			UnregisterConCommand( ConCommandBase *pCommandBase ) = 0;
+	virtual void			UnregisterConCommands( CVarDLLIdentifier_t id ) = 0;
+
+	// If there is a +<varname> <value> on the command line, this returns the value.
+	// Otherwise, it returns NULL.
+	virtual const char*		GetCommandLineValue( const char *pVariableName ) = 0;
+
+	// Try to find the cvar pointer by name
+	virtual ConCommandBase*	FindCommandBase( const char *name ) = 0;
+	virtual const ConCommandBase*	FindCommandBase( const char *name ) const = 0;
+	virtual cvar_t			*FindVar( const char *var_name ) = 0;
+	virtual const cvar_t	*FindVar( const char *var_name ) const = 0;
+	virtual ConCommand		*FindCommand( const char *name ) = 0;
+	virtual const ConCommand *FindCommand( const char *name ) const = 0;
+
+
+
+	// Install a global change callback (to be called when any convar changes) 
+	virtual void			InstallGlobalChangeCallback( FnChangeCallback_t callback ) = 0;
+	virtual void			RemoveGlobalChangeCallback( FnChangeCallback_t callback ) = 0;
+	virtual void			CallGlobalChangeCallbacks( cvar_t *var, const char *pOldString, float flOldValue ) = 0;
+
+	// Install a console printer
+	virtual void			InstallConsoleDisplayFunc( IConsoleDisplayFunc* pDisplayFunc ) = 0;
+	virtual void			RemoveConsoleDisplayFunc( IConsoleDisplayFunc* pDisplayFunc ) = 0;
+	virtual void			ConsoleColorPrintf( const clr_t& clr, const char *pFormat, ... ) const = 0;
+	virtual void			ConsolePrintf( const char *pFormat, ... ) const = 0;
+	virtual void			ConsoleDPrintf( const char *pFormat, ... ) const = 0;
+
+	// Reverts cvars which contain a specific flag
+	virtual void			RevertFlaggedConVars( int nFlag ) = 0;
+
+	// Method allowing the engine ICvarQuery interface to take over
+	// A little hacky, owing to the fact the engine is loaded
+	// well after ICVar, so we can't use the standard connect pattern
+	virtual void			InstallCVarQuery( ICvarQuery *pQuery ) = 0;
+
+
+	virtual void			SetMaxSplitScreenSlots( int nSlots ) = 0;
+	virtual int				GetMaxSplitScreenSlots( ) const = 0;
+
+	virtual void			AddSplitScreenConVars( ) = 0;
+	virtual void			RemoveSplitScreenConVars( CVarDLLIdentifier_t id ) = 0;
+
+	virtual int				GetConsoleDisplayFuncCount( ) const = 0;
+	virtual void			GetConsoleText( int nDisplayFuncIndex, char *pchText, size_t bufSize ) const = 0;
+
+	// Utilities for convars accessed by the material system thread
+	virtual bool			IsMaterialThreadSetAllowed( ) const = 0;
+	virtual void			QueueMaterialThreadSetValue( cvar_t *pConVar, const char *pValue ) = 0;
+	virtual void			QueueMaterialThreadSetValue( cvar_t *pConVar, int nValue ) = 0;
+	virtual void			QueueMaterialThreadSetValue( cvar_t *pConVar, float flValue ) = 0;
+	virtual bool			HasQueuedMaterialThreadConVarSets( ) const = 0;
+	virtual int				ProcessQueuedMaterialThreadConVarSets( ) = 0;
+
+	class ICVarIteratorInternal
+	{
+	public:
+		virtual void		SetFirst( ) = 0;
+		virtual void		Next( ) = 0;
+		virtual	bool		IsValid( ) = 0;
+		virtual ConCommandBase *Get( ) = 0;
+	};
+
+	virtual ICVarIteratorInternal*	FactoryInternalIterator( ) = 0;
+};
+\ No newline at end of file
diff --git a/tf2/IEngineTrace.h b/tf2/IEngineTrace.h
new file mode 100644
index 0000000..7fb317d
--- /dev/null
+++ b/tf2/IEngineTrace.h
@@ -0,0 +1,268 @@
+#pragma once
+#include "vector.hpp"
+#include "VFunc.h"
+
+enum trace_type_t {
+	TRACE_EVERYTHING = 0,
+	TRACE_WORLD_ONLY,
+	TRACE_ENTITIES_ONLY,
+	TRACE_EVERYTHING_FILTER_PROPS,
+};
+
+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 ),
+};
+
+struct csurface_t {
+	const char		*name;
+	short			surfaceProps;
+	unsigned short	flags;
+};
+
+struct cplane_t {
+	vec3_t	normal;
+	float	dist;
+	byte	type;
+	byte	signbits;
+	byte	pad[ 2 ];
+};
+
+class ITraceFilter {
+public:
+	virtual bool ShouldHitEntity( void *pEntity, int contentsMask ) = 0;
+	virtual trace_type_t	GetTraceType( ) const = 0;
+};
+
+class CTraceFilter : public ITraceFilter {
+public:
+	bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) {
+		return !( pEntityHandle == pSkip );
+	}
+	virtual trace_type_t	GetTraceType( ) const {
+		return TRACE_EVERYTHING;
+	}
+
+	void* pSkip;
+};
+
+class CTraceFilterWorldAndPropsOnly : public ITraceFilter {
+public:
+	bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) override {
+		return false;
+	}
+
+	trace_type_t GetTraceType( ) const override {
+		return TRACE_EVERYTHING;
+	}
+};
+
+class CTraceFilterSkipTwoEntities : public ITraceFilter {
+public:
+	CTraceFilterSkipTwoEntities( void* pPassEnt1, void* pPassEnt2 )
+	{
+		passentity1 = pPassEnt1;
+		passentity2 = pPassEnt2;
+	}
+
+	virtual bool ShouldHitEntity( void* pEntityHandle, int contentsMask ) {
+		return !( pEntityHandle == passentity1 || pEntityHandle == passentity2 );
+	}
+
+	virtual trace_type_t GetTraceType( ) const {
+		return TRACE_EVERYTHING;
+	}
+
+	void* passentity1;
+	void* passentity2;
+};
+
+class __declspec( align( 16 ) )VectorAligned : public vec3_t {
+public:
+	VectorAligned& operator=( const vec3_t &vOther ) {
+		x = vOther.x;
+		y = vOther.y;
+		z = vOther.z;
+		return *this;
+	}
+
+	VectorAligned& operator=( const float &other ) {
+		*this = { other, other, other };
+		return *this;
+	}
+	float w;
+};
+
+struct Ray_t {
+	VectorAligned   m_Start;
+	VectorAligned   m_Delta;
+	VectorAligned   m_StartOffset;
+	VectorAligned   m_Extents;
+
+	bool    m_IsRay;
+	bool    m_IsSwept;
+
+	void Init( vec3_t& start, vec3_t& end ) {
+		m_Delta = end - start;
+
+		m_IsSwept = ( m_Delta.lengthsqr( ) != 0 );
+
+		m_Extents = 0.f;
+		m_IsRay = true;
+
+		m_StartOffset = 0.f;
+		m_Start = start;
+	}
+
+	void Init( vec3_t& start, vec3_t& end, vec3_t& mins, vec3_t& maxs ) {
+		m_Delta = end - start;
+
+		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( void ) { return ( ( dispFlags & DISPSURF_FLAG_SURFACE ) != 0 ); } //not in csgo
+	bool IsDispSurfaceWalkable( void ) { return ( ( dispFlags & DISPSURF_FLAG_WALKABLE ) != 0 ); }
+	bool IsDispSurfaceBuildable( void ) { return ( ( dispFlags & DISPSURF_FLAG_BUILDABLE ) != 0 ); }
+	bool IsDispSurfaceProp1( void ) { return ( ( dispFlags & DISPSURF_FLAG_SURFPROP1 ) != 0 ); }
+	bool IsDispSurfaceProp2( void ) { 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;
+
+	IClientEntity*	m_pEnt;
+	int				hitbox;
+
+	CGameTrace( ) {}
+	CGameTrace( const CGameTrace& vOther );
+};
+
+typedef CGameTrace trace_t;
+
+class IEngineTrace {
+public:
+	void clip_ray_to_ent( const Ray_t& ray, unsigned int fMask, IClientEntity* pEnt, trace_t* pTrace ) {
+		return call_vfunc< void( __thiscall* )( void*, const Ray_t&, unsigned int, IClientEntity*, trace_t* ) >( this, 2 )( this, ray, fMask, pEnt, pTrace );
+	}
+
+	void trace_ray( const Ray_t& ray, unsigned int fMask, ITraceFilter* pTraceFilter, trace_t* pTrace ) {
+		return call_vfunc< void( __thiscall* )( void*, const Ray_t&, unsigned int, ITraceFilter*, trace_t* ) >( this, 4 )( this, ray, fMask, pTraceFilter, pTrace );
+	}
+};
+
+
+#define	CONTENTS_EMPTY			0		/**< No contents. */
+#define	CONTENTS_SOLID			0x1		/**< an eye is never valid in a solid . */
+#define	CONTENTS_WINDOW			0x2		/**< translucent, but not watery (glass). */
+#define	CONTENTS_AUX			0x4
+#define	CONTENTS_GRATE			0x8		/**< alpha-tested "grate" textures.  Bullets/sight pass through, but solids don't. */
+#define	CONTENTS_SLIME			0x10
+#define	CONTENTS_WATER			0x20
+#define	CONTENTS_MIST			0x40
+#define CONTENTS_OPAQUE			0x80		/**< things that cannot be seen through (may be non-solid though). */
+#define	LAST_VISIBLE_CONTENTS	0x80
+#define ALL_VISIBLE_CONTENTS 	(LAST_VISIBLE_CONTENTS | (LAST_VISIBLE_CONTENTS-1))
+#define CONTENTS_TESTFOGVOLUME	0x100
+#define CONTENTS_UNUSED5		0x200
+#define CONTENTS_UNUSED6		0x4000
+#define CONTENTS_TEAM1			0x800		/**< per team contents used to differentiate collisions. */
+#define CONTENTS_TEAM2			0x1000		/**< between players and objects on different teams. */
+#define CONTENTS_IGNORE_NODRAW_OPAQUE	0x2000		/**< ignore CONTENTS_OPAQUE on surfaces that have SURF_NODRAW. */
+#define CONTENTS_MOVEABLE		0x4000		/**< hits entities which are MOVETYPE_PUSH (doors, plats, etc) */
+#define	CONTENTS_AREAPORTAL		0x8000		/**< remaining contents are non-visible, and don't eat brushes. */
+#define	CONTENTS_PLAYERCLIP		0x10000
+#define	CONTENTS_MONSTERCLIP	0x20000
+
+/**
+* @section currents can be added to any other contents, and may be mixed
+*/
+#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
+
+/**
+* @endsection
+*/
+
+#define	CONTENTS_ORIGIN			0x1000000	/**< removed before bsping an entity. */
+#define	CONTENTS_MONSTER		0x2000000	/**< should never be on a brush, only in game. */
+#define	CONTENTS_DEBRIS			0x4000000
+#define	CONTENTS_DETAIL			0x8000000	/**< brushes to be added after vis leafs. */
+#define	CONTENTS_TRANSLUCENT	0x10000000	/**< auto set if any surface has trans. */
+#define	CONTENTS_LADDER			0x20000000
+#define CONTENTS_HITBOX			0x40000000	/**< use accurate hitboxes on trace. */
+
+/**
+* @section Trace masks.
+*/
+#define	MASK_ALL				(0xFFFFFFFF)
+#define	MASK_SOLID				(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) 			/**< everything that is normally solid */
+#define	MASK_PLAYERSOLID		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) 	/**< everything that blocks player movement */
+#define	MASK_NPCSOLID			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) /**< blocks npc movement */
+#define	MASK_WATER				(CONTENTS_WATER|CONTENTS_MOVEABLE|CONTENTS_SLIME) 							/**< water physics in these contents */
+#define	MASK_OPAQUE				(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_OPAQUE) 							/**< everything that blocks line of sight for AI, lighting, etc */
+#define MASK_OPAQUE_AND_NPCS	(MASK_OPAQUE|CONTENTS_MONSTER)										/**< everything that blocks line of sight for AI, lighting, etc, but with monsters added. */
+#define	MASK_VISIBLE			(MASK_OPAQUE|CONTENTS_IGNORE_NODRAW_OPAQUE) 								/**< everything that blocks line of sight for players */
+#define MASK_VISIBLE_AND_NPCS	(MASK_OPAQUE_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE) 							/**< everything that blocks line of sight for players, but with monsters added. */
+#define	MASK_SHOT				(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_HITBOX) 	/**< bullets see these as solid */
+#define MASK_SHOT_HULL			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_GRATE) 	/**< non-raycasted weapons see this as solid (includes grates) */
+#define MASK_SHOT_PORTAL		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW) 							/**< hits solids (not grates) and passes through everything else */
+#define MASK_SOLID_BRUSHONLY	(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_GRATE) 					/**< everything normally solid, except monsters (world+brush only) */
+#define MASK_PLAYERSOLID_BRUSHONLY	(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_PLAYERCLIP|CONTENTS_GRATE) 			/**< everything normally solid for player movement, except monsters (world+brush only) */
+#define MASK_NPCSOLID_BRUSHONLY	(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) 			/**< everything normally solid for npc movement, except monsters (world+brush only) */
+#define MASK_NPCWORLDSTATIC		(CONTENTS_SOLID|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) 					/**< just the world, used for route rebuilding */
+#define MASK_SPLITAREAPORTAL	(CONTENTS_WATER|CONTENTS_SLIME) 									/**< These are things that can split areaportals */
+#define MASK_AIM				( 0x200400B | CONTENTS_HITBOX ) //this fixes the aimbot not shooting through shit like invis gates
diff --git a/tf2/IEngineVGui.h b/tf2/IEngineVGui.h
new file mode 100644
index 0000000..091c565
--- /dev/null
+++ b/tf2/IEngineVGui.h
@@ -0,0 +1,26 @@
+#pragma once
+
+enum VGuiPanel_t {
+	PANEL_ROOT = 0,
+	PANEL_GAMEUIDLL,
+	PANEL_CLIENTDLL,
+	PANEL_TOOLS,
+	PANEL_INGAMESCREENS,
+	PANEL_GAMEDLL,
+	PANEL_CLIENTDLL_TOOLS
+};
+
+enum PaintMode_t {
+	PAINT_UIPANELS = ( 1 << 0 ),
+	PAINT_INGAMEPANELS = ( 1 << 1 ),
+	PAINT_CURSOR = ( 1 << 2 ), // software cursor, if appropriate
+};
+
+class IEngineVGui {
+public:
+	virtual					~IEngineVGui( void ) { }
+
+	virtual unsigned int	GetPanel( VGuiPanel_t type ) = 0;
+
+	virtual bool			IsGameUIVisible( ) = 0;
+};
+\ No newline at end of file
diff --git a/tf2/IGameEventManager.h b/tf2/IGameEventManager.h
new file mode 100644
index 0000000..f2e7c25
--- /dev/null
+++ b/tf2/IGameEventManager.h
@@ -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/tf2/IGameMovement.h b/tf2/IGameMovement.h
new file mode 100644
index 0000000..26b5244
--- /dev/null
+++ b/tf2/IGameMovement.h
@@ -0,0 +1,118 @@
+#pragma once
+#pragma once
+
+#include "vector.hpp"
+
+using CBaseEntity = uintptr_t;
+class CUserCmd;
+
+typedef int EntityHandle_t, soundlevel_t;
+class CGameTrace;
+
+typedef CGameTrace trace_t;
+
+#define MAX_CLIMB_SPEED 200.0
+
+class CMoveData
+{
+public:
+	bool			m_bFirstRunOfFunctions : 1;
+	bool			m_bGameCodeMovedPlayer : 1;
+
+	EntityHandle_t	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_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;
+
+	vec3_t			m_vecAbsOrigin;
+};
+
+class IGameMovement
+{
+public:
+	virtual			~IGameMovement( void ) {}
+	virtual void	ProcessMovement( CBaseEntity *pPlayer, CMoveData *pMove ) = 0;
+	virtual void	StartTrackPredictionErrors( CBaseEntity *pPlayer ) = 0;
+	virtual void	FinishTrackPredictionErrors( CBaseEntity *pPlayer ) = 0;
+	virtual void	DiffPrint( char const *fmt, ... ) = 0;
+	virtual vec3_t	GetPlayerMins( bool ducked ) const = 0;
+	virtual vec3_t	GetPlayerMaxs( bool ducked ) const = 0;
+	virtual vec3_t  GetPlayerViewOffset( bool ducked ) const = 0;
+};
+
+class IMoveHelper
+{
+public:
+	virtual	char const*		GetName( EntityHandle_t handle ) const = 0;
+	virtual void	ResetTouchList( void ) = 0;
+	virtual bool	AddToTouched( const CGameTrace& tr, const vec3_t& impactvelocity ) = 0;
+	virtual void	ProcessImpacts( void ) = 0;
+	virtual void	Con_NPrintf( int idx, char const* fmt, ... ) = 0;
+	virtual void	StartSound( const vec3_t& origin, int channel, char const* sample, float volume, soundlevel_t soundlevel, int fFlags, int pitch ) = 0;
+	virtual void	StartSound( const vec3_t& origin, const char *soundname ) = 0;
+	virtual void	PlaybackEventFull( int flags, int clientindex, unsigned short eventindex, float delay, vec3_t& origin, vec3_t& angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 ) = 0;
+	virtual bool	PlayerFallingDamage( void ) = 0;
+	virtual void	PlayerSetAnimation( int playerAnim ) = 0;
+
+	virtual void *GetSurfaceProps( void ) = 0;
+
+	virtual bool IsWorldEntity( const uintptr_t &handle ) = 0;
+
+protected:
+	virtual			~IMoveHelper( ) {}
+};
+
+class IPrediction
+{
+public:
+	virtual			~IPrediction( void ) {};
+
+	virtual void	Init( void ) = 0;
+	virtual void	Shutdown( void ) = 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( void ) = 0;
+	virtual void	PostNetworkDataReceived( int commands_acknowledged ) = 0;
+
+	virtual void	OnReceivedUncompressedPacket( void ) = 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;
+};
+\ No newline at end of file
diff --git a/tf2/IInputSystem.h b/tf2/IInputSystem.h
new file mode 100644
index 0000000..10f8168
--- /dev/null
+++ b/tf2/IInputSystem.h
@@ -0,0 +1,163 @@
+#pragma once
+#include "VFunc.h"
+#include "IAppSystem.h"
+#include "ButtonCode_t.h"
+
+class IInputSystem : public IAppSystem
+{
+public:
+	// Attach, detach input system from a particular window
+	// This window should be the root window for the application
+	// Only 1 window should be attached at any given time.
+	virtual void AttachToWindow( void* hWnd ) = 0;
+	virtual void DetachFromWindow( ) = 0;
+
+	// Enables/disables input. PollInputState will not update current 
+	// button/analog states when it is called if the system is disabled.
+	virtual void EnableInput( bool bEnable ) = 0;
+
+	// Enables/disables the windows message pump. PollInputState will not
+	// Peek/Dispatch messages if this is disabled
+	virtual void EnableMessagePump( bool bEnable ) = 0;
+
+	// Polls the current input state
+	virtual void PollInputState( ) = 0;
+
+	// Gets the time of the last polling in ms
+	virtual int GetPollTick( ) const = 0;
+
+	// Is a button down? "Buttons" are binary-state input devices (mouse buttons, keyboard keys)
+	virtual bool IsButtonDown( ButtonCode_t code ) const = 0;
+
+	// Returns the tick at which the button was pressed and released
+	virtual int GetButtonPressedTick( ButtonCode_t code ) const = 0;
+	virtual int GetButtonReleasedTick( ButtonCode_t code ) const = 0;
+
+	// Gets the value of an analog input device this frame
+	// Includes joysticks, mousewheel, mouse
+	virtual int GetAnalogValue( AnalogCode_t code ) const = 0;
+
+	// Gets the change in a particular analog input device this frame
+	// Includes joysticks, mousewheel, mouse
+	virtual int GetAnalogDelta( AnalogCode_t code ) const = 0;
+
+	// Returns the input events since the last poll
+	virtual int GetEventCount( ) const = 0;
+	virtual const InputEvent_t* GetEventData( ) const = 0;
+
+private:
+	//22	CInputSystem::MotionControllerActive(void)const
+	virtual void __pad22( ) = 0;
+	//23	CInputSystem::GetMotionControllerOrientation(void)const
+	virtual void __pad23( ) = 0;
+	//24	CInputSystem::GetMotionControllerPosX(void)const
+	virtual void __pad24( ) = 0;
+	//25	CInputSystem::GetMotionControllerPosY(void)const
+	virtual void __pad25( ) = 0;
+	//26	CInputSystem::GetMotionControllerDeviceStatus(void)const
+	virtual void __pad26( ) = 0;
+	//27	CInputSystem::GetMotionControllerDeviceStatusFlags(void)const
+	virtual void __pad27( ) = 0;
+	//28	CInputSystem::SetMotionControllerDeviceStatus(int)
+	virtual void __pad28( ) = 0;
+	//29	CInputSystem::SetMotionControllerCalibrationInvalid(void)
+	virtual void __pad29( ) = 0;
+	//30	CInputSystem::StepMotionControllerCalibration(void)
+	virtual void __pad30( ) = 0;
+	//31	CInputSystem::ResetMotionControllerScreenCalibration(void)
+	virtual void __pad31( ) = 0;
+
+public:
+	// Posts a user-defined event into the event queue; this is expected
+	// to be called in overridden wndprocs connected to the root panel.
+	virtual void PostUserEvent( const InputEvent_t &event ) = 0;
+
+	// Returns the number of joysticks
+	virtual int GetJoystickCount( ) const = 0;
+
+	// Enable/disable joystick, it has perf costs
+	virtual void EnableJoystickInput( int nJoystick, bool bEnable ) = 0;
+
+	// Enable/disable diagonal joystick POV (simultaneous POV buttons down)
+	virtual void EnableJoystickDiagonalPOV( int nJoystick, bool bEnable ) = 0;
+
+	// Sample the joystick and append events to the input queue
+	virtual void SampleDevices( ) = 0;
+
+	// FIXME: Currently force-feedback is only supported on the Xbox 360
+	virtual void SetRumble( float fLeftMotor, float fRightMotor, int userId = -1 ) = 0;
+	virtual void StopRumble( ) = 0;
+
+	// Resets the input state
+	virtual void ResetInputState( ) = 0;
+
+	// Convert back + forth between ButtonCode/AnalogCode + strings
+	virtual const char *ButtonCodeToString( ButtonCode_t code ) const = 0;
+	virtual const char *AnalogCodeToString( AnalogCode_t code ) const = 0;
+	virtual ButtonCode_t StringToButtonCode( const char *pString ) const = 0;
+	virtual AnalogCode_t StringToAnalogCode( const char *pString ) const = 0;
+
+	// Sleeps until input happens. Pass a negative number to sleep infinitely
+	virtual void SleepUntilInput( int nMaxSleepTimeMS = -1 ) = 0;
+
+	// Convert back + forth between virtual codes + button codes
+	// FIXME: This is a temporary piece of code
+	virtual ButtonCode_t VirtualKeyToButtonCode( int nVirtualKey ) const = 0;
+	virtual int ButtonCodeToVirtualKey( ButtonCode_t code ) const = 0;
+	virtual ButtonCode_t ScanCodeToButtonCode( int lParam ) const = 0;
+
+	// How many times have we called PollInputState?
+	virtual int GetPollCount( ) const = 0;
+
+	// Sets the cursor position
+	virtual void SetCursorPosition( int x, int y ) = 0;
+
+	// Tells the input system to generate UI-related events, defined
+	// in inputsystem/inputenums.h (see IE_FirstUIEvent)
+	// We could have multiple clients that care about UI-related events
+	// so we refcount the clients with an Add/Remove strategy. If there
+	// are no interested clients, the UI events are not generated
+	virtual void AddUIEventListener( ) = 0;
+	virtual void RemoveUIEventListener( ) = 0;
+
+	// Returns the currently attached window
+	virtual PlatWindow_t GetAttachedWindow( ) const = 0;
+
+	// Creates a cursor using one of the well-known cursor icons
+	virtual InputCursorHandle_t GetStandardCursor( InputStandardCursor_t id ) = 0;
+
+	// Loads a cursor defined in a file
+	virtual InputCursorHandle_t LoadCursorFromFile( const char *pFileName, const char *pPathID = NULL ) = 0;
+
+	// Sets the cursor icon
+	virtual void SetCursorIcon( InputCursorHandle_t hCursor ) = 0;
+
+	// Gets the cursor position
+	virtual void GetCursorPosition( int *pX, int *pY ) = 0;
+
+	// Mouse capture
+	virtual void EnableMouseCapture( PlatWindow_t hWnd ) = 0;
+	virtual void DisableMouseCapture( ) = 0;
+
+	virtual void SetMouseCursorVisible( bool bVisible ) = 0;
+
+	virtual void DisableHardwareCursor( ) = 0;
+	virtual void EnableHardwareCursor( ) = 0;
+	virtual void ResetCursorIcon( ) = 0;
+	virtual bool GetRawMouseAccumulators( int& accumX, int& accumY ) = 0;
+
+	/*64	CInputSystem::GetConnectedInputDevices(void)
+	65	CInputSystem::IsInputDeviceConnected(InputDevice_t)
+	66	CInputSystem::SetInputDeviceConnected(InputDevice_t,bool)
+	67	CInputSystem::IsOnlySingleDeviceConnected(void)
+	68	CInputSystem::GetCurrentInputDevice(void)
+	69	CInputSystem::IsDeviceReadingInput(InputDevice_t)const
+	70	CInputSystem::SetCurrentInputDevice(InputDevice_t)
+	71	CInputSystem::ResetCurrentInputDevice(void)
+	72	CInputSystem::SampleInputToFindCurrentDevice(bool)
+	73	CInputSystem::IsSamplingForCurrentDevice(void)
+	74	CInputSystem::IsSteamControllerActive(void)const
+	75	CInputSystem::SetSteamControllerMode(char const*,void const*)
+	76	CInputSystem::~CInputSystem()
+	77	CInputSystem::~CInputSystem()*/
+};
+\ No newline at end of file
diff --git a/tf2/IMaterialSystem.hpp b/tf2/IMaterialSystem.hpp
new file mode 100644
index 0000000..a8a6a9e
--- /dev/null
+++ b/tf2/IMaterialSystem.hpp
@@ -0,0 +1,222 @@
+#pragma once
+#include "util.hpp"
+#include "ISurface.h"
+
+using MaterialHandle_t = unsigned short;
+
+enum MaterialVarFlags_t {
+	MATERIAL_VAR_DEBUG = 1 << 0,
+	MATERIAL_VAR_NO_DEBUG_OVERRIDE = 1 << 1,
+	MATERIAL_VAR_NO_DRAW = 1 << 2,
+	MATERIAL_VAR_USE_IN_FILLRATE_MODE = 1 << 3,
+	MATERIAL_VAR_VERTEXCOLOR = 1 << 4,
+	MATERIAL_VAR_VERTEXALPHA = 1 << 5,
+	MATERIAL_VAR_SELFILLUM = 1 << 6,
+	MATERIAL_VAR_ADDITIVE = 1 << 7,
+	MATERIAL_VAR_ALPHATEST = 1 << 8,
+	MATERIAL_VAR_MULTIPASS = 1 << 9,
+	MATERIAL_VAR_ZNEARER = 1 << 10,
+	MATERIAL_VAR_MODEL = 1 << 11,
+	MATERIAL_VAR_FLAT = 1 << 12,
+	MATERIAL_VAR_NOCULL = 1 << 13,
+	MATERIAL_VAR_NOFOG = 1 << 14,
+	MATERIAL_VAR_IGNOREZ = 1 << 15,
+	MATERIAL_VAR_DECAL = 1 << 16,
+	MATERIAL_VAR_ENVMAPSPHERE = 1 << 17,
+	MATERIAL_VAR_NOALPHAMOD = 1 << 18,
+	MATERIAL_VAR_ENVMAPCAMERASPACE = 1 << 19,
+	MATERIAL_VAR_BASEALPHAENVMAPMASK = 1 << 20,
+	MATERIAL_VAR_TRANSLUCENT = 1 << 21,
+	MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK = 1 << 22,
+	MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING = 1 << 23,
+	MATERIAL_VAR_OPAQUETEXTURE = 1 << 24,
+	MATERIAL_VAR_ENVMAPMODE = 1 << 25,
+	MATERIAL_VAR_SUPPRESS_DECALS = 1 << 26,
+	MATERIAL_VAR_HALFLAMBERT = 1 << 27,
+	MATERIAL_VAR_WIREFRAME = 1 << 28,
+};
+
+class ITexture {
+public:
+	int GetActualWidth( ) {
+		return util::get_vfunc< 3, int >( this );
+	}
+
+	int GetActualHeight( ) {
+		return util::get_vfunc< 4, int >( this );
+	}
+};
+
+struct MaterialVideoMode_t {
+	int m_width;
+	int m_height;
+	int m_format;
+	int m_hz;
+};
+
+struct IMaterialSystem_Config_t {
+	MaterialVideoMode_t m_vid_mode;
+	float m_monitor_gamma;
+	float m_monitor_max;
+	float m_monitor_min;
+	float m_monitor_exp;
+	bool m_gamma_enabled;
+	bool m_triple_buffer;
+	int m_aa_samples;
+	int m_force_anisotropic_level;
+	int m_skip_mip_levels;
+	int m_dx_level;
+	int m_flags;
+	bool m_edit_mode;
+	char m_proxy_test_mode;
+	bool m_compressed_textures;
+	bool m_filter_lightmaps;
+	bool m_filter_textures;
+	bool m_reverse_depth;
+	bool m_buffer_primitives;
+	bool m_draw_flat;
+	bool m_measure_fillrate;
+	bool m_visualize_fillrate;
+	bool m_no_transperacy;
+	bool m_software_lighting;
+	bool m_allow_cheats;
+	char m_show_mipmap;
+	bool m_low_res;
+	bool m_normal_mapping;
+	bool m_mipmap_textures;
+	char m_fullbright;
+	bool m_fast_nobumd;
+	bool m_supress_rendering;
+	bool m_drawgray;
+	bool m_show_specular;
+	bool m_show_diffuse;
+	int m_winsize_widthlimit;
+	int m_winsize_heightlimit;
+	int m_aa_quality;
+	bool m_shadow_depth_texture;
+	bool m_motion_blur;
+	bool m_flashlight;
+	bool m_paint_enabled;
+	char pad[ 0xC ];
+};
+
+class IMaterial {
+	char pad[ 0x1C ];
+public:
+	int m_ref_count;
+
+	auto GetName( ) {
+		return util::get_vfunc< 0, const char* >( this );
+	}
+
+	auto GetTextureGroupName( ) {
+		return util::get_vfunc< 1, const char* >( this );
+	}
+
+	void IncrementReferenceCount( ) {
+		return util::get_vfunc< 12, void >( this );
+	}
+
+	void DecrementReferenceCount( ) {
+		return util::get_vfunc< 13, void >( this );
+	}
+
+	void AlphaModulate( float alpha ) {
+		return util::get_vfunc< 27, void >( this, alpha );
+	}
+
+	void ColorModulate( float r, float g, float b ) {
+		return util::get_vfunc< 28, void >( this, r, g, b );
+	}
+
+	void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on ) {
+		return util::get_vfunc< 29, void >( this, flag, on );
+	}
+
+	bool GetMaterialVarFlag( MaterialVarFlags_t flag ) {
+		return util::get_vfunc< 30, bool >( this, flag );
+	}
+
+	auto GetAlphaModulation( ) {
+		return util::get_vfunc< 44, float >( this );
+	}
+
+	void GetColorModulate( float* r, float* g, float* b ) {
+		return util::get_vfunc< 45, void >( this, r, g, b );
+	}
+
+	void Refresh( ) {
+		return util::get_vfunc< 37, void >( this );
+	}
+};
+
+class IMaterialSystem
+{
+public:
+	enum RenderTargetSizeMode_t {
+		RT_SIZE_NO_CHANGE = 0,			// Only allowed for render targets that don't want a depth buffer
+										// (because if they have a depth buffer, the render target must be less than or equal to the size of the framebuffer).
+										RT_SIZE_DEFAULT = 1,				// Don't play with the specified width and height other than making sure it fits in the framebuffer.
+										RT_SIZE_PICMIP = 2,				// Apply picmip to the render target's width and height.
+										RT_SIZE_HDR = 3,					// frame_buffer_width / 4
+										RT_SIZE_FULL_FRAME_BUFFER = 4,	// Same size as frame buffer, or next lower power of 2 if we can't do that.
+										RT_SIZE_OFFSCREEN = 5,			// Target of specified size, don't mess with dimensions
+										RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP = 6 // Same size as the frame buffer, rounded up if necessary for systems that can't do non-power of two textures.
+	};
+
+	enum MaterialRenderTargetDepth_t {
+		MATERIAL_RT_DEPTH_SHARED = 0x0,
+		MATERIAL_RT_DEPTH_SEPARATE = 0x1,
+		MATERIAL_RT_DEPTH_NONE = 0x2,
+		MATERIAL_RT_DEPTH_ONLY = 0x3,
+	};
+
+	ImageFormat GetBackBufferFormat( ) {
+		return util::get_vfunc< 36, ImageFormat >( this );
+	}
+
+	IMaterial* CreateMaterial( const char* pMaterialName, void* pVMTKeyValues ) {
+		return util::get_vfunc< 70, IMaterial* >( this, pMaterialName, pVMTKeyValues );
+	}
+
+	IMaterial* FindMaterial( const char* pMaterialName, const char* pTextureGroupName = "Model textures", bool complain = true, const char* pComplainPrefix = nullptr ) {
+		return util::get_vfunc< 84, IMaterial* >( this, pMaterialName, pTextureGroupName, complain, pComplainPrefix );
+	}
+
+	MaterialHandle_t FirstMaterial( ) {
+		return util::get_vfunc< 86, MaterialHandle_t >( this );
+	}
+
+	MaterialHandle_t NextMaterial( MaterialHandle_t h ) {
+		return util::get_vfunc< 87, MaterialHandle_t >( this, h );
+	}
+
+	MaterialHandle_t InvalidMaterial( ) {
+		return util::get_vfunc< 88, MaterialHandle_t >( this );
+	}
+
+	IMaterial* GetMaterial( MaterialHandle_t h ) {
+		return util::get_vfunc< 89, IMaterial* >( this, h );
+	}
+
+	void BeginRenderTargetAllocation( ) {
+		return util::get_vfunc< 94, void >( this );
+	}
+
+	void EndRenderTargetAllocation( ) {
+		return util::get_vfunc< 95, void >( this );
+	}
+
+	ITexture* CreateNamedRenderTargetTextureEx( const char* name, int w, int h, RenderTargetSizeMode_t sizeMode,
+		ImageFormat format, MaterialRenderTargetDepth_t depth )
+	{
+		const int textureFlags = 0x4 | 0x8; //TEXTUREFLAGS_CLAMPS, TEXTUREFLAGS_CLAMPT
+		const int renderTargetFlags = 0x1; //CREATERENDERTARGETFLAGS_HDR
+		return util::get_vfunc< 97, ITexture* >( this, name, w, h, sizeMode, format, depth, textureFlags, renderTargetFlags );
+	}
+
+	/*void* GetRenderContext( ) {
+	typedef IMatRenderContext*( __thiscall* GetRenderContextFn )( void* );
+	return CallVFunction<GetRenderContextFn>( this, 115 )( this );
+	}*/
+};
+\ No newline at end of file
diff --git a/tf2/IPanel.h b/tf2/IPanel.h
new file mode 100644
index 0000000..5252642
--- /dev/null
+++ b/tf2/IPanel.h
@@ -0,0 +1,13 @@
+#pragma once
+
+class IPanel {
+public:
+	const char* GetName( int iPanel ) {
+		return call_vfunc< const char*( __thiscall* )( void*, int ) >( this, 36 )( this, iPanel );
+	}
+
+	void SetMouseInputEnabled( unsigned int iPanel, bool state ) {
+		return call_vfunc< void( __thiscall* )( void*, unsigned int, bool ) >( this, 32 )( this, iPanel, state );
+	}
+
+};
+\ No newline at end of file
diff --git a/tf2/IPlayerInfoManager.h b/tf2/IPlayerInfoManager.h
new file mode 100644
index 0000000..13406b1
--- /dev/null
+++ b/tf2/IPlayerInfoManager.h
@@ -0,0 +1,7 @@
+#pragma once
+#include "CGlobalVarsBase.h"
+class IPlayerInfoManager {
+public:
+	virtual void pad_000( ) = 0;
+	virtual CGlobalVarsBase* GetGlobalVars( ) = 0;
+};
+\ No newline at end of file
diff --git a/tf2/ISurface.h b/tf2/ISurface.h
new file mode 100644
index 0000000..3dbff15
--- /dev/null
+++ b/tf2/ISurface.h
@@ -0,0 +1,223 @@
+#pragma once
+#include "VFunc.h"
+#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;
+
+enum GradientType_t {
+	GRADIENT_HORIZONTAL = 0,
+	GRADIENT_VERTICAL = 1
+};
+
+class ISurface {
+public:
+	void DrawSetColor( clr_t clr ) {
+		return call_vfunc< void( __thiscall* )( void*, int , int , int, int ) >( this, 11 )( this, clr.r( ), clr.g( ), clr.b( ), clr.a( ) );
+	}
+
+	void DrawFilledRect( int x, int y, int w, int h ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int, int, int ) >( this, 12 )( this, x, y, w, h );
+	}
+
+	void DrawOutlinedRect( int x, int y, int w, int h ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int, int, int ) >( this, 14 )( this, x, y, w, h );
+	}
+
+	void DrawLine( int x0, int y0, int x1, int y1 ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int, int, int ) >( this, 15 )( this, x0, y0, x1, y1 );
+	}
+
+	void DrawPolyLine( int* x, int* y, int n ) {
+		return call_vfunc< void( __thiscall* )( void*, int*, int*, int ) >( this, 16 )( this, x, y, n );
+	}
+
+	void DrawSetTextFont( unsigned long index ) {
+		return call_vfunc< void( __thiscall* )( void*, unsigned long ) >( this, 17 )( this, index );
+	}
+
+	void DrawSetTextColor( clr_t clr ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int, int, int ) >( this, 19 )( this, clr.r( ), clr.g( ), clr.b( ), clr.a( ) );
+	}
+
+	void DrawSetTextPos( int x, int y ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int ) >( this, 20 )( this, x, y );
+	}
+
+	void DrawPrintText( const wchar_t* text, int length, FontDrawType_t drawtype = FontDrawType_t::FONT_DRAW_DEFAULT ) {
+		return call_vfunc< void( __thiscall* )( void*, const wchar_t*, int, FontDrawType_t ) >( this, 22 )( this, text, length, drawtype );
+	}
+
+	void DrawSetTextureRGBA( int id, const unsigned char* rgba, int w, int h ) {
+		return call_vfunc< void( __thiscall* )( void*, int, const unsigned char*, int, int, int, bool ) >( this, 31 )( this, id, rgba, w, h, 0, true );
+	}
+
+	void DrawSetTexture( int id ) {
+		return call_vfunc< void( __thiscall* )( void*, int ) >( this, 32 )( this, id );
+	}
+
+	int CreateNewTextureID( bool procedural ) {
+		return call_vfunc< int( __thiscall* )( void*, bool ) >( this, 37 )( this, procedural );
+	}
+
+	void SetCursorAlwaysVis( bool vis ) {
+		return call_vfunc< void( __thiscall* )( void*, bool ) >( this, 52 )( this, vis );
+	}
+
+	unsigned long CreateFnt( ) {
+		return call_vfunc< unsigned long( __thiscall* )( void* ) >( this, 66 )( this );
+	}
+
+	void UnlockCursor( ) {
+		return call_vfunc< void( __thiscall* )( void* ) >( this, 61 )( this );
+	}
+
+	void LockCursor( ) {
+		return call_vfunc< void( __thiscall* )( void* ) >( this, 62 )( this );
+	}
+
+	void SetFontGlyphSet( unsigned long font, const char* windowsFontName, int tall, int weight, int blur, int scanlines, int flags, int nRangeMin = 0, int nRangeMax = 0 ) {
+		return call_vfunc< void( __thiscall* )( void*, unsigned long, const char*, int, int, int, int, int, int, int ) >( this, 67 )( this, font, windowsFontName, tall, weight, blur, scanlines, flags, nRangeMin, nRangeMax );
+	}
+
+	void GetTextSize( unsigned long font, const wchar_t* text, int& wide, int& tall ) {
+		return call_vfunc< void( __thiscall* )( void*, unsigned long, const wchar_t*, int&, int& ) >( this, 75 )( this, font, text, wide, tall );
+	}
+
+	void play_sound( const char* fileName ) {
+		return call_vfunc< void( __thiscall* )( void*, const char* ) >( this, 82 )( this, fileName );
+	}
+
+	void GetCursorPosition( int &x, int &y ) {
+		return call_vfunc< void( __thiscall* )( void*, int&, int& ) >( this, 96 )( this, x, y );
+	}
+
+	void DrawOutlinedCircle( int x, int y, int radius, int segments ) {
+		return call_vfunc< void( __thiscall* )( void*, int, int, int, int ) >( this, 99 )( this, x, y, radius, segments );
+	}
+
+	void DrawTexturedPolygon( int n, vertex_t* pVertice, bool bClipVertices = true ) {
+		return call_vfunc< void( __thiscall* )( void*, int, vertex_t*, bool ) >( this, 102 )( this, n, pVertice, bClipVertices );
+	}
+
+	void DrawGradient( int x, int y, int w, int h, clr_t first, clr_t second, GradientType_t type )
+	{
+		clr_t present_draw_clr = { };
+
+		auto draw_filled_rect_gradient = [ & ]( bool reversed ) -> void {
+			call_vfunc< void( __thiscall* )( void*, int, int, int, int, unsigned, unsigned, bool ) >( this, 118 )
+				( this, x, y, w, h, reversed ? 255 : 0, reversed ? 0 : 255, type == GRADIENT_HORIZONTAL );
+		};
+
+		DrawSetColor( clr_t::blend( first, second, 0.5f ) );
+		DrawFilledRect( x, y, w, h );
+
+		DrawSetColor( first );
+		present_draw_clr = first;
+		draw_filled_rect_gradient( true );
+
+		DrawSetColor( second );
+		present_draw_clr = second;
+		draw_filled_rect_gradient( false );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IVDebugOverlay.h b/tf2/IVDebugOverlay.h
new file mode 100644
index 0000000..664b356
--- /dev/null
+++ b/tf2/IVDebugOverlay.h
@@ -0,0 +1,10 @@
+#pragma once
+#include "VFunc.h"
+
+class vec3_t;
+class IVDebugOverlay {
+public:
+	int ScreenPosition( const vec3_t& point, vec3_t& screen ) {
+		return call_vfunc< int( __thiscall* )( void*, const vec3_t&, vec3_t& ) >( this, 10 )( this, point, screen );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IVEngineClient.h b/tf2/IVEngineClient.h
new file mode 100644
index 0000000..a45e839
--- /dev/null
+++ b/tf2/IVEngineClient.h
@@ -0,0 +1,192 @@
+#pragma once
+#include "VFunc.h"
+
+typedef float matrix3x4[ 3 ][ 4 ];
+typedef struct player_info_s {
+	char			name[ 32 ];
+	int				userID;
+	char			guid[ 33 ];
+	unsigned long	friendsID;
+	char			friendsName[ 32 ];
+	bool			fakeplayer;
+	bool			ishltv;
+	unsigned long	customFiles[ 4 ];
+	byte	filesDownloaded;
+} 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
+		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( void ) const = 0;	// get channel name
+	virtual const char  *GetAddress( void ) const = 0; // get channel IP address as string
+	virtual float		GetTime( void ) const = 0;	// current net time
+	virtual float		GetTimeConnected( void ) const = 0;	// get connection time in seconds
+	virtual int			GetBufferSize( void ) const = 0;	// netchannel packet history size
+	virtual int			GetDataRate( void ) const = 0; // send data rate in byte/sec
+
+	virtual bool		IsLoopback( void ) const = 0;	// true if loopback channel
+	virtual bool		IsTimingOut( void ) const = 0;	// true if timing out
+	virtual bool		IsPlayback( void ) 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			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( void ) 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
+	char pad_0030[ 1044 ]; //0x0030
+
+	bool transmit( bool only_reliable ) {
+		return util::get_vfunc< 49, bool >( this, only_reliable );
+	}
+}; //Size: 0x0444
+
+struct INetMessage {
+	virtual ~INetMessage( );
+};
+
+template<typename T>
+class CNetMessagePB : public INetMessage, public T {};
+
+class CCLCMsg_Move_ {
+private:
+	char __PAD0[ 0x8 ];
+public:
+	int numBackupCommands;
+	int numNewCommands;
+};
+
+using CCLCMsg_Move_t = CNetMessagePB<CCLCMsg_Move_>;
+
+class CClientState {
+public:
+	char pad0[ 0x9C ];
+	INetChannel* netchannel;
+	char pad1[ 0xD4 ];
+	int32_t m_nDeltaTick; //0x174
+	char pad2[ 0x4B34 ];
+	float m_frameTime;
+	int32_t lastoutgoingcommand;
+	int32_t chokedcommands;
+	int32_t last_command_ack;
+};
+
+class CGlobalState {
+public:
+	uintptr_t * m_manager;
+	CClientState *m_def_clientstate;
+
+	__forceinline CClientState* get_client_state( ) {
+		return m_def_clientstate;
+	}
+};
+
+class IVEngineClient {
+public:
+	void GetScreenSize( int& width, int& height ) {
+		return call_vfunc< void( __thiscall* )( void*, int&, int& ) >( this, 5 )( this, width, height );
+	}
+
+	void ClientCmd( const char* command ) {
+		return call_vfunc< void( __thiscall* )( void*, const char* ) >( this, 7 )( this, command );
+	}
+
+	bool GetPlayerInfo( int index, player_info_t* info ) {
+		return call_vfunc< bool( __thiscall* )( void*, int, player_info_t* ) >( this, 8 )( this, index, info );
+	}
+
+	int GetPlayerForUserID( int UserID ) {
+		using fn = int( __thiscall* )( void*, int );
+		return util::get_vfunc< fn >( this, 9 )( this, UserID );
+	}
+
+	bool Cov_IsVisible( ) {
+		return call_vfunc< bool( __thiscall* )( void* ) >( this, 11 )( this );
+	}
+
+	int GetLocalPlayer( ) {
+		return call_vfunc< int( __thiscall* )( void* ) >( this, 12 )( this );
+	}
+
+	float Time( ) {
+		return call_vfunc< float( __thiscall* )( void* ) >( this, 14 )( this );
+	}
+
+	void GetViewAngles( vec3_t& angles ) {
+		return call_vfunc< void( __thiscall* )( void*, vec3_t& ) >( this, 19 )( this, angles );
+	}
+
+	void SetViewAngles( vec3_t& angles ) {
+		return call_vfunc< void( __thiscall* )( void*, vec3_t& ) >( this, 20 )( this, angles );
+	}
+
+	const matrix3x4& GetWorldToScreenMatrix( ) {
+		return call_vfunc< const matrix3x4&( __thiscall* )( void* ) >( this, 36 )( this );
+	}
+
+	int GetMaxClients( ) {
+		return call_vfunc< int( __thiscall* )( void* ) >( this, 21 )( this );
+	}
+
+	bool IsInGame( ) {
+		return call_vfunc< bool( __thiscall* )( void* ) >( this, 26 )( this );
+	}
+
+	bool IsConnected( ) {
+		return call_vfunc< bool( __thiscall* )( void* ) >( this, 27 )( this );
+	}
+
+	void ClientCmd_Unrestricted( const char* command ) {
+		return call_vfunc< void( __thiscall* )( void*, const char* ) >( this, 106 )( this, command );
+	}
+
+	INetChannelInfo* GetNetChannelInfo( ) {
+		using fn = INetChannelInfo * ( __thiscall* )( void* );
+		return util::get_vfunc< fn >( this, 72 )( this );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IVModelInfo.h b/tf2/IVModelInfo.h
new file mode 100644
index 0000000..08df897
--- /dev/null
+++ b/tf2/IVModelInfo.h
@@ -0,0 +1,179 @@
+#pragma once
+#include "IVEngineClient.h"
+#include "IClientEntityList.h"
+class IMaterial;
+struct mstudiobbox_t {
+	int bone;
+	int group;
+	vec3_t bbmin;
+	vec3_t bbmax;
+	int szhitboxnameindex;
+	int unused[8];
+};
+
+enum OverrideType_t {
+	OVERRIDE_NORMAL = 0,
+	OVERRIDE_BUILD_SHADOWS,
+	OVERRIDE_DEPTH_WRITE,
+	OVERRIDE_SSAO_DEPTH_WRITE,
+};
+struct DrawModelState_t;
+
+struct mstudiobone_t {
+	int sznameindex;
+	char* GetName( ) const { return reinterpret_cast< char* >( reinterpret_cast< uintptr_t >( this ) ) + sznameindex; }
+	int parent;
+	int bonecontroller[ 6 ];
+	vec3_t pos;
+	float quat[ 4 ];
+	vec3_t rot;
+	vec3_t posscale;
+	vec3_t rotscale;
+	matrix3x4 poseToBone;
+	float qAlignment[ 4 ];
+	int flags;
+	int proctype;
+	int procindex;
+	mutable int physicsbone;
+	void* GetProcedure( ) const { return procindex == 0 ? nullptr : reinterpret_cast<void*>( reinterpret_cast<uintptr_t>( this ) + procindex ); };
+	int surfacepropidx;
+	char* GetSurfaceProps( ) const { return reinterpret_cast<char*>( reinterpret_cast<uintptr_t>( this ) ) + surfacepropidx; }
+	int contents;
+	unsigned char pad[ 32 ];
+};
+
+struct mstudiohitboxset_t {
+	int sznameindex;
+	inline char *const pszName(void) const { return ((char *)this) + sznameindex; }
+	int numhitboxes;
+	int hitboxindex;
+	mstudiobbox_t *pHitbox(int i) const { return (mstudiobbox_t *)(((BYTE *)this) + hitboxindex) + i; };
+};
+
+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[228];
+
+	mstudiobone_t *GetBone( int i ) const {
+		return reinterpret_cast<mstudiobone_t*>( uintptr_t( this ) + boneindex ) + i;
+	};
+
+	mstudiohitboxset_t	*pHitboxSet(int i) const {
+		return (mstudiohitboxset_t *)(((unsigned char *)this) + hitboxsetindex) + i;
+	};
+
+	mstudiobbox_t *pHitbox(int i, int set) const {
+		const mstudiohitboxset_t *s = pHitboxSet(set);
+		if(!s)
+			return 0;
+
+		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 IVModelInfo {
+public:
+	int GetModelIndex( const char* name ) {
+		return call_vfunc< int( __thiscall* )( void*, const char* ) >( this, 2 )( this, name );
+	}
+
+	const char* GetModelName( const void* model ) {
+		return call_vfunc< const char*( __thiscall* )( void*, const void* ) >( this, 3 )( this, model );
+	}
+
+	studiohdr_t* GetStudioModel( const void* model ) {
+		return call_vfunc< studiohdr_t*( __thiscall* )( void*, const void* ) >( this, 28 )( this, model );
+	}
+
+	model_t* FindOrLoadModel( const char* name ) {
+		using fn = model_t * ( __thiscall* )( void*, const char* );
+		return util::get_vfunc< fn >( this, 43 )( this, name );
+	}
+};
+
+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, 19 )( this, matctx, state, pInfo, pCustomBoneToWorld );
+	}
+};
+
+
+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;
+};
+
+class CStringTable {
+public:
+	INetworkStringTable * FindTable( const char* table ) {
+		using fn = INetworkStringTable * ( __thiscall* )( void*, const char* );
+		return util::get_vfunc< fn >( this, 3 )( this, table );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/IVRenderView.h b/tf2/IVRenderView.h
new file mode 100644
index 0000000..b85b82d
--- /dev/null
+++ b/tf2/IVRenderView.h
@@ -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
+	IClientEntity* m_pStartEnt;
+	int			m_nStartAttachment;
+	IClientEntity* 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/tf2/KeyValues.cpp b/tf2/KeyValues.cpp
new file mode 100644
index 0000000..16ccf6e
--- /dev/null
+++ b/tf2/KeyValues.cpp
@@ -0,0 +1,62 @@
+#include "KeyValues.h"
+#include "pattern.hpp"
+#include "interfaces.h"
+
+void* KeyValues::key_values_ptr;
+
+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( "client.dll" ) ), xors( "FF 15 ? ? ? ? 83 C4 08 89 06 8B C6" ) );
+	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( "client.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;
+}
+
+//honestly keyvalues can suck my fucking cock while i force feeds that fucking whores ass rats to live in its cum infested shithole
+
+
+KeyValues::KeyValues( const char* name ) {
+	static std::string fun_pattern = "E8 ? ? ? ? 80 7D 84 00";
+	static uintptr_t function_offset = pattern::first_code_match( cl.m_chl.dll( ), fun_pattern ) + 0x13C;
+	static auto function = reinterpret_cast< void( __thiscall* )( void*, const char* ) >( function_offset );
+	if( function ) function( this, name );
+}
+
+bool KeyValues::LoadFromBuffer( const char* resource_name, const char* buffer, void* file_system, const char* path_id ) {
+	static std::string fun_pattern = "55 8B EC 83 E4 F8 83 EC 34 53 8B 5D 0C 89 4C 24 04";
+	static auto function = pattern::first_code_match< bool( __thiscall* )( void*, const char*, const char*, void*, const char*, void* ) >( cl.m_chl.dll( ), fun_pattern );
+	if( function ) return function( this, resource_name, buffer, file_system, path_id, 0 );
+	return false;
+}
+
+void* KeyValues::operator new( size_t alloc_size ) {
+	if( !KeyValues::key_values_ptr ) {
+		static auto get_key_values = reinterpret_cast< void*( __cdecl* )( ) >( GetProcAddress( GetModuleHandleA( "vstdlib.dll" ), "KeyValuesSystem" ) );
+		KeyValues::key_values_ptr = get_key_values( );
+	}
+
+	return call_vfunc< void*( __thiscall* )( void*, size_t ) >( KeyValues::key_values_ptr, 1 )( KeyValues::key_values_ptr, 32 );
+}
+
+void KeyValues::operator delete( void* mem ) {
+	if( !KeyValues::key_values_ptr ) {
+		static auto get_key_values = reinterpret_cast< void*( __cdecl* )( ) >( GetProcAddress( GetModuleHandleA( "vstdlib.dll" ), "KeyValuesSystem" ) );
+		KeyValues::key_values_ptr = get_key_values( );
+	}
+
+	call_vfunc< void( __thiscall* )( void*, void* ) >( KeyValues::key_values_ptr, 2 )( KeyValues::key_values_ptr, mem );
+}
diff --git a/tf2/KeyValues.h b/tf2/KeyValues.h
new file mode 100644
index 0000000..1d8ed41
--- /dev/null
+++ b/tf2/KeyValues.h
@@ -0,0 +1,46 @@
+#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 );
+
+	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 ];
+	};
+
+	void* operator new( size_t alloc );
+	void operator delete( void* mem );
+
+	char	   m_iDataType;
+	char	   m_bHasEscapeSequences;
+	char	   m_bEvaluateConditionals;
+	static void* key_values_ptr;
+	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/tf2/README.md b/tf2/README.md
new file mode 100644
index 0000000..fa73fb9
--- /dev/null
+++ b/tf2/README.md
@@ -0,0 +1,3 @@
+# tf2
+
+jukka = bester
diff --git a/tf2/ScreenSpaceEffects.h b/tf2/ScreenSpaceEffects.h
new file mode 100644
index 0000000..ec0b6e8
--- /dev/null
+++ b/tf2/ScreenSpaceEffects.h
@@ -0,0 +1,50 @@
+#pragma once
+class KeyValues;
+
+class IScreenSpaceEffect {
+public:
+
+	virtual void Init( ) = 0;
+	virtual void Shutdown( ) = 0;
+
+	virtual void SetParameters( KeyValues *params ) = 0;
+
+	virtual void Render( int x, int y, int w, int h ) = 0;
+
+	virtual void Enable( bool bEnable ) = 0;
+	virtual bool IsEnabled( ) = 0;
+};
+
+class IScreenSpaceEffectManager {
+public:
+
+	virtual void InitScreenSpaceEffects( ) = 0;
+	virtual void ShutdownScreenSpaceEffects( ) = 0;
+
+	virtual IScreenSpaceEffect *GetScreenSpaceEffect( const char *pEffectName ) = 0;
+
+	virtual void SetScreenSpaceEffectParams( const char *pEffectName, KeyValues *params ) = 0;
+	virtual void SetScreenSpaceEffectParams( IScreenSpaceEffect *pEffect, KeyValues *params ) = 0;
+
+	virtual void EnableScreenSpaceEffect( const char *pEffectName ) = 0;
+	virtual void EnableScreenSpaceEffect( IScreenSpaceEffect *pEffect ) = 0;
+
+	virtual void DisableScreenSpaceEffect( const char *pEffectName ) = 0;
+	virtual void DisableScreenSpaceEffect( IScreenSpaceEffect *pEffect ) = 0;
+
+	virtual void DisableAllScreenSpaceEffects( ) = 0;
+
+	virtual void RenderEffects( int x, int y, int w, int h ) = 0;
+};
+
+class CScreenSpaceEffectRegistration {
+public:
+	CScreenSpaceEffectRegistration( const char *pName, IScreenSpaceEffect *pEffect );
+
+	const char			*m_pEffectName;
+	IScreenSpaceEffect	*m_pEffect;
+
+	CScreenSpaceEffectRegistration *m_pNext;
+
+	static CScreenSpaceEffectRegistration *s_pHead;
+};
+\ No newline at end of file
diff --git a/tf2/Source.cpp b/tf2/Source.cpp
new file mode 100644
index 0000000..3bd44af
--- /dev/null
+++ b/tf2/Source.cpp
@@ -0,0 +1,42 @@
+#pragma warning (disable:4018)
+
+#include <Windows.h>
+#include <iostream>
+
+#include "console.hpp"
+#include "interfaces.h"
+#include "search.h"
+#include "hooks.h"
+#include <thread>
+#include "base_cheat.h"
+
+HMODULE g_dll;
+
+void main_thread( HMODULE module ) {
+
+	cl.initialize( );
+
+	
+
+	while ( !( GetAsyncKeyState( VK_END ) & 0x8000 ) ) {
+		std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
+	}
+
+}
+
+bool __stdcall DllMain(
+	_In_ HINSTANCE hinstDLL,
+	_In_ DWORD     fdwReason,
+	_In_ LPVOID    lpvReserved ) {
+	if ( fdwReason == DLL_PROCESS_ATTACH /*&& ( uintptr_t )( lpvReserved ) == 20*/ ) { //nigga suck who dick?
+		DisableThreadLibraryCalls( hinstDLL );
+		g_dll = hinstDLL;
+		// coca cola coca cola yayo bought me everything
+
+		//no i did not dummy
+
+		CreateThread( nullptr, 0, reinterpret_cast< LPTHREAD_START_ROUTINE >( main_thread ), hinstDLL, 0, nullptr );
+	}
+
+	return true;
+}
+\ No newline at end of file
diff --git a/tf2/UtlMem.h b/tf2/UtlMem.h
new file mode 100644
index 0000000..df4574f
--- /dev/null
+++ b/tf2/UtlMem.h
@@ -0,0 +1,320 @@
+#pragma once
+
+typedef intptr_t intp;
+inline int UtlMemory_CalcNewAllocationCount( int nAllocationCount, int nGrowSize, int nNewSize, int nBytesItem )
+{
+	if( nGrowSize )
+		nAllocationCount = ( ( 1 + ( ( nNewSize - 1 ) / nGrowSize ) ) * nGrowSize );
+	else
+	{
+		if( !nAllocationCount )
+			nAllocationCount = ( 31 + nBytesItem ) / nBytesItem;
+
+		while( nAllocationCount < nNewSize )
+			nAllocationCount *= 2;
+	}
+
+	return nAllocationCount;
+}
+
+template< class T, class I = int >
+class CUtlMemory
+{
+public:
+	T & operator[]( I i )
+	{
+		return m_pMemory[ i ];
+	}
+
+	explicit operator bool( ) const noexcept {
+		return !!( m_pMemory );
+	}
+
+	T *Base( )
+	{
+		return m_pMemory;
+	}
+
+	int NumAllocated( ) const
+	{
+		return m_nAllocationCount;
+	}
+
+	void Grow( int num = 1 )
+	{
+		if( IsExternallyAllocated( ) )
+			return;
+
+		int nAllocationRequested = m_nAllocationCount + num;
+		int nNewAllocationCount = UtlMemory_CalcNewAllocationCount( m_nAllocationCount, m_nGrowSize, nAllocationRequested, sizeof( T ) );
+
+		if( ( int )( I )nNewAllocationCount < nAllocationRequested )
+		{
+			if( ( int )( I )nNewAllocationCount == 0 && ( int )( I )( nNewAllocationCount - 1 ) >= nAllocationRequested )
+				--nNewAllocationCount;
+			else
+			{
+				if( ( int )( I )nAllocationRequested != nAllocationRequested )
+					return;
+
+				while( ( int )( I )nNewAllocationCount < nAllocationRequested )
+					nNewAllocationCount = ( nNewAllocationCount + nAllocationRequested ) / 2;
+			}
+		}
+
+		m_nAllocationCount = nNewAllocationCount;
+
+		if( m_pMemory )
+			m_pMemory = ( T * )realloc( m_pMemory, m_nAllocationCount * sizeof( T ) );
+		else
+			m_pMemory = ( T * )malloc( m_nAllocationCount * sizeof( T ) );
+	}
+
+	bool IsExternallyAllocated( ) const
+	{
+		return m_nGrowSize < 0;
+	}
+
+protected:
+	T * m_pMemory;
+	int m_nAllocationCount;
+	int m_nGrowSize;
+};
+
+template <class T>
+inline T *Construct( T *pMemory )
+{
+	return ::new( pMemory ) T;
+}
+
+template <class T>
+inline T *CopyConstruct( T *pMemory, T const& src )
+{
+	return( new( pMemory ) T( src ) );
+}
+
+template <class T>
+inline void Destruct( T *pMemory )
+{
+	pMemory->~T( );
+}
+
+template< class T >
+class CUtlFixedMemory
+{
+public:
+	// constructor, destructor
+	CUtlFixedMemory( int nGrowSize = 0, int nInitSize = 0 );
+	~CUtlFixedMemory( );
+
+	// Set the size by which the memory grows
+	void Init( int nGrowSize = 0, int nInitSize = 0 );
+
+	// here to match CUtlMemory, but only used by ResetDbgInfo, so it can just return NULL
+	T* Base( ) { return NULL; }
+	const T* Base( ) const { return NULL; }
+
+protected:
+	struct BlockHeader_t;
+
+public:
+	class Iterator_t
+	{
+	public:
+		Iterator_t( BlockHeader_t *p, int i ) : m_pBlockHeader( p ), m_nIndex( i ) {}
+		BlockHeader_t *m_pBlockHeader;
+		intp m_nIndex;
+
+		bool operator==( const Iterator_t it ) const { return m_pBlockHeader == it.m_pBlockHeader && m_nIndex == it.m_nIndex; }
+		bool operator!=( const Iterator_t it ) const { return m_pBlockHeader != it.m_pBlockHeader || m_nIndex != it.m_nIndex; }
+	};
+	Iterator_t First( ) const { return m_pBlocks ? Iterator_t( m_pBlocks, 0 ) : InvalidIterator( ); }
+	Iterator_t Next( const Iterator_t &it ) const
+	{
+		Assert( IsValidIterator( it ) );
+		if( !IsValidIterator( it ) )
+			return InvalidIterator( );
+
+		BlockHeader_t *pHeader = it.m_pBlockHeader;
+		if( it.m_nIndex + 1 < pHeader->m_nBlockSize )
+			return Iterator_t( pHeader, it.m_nIndex + 1 );
+
+		return pHeader->m_pNext ? Iterator_t( pHeader->m_pNext, 0 ) : InvalidIterator( );
+	}
+	intp GetIndex( const Iterator_t &it ) const
+	{
+		Assert( IsValidIterator( it ) );
+		if( !IsValidIterator( it ) )
+			return InvalidIndex( );
+
+		return ( intp )( HeaderToBlock( it.m_pBlockHeader ) + it.m_nIndex );
+	}
+	bool IsIdxAfter( intp i, const Iterator_t &it ) const
+	{
+		Assert( IsValidIterator( it ) );
+		if( !IsValidIterator( it ) )
+			return false;
+
+		if( IsInBlock( i, it.m_pBlockHeader ) )
+			return i > GetIndex( it );
+
+		for( BlockHeader_t *pbh = it.m_pBlockHeader->m_pNext; pbh; pbh = pbh->m_pNext )
+		{
+			if( IsInBlock( i, pbh ) )
+				return true;
+		}
+		return false;
+	}
+	bool IsValidIterator( const Iterator_t &it ) const { return it.m_pBlockHeader && it.m_nIndex >= 0 && it.m_nIndex < it.m_pBlockHeader->m_nBlockSize; }
+	Iterator_t InvalidIterator( ) const { return Iterator_t( NULL, INVALID_INDEX ); }
+
+	// element access
+	T& operator[]( intp i );
+	const T& operator[]( intp i ) const;
+	T& Element( intp i );
+	const T& Element( intp i ) const;
+
+	// Can we use this index?
+	bool IsIdxValid( intp i ) const;
+
+	// Specify the invalid ('null') index that we'll only return on failure
+	static const intp INVALID_INDEX = 0; // For use with COMPILE_TIME_ASSERT
+	static intp InvalidIndex( ) { return INVALID_INDEX; }
+
+	// Size
+	int NumAllocated( ) const;
+	int Count( ) const { return NumAllocated( ); }
+
+	// Grows memory by max(num,growsize), and returns the allocation index/ptr
+	void Grow( int num = 1 );
+
+	// Makes sure we've got at least this much memory
+	void EnsureCapacity( int num );
+
+	// Memory deallocation
+	void Purge( );
+
+protected:
+	// Fast swap - WARNING: Swap invalidates all ptr-based indices!!!
+	void Swap( CUtlFixedMemory< T > &mem );
+
+	bool IsInBlock( intp i, BlockHeader_t *pBlockHeader ) const
+	{
+		T *p = ( T* )i;
+		const T *p0 = HeaderToBlock( pBlockHeader );
+		return p >= p0 && p < p0 + pBlockHeader->m_nBlockSize;
+	}
+
+	struct BlockHeader_t
+	{
+		BlockHeader_t *m_pNext;
+		intp m_nBlockSize;
+	};
+
+	const T *HeaderToBlock( const BlockHeader_t *pHeader ) const { return ( T* )( pHeader + 1 ); }
+	const BlockHeader_t *BlockToHeader( const T *pBlock ) const { return ( BlockHeader_t* )( pBlock )-1; }
+
+	BlockHeader_t* m_pBlocks;
+	int m_nAllocationCount;
+	int m_nGrowSize;
+};
+
+template< class T, class A = CUtlMemory<T> >
+class CUtlVector
+{
+	typedef A CAllocator;
+
+	typedef T *iterator;
+	typedef const T *const_iterator;
+public:
+	T & operator[]( int i )
+	{
+		return m_Memory[ i ];
+	}
+
+	explicit operator bool( ) const noexcept {
+		return !!( m_Memory );
+	}
+
+	T& Element( int i )
+	{
+		return m_Memory[ i ];
+	}
+
+	T* Base( )
+	{
+		return m_Memory.Base( );
+	}
+
+	int Count( ) const
+	{
+		return m_Size;
+	}
+
+	void RemoveAll( )
+	{
+		for( int i = m_Size; --i >= 0; )
+			Destruct( &Element( i ) );
+
+		m_Size = 0;
+	}
+
+	int AddToTail( const T& src )
+	{
+		return InsertBefore( m_Size, src );
+	}
+
+	int AddToTail( )
+	{
+		return InsertBefore( m_Size );
+	}
+
+	int InsertBefore( int elem, const T& src )
+	{
+		Growvec3_t( );
+		ShiftElementsRight( elem );
+		CopyConstruct( &Element( elem ), src );
+		return elem;
+	}
+
+	int InsertBefore( int elem )
+	{
+		Growvec3_t( );
+		ShiftElementsRight( elem );
+		Construct( &Element( elem ) );
+
+		return elem;
+	}
+
+	iterator begin( ) { return Base( ); }
+	const_iterator begin( ) const { return Base( ); }
+	iterator end( ) { return Base( ) + Count( ); }
+	const_iterator end( ) const { return Base( ) + Count( ); }
+
+protected:
+	void Growvec3_t( int num = 1 )
+	{
+		if( m_Size + num > m_Memory.NumAllocated( ) )
+			m_Memory.Grow( m_Size + num - m_Memory.NumAllocated( ) );
+
+		m_Size += num;
+		ResetDbgInfo( );
+	}
+
+	void ShiftElementsRight( int elem, int num = 1 )
+	{
+		int numToMove = m_Size - elem - num;
+		if( ( numToMove > 0 ) && ( num > 0 ) )
+			memmove( &Element( elem + num ), &Element( elem ), numToMove * sizeof( T ) );
+	}
+
+	CAllocator m_Memory;
+	int m_Size;
+
+	T *m_pElements;
+
+	inline void ResetDbgInfo( )
+	{
+		m_pElements = Base( );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/VFunc.h b/tf2/VFunc.h
new file mode 100644
index 0000000..f5e09af
--- /dev/null
+++ b/tf2/VFunc.h
@@ -0,0 +1,12 @@
+#pragma once
+#include <inttypes.h>
+#include <intrin.h>
+
+template < typename Fn > __forceinline Fn call_vfunc( void* classbase, int index ) {
+	if ( !classbase ) return Fn{ };
+	return ( Fn )( ( uintptr_t* )*( uintptr_t** )classbase )[ index ];
+}
+
+template < typename T > __forceinline T get_ebp( ) {
+	__asm mov eax, ebp
+}
+\ No newline at end of file
diff --git a/tf2/aim.cpp b/tf2/aim.cpp
new file mode 100644
index 0000000..15c5e16
--- /dev/null
+++ b/tf2/aim.cpp
@@ -0,0 +1,321 @@
+#include "interfaces.h"
+#include "input_system.hpp"
+#include "ctx.hpp"
+#include "aim.h"
+#include "settings.h"
+#include "math.h"
+
+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{ };
+
+		cl.m_engine( )->GetViewAngles( cur_angle );
+		local_pos = g_ctx.m_local->get_eye_pos( );
+
+		for( int i{ 1 }; i <= cl.m_globals->maxclients; ++i ) {
+			auto entity = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+
+			if( !entity ) continue;
+			if( entity == g_ctx.m_local ) continue;
+			if( !entity->is_valid( ) ) continue;
+			int team = entity->get_team( );
+			if( team == g_ctx.m_local->get_team( )
+				&& !g_settings.legit.friendlies( ) ) {
+				continue;
+			}
+
+			bool visible = entity->is_visible( g_settings.legit.active->m_bone );
+			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_position( g_settings.legit.active->m_bone ) );
+			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_position( g_settings.legit.active->m_bone );
+
+		aim_ang = math::vector_angles( local_pos, enemy_pos );
+
+		move_ang = pixels_to_angle( vec2_t( *x, *y ) );
+		cl.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{ };
+		cl.m_engine( )->GetViewAngles( viewangles );
+
+		auto wep = g_ctx.m_local->get_active_weapon( );
+		if( !wep ) return;
+		if( wep->is_non_aim( ) ) return;
+
+
+		const float length = wep->get_distance( );
+		const float current_time = TICKS_TO_TIME( cl.m_globals->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 ) {
+
+				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 );
+
+				cl.m_trace( )->trace_ray( ray, MASK_SHOT, &filter, &tr );
+
+				if( tr.m_pEnt ) {
+					auto ent = tr.m_pEnt->as< c_base_player >( );
+					if( ent->is_valid( ) ) {
+						if( ent->get_team( ) != g_ctx.m_local->get_team( ) || 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 = cl.m_globals->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 = cl.m_globals->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 = cl.m_cvar( )->FindVar( xors( "m_yaw" ) );
+		static auto m_pitch = cl.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 = cl.m_cvar( )->FindVar( xors( "m_yaw" ) );
+		static auto m_pitch = cl.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_active_weapon( );
+		if( !weapon ) return false;
+
+		if( weapon->is_non_aim( ) ) {
+			return false;
+		}
+
+		if( weapon->is_primary( ) ) {
+			g_settings.legit.active = &g_settings.legit.primary;
+		}
+		else if( weapon->is_secondary( ) ) {
+			g_settings.legit.active = &g_settings.legit.secondary;
+		}
+		else if( weapon->is_third( ) ) {
+			g_settings.legit.active = &g_settings.legit.melee;
+		}
+
+
+		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;
+
+		cl.m_engine( )->GetViewAngles( cur_ang );
+
+		if( g_settings.legit.backtracking( ) && m_lagcomp.find_best_record( target->ce( )->index( ) ) ) {
+			aim_ang = math::vector_angles( g_ctx.m_local->get_eye_pos( ),
+				m_lagcomp.get_backtracked_position( target->ce( )->index( ) ) ).clamp( );
+		}
+		else {
+			aim_ang = math::vector_angles( g_ctx.m_local->get_eye_pos( ),
+				target->get_hitbox_position( g_settings.legit.active->m_bone ) ).clamp( );
+		}
+
+
+		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 = cl.m_globals->curtime;
+		float time = cl.m_globals->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;
+		}
+
+		int  target_index = get_aim_target( );
+		auto target = cl.m_entlist( )->get_client_entity< c_base_player >( 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/tf2/aim.h b/tf2/aim.h
new file mode 100644
index 0000000..82e4943
--- /dev/null
+++ b/tf2/aim.h
@@ -0,0 +1,75 @@
+#pragma once
+#include <deque>
+#include <chrono>
+
+#include "sdk.h"
+
+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/tf2/aim_lagcomp.cpp b/tf2/aim_lagcomp.cpp
new file mode 100644
index 0000000..e3b5486
--- /dev/null
+++ b/tf2/aim_lagcomp.cpp
@@ -0,0 +1,150 @@
+#include "aim.h"
+#include "interfaces.h"
+#include "ctx.hpp"
+#include "settings.h"
+#include "math.h"
+#include "base_cheat.h"
+#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 = cl.m_entlist( )->get_client_entity< c_base_player >( ent_index );
+		vec3_t pos = ent->get_hitbox_position( 0 );
+		int tickcount = TIME_TO_TICKS( ent->m_flSimulationTime( ) );
+
+		lag_record_t new_record;
+		if( ent->ce( )->setup_bones( 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;
+		}
+
+		cl.m_engine( )->GetViewAngles( cur_angle );
+		cur_pos = g_ctx.m_local->get_eye_pos( );
+		cur_tick = cl.m_globals->tickcount;
+
+		for( auto& it : m_data[ ent_index ] ) {
+			int delta = std::abs( cur_tick - it.m_tickcount );
+
+			auto nci = cl.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 = &it;
+			}
+		}
+
+		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 = cl.m_entlist( )->get_client_entity< c_base_player >( 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.aim.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/tf2/base_cheat.h b/tf2/base_cheat.h
new file mode 100644
index 0000000..832386c
--- /dev/null
+++ b/tf2/base_cheat.h
@@ -0,0 +1,22 @@
+#pragma once
+#include "aim.h"
+#include "movement.h"
+#include "prediction.h"
+#include "visuals.hpp"
+#include "chams.h"
+#include "identity.h"
+#include "extra.h"
+namespace tf2 {
+	class c_base_cheat {
+	public:
+		features::c_legitbot aim;
+		features::c_movement movement;
+		features::c_prediction prediction;
+		features::c_visuals visuals;
+		features::c_chams chams;
+		features::c_identity identity;
+		features::c_extra extra;
+	};
+}
+
+static tf2::c_base_cheat g_cheat;
+\ No newline at end of file
diff --git a/tf2/chams.cpp b/tf2/chams.cpp
new file mode 100644
index 0000000..fc5c060
--- /dev/null
+++ b/tf2/chams.cpp
@@ -0,0 +1,321 @@
+#include "chams.h"
+#include "interfaces.h"
+#include "d3d.hpp"
+#include "ctx.hpp"
+#include "hooks.h"
+#include "settings.h"
+
+static auto chams_mat = xors_raw( (
+	R"("VertexLitGeneric"
+{
+	"$basetexture"	"vgui/white"
+	"$model"		"1"
+	"$envmap"    "env_cubemap"
+	"$envmaptint" "[.3 .3 .3]"
+	"$envmapcontrast" ".4"
+	"$envmapsaturation" "1.0"
+	"$flat"			"0"
+	"$nocull"		"1"
+	"$halflambert"	"1"
+	"$nofog"		"1"
+	"$ignorez"		"0"
+	"$znearer"		"0"
+	"$wireframe"	"0"
+	"$phong"		"1"
+	"$phongexponent" "255.0"
+	"$normalmapalphaenvmask" "1"
+	"$phongboost"                "6.0"
+    "$phongfresnelranges"        "[0 0.5 1]" 
+	"$BasemapAlphaPhongMask" "1" 
+})"
+) );
+
+static auto chams_mat_shine = xors_raw( (
+	R"("VertexLitGeneric" 
+{ 
+  "$basetexture"  "vgui/white" 
+  "$envmap"    "env_cubemap"
+  "$envmaptint" "[.3 .3 .3]"
+  "$reflectivity" "[1.0 1.0 1.0]"
+  "$envmapcontrast" ".4"
+  "$envmapsaturation" "1.0"
+  "$model"    "1" 
+  "$flat"      "0" 
+  "$nocull"    "1" 
+  "$selfillum"  "1" 
+  "$halflambert"  "1" 
+  "$nofog"    "1" 
+  "$ignorez"    "0" 
+  "$znearer"    "0" 
+  "$wireframe"  "0" 
+})"
+) );
+
+static auto chams_mat_flat = xors_raw( (
+	R"("UnlitGeneric"
+{
+	"$basetexture"	"vgui/white"
+	"$model"		"1"
+	"$flat"			"1"
+	"$nocull"		"1"
+	"$selfillum"	"1"
+	"$halflambert"	"1"
+	"$nofog"		"1"
+	"$ignorez"		"0"
+	"$znearer"		"0"
+	"$wireframe"	"0"
+})"
+) );
+
+namespace features
+{
+	void c_materials::make_cham_buffer( char* buf, int len, int type ) {
+		switch( type ) {
+		case 1:
+			sprintf_s( buf, len - 1, chams_mat_flat.decrypt( ) );
+			break;
+		case 2:
+			sprintf_s( buf, len - 1, chams_mat_shine.decrypt( ) );
+			break;
+		default:
+			sprintf_s( buf, len - 1, chams_mat.decrypt( ) );
+		}
+	}
+
+	void c_material::init( const char* name, const char* buf ) {
+		m_keyvalues = new KeyValues( name );
+		m_keyvalues->LoadFromBuffer( name, buf );
+
+		// CreateMaterial already increments ref counter
+		m_mat = cl.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( ) };
+		cl.m_render_view( )->SetBlend( clr.a( ) );
+		cl.m_render_view( )->SetColorModulation( col );
+
+		cl.m_model_render( )->ForcedMaterialOverride( mat );
+	}
+
+	void c_materials::initialize_materials( ) {
+		char buffer[ 1024 ];
+
+		make_cham_buffer( buffer, sizeof( buffer ), 0 );
+		m_chams.init( xors( "chamsmat" ), buffer );
+		memset( buffer, 0, 1024 );
+
+		make_cham_buffer( buffer, sizeof( buffer ), 1 );
+		m_chams_flat.init( xors( "chamsmat_flat" ), buffer );
+		memset( buffer, 0, 1024 );
+		m_initialized = true;
+	}
+
+	void c_materials::destroy_materials( ) {
+		m_initialized = false;
+
+		m_chams.destroy( );
+		m_chams_flat.destroy( );
+	}
+
+	void c_materials::update_materials( ) {
+		if( !m_initialized ) return;
+		if( m_chams.m_mat->m_ref_count <= 0 ) return;
+
+		static float last_reflectivity{ };
+		static float last_shine{ };
+		static KeyValues* reflectivity;
+		static KeyValues* shine;
+
+		if( !reflectivity ) {
+			for( auto it = m_chams.m_keyvalues->m_pSub; !!it; it = it->m_pPeer ) {
+				if( it->m_iDataType != 1 ) continue;
+				if( strstr( it->m_sValue, xors( "[.3 .3 .3]" ) ) ) {
+					reflectivity = it;
+				}
+			}
+		}
+
+		if( !shine ) {
+			for( auto it = m_chams.m_keyvalues->m_pSub; !!it; it = it->m_pPeer ) {
+				if( it->m_flValue == 6.0f )
+					shine = it;
+			}
+		}
+
+		if( reflectivity ) {
+			if( last_reflectivity != g_settings.visuals.chams.reflectivity( ) ) {
+				char buf[ 32 ];
+				sprintf_s< 32 >( buf, xors( "[%1.1f %1.1f %1.1f]" ),
+					g_settings.visuals.chams.reflectivity( ),
+					g_settings.visuals.chams.reflectivity( ),
+					g_settings.visuals.chams.reflectivity( ) );
+
+				strcpy( reflectivity->m_sValue, buf );
+				m_chams.m_mat->Refresh( );
+			}
+			last_reflectivity = g_settings.visuals.chams.reflectivity( );
+		}
+
+		if( shine ) {
+			if( last_shine != g_settings.visuals.chams.shine( ) ) {
+				shine->m_flValue = g_settings.visuals.chams.shine( ) * 100.f;
+				m_chams.m_mat->Refresh( );
+			}
+			last_shine = g_settings.visuals.chams.shine( );
+		}
+	}
+
+	void c_chams::d3d_render_chams( c_base_player* ent, int type, int v_index, uint32_t min_index, uint32_t num_vert, uint32_t start_index, uint32_t prim_count ) {
+		static auto d3d_draw = cl.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/tf2/chams.h b/tf2/chams.h
new file mode 100644
index 0000000..4fdc74b
--- /dev/null
+++ b/tf2/chams.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "sdk.h"
+
+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/tf2/checksum_crc.cpp b/tf2/checksum_crc.cpp
new file mode 100644
index 0000000..a2ac9e8
--- /dev/null
+++ b/tf2/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/tf2/checksum_crc.h b/tf2/checksum_crc.h
new file mode 100644
index 0000000..d95b4c5
--- /dev/null
+++ b/tf2/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/tf2/chl_createmove.cpp b/tf2/chl_createmove.cpp
new file mode 100644
index 0000000..581ed25
--- /dev/null
+++ b/tf2/chl_createmove.cpp
@@ -0,0 +1,93 @@
+#include <intrin.h>
+
+#include "hooks.h"
+#include "mem.hpp"
+#include "interfaces.h"
+#include "ctx.hpp"
+#include "input_system.hpp"
+#include "math.h"
+#include "settings.h"
+#include "base_cheat.h"
+
+//YEA FUCK USING THIS EVEN THOUGH I HAVE IT RIGHT HERE
+
+//YEA VIVA LA REVOLUTION
+
+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
+	}
+}
+
+void __fastcall hooks::hl_create_move( void* ecx_, void* edx_, int sequence_number, float input_sameple_frametime, bool active, byte& sendpacket ) {
+	static auto create_move_o = cl.m_chl->get_old_function< void( __fastcall* )( void*, void*, int, float, bool ) >( 21 );
+
+	user_cmd_t* ucmd = &cl.m_hl_input->m_pCommands[ sequence_number % MULTIPLAYER_BACKUP ];
+	if( !ucmd )
+		return;
+
+	verified_cmd_t* verified_cmd = &cl.m_hl_input->m_pVerifiedCommands[ sequence_number % MULTIPLAYER_BACKUP ];
+	if( !verified_cmd )
+		return;
+
+	// when switching to non automatic weapons, it will sometimes not shoot when aimbotting so we reset attack flag
+	bool is_switching_weapon = false;
+	if( cl.m_hl_input->m_hSelectedWeapon != -1 ) {
+		is_switching_weapon = true;
+	}
+
+	cl.m_hl_input->CreateMove( sequence_number, input_sameple_frametime, active );
+	//hl_create_move_o( ecx_, edx_, sequence_number, input_sample_time, active );
+
+	if( !ucmd->m_tick_count || !ucmd->m_cmd_nr )
+		return;
+
+	// FIX ME NAVE
+	// ok love
+
+	byte* send_packet = &sendpacket;
+
+	g_ctx.create_snapshot( ucmd );
+	// soon   g_cheat.m_identity( );
+
+	if( g_ctx.run_frame( ) && g_ctx.m_local->is_alive( ) ) {
+		static int last_frame = cl.m_globals->framecount;
+		if( last_frame != cl.m_globals->framecount )
+			g_ctx.m_has_fired_this_frame = false;
+
+		last_frame = cl.m_globals->framecount;
+
+		g_cheat.aim.sample_angle_data( ucmd->m_viewangles );
+		g_cheat.prediction.run_prediction( ucmd );
+		g_cheat.movement.update( ucmd );
+
+		g_cheat.aim.m_lagcomp( ucmd );
+		g_cheat.aim.triggerbot( ucmd );
+
+	}
+
+
+	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 );
+
+	// crc stuff works, no double steps coming from this
+	verified_cmd->m_cmd = *ucmd;
+	verified_cmd->m_crc = ucmd->get_check_sum( );
+}
+\ No newline at end of file
diff --git a/tf2/clientmode_createmove.cpp b/tf2/clientmode_createmove.cpp
new file mode 100644
index 0000000..f86471e
--- /dev/null
+++ b/tf2/clientmode_createmove.cpp
@@ -0,0 +1,53 @@
+#include "hooks.h"
+#include "interfaces.h"
+#include "search.h"
+#include "base_cheat.h"
+#include <intrin.h>
+#include "mem.hpp"
+#define get_baseptr( ) ( ( uintptr_t )( _AddressOfReturnAddress( ) ) - sizeof( uintptr_t ) )
+bool __fastcall hooks::create_move( void *ecx_, void *edx_, float input_sample_time, user_cmd_t *ucmd ) {
+	static auto create_move_o = cl.m_clientmode->get_old_function< decltype( hooks::create_move )* >( 21 );
+
+	if( cl.m_panic || !ucmd->m_cmd_nr || !ucmd->m_tick_count ) {
+		return create_move_o( ecx_, edx_, input_sample_time, ucmd );
+	}
+
+	// call from CInput::CreateMove, mimic what the engine does.
+	cl.m_engine( )->SetViewAngles( ucmd->m_viewangles );
+
+	// random_seed isn't generated in ClientMode::CreateMove yet (since CInput::CreateMove handles that), we must generate it ourselves.
+	ucmd->m_random_seed = math::md5_pseudorandom( ucmd->m_cmd_nr ) & 0x7fffffff;
+
+	//get sendpacket off the stack
+	stack_t stack( get_baseptr( ) );
+	byte    *send_packet = stack.next( ).local< byte* >( 0x1C );
+
+	g_ctx.create_snapshot( ucmd );
+
+	cl.m_engine( )->SetViewAngles( ucmd->m_viewangles );
+	g_ctx.calculate_tickbase( );
+
+	//bool* send_packet = ***get_ebp< bool**** >( ) - 0x1;
+
+	if( g_ctx.run_frame( ) && g_ctx.m_local->is_alive( ) ) {
+		static int last_frame = cl.m_globals->framecount;
+		if( last_frame != cl.m_globals->framecount )
+			g_ctx.m_has_fired_this_frame = false;
+
+		last_frame = cl.m_globals->framecount;
+
+		g_cheat.aim.sample_angle_data( ucmd->m_viewangles );
+		//g_cheat.prediction.run_prediction( ucmd );
+		g_cheat.movement.update( ucmd );
+
+		g_cheat.aim.m_lagcomp( ucmd );
+		g_cheat.aim.triggerbot( ucmd );
+
+		
+	
+	}
+	
+
+	ucmd->clamp( );
+	return false;
+}
+\ No newline at end of file
diff --git a/tf2/color.hpp b/tf2/color.hpp
new file mode 100644
index 0000000..5ea9454
--- /dev/null
+++ b/tf2/color.hpp
@@ -0,0 +1,278 @@
+#pragma once
+#include <cmath>
+#include <cinttypes>
+
+//this is a fucking mess
+
+class fclr_t {
+	float R, G, B, A;
+public:
+	fclr_t( ) : R( 0 ), G( 0 ), B( 0 ), A( 0 ) { }
+
+	fclr_t( float r, float g, float b, float a ) : R( r ), G( g ), B( b ), A( a ) { }
+
+	fclr_t( float r, float g, float b ) : R( r ), G( g ), B( b ), A( 255 ) { }
+
+	float& r( ) { return R; }
+	float& g( ) { return G; }
+	float& b( ) { return B; }
+	float& a( ) { return A; }
+
+	fclr_t& operator =( fclr_t& c ) {
+		R = c.r( );
+		G = c.g( );
+		B = c.b( );
+		A = c.a( );
+		return *this;
+	}
+
+	fclr_t operator+( const fclr_t& v ) const {
+		return fclr_t( R + v.R, G + v.G, B + v.B, A + v.A );
+	}
+
+	explicit operator bool( ) const noexcept {
+		return ( R > 0 || G > 0 || B > 0 || A > 0 );
+	}
+
+	bool operator==( fclr_t& c ) const {
+		return ( R == c.r( ) && G == c.g( ) && B == c.b( ) );
+	}
+};
+
+class clr_t {
+	uint8_t R, G, B, A;
+public:
+	clr_t( ) : R( 0 ), G( 0 ), B( 0 ), A( 0 ) { }
+
+	clr_t( uint8_t r, uint8_t g, uint8_t b, uint8_t a ) : R( r ), G( g ), B( b ), A( a ) { }
+
+	clr_t( uint8_t r, uint8_t g, uint8_t b ) : R( r ), G( g ), B( b ), A( 255 ) { }
+
+	uint8_t& r( ) { return R; }
+	uint8_t& g( ) { return G; }
+	uint8_t& b( ) { return B; }
+	uint8_t& a( ) { return A; }
+
+	clr_t& operator =( clr_t& c ) {
+		R = c.r( );
+		G = c.g( );
+		B = c.b( );
+		A = c.a( );
+		return *this;
+	}
+
+	clr_t operator+( const clr_t& v ) const {
+		return clr_t( R + v.R, G + v.G, B + v.B, A + v.A );
+	}
+
+	clr_t operator*( float f ) {
+		return clr_t( uint8_t( R * f ), uint8_t( G * f ), uint8_t( B * f ), A );
+	}
+
+	explicit operator bool( ) const noexcept {
+		return ( R > 0 || G > 0 || B > 0 || A > 0 );
+	}
+
+	float brightness( ) {
+		typedef struct {
+			float h, s, v;
+		} hsv;
+		hsv out;
+
+		float min = static_cast<float>( R < G ? R : G );
+		min = static_cast<float>( min < B ? min : B );
+
+		float max = static_cast<float>( R > G ? R : G );
+		max = static_cast<float>( max > B ? max : B );
+
+		out.v = max;
+		float delta = max - min;
+		if( delta < 0.0010f ) {
+			out.s = 0.f;
+			out.h = 0.f;
+			return out.h;
+		}
+		if( max > 0.0f ) {
+			out.s = delta / max;
+		}
+		else {
+			out.s = 0.0f;
+			out.h = NAN;
+			return out.h;
+		}
+		if( R >= max )
+			out.h = static_cast<float>( G - B ) / delta;
+		else if( G >= max )
+			out.h = 2.0f + static_cast<float>( B - R ) / delta;
+		else
+			out.h = 4.0f + static_cast<float>( R - G ) / delta;
+
+		out.h *= 60.0f;
+		out.h /= 360.f;
+
+		if( out.h < 0.0f )
+			out.h += 360.0f;
+
+		return out.v;
+	}
+
+	float saturation( ) {
+		typedef struct {
+			float h, s, v;
+		} hsv;
+		hsv out;
+
+		float min = static_cast<float>( R < G ? R : G );
+		min = static_cast<float>( min < B ? min : B );
+
+		float max = static_cast<float>( R > G ? R : G );
+		max = static_cast<float>( max > B ? max : B );
+
+		out.v = max;
+		float delta = max - min;
+		if( delta < 0.0010f ) {
+			out.s = 0.f;
+			out.h = 0.f;
+			return out.h;
+		}
+		if( max > 0.0f ) {
+			out.s = delta / max;
+		}
+		else {
+			out.s = 0.0f;
+			out.h = NAN;
+			return out.h;
+		}
+		if( R >= max )
+			out.h = static_cast<float>( G - B ) / delta;
+		else if( G >= max )
+			out.h = 2.0f + static_cast<float>( B - R ) / delta;
+		else
+			out.h = 4.0f + static_cast<float>( R - G ) / delta;
+
+		out.h *= 60.0f;
+		out.h /= 360.f;
+
+		if( out.h < 0.0f )
+			out.h += 360.0f;
+
+		return out.s;
+	}
+
+	static clr_t from_hsb( float hue, float saturation, float brightness ) {
+		float h = hue == 1.0f ? 0 : hue * 6.0f;
+		float f = h - ( int )h;
+		float p = brightness * ( 1.0f - saturation );
+		float q = brightness * ( 1.0f - saturation * f );
+		float t = brightness * ( 1.0f - ( saturation * ( 1.0f - f ) ) );
+
+		if( h < 1 ) {
+			return clr_t(
+				( unsigned char )( brightness * 255 ),
+				( unsigned char )( t * 255 ),
+				( unsigned char )( p * 255 )
+			);
+		}
+		else if( h < 2 ) {
+			return clr_t(
+				( unsigned char )( q * 255 ),
+				( unsigned char )( brightness * 255 ),
+				( unsigned char )( p * 255 )
+			);
+		}
+		else if( h < 3 ) {
+			return clr_t(
+				( unsigned char )( p * 255 ),
+				( unsigned char )( brightness * 255 ),
+				( unsigned char )( t * 255 )
+			);
+		}
+		else if( h < 4 ) {
+			return clr_t(
+				( unsigned char )( p * 255 ),
+				( unsigned char )( q * 255 ),
+				( unsigned char )( brightness * 255 )
+			);
+		}
+		else if( h < 5 ) {
+			return clr_t(
+				( unsigned char )( t * 255 ),
+				( unsigned char )( p * 255 ),
+				( unsigned char )( brightness * 255 )
+			);
+		}
+		else {
+			return clr_t(
+				( unsigned char )( brightness * 255 ),
+				( unsigned char )( p * 255 ),
+				( unsigned char )( q * 255 )
+			);
+		}
+	}
+
+	static clr_t blend( clr_t first, clr_t second, float t ) {
+		return clr_t(
+			first.r( ) + static_cast< int >( t * ( second.r( ) - first.r( ) ) ),
+			first.g( ) + static_cast< int >( t * ( second.g( ) - first.g( ) ) ),
+			first.b( ) + static_cast< int >( t * ( second.b( ) - first.b( ) ) ),
+			first.a( ) + static_cast< int >( t * ( second.a( ) - first.a( ) ) )
+		);
+	}
+
+	float hue( ) {
+		typedef struct {
+			float h, s, v;
+		} hsv;
+		hsv         out;
+		float       min, max, delta;
+
+		min = static_cast< float >( R < G ? R : G );
+		min = static_cast< float >( min < B ? min : B );
+
+		max = static_cast< float >( R > G ? R : G );
+		max = static_cast< float >( max > B ? max : B );
+
+		out.v = max;
+		delta = max - min;
+		if( delta < 0.0010f ) {
+			out.s = 0.f;
+			out.h = 0.f;
+			return out.h;
+		}
+		if( max > 0.0f ) {
+			out.s = ( delta / max );
+		}
+		else {
+			out.s = 0.0f;
+			out.h = ( float )NAN;
+			return out.h;
+		}
+		if( R >= max )
+			out.h = static_cast< float >( G - B ) / delta;
+		else
+			if( G >= max )
+				out.h = 2.0f + static_cast< float >( B - R ) / delta;
+			else
+				out.h = 4.0f + static_cast< float >( R - G ) / delta;
+
+		out.h *= 60.0f;
+		out.h /= 360.f;
+
+		if( out.h < 0.0f )
+			out.h += 360.0f;
+
+		return out.h;
+	}
+
+	fclr_t to_fclr( ) {
+		return fclr_t{ R / 255.f, G / 255.f, B / 255.f, A / 255.f };
+	}
+
+	operator fclr_t( ) {
+		return this->to_fclr( );
+	}
+
+	bool operator==( clr_t& c ) const {
+		return ( R == c.r( ) && G == c.g( ) && B == c.b( ) );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/con_alias.hpp b/tf2/con_alias.hpp
new file mode 100644
index 0000000..c943c24
--- /dev/null
+++ b/tf2/con_alias.hpp
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <string>
+#include "simple_settings.h"
+
+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/tf2/con_fn.hpp b/tf2/con_fn.hpp
new file mode 100644
index 0000000..3c06e9b
--- /dev/null
+++ b/tf2/con_fn.hpp
@@ -0,0 +1,172 @@
+#pragma once
+#include <functional>
+
+#include "simple_settings.h"
+
+//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/tf2/conditions.h b/tf2/conditions.h
new file mode 100644
index 0000000..331ad6d
--- /dev/null
+++ b/tf2/conditions.h
@@ -0,0 +1,106 @@
+#pragma once
+
+enum MoveType_t {
+	MOVETYPE_NONE = 0,
+	MOVETYPE_ISOMETRIC,
+	MOVETYPE_WALK,
+	MOVETYPE_STEP,
+	MOVETYPE_FLY,
+	MOVETYPE_FLYGRAVITY,
+	MOVETYPE_VPHYSICS,
+	MOVETYPE_PUSH,
+	MOVETYPE_NOCLIP,
+	MOVETYPE_LADDER,
+	MOVETYPE_OBSERVER,
+	MOVETYPE_CUSTOM,
+
+	MOVETYPE_LAST = MOVETYPE_CUSTOM,
+
+	MOVETYPE_MAX_BITS = 4,
+};
+
+enum TFConditions_t {
+	TFCond_Slowed = ( 1 << 0 ),
+	TFCond_Zoomed = ( 1 << 1 ),
+	TFCond_Disguising = ( 1 << 2 ),
+	TFCond_Disguised = ( 1 << 3 ),
+	TFCond_Cloaked = ( 1 << 4 ),
+	TFCond_Ubercharged = ( 1 << 5 ),
+	TFCond_TeleportedGlow = ( 1 << 6 ),
+	TFCond_Taunting = ( 1 << 7 ),
+	TFCond_UberchargeFading = ( 1 << 8 ),
+	TFCond_CloakFlicker = ( 1 << 9 ),
+	TFCond_Teleporting = ( 1 << 10 ),
+	TFCond_Kritzkrieged = ( 1 << 11 ),
+	TFCond_TmpDamageBonus = ( 1 << 12 ),
+	TFCond_DeadRingered = ( 1 << 13 ),
+	TFCond_Bonked = ( 1 << 14 ),
+	TFCond_Stunned = ( 1 << 15 ),
+	TFCond_Buffed = ( 1 << 16 ),
+	TFCond_Charging = ( 1 << 17 ),
+	TFCond_DemoBuff = ( 1 << 18 ),
+	TFCond_CritCola = ( 1 << 19 ),
+	TFCond_InHealRadius = ( 1 << 20 ),
+	TFCond_Healing = ( 1 << 21 ),
+	TFCond_OnFire = ( 1 << 22 ),
+	TFCond_Overhealed = ( 1 << 23 ),
+	TFCond_Jarated = ( 1 << 24 ),
+	TFCond_Bleeding = ( 1 << 25 ),
+	TFCond_DefenseBuffed = ( 1 << 26 ),
+	TFCond_Milked = ( 1 << 27 ),
+	TFCond_MegaHeal = ( 1 << 28 ),
+	TFCond_RegenBuffed = ( 1 << 29 ),
+	TFCond_MarkedForDeath = ( 1 << 30 ),
+	TFCond_NoHealingDamageBuff = ( 1 << 31 ),
+
+	TFCondEx_SpeedBuffAlly = ( 1 << 0 ),
+	TFCondEx_HalloweenCritCandy = ( 1 << 1 ),
+	TFCondEx_CritCanteen = ( 1 << 2 ),
+	TFCondEx_CritDemoCharge = ( 1 << 3 ),
+	TFCondEx_CritHype = ( 1 << 4 ),
+	TFCondEx_CritOnFirstBlood = ( 1 << 5 ),
+	TFCondEx_CritOnWin = ( 1 << 6 ),
+	TFCondEx_CritOnFlagCapture = ( 1 << 7 ),
+	TFCondEx_CritOnKill = ( 1 << 8 ),
+	TFCondEx_RestrictToMelee = ( 1 << 9 ),
+	TFCondEx_DefenseBuffNoCritBlock = ( 1 << 10 ),
+	TFCondEx_Reprogrammed = ( 1 << 11 ),
+	TFCondEx_PyroCrits = ( 1 << 12 ),
+	TFCondEx_PyroHeal = ( 1 << 13 ),
+	TFCondEx_FocusBuff = ( 1 << 14 ),
+	TFCondEx_DisguisedRemoved = ( 1 << 15 ),
+	TFCondEx_MarkedForDeathSilent = ( 1 << 16 ),
+	TFCondEx_DisguisedAsDispenser = ( 1 << 17 ),
+	TFCondEx_Sapped = ( 1 << 18 ),
+	TFCondEx_UberchargedHidden = ( 1 << 19 ),
+	TFCondEx_UberchargedCanteen = ( 1 << 20 ),
+	TFCondEx_HalloweenBombHead = ( 1 << 21 ),
+	TFCondEx_HalloweenThriller = ( 1 << 22 ),
+	TFCondEx_BulletCharge = ( 1 << 26 ),
+	TFCondEx_ExplosiveCharge = ( 1 << 27 ),
+	TFCondEx_FireCharge = ( 1 << 28 ),
+	TFCondEx_BulletResistance = ( 1 << 29 ),
+	TFCondEx_ExplosiveResistance = ( 1 << 30 ),
+	TFCondEx_FireResistance = ( 1 << 31 ),
+
+	TFCondEx2_Stealthed = ( 1 << 0 ),
+	TFCondEx2_MedigunDebuff = ( 1 << 1 ),
+	TFCondEx2_StealthedUserBuffFade = ( 1 << 2 ),
+	TFCondEx2_BulletImmune = ( 1 << 3 ),
+	TFCondEx2_BlastImmune = ( 1 << 4 ),
+	TFCondEx2_FireImmune = ( 1 << 5 ),
+	TFCondEx2_PreventDeath = ( 1 << 6 ),
+	TFCondEx2_MVMBotRadiowave = ( 1 << 7 ),
+	TFCondEx2_HalloweenSpeedBoost = ( 1 << 8 ),
+	TFCondEx2_HalloweenQuickHeal = ( 1 << 9 ),
+	TFCondEx2_HalloweenGiant = ( 1 << 10 ),
+	TFCondEx2_HalloweenTiny = ( 1 << 11 ),
+	TFCondEx2_HalloweenInHell = ( 1 << 12 ),
+	TFCondEx2_HalloweenGhostMode = ( 1 << 13 ),
+	TFCondEx2_Parachute = ( 1 << 16 ),
+	TFCondEx2_BlastJumping = ( 1 << 17 ),
+
+	TFCond_MiniCrits = ( TFCond_Buffed | TFCond_CritCola ),
+	TFCond_IgnoreStates = ( TFCond_Ubercharged | TFCond_Bonked ),
+	TFCondEx_IgnoreStates = ( TFCondEx_PyroHeal )
+};
+\ No newline at end of file
diff --git a/tf2/console.cpp b/tf2/console.cpp
new file mode 100644
index 0000000..121c57a
--- /dev/null
+++ b/tf2/console.cpp
@@ -0,0 +1,324 @@
+#include "console.hpp"
+#include "interfaces.h"
+#include "settings.h"
+#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/tf2/console.hpp b/tf2/console.hpp
new file mode 100644
index 0000000..a16ad0f
--- /dev/null
+++ b/tf2/console.hpp
@@ -0,0 +1,125 @@
+#pragma once
+#include <memory>
+#include <Windows.h>
+#include <vector>
+#include <functional>
+
+#include "con_fn.hpp"
+#include "con_alias.hpp"
+#include "input_system.hpp"
+#include "math.h"
+
+#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/tf2/console_log.hpp b/tf2/console_log.hpp
new file mode 100644
index 0000000..4659ea1
--- /dev/null
+++ b/tf2/console_log.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+#include <Windows.h>
+#pragma warning(disable: 4996)
+
+class console {
+public:
+	void create( ) {
+		AllocConsole( );
+		freopen( "CONOUT$", "w", stdout );
+		SetConsoleTitleA( "tf2internal" );
+
+		game_console_print = reinterpret_cast< decltype( game_console_print ) >( GetProcAddress( GetModuleHandleA( "tier0.dll" ), "Msg" ) );
+	}
+
+	void destroy( ) {
+		FreeConsole( );
+		fclose( stdout );
+	}
+
+	__forceinline void log_function( const char* msg ) {
+		printf( "%s: %s", __FUNCTION__, msg );
+	}
+
+	using msg_t = void( __cdecl* )( const char*, ... );
+	msg_t game_console_print;
+
+
+	static console *con( ) {
+		static console g_singleton_;
+		return &g_singleton_;
+	}
+};
+\ No newline at end of file
diff --git a/tf2/ctx.cpp b/tf2/ctx.cpp
new file mode 100644
index 0000000..37e192f
--- /dev/null
+++ b/tf2/ctx.cpp
@@ -0,0 +1,97 @@
+#include "ctx.hpp"
+#include "console.hpp"
+#include "hooks.h"
+#include "base_cheat.h"
+
+context::c_context g_ctx;
+
+NAMESPACE_REGION( context )
+
+bool c_context::run_frame( ) {
+	m_local = cl.m_entlist( )->get_client_entity< c_base_player >(
+		cl.m_engine( )->GetLocalPlayer( ) );
+
+	return !!m_local;
+}
+
+
+//predicted servertime of player, use this for breaking lby etc
+float c_context::pred_time( ) {
+	calculate_tickbase( );
+
+	return m_tickbase * cl.m_globals->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->get_tick_base( );
+
+	//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 = cl.m_string_table( )->FindTable( "modelprecache" );
+
+	if( !cache_table )
+		return true;
+
+	cl.m_modelinfo( )->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/tf2/ctx.hpp b/tf2/ctx.hpp
new file mode 100644
index 0000000..8243a19
--- /dev/null
+++ b/tf2/ctx.hpp
@@ -0,0 +1,68 @@
+#pragma once
+#include <deque>
+
+#include "util.hpp"
+#include "sdk.h"
+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{ true };
+	struct {
+		vec3_t min;
+		vec3_t max;
+		float  radius;
+	} m_hitbox;
+	int	m_hitgroup;
+};
+
+//replacement to the old global:: namespace
+class c_context {
+public:
+	//run localplayer check, pointer, is valid etc
+	bool run_frame( );
+	float pred_time( );
+
+	bool create_snapshot( user_cmd_t* );
+	//calculate accurate tickbase
+	bool calculate_tickbase( );
+
+	user_cmd_t* get_last_cmd( ) {
+		return m_snapshot.empty( ) ? nullptr : &m_snapshot.front( );
+	}
+
+	bool precache_model( const char* model );
+
+public:
+	c_base_player * m_local{ };
+	int				m_stage{ };
+	//accurate tickbase
+	int				m_tickbase{ };
+
+	bool			m_drawing_postscreenspace{ };
+	bool			m_drawing_screneend{ };
+
+	bool			m_has_fired_this_frame{ };
+
+	vec3_t			m_thirdperson_angle{ };
+	vec3_t			m_last_origin{ };
+
+	float			m_fov{ 90.f };
+
+public:
+
+	int				m_last_shot_ack;
+	int				m_last_shot;
+	std::array< shot_data_t, 128 > m_shot_data;
+private:
+	std::deque< user_cmd_t > m_snapshot;
+};
+
+END_REGION
+
+extern context::c_context g_ctx;
+\ No newline at end of file
diff --git a/tf2/d3d.cpp b/tf2/d3d.cpp
new file mode 100644
index 0000000..a35f613
--- /dev/null
+++ b/tf2/d3d.cpp
@@ -0,0 +1,367 @@
+#include "d3d.hpp"
+#include "interfaces.h"
+#include "math.h"
+#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, xors( "Verdana" ), 0, 12, 0 ); //change this idc
+		create_font( &f_esp_small, xors( "Tahoma" ), 0, 11, 500 );
+		create_font( &f_16, xors( "Verdana" ), 0, 16, 0 );
+		create_font( &f_18, xors( "Verdana" ), 0, 18, 900 );
+		create_font( &f_menu, xors( "Tahoma" ), 0, 12, 300 );
+		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( cl.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 );
+
+		// set vertex stream declaration.
+		m_device->SetVertexShader( nullptr );
+		m_device->SetPixelShader( nullptr );
+		m_device->SetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE );
+		m_block->Capture( );
+
+		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 );
+	}
+}
diff --git a/tf2/d3d.hpp b/tf2/d3d.hpp
new file mode 100644
index 0000000..a927ee3
--- /dev/null
+++ b/tf2/d3d.hpp
@@ -0,0 +1,126 @@
+#ifndef D3D_HEADER //stackoverflow my niggas
+#define D3D_HEADER
+
+#include <d3d9.h>
+#include <d3dx9.h>
+
+#pragma comment(lib, "d3d9.lib")
+#pragma comment(lib, "d3dx9.lib")
+#pragma warning(disable : 4838)
+
+#include <xnamath.h>
+#include <windows.h>
+
+#include <dwmapi.h>
+#pragma comment(lib, "dwmapi.lib")
+
+#include "util.hpp"
+#include "color.hpp"
+#include "renderer.hpp"
+
+enum D3DFontFlags_t {
+	D3DFONTFLAG_OUTLINE = 0x10,
+	D3DFONTFLAG_DROPSHADOW = 0x100,
+};
+
+enum GradientType_t;
+
+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 = 0.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/tf2/d3d_sprite.cpp b/tf2/d3d_sprite.cpp
new file mode 100644
index 0000000..37bbde1
--- /dev/null
+++ b/tf2/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/tf2/d3d_sprite.hpp b/tf2/d3d_sprite.hpp
new file mode 100644
index 0000000..0d26f4c
--- /dev/null
+++ b/tf2/d3d_sprite.hpp
@@ -0,0 +1,159 @@
+#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, &center, 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 );
+			//m_device->SetSamplerState( 0, D3DSAMPLERSTATETYPE::D3DSAMP_MINFILTER, min_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/tf2/directx.cpp b/tf2/directx.cpp
new file mode 100644
index 0000000..db2d62f
--- /dev/null
+++ b/tf2/directx.cpp
@@ -0,0 +1,233 @@
+#include <chrono>
+
+#include "settings.h"
+#include "hooks.h"
+#include "ui.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+#include "mem.hpp"
+
+//this shit prolly barely working rn like a toddler trying to walk but hes actually mentally slow and 25
+
+using namespace d3d;
+
+float ui::get_tf2_frametime( ) {
+	return cl.m_frametime;
+}
+
+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.visuals( );
+
+	if( g_settings.menu.open ) {
+		if( anim_time >= 0.95f ) {
+			flip = true;
+		}
+		if( anim_time <= 0.05f ) {
+			flip = false;
+		}
+
+		if( flip )
+			anim_time -= fade_step * ui::ui_get_frametime( );
+		else
+			anim_time += fade_step * ui::ui_get_frametime( );
+
+		anim_time = std::clamp( anim_time, 0.f, 1.0f );
+
+		ui::set_animtime( anim_time );
+
+		anim_progress += ui::ui_get_frametime( ) * step * 255;
+		anim_progress = std::clamp( anim_progress, 0, 50 );
+		g_d3d.draw_filled_rect( clr_t( 0, 0, 0, anim_progress ),
+			0, 0, g_d3d.m_width, g_d3d.m_height );
+
+		ui::render( );
+	}
+	else {
+		anim_progress = 0;
+	}
+}
+
+long __stdcall hooks::d3d::draw( IDirect3DDevice9* device, D3DPRIMITIVETYPE type, int v_index, uint32_t min_index, uint32_t num_vert, uint32_t start_index, uint32_t prim_count ) {
+	static auto draw_o = cl.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.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 = cl.m_d3d->get_old_function< decltype( &hooks::d3d::end_scene ) >( 42 );
+	if( cl.m_panic ) return end_scene_o( device );
+
+	static uintptr_t return_address = 0;
+	static uintptr_t gameoverlay_return_address = 0;
+
+	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( !cl.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( );
+
+		cl.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 = cl.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 str( xors( "moneybot | " ) );
+			static bool transform = false;
+			if( !transform ) {
+				str += __DATE__;
+				str += ", ";
+				str += __TIME__;
+
+				std::transform( str.begin( ), str.end( ), str.begin( ),
+					[ ]( char c ) { return ::tolower( c ); } );
+				transform = true;
+			}
+
+			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 = cl.m_d3d->get_old_function< decltype( &hooks::d3d::reset ) >( 16 );
+	if( cl.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/tf2/do_post_screen_space_effects.cpp b/tf2/do_post_screen_space_effects.cpp
new file mode 100644
index 0000000..401b05e
--- /dev/null
+++ b/tf2/do_post_screen_space_effects.cpp
@@ -0,0 +1,16 @@
+#include "hooks.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+//whore?
+bool __fastcall hooks::do_post_screen_space_effects( void* ecx_, void* edx_, CViewSetup* setup ) {
+	static auto old_fn = cl.m_clientmode->get_old_function< decltype( &do_post_screen_space_effects ) >( 39 );
+
+	g_ctx.m_drawing_postscreenspace = true;
+	if( cl.m_engine( )->IsInGame( ) && g_ctx.m_local ) {
+	}
+
+	bool ret = old_fn( ecx_, 0, setup );
+	g_ctx.m_drawing_postscreenspace = false;
+
+	return ret;
+}
+\ No newline at end of file
diff --git a/tf2/draw_model_execute.cpp b/tf2/draw_model_execute.cpp
new file mode 100644
index 0000000..1191a90
--- /dev/null
+++ b/tf2/draw_model_execute.cpp
@@ -0,0 +1,125 @@
+#include "hooks.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+#include "util.hpp"
+#include "settings.h"
+//this is so ugly dont even look at it
+
+//gets called once per frame for every entity
+void __fastcall hooks::draw_model_execute( IVModelInfo* ecx_, void* edx_, void* render_ctx, const DrawModelState_t& state, const ModelRenderInfo_t& info, matrix3x4* bone_to_world ) {
+	static auto dme_o = cl.m_model_render->get_old_function< decltype( &hooks::draw_model_execute ) >( 19 );
+
+	if( cl.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.chams.m_materials.m_chams_flat : g_cheat.chams.m_materials.m_chams;
+	auto model_name = cl.m_modelinfo( )->GetModelName( info.m_model );
+	auto local_index = cl.m_engine( )->GetLocalPlayer( );
+	int local_team = 0;
+	if( g_ctx.m_local )
+		local_team = g_ctx.m_local->m_iTeamNum( );
+	int team = 0;
+	bool is_player = false;
+
+	if( strstr( model_name, xors( "models/player" ) ) && info.m_entity_index == local_index ) {
+		if( g_settings.misc.thirdperson( ) && g_ctx.m_local && g_ctx.m_local->is_valid( )
+			&& g_ctx.m_local->m_bIsScoped( ) ) {
+			float clr[ ] = { 1.0f, 1.0f, 1.0f };
+			cl.m_render_view( )->SetColorModulation( clr );
+			cl.m_render_view( )->SetBlend( 0.5f );
+			return dme_o( ecx_, edx_, render_ctx, state, info, bone_to_world );
+		}
+	}
+
+	if( strstr( model_name, xors( "models/player" ) ) && info.m_entity_index ) {
+		auto player = cl.m_entlist( )->get_client_entity< c_base_player >( info.m_entity_index );
+
+		if( player && player->is_valid( ) ) {
+			is_player = true;
+			team = player->m_iTeamNum( );
+
+			if( g_settings.visuals.chams.enabled ) {
+				if( g_settings.visuals.chams.ignore_z && !g_ctx.m_drawing_screneend && ( team != local_team || g_settings.visuals.chams.friendlies( ) ) )
+					draw = false;
+				else if( !g_settings.visuals.chams.ignore_z && ( 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( );
+
+					mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
+					g_cheat.chams.m_materials.force_material( mat, clr );
+					dme_o( ecx_, 0, render_ctx, state, info, bone_to_world );
+					cl.m_model_render( )->ForcedMaterialOverride( nullptr );
+					cl.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" ) ) ) {
+			cl.m_render_view( )->SetBlend( 0.6f );
+		}
+	}
+
+	if( is_player ) {
+
+		if( g_settings.legit.backtracking_visualize( ) && ( team != local_team || g_settings.legit.friendlies( ) ) ) {
+			auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( info.m_entity_index );
+			auto record = g_cheat.aim.m_lagcomp.find_best_record( info.m_entity_index );
+			{ //idk
+				auto records = g_cheat.aim.m_lagcomp.get_records( info.m_entity_index );
+				if( records.size( ) ) {
+					for( auto& it : util::reverse_iterator( records ) ) {
+						if( it.is_valid( ) ) {
+							record = &it;
+							break;
+						}
+					}
+				}
+			}
+
+			if( record && record->is_valid( ) && record->m_position.dist_to( ent->get_hitbox_position( 0 ) ) > 5.f ) {
+				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;
+				float backup_blend = 1.0f;
+
+				backup_blend = cl.m_render_view( )->GetBlend( );
+				cl.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 ) {
+					auto flat_mat = g_cheat.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 );
+					g_cheat.chams.m_materials.force_material( g_cheat.chams.m_materials.m_chams_flat, g_settings.legit.backtracking_col( ) );
+					dme_o( ecx_, edx_, render_ctx, state, info, record->m_matrix );
+					flat_mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
+				}
+
+				cl.m_render_view( )->SetBlend( backup_blend );
+				cl.m_render_view( )->SetColorModulation( backup_modulation );
+				cl.m_model_render( )->ForcedMaterialOverride( g_settings.visuals.chams.enabled( ) &&
+					( team != local_team || g_settings.visuals.chams.friendlies( ) ) ? mat : nullptr );
+
+				if( draw ) {
+					dme_o( ecx_, edx_, render_ctx, state, info, bone_to_world );
+					draw = false;
+				}
+			}
+		}
+	}
+
+	if( draw ) {
+		dme_o( ecx_, 0, render_ctx, state, info, bone_to_world );
+	}
+
+	cl.m_model_render( )->ForcedMaterialOverride( nullptr );
+}
+\ No newline at end of file
diff --git a/tf2/dt_common.h b/tf2/dt_common.h
new file mode 100644
index 0000000..7f86418
--- /dev/null
+++ b/tf2/dt_common.h
@@ -0,0 +1,127 @@
+#pragma once
+
+#define MAX_DATATABLES		1024	// must be a power of 2.
+#define MAX_DATATABLE_PROPS	4096
+#define MAX_ARRAY_ELEMENTS	2048		// a network array should have more that 1024 elements
+
+#define HIGH_DEFAULT		-121121.121121f
+
+#define BITS_FULLRES	-1	// Use the full resolution of the type being encoded.
+#define BITS_WORLDCOORD	-2	// Encode as a world coordinate.
+
+#define DT_MAX_STRING_BITS			9
+#define DT_MAX_STRING_BUFFERSIZE	(1 << DT_MAX_STRING_BITS)	// Maximum length of a string that can be sent.
+
+#define STRINGBUFSIZE(className, varName)	sizeof(((className*)0)->varName)
+
+// Gets the size of a variable in a class.
+#define PROPSIZEOF(className, varName)		sizeof(((className*)0)->varName)
+
+// SendProp::m_Flags.
+enum SPROP_FLAGS
+{
+	SPROP_UNSIGNED				= (1<<0),	// Unsigned integer data.
+	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.
+	SPROP_NOSCALE				= (1<<2),	// For floating point, don't scale into range, just take value as is.
+	SPROP_ROUNDDOWN				= (1<<3),	// For floating point, limit high value to range minus one bit unit
+	SPROP_ROUNDUP				= (1<<4),	// For floating point, limit low value to range minus one bit unit
+	SPROP_NORMAL				= (1<<5),	// If this is set, the vector is treated like a normal (only valid for vectors),
+	SPROP_EXCLUDE				= (1<<6),	// This is an exclude prop (not excludED, but it points at another prop to be excluded),.
+	SPROP_XYZE					= (1<<7),	// Use XYZ/Exponent encoding for vectors.
+	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.
+	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.
+	SPROP_CHANGES_OFTEN			= (1<<10),	// this is an often changed field, moved to head of sendtable so it gets a small index
+	SPROP_IS_A_VECTOR_ELEM		= (1<<11),	// Set automatically if SPROP_VECTORELEM is used.
+	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.
+	SPROP_COORD_MP				= (1<<13),	// Like SPROP_COORD, but special handling for multiplayer games
+	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
+	SPROP_COORD_MP_INTEGRAL		= (1<<15),	// SPROP_COORD_MP, but coordinates are rounded to integral boundaries
+
+	// 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
+	SPROP_ENCODED_AGAINST_TICKCOUNT	= (1<<16),
+};
+
+#define SPROP_NUMFLAGBITS_NETWORKED		16
+
+#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;
+
+typedef enum
+{
+	DPT_Int = 0,
+	DPT_Float,
+	DPT_Vector,
+	DPT_VectorXY,
+	DPT_String,
+	DPT_Array, // An array of the base types (can't be of datatables).
+	DPT_DataTable,
+	DPT_NUMSendPropTypes
+} SendPropType;
+
+/*
+class DVariant
+{
+public:
+	union
+	{
+		float m_Float;
+		long m_Int;
+		char* m_pString;
+		void* m_pData; // For DataTables.
+		float m_Vector[3];
+	};
+
+	SendPropType m_Type;
+
+	DVariant() { m_Type = DPT_Float; }
+
+	DVariant(float val)
+	{
+		m_Type = DPT_Float;
+		m_Float = val;
+	}
+};
+*/
+
+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;
+}
diff --git a/tf2/dt_recv.h b/tf2/dt_recv.h
new file mode 100644
index 0000000..47f945b
--- /dev/null
+++ b/tf2/dt_recv.h
@@ -0,0 +1,479 @@
+#pragma once
+
+#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.
+};
+*/
+
+struct CRecvProxyData {
+	const RecvProp* m_pRecvProp;
+	DVariant m_Value;
+	int m_iElement;
+	int m_ObjectID;
+};
+
+//-----------------------------------------------------------------------------
+// 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_VectorTovec3_t;
+};
+
+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;
+
+	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:
+	using PropType = RecvProp;
+
+	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)
+{
+	// Assert( i >= 0 && i < m_nProps ); 
+	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;
+}
+
+#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_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);
+
+// 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
+);
+
+// This is here so the RecvTable can look more like the SendTable.
+#define RecvPropQAngles RecvPropVector
+
+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;
+}
diff --git a/tf2/emit_sound.cpp b/tf2/emit_sound.cpp
new file mode 100644
index 0000000..b311b84
--- /dev/null
+++ b/tf2/emit_sound.cpp
@@ -0,0 +1,25 @@
+#include "base_cheat.h"
+#include "hooks.h"
+#include "settings.h"
+
+//eenie meenie miney moe i  kepy this in here incase i wanted to ever do something with it i could fix it to match tf2's emitsound but yknow what? i prolly wont watadearhiugaer sorry i spilt water on my desk and smashed my face into the keyboard
+
+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 = cl.m_engine_sound->get_old_function< decltype( &hooks::emit_sound ) >( 5 );
+
+	if( !cl.m_panic && origin ) {
+		auto entity = cl.m_entlist( )->get_client_entity< c_base_player >( ent );
+		if( entity && entity->is_player( ) && entity->ce( )->is_dormant( ) &&
+			ent >= 0 && ent <= 64 )
+			g_cheat.visuals.update_position( ent, *origin );
+	}
+
+	if( strstr( sample, xors( "weapon" ) ) && g_settings.misc.no_sound )
+		volume = 0.f;
+
+	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/tf2/extra.cpp b/tf2/extra.cpp
new file mode 100644
index 0000000..894c957
--- /dev/null
+++ b/tf2/extra.cpp
@@ -0,0 +1,91 @@
+#include "base_cheat.h"
+#include "ctx.hpp"
+#include "input_system.hpp"
+#include "math.h"
+#include "hooks.h"
+#include "interfaces.h"
+#undef min
+#include "extra.h"
+#include "settings.h"
+
+namespace features
+{
+	//crash too lazy to fix rn will do , who wants to fly out of their body and become their own guardian angel anyway?
+	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 ) {
+				cl.m_hl_input->m_fCameraInThirdPerson = false;
+				enabled = false;
+			}
+
+			return;
+		}
+
+		vec3_t viewangles{ };
+		if( g_ctx.m_local->is_alive( ) ) {
+			cl.m_engine( )->GetViewAngles( viewangles );
+			cl.m_hl_input->m_fCameraInThirdPerson = true;
+			cl.m_hl_input->m_vecCameraOffset = vec3_t( viewangles.x, viewangles.y, 150.0f );
+
+			float    cam_hull_offset{ 16.f };
+
+			vec3_t   cam_hull_min( -cam_hull_offset, -cam_hull_offset, -cam_hull_offset );
+			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 );
+
+			cl.m_trace( )->trace_ray( ray, MASK_SOLID & ~CONTENTS_MONSTER, &filter, &tr );
+			cl.m_hl_input->m_vecCameraOffset.z = 150.f * tr.fraction;
+
+			enabled = true;
+		}
+		else if( cl.m_entlist( )->get_entity_from_handle< c_base_player >( g_ctx.m_local->m_hObserverTarget( ) ) ) {
+			cl.m_hl_input->m_fCameraInThirdPerson = false;
+			g_ctx.m_local->m_iObserverMode( ) = 5;
+		}
+	}
+
+	//hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
+	void c_extra::float_ragdolls( ) {
+		for( int i{ }; i < cl.m_entlist( )->get_highest_entity_index( ); ++i ) {
+			auto ent = cl.m_entlist( )->get_client_entity< IClientEntity >( i );
+			if( !ent ) continue;
+
+			auto client_class = ent->get_client_class( );
+			if( !client_class ) continue;
+
+			int class_id = client_class->m_class_id;
+			if( class_id != CTFRagdoll )
+				return;
+
+			ent->as< c_base_player >( )->m_vecRagdollVelocity( ) *= -1;
+		}
+	}
+
+	
+}
+\ No newline at end of file
diff --git a/tf2/extra.h b/tf2/extra.h
new file mode 100644
index 0000000..d25131c
--- /dev/null
+++ b/tf2/extra.h
@@ -0,0 +1,21 @@
+#pragma once
+#include <vector>
+#include <deque>
+#include "IVEngineClient.h"
+#include "vector.hpp"
+#include "IClientMode.h"
+namespace features
+{
+	class c_extra {
+
+	public:
+		void thirdperson( );
+
+		void float_ragdolls( );
+
+		void disable_post_processing( );
+
+	private:
+
+	};
+}
+\ No newline at end of file
diff --git a/tf2/factory.cpp b/tf2/factory.cpp
new file mode 100644
index 0000000..f8dfd42
--- /dev/null
+++ b/tf2/factory.cpp
@@ -0,0 +1,110 @@
+#include "factory.h"
+#ifndef IFACE_DLLMAIN
+#include "fnv.hpp"
+
+#include <algorithm>
+
+NAMESPACE_REGION( tf2 )
+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/tf2/factory.h b/tf2/factory.h
new file mode 100644
index 0000000..d1e8027
--- /dev/null
+++ b/tf2/factory.h
@@ -0,0 +1,155 @@
+#pragma once
+#include <memory>
+#include <Windows.h>
+#include <winternl.h>
+#include <fstream>
+#include "vmt.h"
+#include "util.hpp"
+#include "x86.hpp"
+#include "console.hpp"
+#include "strings.hpp"
+//IFACE_DLLMAIN - interfaces are passed through dllmain and below code doesnt need to be ran
+#ifndef _DEBUG
+#define IFACE_DLLMAIN
+#endif
+
+#ifdef IFACE_DLLMAIN
+#include "iface_dllmain_impl.hpp"
+#else
+
+NAMESPACE_REGION( tf2 )
+
+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 tf2::interfaces::c_interface_manager g_factory;
+\ No newline at end of file
diff --git a/tf2/factory.hpp b/tf2/factory.hpp
new file mode 100644
index 0000000..4615c34
--- /dev/null
+++ b/tf2/factory.hpp
@@ -0,0 +1,190 @@
+#pragma once
+
+#include <Windows.h>
+#include <winternl.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <Psapi.h>
+#include <vector>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <functional>
+
+namespace tf2
+{
+	namespace interfaces
+	{
+		// this interface linked list iteration code is tf2 specific !
+		// in the future i will write it game/engine version independent
+		// using a disassembly engine
+
+		struct regs {
+			void *( *m_CreateFn )( );
+			const char *m_pName;
+			regs *m_pNext;
+		};
+
+		static inline bool is_create_fn( uintptr_t m_createfn ) {
+			return( *( uint8_t * )( m_createfn ) == 0xB8
+				&& *( uint8_t * )( m_createfn + 5 ) == 0xC3 );
+		}
+
+		static inline bool is_createinterface_fn( uintptr_t m_createfn ) {
+			return( *( uint8_t * )( m_createfn + 4 ) == 0xE9
+				&& *( uint8_t * )( m_createfn + 9 ) == 0xCC );
+		}
+
+		static inline uintptr_t follow_createinterface_export( uintptr_t export_ ) {
+			if ( *( uint8_t * )( export_ + 4 ) != 0xE9 ) return 0;
+
+			return( export_ + 4 + *( uintptr_t * )( export_ + 5 ) + 5 );
+		}
+
+		static inline regs *reg_from_createinterface( uintptr_t ci ) {
+			if ( *( short * )( ci + 4 ) != 0x358B ) return nullptr;
+
+			return( **( regs *** )( ci + 6 ) );
+		}
+
+		static inline uintptr_t interface_from_reg( regs *reg ) {
+			uintptr_t reg_func = *( uintptr_t * )reg;
+
+			if ( is_create_fn( reg_func ) ) {
+				return( *( uintptr_t * )( reg_func + 1 ) );
+			}
+
+			return( 0 );
+		}
+
+
+		class interface_manager {
+		public:
+			struct interface_data {
+			public:
+				std::string name;
+				std::string module;
+				int version;
+				void *ptr;
+
+				template< typename T > inline T get( ) { return reinterpret_cast< T >( ptr ); }
+
+				interface_data( std::string name_T, std::string module_T, void *ptr_T, int version_T = 0 )
+					: name( name_T ), module( module_T ), ptr( ptr_T ), version( version_T ) {}
+			};
+
+			interface_manager() {
+				auto root = &get_peb( )->Ldr->InMemoryOrderModuleList;
+
+				for ( auto entry = root->Flink->Flink->Flink->Flink; entry != root; entry = entry->Flink ) {
+					auto data_table = reinterpret_cast< PLDR_DATA_TABLE_ENTRY >( entry );
+					auto module_base = reinterpret_cast< HMODULE >( data_table->Reserved2[ 0 ] );
+					auto export_ = reinterpret_cast< uintptr_t >( ::GetProcAddress( module_base, "CreateInterface" ) );
+
+					if ( !export_ || !interfaces::is_createinterface_fn( export_ ) ) {
+						continue;
+					}
+
+					auto CreateInterface = interfaces::follow_createinterface_export( export_ );
+
+					if ( !CreateInterface ) {
+						continue;
+					}
+
+					auto regs = interfaces::reg_from_createinterface( CreateInterface );
+
+					while ( regs ) {
+						std::string name( regs->m_pName ), temp_version( name );
+
+						name.erase( std::remove_if( name.begin( ), name.end( ), &isdigit ), name.end( ) );
+
+						temp_version.erase(
+							std::remove_if( temp_version.begin( ), temp_version.end( ),
+								[ ]( int i ) { return !isdigit( i ); }
+							), temp_version.end( )
+						);
+
+						unsigned int version{ };
+						std::stringstream( temp_version ) >> version;
+
+						sorted_list.push_back( interface_data( name, unicode_to_string( data_table->FullDllName ), reinterpret_cast< void * >( interfaces::interface_from_reg( regs ) ), version ) );
+
+						regs = regs->m_pNext;
+					}
+				}
+
+				std::sort( sorted_list.begin( ), sorted_list.end( ), [ ]( const interface_data &lhs, const interface_data &rhs ) {
+					return( lhs.version > rhs.version );
+				} );
+			}
+		public:
+			template< typename T = void * > T create( std::string name ) {
+				std::vector< interface_data >::iterator it = std::find_if( sorted_list.begin( ), sorted_list.end( ), [ & ]( const interface_data &data ) {
+					return ( !data.name.compare( name ) );
+				} );
+
+				if ( it == sorted_list.end( ) || !it->ptr ) {
+					return T{ };
+				}
+
+				printf( "%s\n -> 0x%X\n -> module: %s \n", name.c_str( ), reinterpret_cast< uintptr_t >( it->ptr ), it->module.c_str( ) );
+
+				return( ( T )( it->ptr ) );
+			}
+
+			template< typename T = void* > T create( std::string name, std::string module ) {
+				std::vector< interface_data >::iterator it = std::find_if( sorted_list.begin( ), sorted_list.end( ), [ & ]( const interface_data &data ) {
+					return ( !data.name.compare( name ) && data.module.find( module ) != std::string::npos );
+				} );
+
+
+				if ( it == sorted_list.end( ) || !it->ptr ) {
+					return T{ };
+				}
+
+				//#ifdef DEBUG_PRINT
+				printf( "%s\n -> 0x%x\n -> module: %s \n", name.c_str( ), reinterpret_cast< uintptr_t >( it->ptr ), it->module.c_str( ) );
+				//#endif
+
+				return( static_cast< T >( it->ptr ) );
+			}
+
+			template< typename T = void * > T create_from_hash( uint32_t hash ) {
+				std::vector< interface_data >::iterator it = std::find_if( sorted_list.begin( ), sorted_list.end( ), [ & ]( const interface_data &data )
+				{
+					return ( !data.name.compare( name ) );
+				} );
+
+				if ( it == sorted_list.end( ) || !it->ptr ) {
+					return T{ };
+				}
+
+				return( ( T )( it->ptr ) );
+			}
+		protected:
+			static inline PTEB get_teb( ) {
+#if defined( _M_X64 )
+				auto teb = reinterpret_cast< PTEB >( __readgsqword( reinterpret_cast< uintptr_t >( &static_cast< NT_TIB * >( nullptr )->Self ) ) );
+#else
+				auto teb = reinterpret_cast< PTEB >( __readfsdword( reinterpret_cast< uintptr_t >( &static_cast< NT_TIB * >( nullptr )->Self ) ) );
+#endif
+				
+
+				return teb;
+			}
+
+			static inline PPEB get_peb( ) {
+				return( get_teb( )->ProcessEnvironmentBlock );
+			}
+
+			static inline std::string unicode_to_string( UNICODE_STRING wide ) {
+				std::wstring wide_str( wide.Buffer, wide.Length );
+				return std::string( wide_str.begin( ), wide_str.end( ) );
+			}
+
+			std::vector< interface_data > sorted_list{ };
+		};
+	};
+}
+\ No newline at end of file
diff --git a/tf2/fnv.hpp b/tf2/fnv.hpp
new file mode 100644
index 0000000..a3f2dc9
--- /dev/null
+++ b/tf2/fnv.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#pragma warning( disable : 4307 ) // '*': integral constant overflow
+#pragma warning( disable : 4244 ) // possible loss of data
+
+#include <cstdint>
+#include <string>
+
+using hash_t = unsigned int;
+
+// used for compile-time FNV-1a 32bit hashes.
+#define fnv( str )                                 \
+    [&]() {                                        \
+        constexpr hash_t out = hash::fnv1a( str ); \
+                                                   \
+        return out;                                \
+    }()
+
+// used for compile-time FNV-1a 32bit hashes when above macro cant be used for constexpr variables.
+#define fnv_const( str ) Hash::fnv1a_32( str )
+
+namespace hash // FNV-1a ( Fowler-Noll-Vo hash ).
+{
+	// FNV-1a constants.
+	enum : hash_t {
+		FNV1A_PRIME = 0x1000193,
+		FNV1A_BASIS = 0x811C9DC5
+	};
+
+	// compile-time strlen.
+	__forceinline constexpr size_t ct_strlen( const char *str ) {
+		size_t out = 1;
+
+		for( ; str[ out ] != '\0'; ++out );
+
+		return out;
+	}
+
+	// hash data.
+	__forceinline constexpr hash_t fnv1a( const uint8_t *data, const size_t len ) {
+		hash_t out = FNV1A_BASIS;
+
+		for( size_t i = 0; i < len; ++i )
+			out = ( out ^ data[ i ] ) * FNV1A_PRIME;
+
+		return out;
+	}
+
+	// hash c-style string.
+	__forceinline constexpr hash_t fnv1a( const char *str ) {
+		hash_t out = FNV1A_BASIS;
+		size_t len = ct_strlen( str );
+
+		for( size_t i = 0; i < len; ++i )
+			out = ( out ^ str[ i ] ) * FNV1A_PRIME;
+
+		return out;
+	}
+
+	// hash C++-style string ( runtime only ).
+	__forceinline hash_t fnv1a( const std::string &str ) {
+		return fnv1a( ( uint8_t* )str.c_str( ), str.length( ) );
+	}
+}
+\ No newline at end of file
diff --git a/tf2/framestagenotify.cpp b/tf2/framestagenotify.cpp
new file mode 100644
index 0000000..87e91d9
--- /dev/null
+++ b/tf2/framestagenotify.cpp
@@ -0,0 +1,41 @@
+#include "hooks.h"
+#include "interfaces.h"
+#include "base_cheat.h"
+
+void __fastcall hooks::frame_stage_notify( void* ecx_, void* edx_, frame_stages_t stage ) {
+	static auto fsn_o = cl.m_chl->get_old_function< decltype( hooks::frame_stage_notify )* >( 35 ); //35
+
+	g_ctx.m_stage = stage;
+
+	if ( cl.m_panic ) {
+		return fsn_o( ecx_, edx_, stage );
+	}
+
+	switch( stage ) {
+	case FRAME_NET_UPDATE_START:
+		g_ctx.run_frame( );
+		fsn_o( ecx_, 0, stage );
+
+		return;
+
+	case FRAME_NET_UPDATE_POSTDATAUPDATE_START:
+		g_cheat.extra.float_ragdolls( );
+		//g_cheat.m_skins( );
+		g_cheat.visuals.update_glow( );
+		fsn_o( ecx_, 0, stage );
+
+		return;
+
+	case FRAME_RENDER_START:
+		//g_cheat.extra.disable_post_processing( );
+		util::disable_pvs( );
+		break;
+
+	case FRAME_RENDER_END:
+		fsn_o( ecx_, 0, stage );
+		//g_cheat.chams.m_materials.update_materials( );
+		return;
+	}
+
+	return fsn_o( ecx_, edx_, stage );
+}
diff --git a/tf2/get_viewmodel_fov.cpp b/tf2/get_viewmodel_fov.cpp
new file mode 100644
index 0000000..96c4a1e
--- /dev/null
+++ b/tf2/get_viewmodel_fov.cpp
@@ -0,0 +1,8 @@
+#include "hooks.h"
+#include "settings.h"
+
+float __fastcall hooks::get_viewmodel_fov( void* ecx, void* edx ) {
+	static auto get_viewmodel_fov_o = cl.m_clientmode->get_old_function< decltype( &hooks::get_viewmodel_fov ) >( 32 );
+
+	return get_viewmodel_fov_o( ecx, nullptr ) + float( g_settings.misc.viewmodel_fov );
+}
diff --git a/tf2/graphics.cpp b/tf2/graphics.cpp
new file mode 100644
index 0000000..9670bf9
--- /dev/null
+++ b/tf2/graphics.cpp
@@ -0,0 +1,107 @@
+#include "graphics.h"
+
+tf2::c_fonts fonts;
+tf2::c_graphics graphics;
+
+namespace tf2
+{
+	void c_graphics::draw_line( int x, int y, int x1, int y1, clr_t clr ) {
+		cl.m_surface( )->DrawSetColor( clr );
+		cl.m_surface( )->DrawLine( x, y, x1, y1 );
+	}
+
+	void c_graphics::draw_string( HFont font, int x, int y, clr_t clr, alignment f_alignment, std::string msg ) {
+		std::wstring a( msg.begin( ), msg.end( ) );
+		const wchar_t* wbuf = a.c_str( );
+
+		int w, h; get_text_size( font, msg, w, h );
+
+		if ( f_alignment == alignment::right ) x -= w;
+
+		if ( f_alignment == alignment::center ) x -= w / 2;
+
+		cl.m_surface( )->DrawSetTextFont( font );
+		cl.m_surface( )->DrawSetTextColor( clr );
+		cl.m_surface( )->DrawSetTextPos( x, y - h / 2 );
+		cl.m_surface( )->DrawPrintText( ( wchar_t* )wbuf, wcslen( wbuf ) );
+	}
+
+	void c_graphics::draw_string( HFont font, int x, int y, clr_t clr, alignment f_alignment, std::wstring msg ) {
+		int w, h; get_text_size( font, msg, w, h );
+
+		if ( f_alignment == alignment::right ) x -= w;
+
+		if ( f_alignment == alignment::center ) x -= w / 2;
+
+		cl.m_surface( )->DrawSetTextFont( font );
+		cl.m_surface( )->DrawSetTextColor( clr );
+		cl.m_surface( )->DrawSetTextPos( x, y - h / 2 );
+		cl.m_surface( )->DrawPrintText( ( wchar_t* )msg.c_str( ), wcslen( msg.c_str( ) ) );
+	}
+
+	void c_graphics::draw_rect( int x, int y, int w, int h, clr_t clr ) {
+		cl.m_surface( )->DrawSetColor( clr );
+		cl.m_surface( )->DrawFilledRect( x, y, x + w, y + h );
+	}
+
+	void c_graphics::draw_rect_outlined( int x, int y, int w, int h, clr_t clr ) {
+		cl.m_surface( )->DrawSetColor( clr );
+		cl.m_surface( )->DrawOutlinedRect( x, y, x + w, y + h );
+	}
+
+	void c_graphics::draw_circle_outlined( int x, int y, int r, clr_t clr ) {
+		cl.m_surface( )->DrawSetColor( clr );
+		cl.m_surface( )->DrawOutlinedCircle( x, y, r, 48 );
+	}
+
+	void c_graphics::get_text_size( HFont font, std::string text, int& w, int& h ) {
+		std::wstring a( text.begin( ), text.end( ) );
+		const wchar_t* wstr = a.c_str( );
+
+		cl.m_surface( )->GetTextSize( font, wstr, w, h );
+	}
+
+	void c_graphics::get_text_size( HFont font, std::wstring text, int& w, int& h ) {
+		const wchar_t* wstr = text.c_str( );
+
+		cl.m_surface( )->GetTextSize( font, wstr, w, h );
+	}
+
+	void c_graphics::draw_polygon( int count, vertex_t* vertexs, clr_t clr_t ) {
+		static int texture = cl.m_surface( )->CreateNewTextureID( true );
+		if ( !texture ) texture = cl.m_surface( )->CreateNewTextureID( true );
+
+		byte buffer[ 4 ] = { 255, 255, 255, 255 };
+
+		cl.m_surface( )->DrawSetTextureRGBA( texture, buffer, 1, 1 );
+		cl.m_surface( )->DrawSetColor( clr_t );
+		cl.m_surface( )->DrawSetTexture( texture );
+
+		cl.m_surface( )->DrawTexturedPolygon( count, vertexs );
+	}
+
+	void c_graphics::draw_filled_circle( int x, int y, int r, clr_t clr_t ) {
+		static vertex_t shape[ 24 ];
+		static float step = M_PI * 2.0f / 24;
+
+		for ( int i{ }; i < 24; i++ ) {
+			float theta = i * step;
+			float x1 = x + r * cos( theta );
+			float y1 = y + r * sin( theta );
+			shape[ i ].init( x1, y1 );
+		}
+		draw_polygon( 24, shape, clr_t );
+	}
+
+	vec2_t c_graphics::world_to_screen( vec3_t world_pos ) {
+		vec3_t tmp; cl.m_overlay( )->ScreenPosition( world_pos, tmp );
+		const matrix3x4& w2s_matrix = cl.m_engine( )->GetWorldToScreenMatrix( );
+		float w = w2s_matrix[ 3 ][ 3 ];
+		for ( int i{ }; i < 3; i++ ) {
+			w += w2s_matrix[ 3 ][ i ] * world_pos[ i ];
+		}
+		if ( w < 0.001f ) return{ 10000.f, 10000.f };
+
+		return{ tmp.x, tmp.y };
+	}
+}
+\ No newline at end of file
diff --git a/tf2/graphics.h b/tf2/graphics.h
new file mode 100644
index 0000000..c9c2ef7
--- /dev/null
+++ b/tf2/graphics.h
@@ -0,0 +1,80 @@
+#pragma once
+#include "color.hpp"
+#include "interfaces.h"
+#include "math.h"
+typedef unsigned long HFont;
+
+enum alignment {
+	left,
+	right,
+	center
+};
+
+enum alignment_vertical {
+	top,
+	bottom
+};
+
+enum fontflag : long {
+	none,
+	italic = 0x001,
+	underline = 0x002,
+	strikeout = 0x004,
+	symbol = 0x008,
+	antialias = 0x010,
+	blur = 0x020,
+	rotary = 0x040,
+	dropshadow = 0x080,
+	additive = 0x100,
+	outline = 0x200,
+	custom = 0x400,
+	bitmap = 0x800,
+};
+
+namespace tf2
+{
+	class c_fonts {
+	public:
+		c_fonts( ) {
+		}
+
+		void init( ) {
+			f_12 = cl.m_surface( )->CreateFnt( );
+			f_14 = cl.m_surface( )->CreateFnt( );
+			f_16 = cl.m_surface( )->CreateFnt( );
+			f_18 = cl.m_surface( )->CreateFnt( );
+			f_esp = cl.m_surface( )->CreateFnt( );
+
+			cl.m_surface( )->SetFontGlyphSet( f_12, "Tahoma", 12, 300, 0, 0, fontflag::outline );
+			cl.m_surface( )->SetFontGlyphSet( f_14, "Tahoma", 14, 300, 0, 0, fontflag::outline );
+			cl.m_surface( )->SetFontGlyphSet( f_16, "Tahoma", 16, 300, 0, 0, fontflag::outline );
+			cl.m_surface( )->SetFontGlyphSet( f_18, "Tahoma", 18, 300, 0, 0, fontflag::outline );
+			cl.m_surface( )->SetFontGlyphSet( f_esp, "Verdana", 13, 550, 0, 0, fontflag::dropshadow );
+		}
+
+		HFont f_12;
+		HFont f_14;
+		HFont f_16;
+		HFont f_18;
+
+		HFont f_esp;
+	};
+
+	class c_graphics {
+	public:
+		void draw_line( int x, int y, int x1, int y1, clr_t clr );
+		void draw_string( HFont font, int x, int y, clr_t clr, alignment f_alignment, std::string msg );
+		void draw_string( HFont font, int x, int y, clr_t clr, alignment f_alignment, std::wstring msg );
+		void draw_rect( int x, int y, int w, int h, clr_t clr );
+		void draw_rect_outlined( int x, int y, int w, int h, clr_t clr );
+		void draw_circle_outlined( int x, int y, int r, clr_t clr );
+		void get_text_size( HFont font, std::string text, int& w, int& h );
+		void get_text_size( HFont font, std::wstring text, int& w, int& h );
+		void draw_polygon( int count, vertex_t* vertexs, clr_t clr_t );
+		void draw_filled_circle( int x, int y, int r, clr_t clr_t );
+		vec2_t world_to_screen( vec3_t world_pos );
+	};
+}
+
+extern tf2::c_graphics graphics;
+extern tf2::c_fonts fonts;
+\ No newline at end of file
diff --git a/tf2/hooks.cpp b/tf2/hooks.cpp
new file mode 100644
index 0000000..0472c6e
--- /dev/null
+++ b/tf2/hooks.cpp
@@ -0,0 +1,41 @@
+#include "hooks.h"
+#include "interfaces.h"
+#include "netvars.h"
+
+
+bool hooks::commit( tf2::client* instance ) {
+	while( !( instance->m_hwnd = FindWindowA( xors( "Valve001" ), 0 ) ) )
+		Sleep( 100 );
+
+	window_procedure_o = reinterpret_cast< decltype( window_procedure_o ) >(
+		SetWindowLongA( instance->m_hwnd, GWLP_WNDPROC,
+		( long )window_procedure )
+		);
+
+	instance->m_clientmode->hook( 20, &hooks::override_mouse_input );//n
+	instance->m_clientmode->hook( 32, &hooks::get_viewmodel_fov );//n
+	instance->m_clientmode->hook( 39, &hooks::do_post_screen_space_effects ); //n
+	instance->m_clientmode->hook( 16, &hooks::override_view ); //n
+	instance->m_clientmode->hook( 21, &hooks::create_move ); //y
+	instance->m_chl->hook( 35, &hooks::frame_stage_notify ); //y
+	instance->m_chl->hook( 3, &hooks::shut_down ); //n
+
+	//honestly fuck chams and keyvalues they can lick my mothers toes
+
+	//instance->m_model_render->hook( 19, &hooks::draw_model_execute ); //n
+	//instance->m_render_view->hook( 9, &hooks::scene_end ); //n
+
+
+	instance->m_movement->hook( 1, &hooks::process_movement ); //y
+	instance->m_d3d->hook( 42, &hooks::d3d::end_scene ); //y
+	instance->m_d3d->hook( 16, &hooks::d3d::reset );//y
+	instance->m_d3d->hook( 17, &hooks::d3d::present );//y
+	instance->m_panel->hook( 41, &hooks::paint_traverse ); //y
+
+	instance->m_vgui->hook( 13, &hooks::paint ); //y
+
+	instance->m_surface->hook( 116, &hooks::on_screen_size_changed ); //n
+	//instance->m_engine_sound->hook( 5, &hooks::emit_sound ); //n
+
+	return true;
+}
diff --git a/tf2/hooks.h b/tf2/hooks.h
new file mode 100644
index 0000000..c34d71f
--- /dev/null
+++ b/tf2/hooks.h
@@ -0,0 +1,50 @@
+#pragma once
+#include <windows.h>
+
+#include "util.hpp"
+#include "d3d.hpp"
+#include "interfaces.h"
+#include "netvar_proxy.hpp"
+
+namespace hooks
+{
+	//hook like the hooker that u are
+
+	void __fastcall paint( void* ecx_, void* edx_, int mode );
+	long __stdcall window_procedure( HWND, uint32_t, uint32_t, long );
+	extern decltype( &window_procedure ) window_procedure_o;
+	void __fastcall process_movement( void*, void*, c_base_player*, CMoveData* );
+	void __fastcall paint_traverse( void*, void*, unsigned int, bool, bool );
+	bool __fastcall create_move( void*, void*, float, user_cmd_t* );
+	void __stdcall hl_create_move_gate( int sequence_number, float input_sample_time, bool active );
+	void __fastcall hl_create_move( void*, void*, int, float, bool, byte& );
+	void __fastcall frame_stage_notify( void*, void*, frame_stages_t );
+	void __fastcall override_mouse_input( void*, void*, float*, float* );
+	void __fastcall draw_model_execute( IVModelInfo*, void*, void*, const DrawModelState_t&, const ModelRenderInfo_t&, matrix3x4* );
+	void __fastcall scene_end( void*, void* );
+	float __fastcall get_viewmodel_fov( void*, void* );
+	void __fastcall override_view( void* ecx_, void* edx_, CViewSetup* setup );
+	void __fastcall emit_sound( void* ecx_, void* edx_, void* filter, int ent, int channel, const char* sound, uint32_t hash,
+		const char* sample, float volume, float attenuation, int seed, int flags, int pitch, const vec3_t* origin,
+		const vec3_t* direction, vec3_t* origins, bool update_pos, float sound_time, int speaker_entry );
+	void __fastcall shut_down( void* ecx_, void* edx_ );
+
+	bool __fastcall is_connected( void* ecx_, void* edx_ );
+
+	bool __fastcall in_prediction( void* ecx_, void* edx_ );
+	int __fastcall send_datagram( INetChannel* channel, void* edx, void* datagram );
+	bool __fastcall do_post_screen_space_effects( void* ecx_, void* edx_, CViewSetup* setup );
+	void __fastcall on_screen_size_changed( void* ecx_, void* edx_, int old_h, int old_w );
+
+
+
+	//do we wanna only run menu in d3d or visuals too?
+	namespace d3d {
+		long __stdcall end_scene( IDirect3DDevice9* );
+		long __stdcall reset( IDirect3DDevice9*, D3DPRESENT_PARAMETERS* );
+		long __stdcall present( IDirect3DDevice9*, RECT*, RECT*, HWND, RGNDATA* );
+		long __stdcall draw( IDirect3DDevice9*, D3DPRIMITIVETYPE, int, uint32_t, uint32_t, uint32_t, uint32_t );
+	}
+
+	extern bool commit( tf2::client* );
+}
+\ No newline at end of file
diff --git a/tf2/icons.hpp b/tf2/icons.hpp
new file mode 100644
index 0000000..bffd94e
--- /dev/null
+++ b/tf2/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/tf2/icons/config.hpp b/tf2/icons/config.hpp
new file mode 100644
index 0000000..e47c75b
--- /dev/null
+++ b/tf2/icons/config.hpp
@@ -0,0 +1,1297 @@
+/* E:\Users\admin\Desktop\stuff\icons\config.png (1/26/2018 4:19:12 AM)
+   StartOffset: 00000000, EndOffset: 00003C3C, Length: 00003C3D */
+
+namespace icons {
+static const size_t config_size = 15421;
+namespace raw {
+static const unsigned char config_raw[15421] = {
+	0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+	0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42,
+	0x08, 0x06, 0x00, 0x00, 0x00, 0xE3, 0x54, 0x00, 0xE8, 0x00, 0x00, 0x00,
+	0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+	0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x39, 0xEC, 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, 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, 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, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A,
+	0x31, 0x39, 0x3A, 0x30, 0x39, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x39,
+	0x3A, 0x30, 0x39, 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,
+	0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x39, 0x3A, 0x30,
+	0x39, 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,
+	0x34, 0x30, 0x32, 0x65, 0x31, 0x36, 0x64, 0x39, 0x2D, 0x37, 0x38, 0x63,
+	0x30, 0x2D, 0x61, 0x32, 0x34, 0x33, 0x2D, 0x39, 0x63, 0x63, 0x62, 0x2D,
+	0x37, 0x32, 0x66, 0x30, 0x65, 0x38, 0x35, 0x36, 0x33, 0x65, 0x62, 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, 0x61, 0x63, 0x34,
+	0x61, 0x35, 0x32, 0x38, 0x31, 0x2D, 0x30, 0x32, 0x34, 0x37, 0x2D, 0x31,
+	0x31, 0x65, 0x38, 0x2D, 0x61, 0x33, 0x38, 0x37, 0x2D, 0x38, 0x65, 0x34,
+	0x32, 0x36, 0x32, 0x63, 0x35, 0x34, 0x30, 0x63, 0x32, 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, 0x30, 0x31, 0x35, 0x36, 0x63, 0x64, 0x31, 0x2D, 0x34, 0x62, 0x37,
+	0x62, 0x2D, 0x36, 0x31, 0x34, 0x37, 0x2D, 0x62, 0x33, 0x31, 0x64, 0x2D,
+	0x35, 0x36, 0x63, 0x33, 0x63, 0x36, 0x64, 0x31, 0x34, 0x38, 0x66, 0x32,
+	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, 0x30, 0x31, 0x35, 0x36,
+	0x63, 0x64, 0x31, 0x2D, 0x34, 0x62, 0x37, 0x62, 0x2D, 0x36, 0x31, 0x34,
+	0x37, 0x2D, 0x62, 0x33, 0x31, 0x64, 0x2D, 0x35, 0x36, 0x63, 0x33, 0x63,
+	0x36, 0x64, 0x31, 0x34, 0x38, 0x66, 0x32, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31,
+	0x39, 0x3A, 0x30, 0x39, 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, 0x34, 0x30, 0x32, 0x65, 0x31, 0x36, 0x64, 0x39, 0x2D, 0x37,
+	0x38, 0x63, 0x30, 0x2D, 0x61, 0x32, 0x34, 0x33, 0x2D, 0x39, 0x63, 0x63,
+	0x62, 0x2D, 0x37, 0x32, 0x66, 0x30, 0x65, 0x38, 0x35, 0x36, 0x33, 0x65,
+	0x62, 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, 0x31, 0x2D,
+	0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x39, 0x3A, 0x30, 0x39, 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, 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, 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, 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, 0x37, 0x32, 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, 0x37, 0x32, 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, 0x36, 0x35, 0x35, 0x33, 0x35, 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,
+	0x36, 0x36, 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, 0x36, 0x36, 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, 0x8F, 0x3F,
+	0x33, 0x69, 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,
+	0x01, 0xCB, 0x49, 0x44, 0x41, 0x54, 0x78, 0xDA, 0xEC, 0xD9, 0x3F, 0x4A,
+	0x03, 0x41, 0x14, 0xC7, 0xF1, 0xEF, 0xC6, 0x44, 0x08, 0x98, 0x28, 0x2A,
+	0xA6, 0xB1, 0xB1, 0x13, 0x8B, 0x94, 0xA2, 0x17, 0xB0, 0x14, 0x2C, 0xBC,
+	0x82, 0xB5, 0x8D, 0x37, 0xB0, 0x14, 0x53, 0xD8, 0x08, 0xE2, 0x01, 0xB4,
+	0x50, 0x04, 0x2F, 0x60, 0x23, 0x01, 0x0B, 0x49, 0x29, 0xD6, 0x16, 0xDA,
+	0x28, 0x0A, 0x2A, 0x89, 0x1A, 0x8B, 0xAC, 0x10, 0x06, 0x12, 0x77, 0xB3,
+	0x33, 0xC9, 0xCE, 0xF2, 0x7B, 0xB0, 0x84, 0xB7, 0xB0, 0x84, 0xF9, 0xEC,
+	0xCC, 0x9B, 0x3F, 0x1B, 0xB4, 0xDB, 0x6D, 0x14, 0x90, 0x13, 0x81, 0x20,
+	0x04, 0x21, 0x08, 0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04,
+	0x21, 0x08, 0x41, 0x08, 0x42, 0x10, 0xC3, 0x8A, 0x7C, 0x82, 0x67, 0xA7,
+	0x80, 0x95, 0xF0, 0xB7, 0x57, 0x3C, 0x00, 0x75, 0xA0, 0x95, 0x45, 0x88,
+	0x6D, 0xA0, 0x36, 0xC0, 0x73, 0xF3, 0x21, 0x4C, 0x2A, 0x23, 0x88, 0x79,
+	0x42, 0x75, 0x0A, 0x6C, 0x26, 0xF8, 0xBF, 0x45, 0xE0, 0x2E, 0x0B, 0x10,
+	0x36, 0xCE, 0xF5, 0x02, 0xDF, 0x8B, 0xE5, 0xB1, 0x91, 0xDF, 0x84, 0x8D,
+	0xEA, 0x77, 0xE5, 0x80, 0x17, 0xE3, 0xB9, 0x1A, 0x50, 0x70, 0x78, 0x8D,
+	0xB9, 0xEE, 0x11, 0x8F, 0xC0, 0xDC, 0x80, 0x6F, 0x76, 0x54, 0x27, 0xC4,
+	0x5B, 0xC0, 0x91, 0x6D, 0x88, 0x67, 0x63, 0x86, 0xF0, 0x01, 0x02, 0xE0,
+	0x09, 0xA8, 0x68, 0x1D, 0xD1, 0xE9, 0xC5, 0x7B, 0x69, 0xE9, 0x11, 0xB3,
+	0x43, 0x6C, 0xF8, 0x04, 0x70, 0x01, 0x54, 0xE3, 0x14, 0xE9, 0x61, 0x41,
+	0x8C, 0x22, 0xCE, 0x80, 0x8D, 0xAE, 0xBC, 0x00, 0x7C, 0xB9, 0x58, 0x59,
+	0x36, 0x80, 0xE9, 0x94, 0x22, 0xB4, 0x80, 0xB2, 0x71, 0x6F, 0x01, 0xB8,
+	0x77, 0x01, 0x51, 0xF5, 0xAC, 0x56, 0x94, 0x6C, 0x15, 0xCB, 0x62, 0x06,
+	0x8A, 0xA6, 0x95, 0x1A, 0xE1, 0xFB, 0xD7, 0xE2, 0xBE, 0xD3, 0x68, 0x54,
+	0x88, 0x22, 0xF0, 0x6E, 0xDC, 0x3B, 0x04, 0x4E, 0x80, 0x66, 0x0A, 0x1B,
+	0x5D, 0x01, 0x76, 0x81, 0xA5, 0xA8, 0x33, 0x47, 0xD4, 0x1A, 0xB1, 0xEF,
+	0xC3, 0x7E, 0xC1, 0x88, 0xF3, 0x70, 0x1A, 0x5D, 0xB7, 0xB9, 0xB2, 0x6C,
+	0x18, 0xC5, 0x31, 0xF0, 0x64, 0x38, 0x94, 0x80, 0xD7, 0xAE, 0x7C, 0xBC,
+	0xD7, 0xD9, 0x48, 0xD4, 0x62, 0x99, 0xF7, 0xB4, 0x2E, 0x7C, 0xBA, 0xD8,
+	0x7D, 0x66, 0x3A, 0x04, 0x21, 0x08, 0x41, 0x08, 0x42, 0x10, 0x16, 0x21,
+	0x3E, 0x3C, 0x6D, 0xDF, 0xA4, 0x91, 0xFF, 0x24, 0x85, 0xB8, 0x34, 0xF2,
+	0xB2, 0x27, 0x10, 0xD7, 0x46, 0xFE, 0xED, 0x62, 0xD3, 0xB5, 0x03, 0x1C,
+	0xF4, 0x53, 0x1E, 0x71, 0x4F, 0xB8, 0x8A, 0xB3, 0xD7, 0x88, 0x03, 0xF1,
+	0x46, 0xE7, 0x18, 0xCC, 0xD7, 0x58, 0xA6, 0xF3, 0x09, 0x22, 0x31, 0xC4,
+	0xDF, 0x18, 0x0B, 0x3C, 0x44, 0xA8, 0x03, 0xAB, 0x36, 0x67, 0x8D, 0x1C,
+	0x70, 0xEB, 0x19, 0xC2, 0xDA, 0x7F, 0x08, 0x83, 0xF4, 0x08, 0x73, 0xBC,
+	0xCD, 0xA4, 0xB4, 0xF1, 0x4D, 0x63, 0xD7, 0x89, 0x4B, 0x08, 0x2D, 0xA8,
+	0x04, 0x21, 0x08, 0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x42, 0x10,
+	0x82, 0x10, 0x84, 0x20, 0x04, 0x21, 0x08, 0x41, 0x08, 0x42, 0x10, 0x82,
+	0xB0, 0x16, 0xBF, 0x03, 0x00, 0xF4, 0xAF, 0x63, 0xB0, 0x6A, 0xED, 0xB9,
+	0x23, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60,
+	0x82
+};
+}
+static const unsigned char* config_icon = raw::config_raw;
+}
+\ No newline at end of file
diff --git a/tf2/icons/legit.hpp b/tf2/icons/legit.hpp
new file mode 100644
index 0000000..8e5523e
--- /dev/null
+++ b/tf2/icons/legit.hpp
@@ -0,0 +1,1316 @@
+/* E:\Users\admin\Desktop\stuff\icons\legit.png (1/26/2018 4:18:16 AM)
+   StartOffset: 00000000, EndOffset: 00003D23, Length: 00003D24 */
+
+namespace icons {
+static const size_t legit_size = 15652;
+namespace raw {
+static const unsigned char legit_raw[15652] = {
+	0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+	0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42,
+	0x08, 0x06, 0x00, 0x00, 0x00, 0xE3, 0x54, 0x00, 0xE8, 0x00, 0x00, 0x00,
+	0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+	0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x39, 0xEC, 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, 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, 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, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A,
+	0x31, 0x38, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38,
+	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,
+	0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 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,
+	0x65, 0x39, 0x33, 0x64, 0x37, 0x33, 0x38, 0x37, 0x2D, 0x31, 0x30, 0x36,
+	0x39, 0x2D, 0x35, 0x64, 0x34, 0x32, 0x2D, 0x38, 0x66, 0x38, 0x63, 0x2D,
+	0x63, 0x33, 0x34, 0x33, 0x37, 0x39, 0x35, 0x36, 0x35, 0x65, 0x30, 0x63,
+	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, 0x38, 0x62, 0x66,
+	0x62, 0x37, 0x35, 0x37, 0x35, 0x2D, 0x30, 0x32, 0x34, 0x37, 0x2D, 0x31,
+	0x31, 0x65, 0x38, 0x2D, 0x61, 0x33, 0x38, 0x37, 0x2D, 0x38, 0x65, 0x34,
+	0x32, 0x36, 0x32, 0x63, 0x35, 0x34, 0x30, 0x63, 0x32, 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,
+	0x32, 0x35, 0x33, 0x61, 0x62, 0x33, 0x39, 0x61, 0x2D, 0x33, 0x37, 0x31,
+	0x31, 0x2D, 0x35, 0x64, 0x34, 0x64, 0x2D, 0x62, 0x63, 0x33, 0x38, 0x2D,
+	0x62, 0x36, 0x66, 0x30, 0x34, 0x36, 0x62, 0x62, 0x30, 0x31, 0x66, 0x34,
+	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, 0x32, 0x35, 0x33, 0x61, 0x62,
+	0x33, 0x39, 0x61, 0x2D, 0x33, 0x37, 0x31, 0x31, 0x2D, 0x35, 0x64, 0x34,
+	0x64, 0x2D, 0x62, 0x63, 0x33, 0x38, 0x2D, 0x62, 0x36, 0x66, 0x30, 0x34,
+	0x36, 0x62, 0x62, 0x30, 0x31, 0x66, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31,
+	0x38, 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, 0x65, 0x39, 0x33, 0x64, 0x37, 0x33, 0x38, 0x37, 0x2D, 0x31,
+	0x30, 0x36, 0x39, 0x2D, 0x35, 0x64, 0x34, 0x32, 0x2D, 0x38, 0x66, 0x38,
+	0x63, 0x2D, 0x63, 0x33, 0x34, 0x33, 0x37, 0x39, 0x35, 0x36, 0x35, 0x65,
+	0x30, 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, 0x31, 0x2D,
+	0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 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, 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, 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, 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, 0x37, 0x32, 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, 0x37, 0x32, 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, 0x36, 0x35, 0x35, 0x33, 0x35, 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,
+	0x36, 0x36, 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, 0x36, 0x36, 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, 0x56, 0x82,
+	0xD6, 0xC2, 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,
+	0x02, 0xB2, 0x49, 0x44, 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9B, 0x3D, 0x68,
+	0x14, 0x41, 0x14, 0x80, 0xBF, 0x4D, 0x2E, 0xE4, 0x40, 0x51, 0x8C, 0x10,
+	0x83, 0x0A, 0x11, 0xB4, 0x51, 0x2C, 0x44, 0xAB, 0xA4, 0x31, 0x9D, 0xD8,
+	0x89, 0x60, 0x61, 0x44, 0xC4, 0x46, 0x6B, 0x8B, 0x34, 0x22, 0xD8, 0x88,
+	0x82, 0x60, 0x2F, 0xDA, 0x58, 0x18, 0x41, 0x2C, 0x44, 0x84, 0x80, 0x9D,
+	0x29, 0x4C, 0xA9, 0x85, 0x28, 0x41, 0x2D, 0xD4, 0xA8, 0x10, 0x11, 0x7F,
+	0x88, 0x62, 0x40, 0x93, 0xB5, 0xB8, 0x39, 0x0C, 0xC3, 0xDB, 0xDC, 0xCE,
+	0xDE, 0xEC, 0xEE, 0x8C, 0xBE, 0x07, 0x03, 0xB7, 0x6F, 0x6F, 0x96, 0xD9,
+	0x6F, 0xDF, 0x7B, 0xF3, 0xDE, 0xDB, 0xBB, 0x24, 0x4D, 0x53, 0x54, 0xA0,
+	0x47, 0x11, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82, 0x50, 0x10,
+	0x0A, 0x42, 0x41, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82, 0x50,
+	0x10, 0xFF, 0x1B, 0x88, 0x8B, 0xC0, 0x1D, 0x20, 0xA9, 0x6B, 0x01, 0x8D,
+	0x00, 0x20, 0xFC, 0x04, 0x9A, 0xE6, 0xF3, 0x72, 0x5D, 0x30, 0x92, 0x00,
+	0x3A, 0x54, 0xF6, 0x02, 0x12, 0x8D, 0x11, 0x91, 0xC7, 0x88, 0x8D, 0xC0,
+	0x4B, 0xF3, 0x64, 0x8B, 0x0C, 0xC9, 0x42, 0x8A, 0x8C, 0x2B, 0x75, 0xB9,
+	0xC6, 0x0E, 0x03, 0x20, 0x34, 0x79, 0x03, 0x6C, 0xAB, 0xCA, 0x22, 0xDE,
+	0x07, 0x0A, 0x01, 0x60, 0xD8, 0x58, 0xC8, 0x48, 0xD9, 0x20, 0x52, 0x60,
+	0x73, 0x04, 0x6E, 0x3F, 0x03, 0x5C, 0x2E, 0x0B, 0xC4, 0x6A, 0x7E, 0xF4,
+	0xC8, 0x98, 0x64, 0x52, 0xE1, 0x68, 0x00, 0x47, 0x80, 0xC5, 0x8C, 0x35,
+	0x4D, 0x00, 0x67, 0x7C, 0xC7, 0x88, 0x4F, 0x26, 0x30, 0xDA, 0x72, 0x09,
+	0x38, 0x1B, 0x80, 0x05, 0x34, 0x0C, 0x90, 0x5E, 0xE1, 0xDC, 0x16, 0xE0,
+	0x83, 0x0F, 0x10, 0x7B, 0x80, 0x27, 0x82, 0x7E, 0x1D, 0xB0, 0x10, 0x98,
+	0x4B, 0x4C, 0x02, 0xE3, 0xD2, 0xBD, 0xFA, 0x70, 0x0D, 0x09, 0xC2, 0x5A,
+	0x4F, 0x10, 0x3A, 0x6D, 0xA7, 0xAE, 0x72, 0x0C, 0x98, 0x16, 0xF4, 0xE7,
+	0xBB, 0xB5, 0x88, 0x5D, 0xC0, 0x33, 0x4B, 0x77, 0x1C, 0xB8, 0x19, 0x78,
+	0x66, 0x99, 0xBA, 0x58, 0x45, 0x1E, 0x10, 0x0B, 0xE6, 0xE9, 0x97, 0x95,
+	0x06, 0x97, 0x05, 0x62, 0x2B, 0x30, 0x67, 0xE9, 0x06, 0x80, 0x2F, 0x45,
+	0x5D, 0xC3, 0x86, 0x70, 0x2E, 0x92, 0xAC, 0xF9, 0x5D, 0x46, 0xFC, 0x28,
+	0x6C, 0x11, 0xA9, 0x00, 0x2F, 0xCD, 0x28, 0xA5, 0xF7, 0x16, 0x58, 0xF0,
+	0x01, 0xEB, 0xF8, 0x81, 0xE3, 0xFC, 0x5F, 0x66, 0x9B, 0x9C, 0x15, 0xCE,
+	0x3D, 0x05, 0x76, 0xAF, 0x38, 0xFE, 0x0D, 0xF4, 0x15, 0x01, 0xB1, 0x01,
+	0xF8, 0x9C, 0xC3, 0x74, 0x43, 0xF8, 0x91, 0xC5, 0x29, 0xE0, 0xBA, 0xA5,
+	0x3B, 0x01, 0xDC, 0xC8, 0xE3, 0x7A, 0x9D, 0x5C, 0xA3, 0x19, 0x51, 0x01,
+	0x79, 0x55, 0xD0, 0xBD, 0xF0, 0x95, 0x59, 0x2E, 0x45, 0x04, 0xE2, 0xBE,
+	0xA0, 0x1B, 0xF4, 0x59, 0x7D, 0xE6, 0x89, 0xEA, 0x6B, 0x80, 0xD7, 0xC6,
+	0x95, 0x5C, 0xA5, 0xB7, 0x4B, 0xF8, 0xCB, 0x26, 0x08, 0x9E, 0x14, 0xCE,
+	0x3D, 0x04, 0xF6, 0x5B, 0xF7, 0xD2, 0xE3, 0x0B, 0xC4, 0x21, 0xE0, 0x5E,
+	0x04, 0xDB, 0xA7, 0x74, 0xED, 0xC7, 0xC0, 0xBE, 0xA2, 0x20, 0xA4, 0x3E,
+	0x62, 0x0C, 0x79, 0x44, 0x93, 0x56, 0x3F, 0x74, 0xA5, 0xEC, 0xCC, 0xD8,
+	0x5D, 0x72, 0xE5, 0x11, 0x47, 0x05, 0xDD, 0xF6, 0x08, 0x62, 0xC6, 0x57,
+	0x41, 0x37, 0xDB, 0x4D, 0xAD, 0x71, 0x5B, 0xD0, 0xBD, 0x0A, 0x1C, 0xC2,
+	0x38, 0xD0, 0x6F, 0xE9, 0xA6, 0x7D, 0x54, 0x9F, 0x13, 0x19, 0x4D, 0x0E,
+	0x1F, 0x66, 0x3C, 0x60, 0x25, 0x39, 0xF3, 0x5D, 0x5E, 0x6F, 0xC4, 0x34,
+	0x65, 0x9C, 0xD6, 0xEA, 0xD2, 0x8F, 0xC8, 0xFA, 0xE2, 0x30, 0xF0, 0x36,
+	0x10, 0x4B, 0x98, 0x02, 0x0E, 0x0A, 0xFA, 0xC3, 0xC0, 0x5D, 0x1F, 0x65,
+	0x38, 0x59, 0xA9, 0x29, 0xAD, 0x66, 0xE9, 0x12, 0x30, 0x56, 0x63, 0x43,
+	0x66, 0xD2, 0x3C, 0x28, 0x09, 0xC2, 0xF3, 0x4E, 0x10, 0x5C, 0x2D, 0xA2,
+	0x9D, 0x2F, 0x7C, 0x8F, 0x28, 0xC9, 0x9A, 0x07, 0x86, 0x7C, 0x64, 0x96,
+	0xB6, 0xFC, 0x58, 0xC5, 0x32, 0x42, 0x93, 0x5B, 0x79, 0x21, 0x14, 0x01,
+	0xD1, 0xAE, 0xE0, 0x12, 0xE0, 0x5A, 0xC0, 0x10, 0x36, 0xD1, 0xEA, 0x54,
+	0x51, 0x26, 0x88, 0xB6, 0x9C, 0x36, 0x40, 0x2E, 0x04, 0x72, 0xF3, 0xDF,
+	0xF8, 0xDB, 0x45, 0xFF, 0xE8, 0x3A, 0xD9, 0xF7, 0x4B, 0xE0, 0x7E, 0x93,
+	0x6C, 0xAD, 0x77, 0x98, 0x63, 0x6F, 0x75, 0xA3, 0x0E, 0x73, 0xE7, 0x32,
+	0x1A, 0x30, 0xD4, 0x0D, 0x22, 0xB4, 0x5A, 0xA3, 0x12, 0xD7, 0xF8, 0xA7,
+	0x24, 0x04, 0x10, 0x7D, 0xB4, 0x1A, 0xAA, 0x8B, 0xC8, 0x2F, 0x90, 0x2A,
+	0x91, 0x44, 0xFF, 0xCA, 0xA4, 0xAE, 0xA1, 0x20, 0x14, 0x84, 0x82, 0x50,
+	0x10, 0x0A, 0x42, 0x41, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82,
+	0x50, 0x10, 0x0A, 0xA2, 0x2A, 0xF9, 0x33, 0x00, 0x85, 0x3D, 0xBB, 0x66,
+	0xA5, 0x18, 0xA1, 0xED, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44,
+	0xAE, 0x42, 0x60, 0x82
+};
+}
+static const unsigned char* legit_icon = raw::legit_raw;
+}
+\ No newline at end of file
diff --git a/tf2/icons/misc.hpp b/tf2/icons/misc.hpp
new file mode 100644
index 0000000..d15e736
--- /dev/null
+++ b/tf2/icons/misc.hpp
@@ -0,0 +1,1313 @@
+/* E:\Users\admin\Desktop\stuff\icons\misc.png (1/26/2018 4:19:00 AM)
+   StartOffset: 00000000, EndOffset: 00003CFF, Length: 00003D00 */
+
+namespace icons {
+static const size_t misc_size = 15616;
+namespace raw {
+static const unsigned char misc_raw[15616] = {
+	0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+	0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42,
+	0x08, 0x06, 0x00, 0x00, 0x00, 0xE3, 0x54, 0x00, 0xE8, 0x00, 0x00, 0x00,
+	0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+	0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x39, 0xEC, 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, 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, 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, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A,
+	0x31, 0x38, 0x3A, 0x35, 0x37, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38,
+	0x3A, 0x35, 0x37, 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,
+	0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x35,
+	0x37, 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,
+	0x63, 0x36, 0x30, 0x66, 0x62, 0x37, 0x34, 0x35, 0x2D, 0x30, 0x38, 0x61,
+	0x63, 0x2D, 0x35, 0x64, 0x34, 0x38, 0x2D, 0x38, 0x65, 0x39, 0x33, 0x2D,
+	0x39, 0x65, 0x62, 0x38, 0x39, 0x65, 0x31, 0x32, 0x30, 0x63, 0x64, 0x35,
+	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, 0x39, 0x61, 0x63,
+	0x30, 0x38, 0x39, 0x32, 0x64, 0x2D, 0x30, 0x32, 0x34, 0x37, 0x2D, 0x31,
+	0x31, 0x65, 0x38, 0x2D, 0x61, 0x33, 0x38, 0x37, 0x2D, 0x38, 0x65, 0x34,
+	0x32, 0x36, 0x32, 0x63, 0x35, 0x34, 0x30, 0x63, 0x32, 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,
+	0x38, 0x30, 0x61, 0x38, 0x30, 0x31, 0x39, 0x38, 0x2D, 0x30, 0x62, 0x66,
+	0x32, 0x2D, 0x37, 0x64, 0x34, 0x62, 0x2D, 0x39, 0x65, 0x32, 0x36, 0x2D,
+	0x62, 0x66, 0x39, 0x36, 0x37, 0x34, 0x36, 0x39, 0x63, 0x65, 0x34, 0x66,
+	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, 0x38, 0x30, 0x61, 0x38, 0x30,
+	0x31, 0x39, 0x38, 0x2D, 0x30, 0x62, 0x66, 0x32, 0x2D, 0x37, 0x64, 0x34,
+	0x62, 0x2D, 0x39, 0x65, 0x32, 0x36, 0x2D, 0x62, 0x66, 0x39, 0x36, 0x37,
+	0x34, 0x36, 0x39, 0x63, 0x65, 0x34, 0x66, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31,
+	0x38, 0x3A, 0x35, 0x37, 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, 0x63, 0x36, 0x30, 0x66, 0x62, 0x37, 0x34, 0x35, 0x2D, 0x30,
+	0x38, 0x61, 0x63, 0x2D, 0x35, 0x64, 0x34, 0x38, 0x2D, 0x38, 0x65, 0x39,
+	0x33, 0x2D, 0x39, 0x65, 0x62, 0x38, 0x39, 0x65, 0x31, 0x32, 0x30, 0x63,
+	0x64, 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, 0x31, 0x2D,
+	0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x35, 0x37, 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, 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, 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, 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, 0x37, 0x32, 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, 0x37, 0x32, 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, 0x36, 0x35, 0x35, 0x33, 0x35, 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,
+	0x36, 0x36, 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, 0x36, 0x36, 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, 0xE2, 0x3E,
+	0xB4, 0x34, 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,
+	0x02, 0x8E, 0x49, 0x44, 0x41, 0x54, 0x78, 0xDA, 0xEC, 0xDB, 0xBF, 0x6B,
+	0x14, 0x41, 0x18, 0xC6, 0xF1, 0xEF, 0xC6, 0x5C, 0xCE, 0xC3, 0x93, 0xA0,
+	0x48, 0xF0, 0x07, 0x6A, 0x0A, 0x15, 0x31, 0x8D, 0x55, 0x40, 0xB0, 0xB4,
+	0xD0, 0x42, 0xD0, 0xCE, 0x7F, 0x40, 0x41, 0x11, 0x04, 0x5B, 0x7B, 0x3B,
+	0x11, 0xC4, 0x42, 0x05, 0xB1, 0x13, 0x04, 0x1B, 0x41, 0xAC, 0x6D, 0xAD,
+	0x04, 0x41, 0xC4, 0x46, 0xB0, 0x88, 0x12, 0x41, 0xD0, 0x80, 0x07, 0x31,
+	0xB9, 0x5B, 0x8B, 0x4C, 0x40, 0xD6, 0x99, 0xDD, 0xD9, 0x99, 0x59, 0xDD,
+	0x95, 0x67, 0xE0, 0x8A, 0x5B, 0xDE, 0xEC, 0xED, 0x7C, 0xF6, 0x9D, 0x99,
+	0x77, 0xF6, 0x72, 0x59, 0x9E, 0xE7, 0xA8, 0xC1, 0x94, 0x08, 0x04, 0x21,
+	0x08, 0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04, 0x21, 0x08,
+	0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04, 0x21, 0x88, 0xFF,
+	0x09, 0xE2, 0x3C, 0xB0, 0x02, 0xE4, 0xFF, 0xE8, 0xB5, 0x0A, 0xDC, 0x88,
+	0xE9, 0x40, 0x16, 0xF9, 0xF0, 0xF6, 0x15, 0xB0, 0xD8, 0xB2, 0x9B, 0xFB,
+	0x09, 0x38, 0x00, 0x8C, 0xFF, 0x46, 0x46, 0x1C, 0x37, 0x77, 0x62, 0xB1,
+	0x85, 0x59, 0xBE, 0x17, 0x58, 0x07, 0x2E, 0x36, 0x0D, 0x71, 0x0B, 0x78,
+	0xDD, 0x81, 0x61, 0xFF, 0x00, 0x78, 0xD7, 0x14, 0xC4, 0x4D, 0xE0, 0x7A,
+	0xC5, 0x87, 0x1F, 0x06, 0xB6, 0x02, 0x7D, 0x8F, 0xD7, 0x7C, 0xC9, 0xB9,
+	0x06, 0x85, 0xD8, 0x61, 0x49, 0xAC, 0x6B, 0x7C, 0x1F, 0x05, 0xDE, 0xA7,
+	0x9E, 0x23, 0x8E, 0x94, 0x9C, 0x74, 0x1B, 0x30, 0xAA, 0x89, 0xDA, 0x03,
+	0x7E, 0xBA, 0xAE, 0xAB, 0x46, 0x67, 0x67, 0x80, 0x35, 0x60, 0x1A, 0xF8,
+	0x02, 0xEC, 0xB0, 0xC4, 0x5C, 0x03, 0xEE, 0xA4, 0x82, 0xB0, 0x05, 0x3E,
+	0x01, 0x2E, 0x04, 0xA4, 0x6D, 0x2A, 0x84, 0x21, 0xF0, 0xC3, 0x33, 0xB6,
+	0x67, 0xE6, 0x8E, 0xA8, 0xA1, 0xF1, 0xC2, 0x72, 0xEC, 0x69, 0x87, 0x10,
+	0x00, 0xBE, 0xA5, 0xC8, 0x88, 0xDC, 0xF3, 0xA2, 0xDB, 0x8A, 0xB0, 0xD9,
+	0xB6, 0x00, 0x93, 0xD0, 0x8C, 0x38, 0xE1, 0x98, 0x13, 0xBA, 0x86, 0x00,
+	0xF0, 0x38, 0x26, 0x23, 0x96, 0xCC, 0xDA, 0x1C, 0x93, 0x0D, 0x53, 0x25,
+	0x05, 0x4E, 0x53, 0x08, 0x43, 0xB3, 0x7C, 0xEE, 0xF7, 0xB9, 0x76, 0x9F,
+	0x8C, 0x28, 0x22, 0xDC, 0x4D, 0x88, 0x60, 0xFB, 0xFC, 0x89, 0x23, 0x76,
+	0xA7, 0x05, 0x61, 0x52, 0x01, 0x76, 0x3A, 0x65, 0x89, 0x5D, 0x0C, 0xD8,
+	0x67, 0xCA, 0xD8, 0x58, 0x04, 0xDB, 0x78, 0x9D, 0x38, 0xEE, 0xD8, 0x2E,
+	0xE0, 0x6B, 0x60, 0x6C, 0xEE, 0x93, 0x11, 0x21, 0x10, 0xFD, 0x92, 0xB1,
+	0xDE, 0x36, 0x04, 0x6F, 0x88, 0x90, 0x12, 0xBB, 0xD7, 0x21, 0x84, 0x46,
+	0xF7, 0x1A, 0xA7, 0x3A, 0x84, 0xD0, 0x4F, 0x09, 0x51, 0xEC, 0xD4, 0xBD,
+	0x9A, 0xF1, 0x65, 0x08, 0xAB, 0x35, 0x3A, 0xB6, 0x1E, 0x90, 0x09, 0xB7,
+	0x53, 0x42, 0x3C, 0x2C, 0xBC, 0xDF, 0x1D, 0xB0, 0xF9, 0x99, 0xB1, 0x20,
+	0x8C, 0xCC, 0xF1, 0x62, 0x9B, 0xB7, 0x74, 0x6C, 0x64, 0x20, 0x7D, 0x62,
+	0x7F, 0x6F, 0x97, 0x0B, 0xEF, 0x97, 0x63, 0x20, 0xAE, 0x58, 0x8E, 0x3D,
+	0x0A, 0xD8, 0x14, 0x15, 0x3B, 0x36, 0x70, 0x74, 0xEC, 0x63, 0x44, 0x6C,
+	0x55, 0x21, 0x78, 0x32, 0xB6, 0xC4, 0x1E, 0x5B, 0xD0, 0x66, 0xD9, 0x78,
+	0x3C, 0xD7, 0x46, 0x84, 0xCC, 0x51, 0x63, 0x64, 0xB1, 0x93, 0xE5, 0x9C,
+	0xE5, 0xD8, 0x77, 0x53, 0x6A, 0xB7, 0x0D, 0xC1, 0x55, 0x68, 0x9D, 0x4B,
+	0xB5, 0x0D, 0x7F, 0x0B, 0x1C, 0xF3, 0x8C, 0xB5, 0x21, 0xAC, 0x00, 0xDB,
+	0x1B, 0x46, 0x98, 0x73, 0xCC, 0x03, 0x79, 0xD5, 0x4D, 0xAF, 0xB3, 0x7C,
+	0x2E, 0x78, 0xC6, 0x0D, 0x2C, 0x08, 0x4B, 0x0E, 0x84, 0x05, 0x4B, 0xC7,
+	0x3E, 0x3B, 0x10, 0x0E, 0x95, 0x20, 0xEC, 0x31, 0x25, 0xF5, 0x72, 0xC9,
+	0x8A, 0x95, 0xEC, 0x09, 0x55, 0xD9, 0xD8, 0x6B, 0x73, 0xB3, 0x6D, 0xD4,
+	0xFE, 0x68, 0xD3, 0x35, 0x4F, 0x9A, 0x1B, 0x8C, 0x31, 0xDD, 0xF8, 0x72,
+	0xC8, 0x36, 0x44, 0x93, 0x55, 0x96, 0x9B, 0xA9, 0x76, 0xB5, 0xC5, 0x00,
+	0xCF, 0xCC, 0x0D, 0x5B, 0xF3, 0x4E, 0xF5, 0x04, 0xFF, 0x9D, 0x7F, 0x1F,
+	0xB8, 0xD4, 0x12, 0x80, 0xE7, 0xC0, 0xD9, 0x90, 0x3F, 0xCC, 0x12, 0xFF,
+	0x4C, 0xE1, 0x20, 0x70, 0x86, 0x8D, 0xC7, 0xE8, 0x31, 0x6D, 0xD6, 0x2C,
+	0xCF, 0x55, 0xED, 0x03, 0xF0, 0x12, 0x78, 0x13, 0x7B, 0xE1, 0x99, 0x7E,
+	0xAF, 0x11, 0x37, 0x47, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04,
+	0x21, 0x08, 0x35, 0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04,
+	0x21, 0x08, 0x41, 0x44, 0xB6, 0x5F, 0x03, 0x00, 0xB0, 0xEE, 0xE7, 0x04,
+	0x67, 0x01, 0x94, 0x88, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44,
+	0xAE, 0x42, 0x60, 0x82
+};
+}
+static const unsigned char* misc_icon = raw::misc_raw;
+}
+\ No newline at end of file
diff --git a/tf2/icons/rage.hpp b/tf2/icons/rage.hpp
new file mode 100644
index 0000000..00dff07
--- /dev/null
+++ b/tf2/icons/rage.hpp
@@ -0,0 +1,1293 @@
+/* E:\Users\admin\Desktop\stuff\icons\rage.png (1/26/2018 4:18:26 AM)
+   StartOffset: 00000000, EndOffset: 00003C11, Length: 00003C12 */
+
+namespace icons {   
+static const size_t rage_size = 15378;
+namespace raw {
+static const unsigned char rage_raw[15378] = {
+	0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+	0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42,
+	0x08, 0x06, 0x00, 0x00, 0x00, 0xE3, 0x54, 0x00, 0xE8, 0x00, 0x00, 0x00,
+	0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+	0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x39, 0xEC, 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, 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, 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, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A,
+	0x31, 0x38, 0x3A, 0x32, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38,
+	0x3A, 0x32, 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,
+	0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x32,
+	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,
+	0x39, 0x61, 0x36, 0x38, 0x61, 0x33, 0x31, 0x37, 0x2D, 0x37, 0x65, 0x39,
+	0x34, 0x2D, 0x37, 0x30, 0x34, 0x31, 0x2D, 0x38, 0x63, 0x62, 0x30, 0x2D,
+	0x61, 0x39, 0x35, 0x63, 0x62, 0x61, 0x33, 0x33, 0x39, 0x66, 0x34, 0x65,
+	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, 0x39, 0x31, 0x65,
+	0x62, 0x39, 0x62, 0x37, 0x65, 0x2D, 0x30, 0x32, 0x34, 0x37, 0x2D, 0x31,
+	0x31, 0x65, 0x38, 0x2D, 0x61, 0x33, 0x38, 0x37, 0x2D, 0x38, 0x65, 0x34,
+	0x32, 0x36, 0x32, 0x63, 0x35, 0x34, 0x30, 0x63, 0x32, 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,
+	0x33, 0x62, 0x30, 0x66, 0x31, 0x39, 0x37, 0x63, 0x2D, 0x32, 0x35, 0x66,
+	0x66, 0x2D, 0x30, 0x66, 0x34, 0x63, 0x2D, 0x61, 0x62, 0x66, 0x36, 0x2D,
+	0x33, 0x66, 0x33, 0x30, 0x39, 0x30, 0x65, 0x33, 0x32, 0x31, 0x63, 0x62,
+	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, 0x33, 0x62, 0x30, 0x66, 0x31,
+	0x39, 0x37, 0x63, 0x2D, 0x32, 0x35, 0x66, 0x66, 0x2D, 0x30, 0x66, 0x34,
+	0x63, 0x2D, 0x61, 0x62, 0x66, 0x36, 0x2D, 0x33, 0x66, 0x33, 0x30, 0x39,
+	0x30, 0x65, 0x33, 0x32, 0x31, 0x63, 0x62, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31,
+	0x38, 0x3A, 0x32, 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, 0x39, 0x61, 0x36, 0x38, 0x61, 0x33, 0x31, 0x37, 0x2D, 0x37,
+	0x65, 0x39, 0x34, 0x2D, 0x37, 0x30, 0x34, 0x31, 0x2D, 0x38, 0x63, 0x62,
+	0x30, 0x2D, 0x61, 0x39, 0x35, 0x63, 0x62, 0x61, 0x33, 0x33, 0x39, 0x66,
+	0x34, 0x65, 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, 0x31, 0x2D,
+	0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x32, 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, 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, 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, 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, 0x37, 0x32, 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, 0x37, 0x32, 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, 0x36, 0x35, 0x35, 0x33, 0x35, 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,
+	0x36, 0x36, 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, 0x36, 0x36, 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, 0x2C, 0xB7,
+	0x84, 0x1B, 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,
+	0x01, 0xA0, 0x49, 0x44, 0x41, 0x54, 0x78, 0xDA, 0xEC, 0xDA, 0x3F, 0x4B,
+	0xC3, 0x40, 0x18, 0xC7, 0xF1, 0x6F, 0xFC, 0x8B, 0xA2, 0xB3, 0x48, 0x07,
+	0x37, 0x11, 0x1C, 0xEC, 0x24, 0x3A, 0x14, 0xC1, 0xC5, 0x97, 0xE0, 0x24,
+	0x4E, 0xBE, 0x0B, 0x57, 0x75, 0x76, 0x12, 0x9C, 0x1C, 0xC4, 0xD1, 0x17,
+	0xE0, 0x20, 0x4E, 0x8A, 0x20, 0xBA, 0x15, 0xD1, 0x41, 0x57, 0x9D, 0x05,
+	0x07, 0x5B, 0xCF, 0x21, 0x05, 0xCB, 0x79, 0x36, 0x09, 0xB4, 0x49, 0x9B,
+	0xE7, 0xF7, 0xC0, 0x0D, 0xF7, 0x5C, 0x2E, 0x21, 0x9F, 0x34, 0x77, 0xD7,
+	0x6B, 0x23, 0xE7, 0x1C, 0x0A, 0x18, 0x12, 0x81, 0x20, 0x04, 0x21, 0x08,
+	0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04, 0x21, 0x08, 0x41,
+	0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04, 0x31, 0x28, 0x10, 0x93,
+	0x80, 0x6B, 0x2B, 0x7E, 0x34, 0xBC, 0xF6, 0xA2, 0xCA, 0x2B, 0x50, 0xED,
+	0x25, 0xC4, 0x47, 0x42, 0xFB, 0x70, 0x9F, 0x3C, 0xD4, 0x39, 0xE0, 0xA1,
+	0x85, 0xB2, 0x93, 0xB5, 0x73, 0x94, 0x62, 0x17, 0xDB, 0x3F, 0x20, 0x4A,
+	0x68, 0xEF, 0xA7, 0x88, 0x34, 0x46, 0xFC, 0x3E, 0xA4, 0x54, 0xF7, 0x38,
+	0xD2, 0x83, 0x8B, 0x9F, 0x01, 0x17, 0x5D, 0x3C, 0xDF, 0x89, 0x57, 0x7F,
+	0x02, 0xF6, 0xDB, 0xEA, 0x53, 0xC0, 0x26, 0x50, 0xFB, 0xA7, 0x7F, 0x33,
+	0xD5, 0x27, 0xC3, 0x39, 0x97, 0x54, 0xFC, 0x48, 0x6A, 0x9F, 0x4D, 0x71,
+	0xCE, 0x2C, 0xC5, 0x8F, 0xED, 0x0E, 0xC7, 0xAE, 0xBB, 0x70, 0x5C, 0x25,
+	0x5D, 0xA7, 0x6C, 0xAF, 0xC6, 0x25, 0x30, 0x16, 0xC8, 0xAF, 0x01, 0xA3,
+	0xD6, 0xC6, 0x88, 0x2F, 0x60, 0x26, 0x90, 0x7F, 0xB1, 0x38, 0x58, 0xBE,
+	0x03, 0x8F, 0x5E, 0xAE, 0x62, 0x75, 0xD6, 0x58, 0x0C, 0xE4, 0x16, 0x2C,
+	0x42, 0x7C, 0x07, 0x72, 0xC7, 0x56, 0xD7, 0x11, 0xF7, 0x5E, 0x7D, 0xD9,
+	0x2A, 0xC4, 0xB5, 0x57, 0x1F, 0xB7, 0x0A, 0xF1, 0xAC, 0x25, 0x76, 0x1C,
+	0x35, 0x41, 0xC4, 0xB1, 0xE1, 0xD5, 0xDF, 0xAC, 0x42, 0x4C, 0x7B, 0xF5,
+	0x23, 0x8B, 0x10, 0xA1, 0x19, 0x62, 0xCF, 0x22, 0xC4, 0x6D, 0x20, 0xD7,
+	0xB0, 0x06, 0x71, 0x13, 0xC8, 0x6D, 0x59, 0x1B, 0x2C, 0xCF, 0x81, 0x95,
+	0x40, 0xFE, 0x34, 0xEF, 0x8D, 0x99, 0xA2, 0xA2, 0x4A, 0xBC, 0x67, 0x19,
+	0x8A, 0x4A, 0x52, 0xE7, 0xB2, 0xEF, 0x59, 0x02, 0xEC, 0x76, 0x1A, 0x24,
+	0xAD, 0x4C, 0x9F, 0x07, 0x69, 0x10, 0xCA, 0xF6, 0x6A, 0x84, 0xBE, 0x86,
+	0xD7, 0xBB, 0xB9, 0xB2, 0x5C, 0x1A, 0x30, 0x80, 0xC3, 0xD6, 0xEB, 0x5B,
+	0xCF, 0xD2, 0x29, 0xEA, 0xC2, 0xBF, 0xF3, 0x57, 0x81, 0xF9, 0x9C, 0x6E,
+	0x72, 0x02, 0xF8, 0xF4, 0x72, 0x4D, 0xE0, 0x8E, 0xBF, 0x3B, 0x52, 0xE4,
+	0x0D, 0x51, 0x8A, 0xD0, 0x8F, 0xC0, 0x82, 0x10, 0x84, 0x20, 0x04, 0x21,
+	0x08, 0x41, 0x08, 0x42, 0x10, 0x82, 0x10, 0x84, 0x20, 0x04, 0x21, 0x08,
+	0x41, 0x08, 0x42, 0x10, 0x82, 0x28, 0x36, 0x7E, 0x06, 0x00, 0x5C, 0x33,
+	0x34, 0xCB, 0x4C, 0x00, 0x5F, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
+	0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82
+};
+}
+static const unsigned char* rage_icon = raw::rage_raw;
+}
+\ No newline at end of file
diff --git a/tf2/icons/visuals.hpp b/tf2/icons/visuals.hpp
new file mode 100644
index 0000000..4d50ae3
--- /dev/null
+++ b/tf2/icons/visuals.hpp
@@ -0,0 +1,1318 @@
+namespace icons {
+constexpr size_t visuals_size = 15715;
+namespace raw {
+constexpr unsigned char visuals_raw[15715] = {
+	0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+	0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42,
+	0x08, 0x06, 0x00, 0x00, 0x00, 0xE3, 0x54, 0x00, 0xE8, 0x00, 0x00, 0x00,
+	0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+	0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x39, 0xEC, 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, 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, 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, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A,
+	0x31, 0x38, 0x3A, 0x33, 0x37, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38,
+	0x3A, 0x33, 0x37, 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,
+	0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x33,
+	0x37, 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, 0x39, 0x31, 0x35, 0x36, 0x62, 0x33, 0x33, 0x2D, 0x65, 0x62, 0x62,
+	0x31, 0x2D, 0x63, 0x39, 0x34, 0x36, 0x2D, 0x38, 0x62, 0x33, 0x34, 0x2D,
+	0x30, 0x39, 0x32, 0x39, 0x31, 0x63, 0x62, 0x31, 0x34, 0x65, 0x36, 0x35,
+	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, 0x39, 0x33, 0x30,
+	0x65, 0x35, 0x38, 0x62, 0x39, 0x2D, 0x30, 0x32, 0x34, 0x37, 0x2D, 0x31,
+	0x31, 0x65, 0x38, 0x2D, 0x61, 0x33, 0x38, 0x37, 0x2D, 0x38, 0x65, 0x34,
+	0x32, 0x36, 0x32, 0x63, 0x35, 0x34, 0x30, 0x63, 0x32, 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,
+	0x62, 0x64, 0x62, 0x35, 0x39, 0x65, 0x61, 0x36, 0x2D, 0x37, 0x63, 0x63,
+	0x30, 0x2D, 0x65, 0x65, 0x34, 0x34, 0x2D, 0x39, 0x33, 0x61, 0x66, 0x2D,
+	0x32, 0x64, 0x33, 0x62, 0x38, 0x30, 0x39, 0x32, 0x31, 0x35, 0x33, 0x39,
+	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, 0x62, 0x64, 0x62, 0x35, 0x39,
+	0x65, 0x61, 0x36, 0x2D, 0x37, 0x63, 0x63, 0x30, 0x2D, 0x65, 0x65, 0x34,
+	0x34, 0x2D, 0x39, 0x33, 0x61, 0x66, 0x2D, 0x32, 0x64, 0x33, 0x62, 0x38,
+	0x30, 0x39, 0x32, 0x31, 0x35, 0x33, 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, 0x31, 0x2D, 0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31,
+	0x38, 0x3A, 0x33, 0x37, 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, 0x39, 0x31, 0x35, 0x36, 0x62, 0x33, 0x33, 0x2D, 0x65,
+	0x62, 0x62, 0x31, 0x2D, 0x63, 0x39, 0x34, 0x36, 0x2D, 0x38, 0x62, 0x33,
+	0x34, 0x2D, 0x30, 0x39, 0x32, 0x39, 0x31, 0x63, 0x62, 0x31, 0x34, 0x65,
+	0x36, 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, 0x31, 0x2D,
+	0x32, 0x36, 0x54, 0x31, 0x31, 0x3A, 0x31, 0x38, 0x3A, 0x33, 0x37, 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, 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, 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, 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, 0x37, 0x32, 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, 0x37, 0x32, 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, 0x36, 0x35, 0x35, 0x33, 0x35, 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,
+	0x36, 0x36, 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, 0x36, 0x36, 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, 0x20, 0x2B,
+	0x35, 0xED, 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,
+	0x02, 0xF1, 0x49, 0x44, 0x41, 0x54, 0x78, 0xDA, 0xEC, 0x9B, 0xBD, 0x6B,
+	0x14, 0x41, 0x18, 0x87, 0x9F, 0xBD, 0xDC, 0x25, 0x31, 0x41, 0x31, 0x11,
+	0x4E, 0x05, 0x25, 0x48, 0x48, 0x2C, 0x04, 0x2B, 0x15, 0x14, 0x84, 0x60,
+	0x6C, 0xAC, 0xFC, 0x28, 0x44, 0xD2, 0x89, 0xA8, 0x85, 0x85, 0x58, 0xD9,
+	0x08, 0xFE, 0x01, 0x82, 0xFD, 0x89, 0x85, 0x8D, 0x60, 0x17, 0x45, 0x10,
+	0x8D, 0x85, 0x96, 0x36, 0x62, 0x65, 0x21, 0x58, 0x84, 0x53, 0x50, 0xB9,
+	0x22, 0x28, 0x1A, 0xF5, 0x72, 0xB9, 0xD7, 0xC2, 0x0D, 0x1C, 0xCB, 0x7C,
+	0xEC, 0xEC, 0xEE, 0x7D, 0x04, 0xDE, 0x1F, 0x6C, 0xB1, 0x33, 0xF3, 0x9B,
+	0xF7, 0xE6, 0xB9, 0x77, 0x67, 0x67, 0xE6, 0xB8, 0x48, 0x44, 0x50, 0x41,
+	0x49, 0x11, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82, 0x50, 0x10,
+	0x0A, 0x42, 0x41, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82, 0x50,
+	0x10, 0x0A, 0x42, 0x41, 0x28, 0x88, 0xBE, 0xAA, 0x5C, 0x70, 0x7F, 0x3B,
+	0x81, 0x79, 0x60, 0x06, 0x98, 0x08, 0xF4, 0x0E, 0x03, 0xCD, 0x80, 0xF6,
+	0x4D, 0xE0, 0x3D, 0xF0, 0x0A, 0xA8, 0x0F, 0x02, 0x88, 0x1B, 0xC0, 0xDD,
+	0x01, 0xF9, 0x62, 0x1F, 0x00, 0x17, 0xB3, 0x18, 0xA3, 0x1C, 0x87, 0xB7,
+	0x0B, 0xC0, 0xC3, 0x01, 0xCD, 0xF4, 0x60, 0x20, 0x59, 0x41, 0xFC, 0x8D,
+	0x53, 0x79, 0xD0, 0x55, 0x01, 0x5A, 0xDD, 0x9A, 0x2C, 0x65, 0x93, 0x40,
+	0x00, 0x58, 0x03, 0x46, 0xBB, 0x01, 0xC2, 0x95, 0x3E, 0xF3, 0x40, 0x94,
+	0xB8, 0x86, 0x3C, 0xFD, 0xDD, 0x01, 0xB6, 0x74, 0xB4, 0xAF, 0x00, 0x97,
+	0x3C, 0x9E, 0x49, 0x43, 0x9C, 0x99, 0x38, 0x4B, 0x4D, 0xFA, 0x1D, 0xB7,
+	0xF1, 0x8C, 0x4C, 0x24, 0xED, 0xF5, 0x56, 0xCC, 0x3A, 0xEE, 0xF0, 0xD8,
+	0x74, 0x28, 0x45, 0xBC, 0xAA, 0xC3, 0x6F, 0xF3, 0xEC, 0xB1, 0xB4, 0x6F,
+	0xF9, 0xE2, 0xA5, 0x85, 0xB0, 0xDD, 0x12, 0x60, 0xDC, 0xE1, 0xB9, 0x66,
+	0xF1, 0x44, 0x01, 0xF0, 0x89, 0x07, 0x91, 0xD4, 0x3B, 0x47, 0xFB, 0xC8,
+	0x12, 0xF7, 0x84, 0x2B, 0x4E, 0xDA, 0xC9, 0xB2, 0x65, 0x48, 0xF3, 0x49,
+	0x60, 0x25, 0xF0, 0x31, 0x2A, 0x79, 0x1E, 0xAF, 0x90, 0xBE, 0x86, 0x80,
+	0xB6, 0xE3, 0x91, 0x5F, 0x37, 0xBD, 0x1C, 0xF2, 0xCC, 0x11, 0x25, 0x03,
+	0x84, 0x27, 0x1E, 0x08, 0xA7, 0x0D, 0x65, 0xFB, 0x33, 0x42, 0x00, 0x18,
+	0x31, 0x94, 0xBD, 0x70, 0xB4, 0x6F, 0xC7, 0x73, 0x56, 0x52, 0xD3, 0x79,
+	0x5E, 0x9F, 0x35, 0xE0, 0x4A, 0x5A, 0xB2, 0x1D, 0xB3, 0x75, 0x39, 0xD0,
+	0xE3, 0x53, 0x1D, 0xD8, 0x1B, 0xD8, 0x67, 0x72, 0x70, 0x5F, 0x81, 0xDD,
+	0x59, 0x33, 0x22, 0x39, 0x8B, 0x7F, 0xCB, 0xB0, 0x62, 0xBD, 0x50, 0xC0,
+	0xAB, 0xF0, 0x40, 0x06, 0xCF, 0xBD, 0xC4, 0xFD, 0xAE, 0x3C, 0x19, 0x91,
+	0x6C, 0x70, 0x0E, 0x58, 0x0C, 0xF4, 0x44, 0x14, 0xA3, 0x64, 0xBF, 0x53,
+	0x9E, 0x7D, 0xC6, 0x18, 0xF0, 0x2B, 0xCD, 0x67, 0xC9, 0xB2, 0xA0, 0x5A,
+	0xF2, 0xD4, 0x8F, 0xD2, 0x3B, 0x1D, 0xF1, 0xD4, 0xAF, 0x76, 0x73, 0x1B,
+	0xBE, 0xE6, 0xA9, 0x1F, 0xEF, 0x21, 0x88, 0xC2, 0x62, 0x65, 0x01, 0xB1,
+	0xC3, 0x53, 0xFF, 0xBD, 0x87, 0x20, 0x3E, 0xF5, 0x13, 0xC4, 0xCD, 0x14,
+	0x6B, 0x8E, 0x5E, 0x3D, 0x2E, 0x6F, 0x3C, 0xF5, 0xB3, 0x45, 0x82, 0x68,
+	0x24, 0xEE, 0xAF, 0x67, 0xF8, 0xC0, 0x8F, 0x0A, 0x18, 0xF4, 0xC9, 0x0C,
+	0x73, 0xC0, 0x52, 0x91, 0x20, 0xCE, 0x5B, 0x66, 0x63, 0x97, 0x3E, 0xA6,
+	0x58, 0x60, 0x85, 0xEA, 0x65, 0x06, 0xCF, 0x54, 0xE2, 0x7E, 0x31, 0x0F,
+	0x88, 0xD7, 0x86, 0xB2, 0x9F, 0x1E, 0xCF, 0x61, 0x43, 0xD9, 0xD3, 0x1C,
+	0x10, 0xCE, 0x1A, 0xCA, 0xCE, 0x78, 0x3C, 0x1F, 0x52, 0x7E, 0xA9, 0x41,
+	0xBB, 0xCF, 0xE7, 0x86, 0x4D, 0x4C, 0xCD, 0xE3, 0x31, 0xE9, 0x68, 0xE0,
+	0x86, 0x0B, 0x11, 0x99, 0x08, 0xDC, 0x81, 0x22, 0x22, 0x73, 0x86, 0xF6,
+	0xAB, 0x45, 0xEC, 0x3E, 0x6D, 0x03, 0x73, 0xC1, 0xD8, 0x6A, 0xF1, 0x2C,
+	0x04, 0xC4, 0x9C, 0xB6, 0xF4, 0x31, 0xE7, 0xF0, 0x9C, 0xB2, 0x78, 0x2A,
+	0x45, 0x81, 0x38, 0x68, 0x09, 0xB0, 0x2E, 0x22, 0xC3, 0x16, 0xCF, 0x7D,
+	0x8B, 0xA7, 0x29, 0x22, 0x63, 0x8E, 0x58, 0x65, 0x11, 0x59, 0xB6, 0x78,
+	0x1B, 0x16, 0x4F, 0x49, 0x44, 0xBE, 0x58, 0x3C, 0xB7, 0x8B, 0x3A, 0x8F,
+	0xD8, 0xB8, 0x6A, 0x8E, 0xC3, 0x92, 0x76, 0x1C, 0xB0, 0x1A, 0x83, 0xD9,
+	0xB8, 0x7E, 0x88, 0x5B, 0x0D, 0x11, 0x79, 0x26, 0x22, 0x8F, 0x45, 0xE4,
+	0xB3, 0xF8, 0x35, 0xD2, 0xD1, 0xF7, 0x36, 0x11, 0xB9, 0x1C, 0xA7, 0xBD,
+	0x4D, 0xF5, 0x34, 0x63, 0xCB, 0x72, 0x78, 0x6B, 0xDA, 0x8D, 0x0E, 0xAA,
+	0x96, 0x81, 0x7D, 0xDD, 0x5A, 0x50, 0x5D, 0x05, 0x8E, 0x6D, 0x02, 0x08,
+	0xB7, 0xD2, 0x42, 0xC8, 0x73, 0x9C, 0xDF, 0xF9, 0x8A, 0x9A, 0x1D, 0x30,
+	0x00, 0x2B, 0x40, 0x35, 0xED, 0x31, 0x7E, 0x9E, 0x8C, 0x48, 0x9E, 0x3A,
+	0x45, 0xF1, 0xA3, 0xF2, 0xA7, 0x8F, 0x83, 0x6F, 0xF3, 0xFF, 0xD7, 0xB6,
+	0x52, 0x7C, 0x84, 0xD8, 0x0A, 0xED, 0x20, 0xD2, 0xBF, 0x29, 0x14, 0x93,
+	0x11, 0x0A, 0x42, 0x41, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84, 0x82,
+	0x50, 0x10, 0x0A, 0x42, 0x11, 0x28, 0x08, 0x05, 0xA1, 0x20, 0x14, 0x84,
+	0x82, 0x50, 0x10, 0x0A, 0x42, 0x41, 0xE4, 0xD3, 0xBF, 0x01, 0x00, 0x36,
+	0xC5, 0x99, 0x33, 0xE0, 0x8B, 0x14, 0x09, 0x00, 0x00, 0x00, 0x00, 0x49,
+	0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82
+};
+}
+static const unsigned char* visuals_icon = raw::visuals_raw;
+}
diff --git a/tf2/identity.h b/tf2/identity.h
new file mode 100644
index 0000000..0b3906a
--- /dev/null
+++ b/tf2/identity.h
@@ -0,0 +1,12 @@
+#pragma once
+#include "sdk.h"
+//kept incase i wanna do shit here fuck you
+namespace features
+{
+	class c_identity {
+	private:
+	public:
+		void operator()( ) {
+		}
+	};
+}
+\ No newline at end of file
diff --git a/tf2/input_system.cpp b/tf2/input_system.cpp
new file mode 100644
index 0000000..881fa02
--- /dev/null
+++ b/tf2/input_system.cpp
@@ -0,0 +1,527 @@
+#include <Windows.h>
+
+#include "input_system.hpp"
+#include "util.hpp"
+
+util::c_input_manager g_input;
+
+NAMESPACE_REGION( util )
+
+const char* const key_names_short[] = {
+	"unk",
+	"m1",
+	"m2",
+	"can",
+	"m3",
+	"m4",
+	"m5",
+	"unk",
+	"back",
+	"tab",
+	"unk",
+	"unk",
+	"clr",
+	"ret",
+	"unk",
+	"unk",
+	"shift",
+	"ctrl",
+	"alt",
+	"pause",
+	"caps",
+	"kana",
+	"unk",
+	"junja",
+	"final",
+	"kanji",
+	"unk",
+	"esc",
+	"convert",
+	"nonconvert",
+	"accept",
+	"modechange",
+	" ",
+	"prior",
+	"next",
+	"end",
+	"home",
+	"left",
+	"up",
+	"right",
+	"down",
+	"slct",
+	"prnt",
+	"execute",
+	"snapshot",
+	"ins",
+	"del",
+	"help",
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"lwin",
+	"rwin",
+	"apps",
+	"unk",
+	"unk",
+	"num0",
+	"num1",
+	"num2",
+	"num3",
+	"num4",
+	"num5",
+	"num6",
+	"num7",
+	"num8",
+	"num9",
+	"*",
+	"+",
+	"sep",
+	"-",
+	",",
+	"/",
+	"f1",
+	"f2",
+	"f3",
+	"f4",
+	"f5",
+	"f6",
+	"f7",
+	"f8",
+	"f9",
+	"f10",
+	"f11",
+	"f12",
+	"f13",
+	"f14",
+	"f15",
+	"f16",
+	"f17",
+	"f18",
+	"f19",
+	"f20",
+	"f21",
+	"f22",
+	"f23",
+	"f24",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"numlock",
+	"scroll",
+	"oem_nec_equal",
+	"oem_fj_masshou",
+	"oem_fj_touroku",
+	"oem_fj_loya",
+	"oem_fj_roya",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"unk",
+	"lshift",
+	"rshift",
+	"lctrl",
+	"rctrl",
+	"lalt",
+	"ralt",
+};
+
+const char* const key_names[] = {
+	"unknown",
+	"mouse_1",
+	"mouse_2",
+	"cancel",
+	"mouse_3",
+	"mouse_4",
+	"mouse_5",
+	"unknown",
+	"back",
+	"tab",
+	"unknown",
+	"unknown",
+	"clear",
+	"return",
+	"unknown",
+	"unknown",
+	"shift",
+	"control",
+	"alt",
+	"pause",
+	"capital",
+	"kana",
+	"unknown",
+	"junja",
+	"final",
+	"kanji",
+	"unknown",
+	"escape",
+	"convert",
+	"nonconvert",
+	"accept",
+	"modechange",
+	"space",
+	"prior",
+	"next",
+	"end",
+	"home",
+	"left",
+	"up",
+	"right",
+	"down",
+	"select",
+	"print",
+	"execute",
+	"snapshot",
+	"insert",
+	"delete",
+	"help",
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"lwin",
+	"rwin",
+	"apps",
+	"unknown",
+	"unknown",
+	"numpad0",
+	"numpad1",
+	"numpad2",
+	"numpad3",
+	"numpad4",
+	"numpad5",
+	"numpad6",
+	"numpad7",
+	"numpad8",
+	"numpad9",
+	"multiply",
+	"add",
+	"separator",
+	"subtract",
+	"decimal",
+	"divide",
+	"f1",
+	"f2",
+	"f3",
+	"f4",
+	"f5",
+	"f6",
+	"f7",
+	"f8",
+	"f9",
+	"f10",
+	"f11",
+	"f12",
+	"f13",
+	"f14",
+	"f15",
+	"f16",
+	"f17",
+	"f18",
+	"f19",
+	"f20",
+	"f21",
+	"f22",
+	"f23",
+	"f24",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"numlock",
+	"scroll",
+	"oem_nec_equal",
+	"oem_fj_masshou",
+	"oem_fj_touroku",
+	"oem_fj_loya",
+	"oem_fj_roya",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"unknown",
+	"lshift",
+	"rshift",
+	"lcontrol",
+	"rcontrol",
+	"lmenu",
+	"rmenu",
+};
+
+void c_input_manager::capture_mouse_move( ulong_t lparam ) {
+	m_mouse_pos[ 0 ] = LOWORD( lparam );
+	m_mouse_pos[ 1 ] = HIWORD( lparam );
+}
+
+void c_input_manager::clear_keys( ) {
+	memset( m_pressed_keys, 0, sizeof( m_pressed_keys ) );
+}
+
+bool c_input_manager::register_key_press( int key_event, int key )
+{
+	switch ( key_event ) {
+	case KEYDOWN: {
+		if ( is_valid_key( key ) )
+			m_pressed_keys[ key ] = true;
+		return true;
+	}
+	case KEYUP: {
+		if ( is_valid_key( key ) )
+			m_pressed_keys[ key ] = false;
+		return true;
+	}
+	case SYSKEYDOWN: { //WTF IS THIS STUPID SHIT, WHY IS ALT LITERALLY THE ONLY FUCKING KEY UNDER SYSKEYDOWN OUT OF ALL THE MODIFIER KEYS?
+		if ( key == KEYS_ALT )
+			m_pressed_keys[ key ] = true;
+		break;
+	}
+	case SYSKEYUP: {
+		if ( key == KEYS_ALT )
+			m_pressed_keys[ key ] = false;
+		break;
+	}
+	case LBUTTONDOWN:
+		m_pressed_keys[ KEYS_MOUSE1 ] = true;
+		return true;
+	case LBUTTONUP:
+		m_pressed_keys[ KEYS_MOUSE1 ] = false;
+		return true;
+	case RBUTTONDOWN:
+		m_pressed_keys[ KEYS_MOUSE2 ] = true;
+		return true;
+	case RBUTTONUP:
+		m_pressed_keys[ KEYS_MOUSE2 ] = false;
+		return true;
+	case MBUTTONDOWN:
+		m_pressed_keys[ KEYS_MOUSE3 ] = true;
+		return true;
+	case MBUTTONUP:
+		m_pressed_keys[ KEYS_MOUSE3 ] = false;
+		return true;
+	case XBUTTONDOWN: {
+		bool pressed_xbutton = static_cast<bool>( HIWORD( key ) - 1 ); //should result in mouse4 as false, and mouse5 as true
+		m_pressed_keys[ pressed_xbutton ? KEYS_MOUSE5 : KEYS_MOUSE4 ] = true;
+		return true;
+	}
+	case XBUTTONUP: {
+		bool pressed_xbutton = static_cast<bool>( HIWORD( key ) - 1 ); //should result in mouse4 as false, and mouse5 as true
+		m_pressed_keys[ pressed_xbutton ? KEYS_MOUSE5 : KEYS_MOUSE4 ] = false;
+		return true;
+	}
+	case MOUSEWHEEL: {
+		short scroll_input = ( short )HIWORD( key );
+		m_scroll_wheel_state = scroll_input > 0 ? 1 : -1;
+		return true;
+	}
+	}
+
+	return key_event == 0x200 || key_event == 0x203 || key_event == 0x206 || key_event == 0x209; //gotta block WM_MOUSEFIST | WM_LBUTTONDBLCLK | WM_RBUTTONDBLCLK | WM_MBUTTONDBLCLK
+}
+
+bool c_input_manager::is_key_pressed( int key ) {
+	auto k = key;
+	return is_valid_key( k ) && m_pressed_keys[ k ];
+}
+
+const char* c_input_manager::get_key_name( int key ) {
+	if ( !is_valid_key( key ) || key > KEYS_MAX )
+		return key_names[ KEYS_NONE ];
+
+	return key_names[ key ];
+}
+
+const char* c_input_manager::get_short_name( int key ) {
+	return key_names_short[ is_valid_key( key ) ? key : KEYS_NONE ];
+}
+
+VirtualKeys_t c_input_manager::is_any_key_pressed( ) {
+	for ( size_t i{ }; i < KEYS_MAX; ++i ) {
+		if ( m_pressed_keys[ i ] ) {
+			return VirtualKeys_t( i );
+		}
+	}
+
+	return KEYS_NONE;
+}
+
+int c_input_manager::get_scroll_state( ) {
+	int current_state = m_scroll_wheel_state;
+	m_scroll_wheel_state = 0;
+	return current_state;
+}
+
+char c_input_manager::get_pressed_char( int* out ) {
+	size_t pressed_character{ };
+	for ( size_t i{ }; i < KEYS_MAX; ++i ) {
+		if ( is_key_pressed( VirtualKeys_t( i ) ) ) {
+			if ( ( i >= KEYS_A && i <= KEYS_Z )
+				|| ( i >= KEYS_N0 && i <= KEYS_N9 ) ) {
+				pressed_character = i;
+			}
+		}
+	}
+
+	if ( pressed_character ) {
+		if ( out ) {
+			*out = int( pressed_character );
+		}
+
+		if ( is_key_pressed( KEYS_SHIFT ) ) {
+			if ( pressed_character >= KEYS_A
+				&& pressed_character <= KEYS_Z )
+				return char( pressed_character );
+
+			//gay way to shift it to symbols
+			if ( pressed_character >= KEYS_N0
+				&& pressed_character <= KEYS_N9 ) {
+				switch ( pressed_character ) {
+				case KEYS_N0:
+					return ')';
+				case KEYS_N1:
+					return '!';
+				case KEYS_N2:
+					return '@';
+				case KEYS_N3:
+					return '#';
+				case KEYS_N4:
+					return '$';
+				case KEYS_N5:
+					return '%';
+				case KEYS_N6:
+					return '^';
+				case KEYS_N7:
+					return '&';
+				case KEYS_N8:
+					return '*';
+				case KEYS_N9:
+					return '(';
+				}
+			}
+		}
+		else {
+			if ( pressed_character >= KEYS_A
+				&& pressed_character <= KEYS_Z )
+				return char( ::tolower( pressed_character ) );
+
+			if ( pressed_character >= KEYS_N0
+				&& pressed_character <= KEYS_N9 )
+				return char( pressed_character );
+		}
+	}
+	else if ( is_key_pressed( KEYS_SPACE ) ) {
+		if ( out )
+			*out = KEYS_SPACE;
+		
+		return ' ';
+	}
+	else if ( is_key_pressed( KEYS_BACK ) ) {
+		if ( out )
+			*out = KEYS_BACK;
+
+		return 0;
+	}
+
+	if ( out )
+		*out = KEYS_NONE;
+
+	return 0;
+}
+
+END_REGION
+\ No newline at end of file
diff --git a/tf2/input_system.hpp b/tf2/input_system.hpp
new file mode 100644
index 0000000..6631a09
--- /dev/null
+++ b/tf2/input_system.hpp
@@ -0,0 +1,185 @@
+#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 );
+
+		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/tf2/interfaces.cpp b/tf2/interfaces.cpp
new file mode 100644
index 0000000..8ca7ff3
--- /dev/null
+++ b/tf2/interfaces.cpp
@@ -0,0 +1,241 @@
+#include "interfaces.h"
+#include "console.hpp"
+#include "hooks.h"
+#include "renderer.hpp"
+#include "pattern.hpp"
+#include "base_cheat.h"
+#include "settings.h"
+#include "ctx.hpp"
+#include "netvars.h"
+#include <thread>
+
+tf2::client cl;
+tf2::interfaces::c_interface_manager g_factory;
+
+bool tf2::create_interfaces( client *instance )
+{
+	if ( !instance ) {
+		return false;
+	}
+
+	
+
+	auto d3d_device = pattern::first_code_match( GetModuleHandleA( xors( "shaderapidx9.dll" ) ),
+		xors( "A1 ?? ?? ?? ?? 50 8B 08 FF 51 0C" ) ) + 0x1;
+
+	auto move_helper = pattern::first_code_match( GetModuleHandleA( xors( "client.dll" ) ),
+		xors( "8B 0D ?? ?? ?? ?? 8B 46 08 68" ) ) + 0x2;
+
+	//sig to containing function: (+0x69) E9 ? ? ? ? CC 55 8B EC 5D 
+	//auto beam_ptr = pattern::first_code_match( GetModuleHandleA( xors( "client.dll" ) ), xors( "" ) ); 
+
+	//g_con->print( "beam_found: 0x%08x\n", beam_ptr );
+
+	instance->create( &instance->m_d3d, **reinterpret_cast< uintptr_t** >( d3d_device ) );
+	instance->create( &instance->m_movehelper, **reinterpret_cast< uintptr_t** >( move_helper ) );
+	//instance->create( &instance->m_beams, *reinterpret_cast< uintptr_t* >( beam_ptr ) );
+
+
+	/*
+	
+
+	important
+
+	issues:
+
+	the background is white but so am i so really this isnt an issue
+
+	THIS ENTIRE THING IS MESSY AND RIDDLED WITH SHIT COMMENTS AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+
+	chams
+
+	fucking keyvalues
+
+	glow count aint happy cbf looking into it
+
+	menu goes invis because ????? gj menu
+
+	too lazy to fix d3d
+
+	emitsound hook is different
+
+	aimbot is meh meh rn
+
+
+	lots of stuff not done that i want to get done, just wanna get it out there so i can keep working on it and not get harrased for the push
+
+
+
+
+	
+	*/
+
+	//tf2::interfaces::interface_manager factory;
+	instance->create( &instance->m_chl, xors( "VClient" ) );
+	instance->create( &instance->m_vgui, xors( "VEngineVGui" ) );
+	instance->create( &instance->m_surface, xors( "VGUI_Surface" ) );
+	instance->create( &instance->m_input, xors( "InputSystemVersion" ) );
+	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_movement, xors( "GameMovement" ) );
+	instance->create( &instance->m_modelinfo, xors( "VModelInfoClient" ) );
+	instance->create( &instance->m_overlay, "VDebugOverlay" );
+	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_engine_sound, xors( "IEngineSoundClient" ) );
+	instance->create( &instance->m_event_mgr, xors( "GAMEEVENTSMANAGER002" ) );
+	instance->create( &instance->m_string_table, xors( "VEngineClientStringTable" ) );
+	instance->create( &instance->m_clientmode, **reinterpret_cast< uintptr_t** >( instance->m_chl->get_function( 10 ) + 5 ) );
+
+	instance->m_globals = *reinterpret_cast< CGlobalVarsBase** >( pattern::first_code_match( instance->m_engine.dll( ), "A1 ? ? ? ? 8B 11 68", 0x8 ) );
+
+	uintptr_t* input = *reinterpret_cast< uintptr_t** >(
+		instance->m_chl->get_old_function( 1 ) + 0x1 );
+	instance->m_hl_input = reinterpret_cast< CInput* >( input );
+
+	auto kv_fn = ( void*( __cdecl* )( ) )( GetProcAddress(
+		GetModuleHandleA( xors( "vstdlib.dll" ) ),
+		xors( "KeyValuesSystem" ) ) );
+
+	instance->m_keyvalues = ( IKeyValuesSystem* )kv_fn( );
+	instance->listeners.player_hurt.init( );
+
+	return true;
+}
+
+con_fn clear_fn{ fnv( "clear" ), [ ]( const char*, const char* ) { g_con->m_logs.clear( ); }, "" };
+con_fn enable_logs_fn{ fnv( "log_enable" ),
+[ ]( const char* a, const char* ) {
+	g_settings.menu.logs_enable ^= 1;
+	g_con->log( g_settings.menu.logs_enable ? xors( "logs enabled" ) : xors( "logs disabled" ) );
+},
+""
+};
+
+con_fn fnv_fn{ fnv( "fnv" ),
+[ ]( const char* a, const char* ) {
+	auto print = hash::fnv1a( a );
+	g_con->log( "%08x", print );
+},
+"%S"
+};
+
+con_fn sum_fn{ fnv( "sum" ),
+[ ]( const char* a, const char* syntax ) {
+	auto arg_1 = con_fn::get_arg< int >( a, 0, syntax );
+	auto arg_2 = con_fn::get_arg< int >( a, 1, syntax );
+	g_con->log( "%d + %d = %d", arg_1, arg_2, arg_1 + arg_2 );
+},
+"%D %D"
+};
+
+con_fn dump_cfg{ fnv( "dump_cfg" ),
+[ ]( const char* , const char* ) {
+	for( auto& it : data::holder_.get_nodes( ) ) {
+		auto setting = static_cast< ISetting* >( it );
+		g_con->log( "%08x: %s", setting->get_hash( ), setting->get_string( ).c_str( ) );
+	}
+},
+""
+};
+
+con_fn retard_fn{ fnv( "retard" ),
+[ ]( const char*, const char* ) {
+	g_con->log( "snuze" );
+},
+""
+};
+
+con_fn unload_fn{ fnv( "unload" ),
+[ ]( const char*, const char* ) {
+	cl.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 tf2::client::initialize( ) {
+	//m_panic = true;
+	g_con->create( );
+	auto now = std::chrono::high_resolution_clock::now( );
+	g_con->print( xors( "hello\n" ) );
+	//hi
+	//bye
+
+	tf2::create_interfaces( &cl );
+	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( &cl );
+
+	//g_cheat.chams.m_materials.initialize_materials( );
+
+
+	auto offset = g_netvars.get_netvar( fnv( "DT_WeaponTFBaseGun" ), fnv( "m_fLastShotTime" ) );
+	g_con->log( "lastshottime: %08x", offset );
+	g_con->log( "prop: %08x", g_netvars.get_prop( fnv( "DT_WeaponTFBaseGun" ), fnv( "m_fLastShotTime" ) ) );
+
+	auto after = std::chrono::high_resolution_clock::now( );
+	std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
+
+	std::chrono::duration< float > delta = after - now;
+	g_con->log( xors( "cheat initialized\n" ) );
+	g_con->log( xors( "time taken: %f\n" ), delta.count( ) );
+
+
+
+	m_panic = false;
+}
+
+void tf2::client::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.chams.m_materials.destroy_materials( );
+
+	//restore all interfaces
+	restore( );
+
+	Sleep( 100 );
+
+	//free the library
+	FreeLibraryAndExitThread( g_dll, 0 );
+}
+\ No newline at end of file
diff --git a/tf2/interfaces.h b/tf2/interfaces.h
new file mode 100644
index 0000000..96e3be1
--- /dev/null
+++ b/tf2/interfaces.h
@@ -0,0 +1,160 @@
+#pragma once
+
+#include <memory>
+#include "sdk.h"
+#include "vmt.h"
+#include "ctx.hpp"
+#include "listener.hpp"
+#include "factory.h"
+struct IDirect3DDevice9;
+namespace tf2
+{
+template < typename t >
+class interface_base {
+	friend class client;
+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;
+};
+
+
+	class client {
+	public:
+		interface_base< IEngineVGui >			m_vgui;
+		interface_base< IClientMode >			m_clientmode;
+		interface_base< IEngineTrace >			m_trace;
+		interface_base< IVEngineClient >		m_engine;
+		interface_base< IInputSystem >			m_input;
+		interface_base< chl_client >			m_chl;
+		interface_base< IVDebugOverlay >		m_overlay;
+		interface_base< client_ent_list >		m_entlist;
+		interface_base< IPlayerInfoManager >	m_playerinfo;
+		interface_base< ISurface >				m_surface;
+		interface_base< IPanel >				m_panel;
+		interface_base< ICVar >					m_cvar;
+		interface_base< IVRenderView >			m_renderview;
+		interface_base< IPrediction >			m_prediction;
+		interface_base< IGameMovement >			m_movement;
+		interface_base< IVModelInfo >			m_modelinfo;
+		interface_base< uintptr_t >				m_d3d;
+		interface_base< IVModelRender >			m_model_render;
+		interface_base< IVRenderView >			m_render_view;
+		interface_base< uintptr_t >				m_engine_sound;
+		interface_base< IGameEventManager2 >	m_event_mgr;
+		interface_base< IMaterialSystem >		m_mat_system;
+		interface_base< CStringTable >			m_string_table;
+		interface_base< IViewRenderBeams >		m_beams;
+		IKeyValuesSystem*						 m_keyvalues;
+		CGlobalVarsBase*						m_globals;
+		IMoveHelper*							m_movehelper;
+		CInput*									m_hl_input;
+		bool									m_panic;
+		HWND									m_hwnd{ };
+		float									m_frametime;
+
+		struct {
+			generic_listener_t player_hurt{ xors( "player_hurt" ), &listeners::player_hurt };
+		} 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< 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< 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< 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< interface_base< uintptr_t >* > m_container;
+	};
+
+	bool create_interfaces( client * );
+}
+
+extern tf2::client cl;
diff --git a/tf2/listener.cpp b/tf2/listener.cpp
new file mode 100644
index 0000000..c48b900
--- /dev/null
+++ b/tf2/listener.cpp
@@ -0,0 +1,42 @@
+#include "listener.hpp"
+#include "interfaces.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+#include "settings.h"
+#undef PlaySound
+
+//how can you listen if youre deaf
+
+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 )
+		cl.m_event_mgr( )->RemoveListener( this );
+
+}
+
+void generic_listener_t::init( ) {
+	cl.m_event_mgr( )->AddListener( this, m_name, false );
+	m_registered = true;
+}
+
+namespace listeners
+{
+
+	void player_hurt( IGameEvent* e ) {
+		if( !cl.m_panic && e ) {
+			int user_id = e->GetInt( xors( "userid" ) );
+			int attacker = e->GetInt( xors( "attacker" ) );
+			int attacker_id = cl.m_engine( )->GetPlayerForUserID( attacker );
+			int player_id = cl.m_engine( )->GetPlayerForUserID( user_id );
+
+
+			//if( attacker_id == cl.m_engine( )->GetLocalPlayer( ) && user_id != attacker_id ) {
+				g_cheat.visuals.store_hit( );
+
+			//}
+		}
+	}
+
+}
+\ No newline at end of file
diff --git a/tf2/listener.hpp b/tf2/listener.hpp
new file mode 100644
index 0000000..1ee442f
--- /dev/null
+++ b/tf2/listener.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include "sdk.h"
+
+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 player_hurt( IGameEvent* e );
+}
+\ No newline at end of file
diff --git a/tf2/math.cpp b/tf2/math.cpp
new file mode 100644
index 0000000..e3e7436
--- /dev/null
+++ b/tf2/math.cpp
@@ -0,0 +1,267 @@
+#include <xmmintrin.h>  
+#include "math.h"
+#include "interfaces.h"
+
+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 >( cl.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 ] = {
+		{ 0xFFFFFFFF, 0, 0, 0 },
+	{ 0, 0xFFFFFFFF, 0, 0 },
+	{ 0, 0, 0xFFFFFFFF, 0 },
+	{ 0, 0, 0, 0xFFFFFFFF }
+	};
+
+	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 __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/tf2/math.h b/tf2/math.h
new file mode 100644
index 0000000..c5a107f
--- /dev/null
+++ b/tf2/math.h
@@ -0,0 +1,157 @@
+#pragma once
+#include <random>
+#include "util.hpp"
+#include "pattern.hpp"
+#include "sdk.h"
+
+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 )... );
+}
+
+// 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 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/tf2/mem.hpp b/tf2/mem.hpp
new file mode 100644
index 0000000..22e8fbf
--- /dev/null
+++ b/tf2/mem.hpp
@@ -0,0 +1,66 @@
+#pragma once
+#include <intrin.h>
+#include "util.hpp"
+
+#define get_baseptr( ) ( ( uintptr_t )( _AddressOfReturnAddress( ) ) - sizeof( uintptr_t ) )
+
+class stack_t {
+	uintptr_t m_ptr;
+
+public:
+	__forceinline stack_t( ) : m_ptr( get_baseptr( ) ) { }
+
+	__forceinline stack_t( uintptr_t ptr ) : m_ptr( ptr ) { }
+
+	template < typename t = uintptr_t >
+	__forceinline t get( ) {
+		return ( t )m_ptr;
+	}
+
+	template < typename t = uintptr_t >
+	__forceinline t return_address( ) {
+		return *( t* )( m_ptr + sizeof( void* ) );
+	}
+
+	template < typename t = uintptr_t >
+	__forceinline t address_of_return_address( ) {
+		return ( t )( m_ptr + sizeof( uintptr_t ) );
+	}
+
+	__forceinline stack_t& next( ) {
+		return *( stack_t* )( m_ptr );
+	}
+
+	template < typename t = uintptr_t >
+	__forceinline t local( size_t at ) {
+		return ( t )( m_ptr - at );
+	}
+
+	template < typename t = uintptr_t >
+	__forceinline t arg( size_t at ) {
+		return ( t )( m_ptr + at );
+	}
+};
+
+namespace util {
+	template < typename t = uint8_t >
+	__forceinline t* memcpy( t* dst, t* src, size_t size = sizeof( t ) ) {
+		__movsb(
+			( uint8_t* )dst,
+			( uint8_t* )src,
+			size
+		);
+
+		return dst;
+	}
+
+	__forceinline void* memset( uint8_t* dst, uint8_t val, size_t size ) {
+		__stosb(
+			dst,
+			val,
+			size
+		);
+
+		return dst;
+	}
+}
+\ No newline at end of file
diff --git a/tf2/movement.cpp b/tf2/movement.cpp
new file mode 100644
index 0000000..e1dd335
--- /dev/null
+++ b/tf2/movement.cpp
@@ -0,0 +1,41 @@
+#include "movement.h"
+#include "interfaces.h"
+#include "settings.h"
+
+namespace features {
+	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 -> WELL THERES FUCKING HATS IN THIS GAME ISNT THERE CUNT
+		if( m_cmd->m_buttons & IN_JUMP && !( g_ctx.m_local->m_fFlags( ) & FL_ONGROUND ) ) {
+			m_cmd->m_buttons &= ~IN_JUMP;
+		}
+	}
+
+
+	//ehhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh lazy
+	void c_movement::autostrafe( ) {
+		if( !g_settings.misc.auto_strafe )
+			return;
+
+		float velocity = g_ctx.m_local->m_vecVelocity( ).length2d( );
+		auto cmd = g_ctx.get_last_cmd( );
+
+		if( cmd && m_cmd->m_buttons & IN_JUMP && velocity > 1.0f ) {
+			if( !cmd->m_forwardmove && !cmd->m_sidemove ) {
+				if( !cmd->m_mousedx ) {
+					cmd->m_forwardmove = std::min< float >( 450.f, 5850.f / velocity );
+					cmd->m_sidemove = ( m_cmd->m_cmd_nr % 2 ) == 0 ? -450.f : 450.f;
+				}
+				else {
+					cmd->m_sidemove = m_cmd->m_mousedx < 0.f ? -450.f : 450.f;
+				}
+			}
+		}
+	}
+}
diff --git a/tf2/movement.h b/tf2/movement.h
new file mode 100644
index 0000000..d32fb2b
--- /dev/null
+++ b/tf2/movement.h
@@ -0,0 +1,19 @@
+#pragma once
+#include "sdk.h"
+
+namespace features {
+	class c_movement {
+	public:
+		void update( user_cmd_t* cmd ) {
+			if ( !cmd ) return;
+			m_cmd = cmd;
+
+			bhop( );
+		}
+
+	private:
+		void bhop( );
+		void autostrafe( );
+		user_cmd_t* m_cmd;
+	};
+}
+\ No newline at end of file
diff --git a/tf2/netvar_proxy.hpp b/tf2/netvar_proxy.hpp
new file mode 100644
index 0000000..ea18a4d
--- /dev/null
+++ b/tf2/netvar_proxy.hpp
@@ -0,0 +1,37 @@
+#pragma once
+#include "dt_recv.h"
+
+//dont leave things out of namespaces
+namespace hooks
+{
+	class c_netvar_proxy {
+	public:
+		c_netvar_proxy( RecvProp* target_property, RecvVarProxyFn new_proxy ) {
+			m_target = target_property;
+			m_original = target_property->m_ProxyFn;
+			m_target->m_ProxyFn = new_proxy;
+		}
+
+		c_netvar_proxy( ) = default;
+
+		void init( RecvProp* target, RecvVarProxyFn new_proxy ) {
+			m_target = target;
+			m_original = target->m_ProxyFn;
+			m_target->m_ProxyFn = new_proxy;
+		}
+
+		~c_netvar_proxy( ) {
+			if( !m_target ) return;
+			m_target->m_ProxyFn = m_original;
+		}
+
+		RecvVarProxyFn get_old_function( ) const {
+			return m_original;
+		}
+
+	private:
+		//overcomplicated...
+		RecvProp * m_target;
+		RecvVarProxyFn m_original;
+	};
+}
+\ No newline at end of file
diff --git a/tf2/netvars.cpp b/tf2/netvars.cpp
new file mode 100644
index 0000000..2a064bd
--- /dev/null
+++ b/tf2/netvars.cpp
@@ -0,0 +1,93 @@
+#include "netvars.h"
+#include "interfaces.h"
+
+tf2::c_netvars g_netvars;
+
+NAMESPACE_REGION( tf2 )
+
+void c_netvars::init( ) {
+	for( auto client_class = cl.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/tf2/netvars.h b/tf2/netvars.h
new file mode 100644
index 0000000..54b92be
--- /dev/null
+++ b/tf2/netvars.h
@@ -0,0 +1,44 @@
+#pragma once
+#include <vector>
+
+#include "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( tf2 )
+
+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 tf2::c_netvars g_netvars;
+\ No newline at end of file
diff --git a/tf2/on_screen_size_changed.cpp b/tf2/on_screen_size_changed.cpp
new file mode 100644
index 0000000..580e2db
--- /dev/null
+++ b/tf2/on_screen_size_changed.cpp
@@ -0,0 +1,9 @@
+#include "hooks.h"
+
+void __fastcall hooks::on_screen_size_changed( void* ecx_, void* edx_, int old_w, int old_h ) {
+	static auto old_fn = cl.m_surface->get_old_function< decltype( &hooks::on_screen_size_changed ) >( 116 );
+
+	old_fn( ecx_, nullptr, old_w, old_h );
+
+	g_fonts.initialize( );
+}
+\ No newline at end of file
diff --git a/tf2/override_mouse_input.cpp b/tf2/override_mouse_input.cpp
new file mode 100644
index 0000000..d3a4b9b
--- /dev/null
+++ b/tf2/override_mouse_input.cpp
@@ -0,0 +1,14 @@
+#include "hooks.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+
+void __fastcall hooks::override_mouse_input( void* ecx_, void* edx_, float* x, float* y ) {
+	static auto omi_o = cl.m_clientmode->get_old_function< decltype( &hooks::override_mouse_input ) >( 20 );
+	omi_o( ecx_, edx_, x, y );
+
+	if( cl.m_panic ) return;
+
+	if( g_ctx.run_frame( ) && g_ctx.m_local->is_alive( ) ) {
+		g_cheat.aim( x, y );
+	}
+}
+\ No newline at end of file
diff --git a/tf2/override_view.cpp b/tf2/override_view.cpp
new file mode 100644
index 0000000..2e22e58
--- /dev/null
+++ b/tf2/override_view.cpp
@@ -0,0 +1,17 @@
+#include "base_cheat.h"
+#include "ctx.hpp"
+#include "hooks.h"
+#include "settings.h"
+void __fastcall hooks::override_view( void* ecx_, void* edx_, CViewSetup* setup ) {
+	static auto override_view_o = cl.m_clientmode->get_old_function< decltype( &hooks::override_view ) >( 16 );
+	if( cl.m_panic ) {
+		return override_view_o( ecx_, nullptr, setup );
+	}
+
+	g_ctx.m_fov = setup->m_flFov;
+	if( g_ctx.run_frame( ) && g_ctx.m_local->is_valid( ) ) {
+		setup->m_flFov = g_settings.misc.fov_changer( );
+	}
+	g_cheat.extra.thirdperson( );
+	override_view_o( ecx_, nullptr, setup );
+}
+\ No newline at end of file
diff --git a/tf2/paint.cpp b/tf2/paint.cpp
new file mode 100644
index 0000000..144847b
--- /dev/null
+++ b/tf2/paint.cpp
@@ -0,0 +1,51 @@
+#include "hooks.h"
+#include "interfaces.h"
+#include "search.h"
+#include "graphics.h"
+#include "settings.h"
+#include "base_cheat.h"
+
+
+void __fastcall hooks::paint_traverse( void *ecx_, void *edx_, unsigned int panel, bool forcerepaint, bool allowforce ) {
+	static auto paint_o = cl.m_panel->get_old_function< decltype( hooks::paint_traverse )* >( 41 );
+	paint_o( ecx_, edx_, panel, forcerepaint, allowforce );
+
+	if ( cl.m_panic /*|| !g_ctx->run_frame( ) this will disable esp when dead u dummie!!!*/ ) {
+		return;
+	}
+
+	static uint32_t focus_overlay_panel{ };
+	if ( !focus_overlay_panel ) {
+		std::string panelname( cl.m_panel( )->GetName( panel ) );
+		if ( panelname.find( "FocusOverlayPanel" ) != std::string::npos ) { //matsystemtoppanel is glitched the fuck out in tf2
+			focus_overlay_panel = panel;									//hovewer this draws on shit other than the main screen
+		}																	//so we should get paint working
+	}
+
+	if ( panel == focus_overlay_panel ) { //i still wonder why dont we do this in paint
+		//dank 2007 esp here
+		cl.m_panel( )->SetMouseInputEnabled( panel, g_settings.menu.open || g_con->m_open );
+	}
+}
+
+void __fastcall hooks::paint( void* ecx_, void* edx_, int mode ) {
+	static auto engine_paint_o = cl.m_vgui->get_old_function< decltype( hooks::paint )* >( 13 );
+	static auto start_d = pattern::first_code_match< void( __thiscall* )( void* ) >( cl.m_surface.dll( ), "55 8B EC 64 A1 ? ? ? ? 6A FF 68 ? ? ? ? 50 64 89 25 ? ? ? ? 83 EC 14" );
+	static auto finish_d = pattern::first_code_match< void( __thiscall* )( void* ) >( cl.m_surface.dll( ), "55 8B EC 6A FF 68 ? ? ? ? 64 A1 ? ? ? ? 50 64 89 25 ? ? ? ? 51 56 6A 00" );
+
+	engine_paint_o( ecx_, edx_, mode );
+
+	if ( cl.m_panic ) return;
+
+	if ( mode & PAINT_UIPANELS ) {
+		start_d( cl.m_surface( ) );
+
+		//did you say lazy?
+
+		g_renderer.draw_box( 0, 0, 1, 1, clr_t( 0, 0, 0, 1 ) );
+		if( !g_settings.misc.hide_from_obs )
+			g_cheat.visuals( );
+
+		finish_d( cl.m_surface( ) );
+	}
+}
+\ No newline at end of file
diff --git a/tf2/pattern.hpp b/tf2/pattern.hpp
new file mode 100644
index 0000000..0bc4b1b
--- /dev/null
+++ b/tf2/pattern.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <Windows.h>
+#include <stdio.h>
+#include <Psapi.h>
+#include <vector>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+
+#pragma warning ( disable : 4018 )
+
+namespace pattern
+{
+	inline bool bin_match( uint8_t* code, uint8_t* pattern, size_t size ) {
+		for( size_t j = 0; j < size; j++ ) {
+			if( pattern[ j ] && code[ j ] != pattern[ j ] ) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	template< typename t = uintptr_t > static t first_match( uintptr_t start, std::string sig, size_t len, std::ptrdiff_t offset = 0 ) {
+		std::istringstream iss( sig );
+		std::vector< std::string > tokens{ std::istream_iterator< std::string >{ iss }, std::istream_iterator< std::string >{} };
+		std::vector< uint8_t > sig_bytes;
+
+		for( const auto& hex_byte : tokens ) {
+			sig_bytes.push_back( static_cast< uint8_t >( std::strtoul( hex_byte.c_str( ), nullptr, 16 ) ) );
+		}
+
+		if( sig_bytes.empty( ) || sig_bytes.size( ) < 2 ) {
+			return t{ };
+		}
+
+		auto sig_data = sig_bytes.data( );
+		auto sig_size = sig_bytes.size( );
+
+		for( size_t i{ }; i < len; i++ ) {
+			uint8_t* code_ptr = reinterpret_cast< uint8_t* >( start + i );
+
+			if( bin_match( code_ptr, sig_data, sig_size ) ) {
+				return( ( t )( start + i + offset ) );
+			}
+		}
+
+		return t{ };
+	}
+
+	//ultimately the function you want to call to sigscan ( ida style )
+	template< typename t = uintptr_t > static t first_code_match( HMODULE start, std::string sig, std::ptrdiff_t offset = 0 ) {
+		auto dos_hdr = reinterpret_cast< PIMAGE_DOS_HEADER >( start );
+
+		if( !dos_hdr ) return t{ };
+
+		//DOS header, verifies if module is valid
+		if( dos_hdr->e_magic != 0x5a4d ) {
+			return t{ };
+		}
+
+		auto nt_hdrs = reinterpret_cast< PIMAGE_NT_HEADERS >( reinterpret_cast< uintptr_t >( dos_hdr ) + dos_hdr->e_lfanew );
+
+		return first_match< t >( reinterpret_cast< uintptr_t >( dos_hdr ) + nt_hdrs->OptionalHeader.BaseOfCode, sig, nt_hdrs->OptionalHeader.SizeOfCode, offset );
+	}
+};
+\ No newline at end of file
diff --git a/tf2/prediction.cpp b/tf2/prediction.cpp
new file mode 100644
index 0000000..c9e2493
--- /dev/null
+++ b/tf2/prediction.cpp
@@ -0,0 +1,70 @@
+#include "prediction.h"
+#include "sdk.h"
+#include "interfaces.h"
+
+void features::c_prediction::run_prediction( user_cmd_t* cmd ) {
+	static uintptr_t addr_of_runcommand = cl.m_prediction->get_function( 17 );
+	static uint32_t pseudo_random_offset = pattern::first_code_match( cl.m_chl.dll( ), "55 8B EC 8B 45 08 85 C0 75 0C", 0x1 );
+	static char* move_data = reinterpret_cast< char* >( malloc( 0x256 ) );
+
+	if ( !cmd || !g_ctx.m_local ) return;
+
+	int flags = g_ctx.m_local->get_flags( );
+	int cmd_buttons = cmd->m_buttons;
+
+	auto set_random_seed = reinterpret_cast< void( __cdecl* )( uint32_t ) >( pseudo_random_offset );
+
+	*reinterpret_cast< user_cmd_t** >( uintptr_t( g_ctx.m_local ) + 0x107c ) = cmd;
+
+	if ( cmd->m_impulse ) {
+		*reinterpret_cast< uint8_t* >( uintptr_t( g_ctx.m_local ) + 0x1124 ) = cmd->m_impulse;
+	}
+
+	/*void __cdecl SetButtonState(int a1)
+	{
+	int v1; // ecx@0
+	int v2; // edx@1
+
+	 v2 = a1 ^ *(_DWORD *)(v1 + 0x1078);
+	*(_DWORD *)(v1 + 0x106C) = *(_DWORD *)(v1 + 0x1078);
+	*(_DWORD *)(v1 + 0x1078) = a1;
+	 *(_DWORD *)(v1 + 0x1070) = a1 & v2;
+	 *(_DWORD *)(v1 + 0x1074) = v2 & ~a1;
+	}*/
+	auto v2 = cmd->m_buttons ^ *reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x1078 );
+
+	*reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x106c ) = *reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x1078 );
+	*reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x1078 ) = cmd->m_buttons;
+	*reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x1070 ) = cmd->m_buttons & v2;
+	*reinterpret_cast< int* >( uintptr_t( g_ctx.m_local ) + 0x1074 ) = v2 &~ cmd->m_buttons;
+
+	cl.m_globals->curtime = g_ctx.m_local->get_tick_base( ) * cl.m_globals->interval_per_tick;
+	cl.m_globals->frametime = cl.m_globals->interval_per_tick;
+
+	set_random_seed( cmd->m_random_seed );
+	**reinterpret_cast< uintptr_t** >( addr_of_runcommand + 0x2b + 0x2 ) = uintptr_t( g_ctx.m_local );
+
+	cl.m_movement( )->StartTrackPredictionErrors( reinterpret_cast< uintptr_t* >( g_ctx.m_local ) );
+
+	int tick_base = g_ctx.m_local->get_tick_base( );
+
+	static auto setup_move = cl.m_prediction->get_function< void( __thiscall* )( void*, c_base_player*, user_cmd_t*, IMoveHelper*, CMoveData* ) >( 18 );
+	static auto finish_move = cl.m_prediction->get_function< void( __thiscall* )( void*, c_base_player*, user_cmd_t*, CMoveData* ) >( 19 );
+	setup_move( cl.m_prediction( ), g_ctx.m_local, cmd, cl.m_movehelper, reinterpret_cast< CMoveData* >( move_data ) );
+	cl.m_movement( )->ProcessMovement( reinterpret_cast< uintptr_t* >( g_ctx.m_local ), reinterpret_cast< CMoveData* >( move_data ) );
+	finish_move( cl.m_prediction( ), g_ctx.m_local, cmd, reinterpret_cast< CMoveData* >( move_data ) );
+
+	g_ctx.m_local->m_nTickBase( );
+
+	cl.m_movement( )->FinishTrackPredictionErrors( reinterpret_cast< uintptr_t* >( g_ctx.m_local ) );
+
+	set_random_seed( 0xfffffff );
+	**reinterpret_cast< uintptr_t*** >( addr_of_runcommand + 0x2b + 0x2 ) = nullptr;
+	*reinterpret_cast< user_cmd_t** >( uintptr_t( g_ctx.m_local ) + 0x107c ) = nullptr;
+
+	cl.m_globals->curtime = g_ctx.m_local->get_tick_base( ) * cl.m_globals->interval_per_tick;
+	cl.m_globals->frametime = cl.m_globals->interval_per_tick;
+
+	g_ctx.m_local->m_nTickBase( );
+	cmd->m_buttons = cmd_buttons;
+}
+\ No newline at end of file
diff --git a/tf2/prediction.h b/tf2/prediction.h
new file mode 100644
index 0000000..e71ac24
--- /dev/null
+++ b/tf2/prediction.h
@@ -0,0 +1,10 @@
+#pragma once
+class user_cmd_t;
+class c_base_player;
+namespace features
+{
+	class c_prediction {
+	public:
+		void run_prediction( user_cmd_t* cmd );
+	};
+}
+\ No newline at end of file
diff --git a/tf2/process_movement.cpp b/tf2/process_movement.cpp
new file mode 100644
index 0000000..c6f186e
--- /dev/null
+++ b/tf2/process_movement.cpp
@@ -0,0 +1,12 @@
+#include "hooks.h"
+#include "interfaces.h"
+
+void __fastcall hooks::process_movement( void* thisptr, void* edx_, c_base_player* player, CMoveData* move ) {
+	static auto old_fn = cl.m_movement->get_old_function< decltype( hooks::process_movement )* >( 1 );
+
+	if ( cl.m_input( )->IsButtonDown( MOUSE_MIDDLE ) ) {
+		move->m_outStepHeight = -1.0f;
+	}
+
+	return old_fn( thisptr, edx_, player, move );
+}
+\ No newline at end of file
diff --git a/tf2/projectile_pred.cpp b/tf2/projectile_pred.cpp
new file mode 100644
index 0000000..c54f712
--- /dev/null
+++ b/tf2/projectile_pred.cpp
@@ -0,0 +1,70 @@
+#include "projectile_pred.h"
+#include "sdk.h"
+#include "interfaces.h"
+
+namespace util
+{
+
+	vec3_t c_projectile_pred::predict_player( c_base_player* player ) {
+		if ( !player || !player->is_valid( ) ) return vec3_t{ };
+
+		static auto sv_gravity = cl.m_cvar( )->FindVar( "sv_gravity" ); //unnecessary for now
+		auto local = g_ctx.m_local;								//will be used for stuff like grenades
+																		//will also need to calculate friction etc
+		auto weapon = local->get_active_weapon( );
+		if ( !weapon ) return player->get_origin( );
+
+		float projectile_speed = get_projectile_speed( weapon );
+
+		vec3_t player_vel = player->get_velocity( );
+		vec3_t projectile_vel = vec3_t( );
+
+		float estimated_travel_time = ( local->get_eye_pos( ) - player->get_origin( ) ).length( ) / projectile_speed + cl.m_globals->interval_per_tick;
+		vec3_t estimated_predicted_pos = player->get_origin( ) + player_vel * estimated_travel_time;
+
+		return estimated_predicted_pos;
+	}
+
+	float c_projectile_pred::get_projectile_speed( c_base_weapon* weapon ) {
+		if ( !weapon )
+			return -1.f;
+		/*
+			this is completely hardcoded
+			if you can find a better way to figure this out
+			then please tell me
+			-- nave
+		*/
+
+		int id = weapon->GetClientClass( )->m_class_id;
+
+		float BeginCharge;
+		float Charge;
+
+		//return flSpeed;
+		switch ( id ) {
+		case ClientClassIDs::CTFGrenadeLauncher:
+			return 840.0f;
+		case ClientClassIDs::CTFRocketLauncher_DirectHit:
+			return 1980.0f;
+		case ClientClassIDs::CTFRocketLauncher:
+		case ClientClassIDs::CTFRocketLauncher_Mortar:
+			return 1100.0f;
+		case ClientClassIDs::CTFFlareGun:
+			return 1450.0f;
+		case ClientClassIDs::CTFBat_Wood:
+			return 1940.0f;
+		case ClientClassIDs::CTFSyringeGun:
+			return 990.0f;
+		case ClientClassIDs::CTFCompoundBow: {
+			return 0.f; //need more shit, cba now
+		}
+
+		default:
+			return -1.0f;
+		}
+
+		return -1.0f;
+	}
+}
+
+util::c_projectile_pred projectile_pred;
+\ No newline at end of file
diff --git a/tf2/projectile_pred.h b/tf2/projectile_pred.h
new file mode 100644
index 0000000..bd1b3d8
--- /dev/null
+++ b/tf2/projectile_pred.h
@@ -0,0 +1,15 @@
+#pragma once
+class c_base_weapon;
+class c_base_player;
+class vec3_t;
+namespace util 
+{
+	class c_projectile_pred {
+	public:
+		vec3_t predict_player( c_base_player* );
+	private:
+		float get_projectile_speed( c_base_weapon* );
+	};
+}
+
+extern util::c_projectile_pred projectile_pred;
+\ No newline at end of file
diff --git a/tf2/renderer.cpp b/tf2/renderer.cpp
new file mode 100644
index 0000000..8f5e8e7
--- /dev/null
+++ b/tf2/renderer.cpp
@@ -0,0 +1,93 @@
+#include "renderer.hpp"
+#include "interfaces.h"
+
+#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 = cl.m_surface( )->CreateFnt( );
+	cl.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 ) {
+	cl.m_surface( )->DrawSetTextPos( x, y );
+	cl.m_surface( )->DrawSetTextFont( font );
+	cl.m_surface( )->DrawSetTextColor( color );
+	cl.m_surface( )->DrawPrintText( text, wcslen( text ) );
+}
+
+void c_drawings::draw_rect( int x, int y, int w, int h, const clr_t& color ) {
+	cl.m_surface( )->DrawSetColor( color );
+	cl.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 ) {
+	cl.m_surface( )->DrawSetColor( clr );
+	cl.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 ) {
+	cl.m_surface( )->DrawSetColor( col );
+	cl.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 = cl.m_surface( )->CreateNewTextureID( true );
+
+	clr_t buf( 255, 255, 255 );
+
+	cl.m_surface( )->DrawSetTextureRGBA( texture, ( byte* )( &buf ), 1, 1 );
+	cl.m_surface( )->DrawSetColor( col );
+	cl.m_surface( )->DrawSetTexture( texture );
+
+	cl.m_surface( )->DrawTexturedPolygon( count, vertices );
+}
+
+END_REGION
+\ No newline at end of file
diff --git a/tf2/renderer.hpp b/tf2/renderer.hpp
new file mode 100644
index 0000000..1c86511
--- /dev/null
+++ b/tf2/renderer.hpp
@@ -0,0 +1,120 @@
+#pragma once
+#include <stdio.h>
+#include <stdarg.h>
+#include <vector>
+
+#include "util.hpp"
+#include "sdk.h"
+
+enum e_font_style : size_t {
+
+};
+
+enum FontAlign_t : size_t {
+	ALIGN_CENTER,
+	ALIGN_LEFT,
+	ALIGN_RIGHT
+};
+
+NAMESPACE_REGION( drawings )
+
+
+class c_fonts {
+protected:
+	struct font_t {
+		friend class c_fonts;
+		font_t( std::string name, int size,
+			int weight, ulong_t flags );
+
+		operator HFont( ) {
+			return m_font;
+		}
+
+	private:
+		void initialize( );
+
+		HFont		m_font;
+		std::string m_name;
+		int			m_size;
+		int			m_weight;
+		ulong_t		m_flags;
+	};
+
+	std::vector< font_t* > m_container;
+	friend struct c_fonts::font_t;
+public:
+	void initialize( );
+
+	font_t f_esp_small{ xors( "Tahoma" ), 11, 500, FONTFLAG_OUTLINE };
+	font_t f_bold{ xors( "Verdana" ), 18, 900, FONTFLAG_DROPSHADOW | FONTFLAG_ANTIALIAS };
+	font_t f_12{ xors( "Verdana" ), 12, 700, 128 };
+	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 );
+
+		cl.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/tf2/scene_end.cpp b/tf2/scene_end.cpp
new file mode 100644
index 0000000..bb88311
--- /dev/null
+++ b/tf2/scene_end.cpp
@@ -0,0 +1,37 @@
+#include "hooks.h"
+#include "settings.h"
+#include "base_cheat.h"
+#include "ctx.hpp"
+
+void __fastcall hooks::scene_end( void* ecx_, void* edx_ ) {
+	static auto scene_end_o = cl.m_render_view->get_old_function< decltype( &hooks::scene_end ) >( 9 );
+	scene_end_o( edx_, 0 );
+
+	if( !cl.m_panic && g_ctx.m_local && g_settings.visuals.chams.enabled( ) && g_settings.visuals.chams.ignore_z( ) ) {
+		g_ctx.m_drawing_screneend = true;
+		for( int i = 1; i < cl.m_globals->maxclients; ++i ) {
+			auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+			if( ent && ent->is_valid( ) ) {
+				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.chams.m_materials.m_chams_flat : g_cheat.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.chams.m_materials.force_material( mat, clr_hid );
+					ent->ce( )->DrawModel( 0x1, 255 );
+					mat->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
+					//g_cheat.chams.m_materials.force_material( mat, clr_vis );
+					ent->ce( )->DrawModel( 0x1, 255 );
+					cl.m_model_render( )->ForcedMaterialOverride( nullptr );
+				}
+			}
+		}
+
+		g_ctx.m_drawing_screneend = false;
+	}
+}
+\ No newline at end of file
diff --git a/tf2/sdk.h b/tf2/sdk.h
new file mode 100644
index 0000000..4db8a8f
--- /dev/null
+++ b/tf2/sdk.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#define CLIENT_DLL
+
+#include <Windows.h>
+#include <map>
+#include <algorithm>
+
+#include "vector.hpp"
+
+#include "color.hpp"
+#include "IClientMode.h"
+#include "CHLClient.h"
+#include "IEngineVGui.h"
+#include "IClientEntityList.h"
+#include "IEngineTrace.h"
+#include "CGlobalVarsBase.h"
+#include "ICvar.h"
+#include "IVDebugOverlay.h"
+#include "IVEngineClient.h"
+#include "IPlayerInfoManager.h"
+#include "CBasePlayer.h"
+#include "IPanel.h"
+#include "ISurface.h"
+#include "GlowObject.h"
+#include "IInputSystem.h"
+#include "IVRenderView.h"
+#include "CBaseWeapon.h"
+#include "IVModelInfo.h"
+#include "IGameMovement.h"
+#include "IMaterialSystem.hpp"
+#include "IGameEventManager.h"
+#include "CInput.hpp"
+#include "KeyValues.h"
+\ No newline at end of file
diff --git a/tf2/settings.cpp b/tf2/settings.cpp
new file mode 100644
index 0000000..144c74a
--- /dev/null
+++ b/tf2/settings.cpp
@@ -0,0 +1,4 @@
+#include "settings.h"
+
+SettingHolder holder_{ "" };
+c_settings settings;
+\ No newline at end of file
diff --git a/tf2/settings.h b/tf2/settings.h
new file mode 100644
index 0000000..3f9fbac
--- /dev/null
+++ b/tf2/settings.h
@@ -0,0 +1,276 @@
+#pragma once
+#include "simple_settings.h"
+#include "strings.hpp"
+#include "color.hpp"
+#include <unordered_map>
+//later i will implement a way to load all config files
+
+namespace data
+{
+
+
+	extern SettingHolder holder_;
+
+
+	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_assist_strength{ this, fnv( "assist_strength" ), 0.f };
+		con_var< int > m_hitbox{ this, fnv( "hitbox" ), 0 };
+		con_var< int > m_bone{ this, fnv( "bone" ), 0 };
+	};
+
+
+	class c_settings {
+	public:
+
+		void load( ) {
+			switch( menu.cur_setting ) {
+			case 0:
+				holder_.load( "", xors( "./tf/cfg/scout.cfg" ) );
+				break;
+			case 1:
+				holder_.load( "", xors( "./tf/cfg/soldier.cfg" ) );
+				break;
+			case 2:
+				holder_.load( "", xors( "./tf/cfg/pyro.cfg" ) );
+				break;
+			case 3:
+				holder_.load( "", xors( "./tf/cfg/demo.cfg" ) );
+				break;
+			case 4:
+				holder_.load( "", xors( "./tf/cfg/heavy.cfg" ) );
+				break;
+			case 5:
+				holder_.load( "", xors( "./tf/cfg/engineer.cfg" ) );
+				break;
+			case 6:
+				holder_.load( "", xors( "./tf/cfg/medic.cfg" ) );
+				break;
+			case 7:
+				holder_.load( "", xors( "./tf/cfg/sniper.cfg" ) );
+				break;
+			case 8:
+				holder_.load( "", xors( "./tf/cfg/spy.cfg" ) );
+				break;
+			case 9:
+				holder_.load( "", xors( "./tf/cfg/money_rage1.cfg" ) );
+				break;
+			case 10:
+				holder_.load( "", xors( "./tf/cfg/money_rage2.cfg" ) );
+				break;
+			}
+
+			menu.anti_untrusted = true;
+		}
+
+		void save( ) {
+			switch( menu.cur_setting ) {
+			case 0:
+				holder_.load( "", xors( "./tf/cfg/scout.cfg" ) );
+				break;
+			case 1:
+				holder_.load( "", xors( "./tf/cfg/soldier.cfg" ) );
+				break;
+			case 2:
+				holder_.load( "", xors( "./tf/cfg/pyro.cfg" ) );
+				break;
+			case 3:
+				holder_.load( "", xors( "./tf/cfg/demo.cfg" ) );
+				break;
+			case 4:
+				holder_.load( "", xors( "./tf/cfg/heavy.cfg" ) );
+				break;
+			case 5:
+				holder_.load( "", xors( "./tf/cfg/engineer.cfg" ) );
+				break;
+			case 6:
+				holder_.load( "", xors( "./tf/cfg/medic.cfg" ) );
+				break;
+			case 7:
+				holder_.load( "", xors( "./tf/cfg/sniper.cfg" ) );
+				break;
+			case 8:
+				holder_.load( "", xors( "./tf/cfg/spy.cfg" ) );
+				break;
+			case 9:
+				holder_.load( "", xors( "./tf/cfg/money_rage1.cfg" ) );
+				break;
+			case 10:
+				holder_.load( "", xors( "./tf/cfg/money_rage2.cfg" ) );
+				break;
+			}
+		}
+
+		void copy_to_clipboard( ) {
+			holder_.save( "", xors( "./tf/cfg/money_temp.cfg" ) );
+			std::vector< uint8_t > file_data;
+			FILE* f = fopen( xors( "./tf/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( "./tf/cfg/money_temp.cfg" ) );
+		}
+
+		void load_from_clipboard( ) {
+			FILE* f = fopen( xors( "./tf/cfg/money_temp.cfg" ), "wb" );
+			auto data = GetClipboardData( CF_TEXT );
+
+			auto size = GlobalSize( data );
+			fwrite( data, 1, size, f );
+			fclose( f );
+
+			holder_.load( "", xors( "./tf/cfg/money_temp.cfg" ) );
+
+			CloseClipboard( );
+			//DeleteFileA( xors( "./tf/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 > 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 };
+			legitbot_settings secondary{ &holder_, "legit_primary" };
+			legitbot_settings melee{ &holder_, "legit_melee" };
+			legitbot_settings primary{ &holder_, "legit_secondary" };
+			legitbot_settings* active = &primary;
+		} legit;
+
+		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 ) };
+			} chams;
+			
+			con_var< int > activation_type{ &holder_, fnv( "visuals_activation" ), false };
+			//players
+			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 > conditions{ &holder_, fnv( "visuals_conditions" ), false }; //conditions
+			con_var< bool > resolver_indicator{ &holder_, fnv( "visuals_resolver_indicator" ), false };
+			con_var< bool > ammo{ &holder_, fnv( "visuals_ammo" ), false };
+			con_var< bool > player_class{ &holder_, fnv( "visuals_player_class" ) };
+			con_var< bool > floating_ragdolls{ &holder_, fnv( "visuals_floating_ragdolls" ) }; //dont remember
+			con_var< bool > sound{ &holder_, fnv( "visuals_sound" ), false };
+			con_var< clr_t > box_enemy{ &holder_, fnv( "visuals_clr_enemy" ), clr_t( 0, 255, 255 ) };
+			con_var< clr_t > box_friendly{ &holder_, fnv( "visuals_clr_friendly" ), clr_t( 255, 0, 255 ) };
+			con_var< clr_t > glow_enemy{ &holder_, fnv( "visuals_glow_enemy" ), clr_t( 255, 0, 255, 150 ) };
+			con_var< clr_t > glow_friendly{ &holder_, fnv( "visuals_glow_friendly" ), clr_t( 255, 120, 0, 150 ) };
+			con_var< clr_t > skeleton_enemy{ &holder_, fnv( "visuals_skeleton_enemy" ), clr_t( 255, 255, 255 ) };
+			con_var< clr_t > skeleton_friendly{ &holder_, fnv( "visuals_skeleton_friendly" ), clr_t( 255, 255, 255 ) };
+			con_var< int > bullet_tracers{ &holder_, fnv( "visuals_bullet_tracers" ), 0 };
+			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 };
+
+			
+			//world
+			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< int > projectile_esp{ &holder_, fnv( "visuals_projectile_esp" ), 0 }; //projectile_esp
+			con_var< int > building_esp{ &holder_, fnv( "visuals_building_esp" ), 0 };//building_esp
+			con_var< bool > building_owner{ &holder_, fnv( "visuals_building_owner" ), false }; //building_owner
+			con_var< clr_t > projectile_esp_clr{ &holder_, fnv( "visuals_projectile_esp_clr" ), clr_t( 255, 255, 255, 180 ) };
+			con_var< clr_t > building_esp_clr{ &holder_, fnv( "visuals_building_esp_clr" ), clr_t( 255, 255, 255, 180 ) };
+			con_var< bool > fullbright{ &holder_, fnv( "visuals_fullbright" ), false };
+			con_var< bool > objective_info{ &holder_, fnv( "visuals_objective_info" ), false }; //objective_info
+			
+			//local
+			con_var< bool > draw_spread{ &holder_, fnv( "misc_draw_spread" ), false };
+			con_var< bool > grenade_prediction{ &holder_, fnv( "visuals_grenade_prediction" ), false };
+			con_var< bool > spec_list{ &holder_, fnv( "visuals_spec_list" ), false };
+
+			bool active = true;
+		} visuals;
+
+		struct {
+			con_var< bool > watermark{ &holder_, fnv( "misc_watermark" ), false };
+			con_var< bool > bunny_hop{ &holder_, fnv( "misc_bhop" ), false };
+			con_var< bool > auto_strafe{ &holder_, fnv( "misc_autostrafe" ), false };
+			con_var< int > viewmodel_fov{ &holder_, fnv( "misc_viewmodel_fov" ), 0 };
+			con_var< int > fov_changer{ &holder_, fnv( "fov_changer" ), 90 };
+			con_var< bool > thirdperson{ &holder_, fnv( "misc_thirdperson" ), false };
+			con_var< int > thirdperson_key{ &holder_, fnv( "misc_tp_key" ), 0 };
+
+			con_var< bool > no_recoil{ &holder_, fnv( "misc_no_recoil" ), false };
+			con_var< bool > no_sound{ &holder_, fnv( "misc_no_sound" ), false };
+			con_var< bool > no_scope{ &holder_, fnv( "misc_no_scope" ), 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 };
+
+			bool recorder_enable = false;
+		} misc;
+
+		struct {
+			con_var< uint8_t > menu_color_1r{ &holder_, fnv( "menu_color_1r" ), 231 };
+			con_var< uint8_t > menu_color_1g{ &holder_, fnv( "menu_color_1g" ), 105 };
+			con_var< uint8_t > menu_color_1b{ &holder_, fnv( "menu_color_1b" ), 105 };
+
+			con_var< uint8_t > menu_color_2r{ &holder_, fnv( "menu_color_2r" ), 0xf4 };
+			con_var< uint8_t > menu_color_2g{ &holder_, fnv( "menu_color_2g" ), 0x7c };
+			con_var< uint8_t > menu_color_2b{ &holder_, fnv( "menu_color_2b" ), 0xa8 };
+
+			bool auto_class_settings = false;
+			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/tf2/shut_down.cpp b/tf2/shut_down.cpp
new file mode 100644
index 0000000..149fbf6
--- /dev/null
+++ b/tf2/shut_down.cpp
@@ -0,0 +1,16 @@
+#include "hooks.h"
+#include "chams.h"
+#include "base_cheat.h"
+
+void __fastcall hooks::shut_down( void* ecx_, void* edx_ ) {
+	static auto original_fn = cl.m_chl->get_old_function< decltype( &shut_down ) >( 3 );
+
+	cl.m_engine( )->ClientCmd_Unrestricted( xors( "host_writeconfig" ) );
+	//fuck you
+	abort( );
+
+	//how about fuck you instead dumb fucking tentacle hentai lookin ass mofo
+
+	//g_cheat.chams.m_materials.destroy_materials( );
+	return original_fn( ecx_, edx_ );
+}
+\ No newline at end of file
diff --git a/tf2/simple_settings.cpp b/tf2/simple_settings.cpp
new file mode 100644
index 0000000..9d1d1de
--- /dev/null
+++ b/tf2/simple_settings.cpp
@@ -0,0 +1,32 @@
+#include "settings.h"
+
+SettingHolder data::holder_{ "fucking_nerd" };
+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/tf2/simple_settings.h b/tf2/simple_settings.h
new file mode 100644
index 0000000..db9b814
--- /dev/null
+++ b/tf2/simple_settings.h
@@ -0,0 +1,204 @@
+#pragma once
+#include <Windows.h>
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "util.hpp"
+#include "fnv.hpp"
+
+//nama stuff
+extern void simple_save( const char* path, const char* name, const void* src, size_t size, const char* filename );
+extern void simple_load( const char* path, const char* name, void* dest, size_t size, const char* filename );
+
+class ISettingNode {
+public:
+	virtual ~ISettingNode( ) = default;
+
+	virtual void load( const char* path, const char* file ) = 0;
+	virtual void save( const char* path, const char* file ) const = 0;
+	virtual void register_( ISettingNode* node_ptr ) = 0;
+	virtual bool has_nodes( ) { return false; }
+	virtual hash_t get_hash( ) { return 0; }
+};
+
+class SettingHolder : public ISettingNode {
+public:
+	__forceinline SettingHolder( const char* name ) : name_( name ) {}
+	__forceinline SettingHolder( SettingHolder* holder_ptr, const char* name ) : name_( name ) { holder_ptr->register_( this ); }
+
+	void register_( ISettingNode* node_ptr ) override {
+		setting_nodes_.push_back( node_ptr );
+	}
+
+	void load( const char* path, const char* file ) override {
+		char full_path[ 64 ];
+		strcpy_s( full_path, path );
+		strcat_s( full_path, "_" );
+		strcat_s( full_path, name_ );
+		for( auto x : setting_nodes_ )
+			x->load( full_path, file );
+	}
+
+	void save( const char* path, const char* file ) const override {
+		char full_path[ 64 ];
+		strcpy_s( full_path, path );
+		strcat_s( full_path, "_" );
+		strcat_s( full_path, name_ );
+		for( auto x : setting_nodes_ )
+			x->save( full_path, file );
+	}
+
+	auto& get_nodes( ) {
+		return setting_nodes_;
+	}
+
+	virtual bool has_nodes( ) {
+		return true;
+	}
+
+private:
+	const char* name_;
+	bool has_nodes_;
+	std::vector<ISettingNode*> setting_nodes_;
+};
+
+class ISetting : public ISettingNode {
+	void register_( ISettingNode* node_ptr ) override {}
+public:
+	virtual void set( float value ) = 0;
+	virtual void set( int value ) = 0;
+	virtual void set( ulong_t value ) = 0;
+	virtual std::string get_string( ) = 0;
+	virtual hash_t get_hash( ) = 0;
+	virtual std::string get_data_string( ) = 0;
+	virtual void load_from_string( const std::string& ) = 0;
+};
+
+template < size_t L >
+class SettingString : ISetting {
+public:
+	__forceinline SettingString( SettingHolder* holder_ptr, hash_t hash ) :
+		m_name( name ), m_value( "" ) {
+		holder_ptr->register_( this );
+	};
+
+	void load( const char* path, const char* file ) override {
+		GetPrivateProfileStringA( path, std::to_string( m_name ).c_str( ), "", m_value, L, file );
+	}
+
+	void save( const char* path, const char* file ) const override {
+		WritePrivateProfileStringA( path, std::to_string( m_name ).c_str( ), m_value, file );
+	}
+
+	char* get( ) {
+		return m_value;
+	}
+
+private:
+	char m_value[ L ];
+	hash_t m_name;
+};
+
+template < typename T >
+class con_var : public ISetting {
+public:
+	__forceinline con_var( SettingHolder* holder_ptr, hash_t name ) :
+		name_( name ),
+		is_float_( std::is_floating_point_v< T > ),
+		is_integral_( std::is_integral_v< T > ) {
+		holder_ptr->register_( this );
+	}
+	__forceinline con_var( SettingHolder* holder_ptr, hash_t name, const T& rhs ) :
+		value_( rhs ),
+		name_( name ),
+		is_float_( std::is_floating_point_v< T > ),
+		is_integral_( std::is_integral_v< T > ) {
+		holder_ptr->register_( this );
+	}
+
+	void load( const char* path, const char* file ) override { simple_load( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), file ); }
+
+	void save( const char* path, const char* file ) const override { simple_save( path, std::to_string( name_ ).c_str( ), &value_, sizeof( value_ ), file ); }
+
+	__forceinline operator T&( ) { return value_; }
+	__forceinline T* operator &( ) { return &value_; }
+
+	__forceinline T& operator ()( ) { return value_; }
+
+	virtual std::string get_string( ) {
+		if constexpr( std::is_arithmetic_v< T > ) {
+			return std::to_string( value_ );
+		}
+		else {
+			return util::to_hex_str( *( ulong_t* )( &value_ ) );
+		}
+	}
+
+	virtual void set( float value ) {
+		if constexpr( std::is_arithmetic_v< T > ) {
+			value_ = ( T )( value );
+		}
+	}
+
+	virtual void set( int value ) {
+		if constexpr( std::is_arithmetic_v< T > ) {
+			value_ = ( T )( value );
+		}
+		else {
+			value_ = *( T* )( &value );
+		}
+	}
+
+	virtual void set( ulong_t value ) {
+		if constexpr( sizeof( T ) == sizeof( ulong_t ) ) {
+			*( ulong_t* )( &value_ ) = value;
+			return;
+		}
+
+		memcpy( &value_, &value, sizeof( value_ ) );
+	}
+
+	virtual hash_t get_hash( ) {
+		return name_;
+	}
+
+	__forceinline bool is_floating_point( ) {
+		return is_float_;
+	}
+
+	__forceinline bool is_integral( ) {
+		return is_integral_;
+	}
+
+	virtual std::string get_data_string( ) override {
+		auto buffer = reinterpret_cast< char* >( _alloca( sizeof( T ) * 2 + 1 ) );
+		auto data = reinterpret_cast< const uint8_t* >( &value_ );
+
+		for( size_t i = 0; i < sizeof( T ); i++ )
+			sprintf( &buffer[ 2 * i ], "%02X", data[ i ] );
+
+		return buffer;
+	}
+
+	virtual void load_from_string( const std::string& str ) override {
+		auto data = reinterpret_cast< uint8_t* >( &value_ );
+		auto buffer = str.data( );
+
+		if( *buffer == 0 )
+			return;
+
+		for( size_t i = 0; i < sizeof( T ); i++ ) {
+			unsigned temp;
+			sscanf( &buffer[ 2 * i ], "%02X", &temp );
+			data[ i ] = temp;
+		}
+	}
+
+
+private:
+	hash_t name_;
+	bool is_float_;
+	bool is_integral_;
+	T value_;
+};
+\ No newline at end of file
diff --git a/tf2/strings.hpp b/tf2/strings.hpp
new file mode 100644
index 0000000..dfdeb8b
--- /dev/null
+++ b/tf2/strings.hpp
@@ -0,0 +1,162 @@
+//--------------------------------------------------------------------------------
+//-- XorCompileTime.hpp
+//
+// Author: frk
+// Date: 12.12.2015
+//
+//--------------------------------------------------------------------------------
+
+#pragma once
+#include <string>
+#include <array>
+#include <cstdarg>
+
+#define BEGIN_NAMESPACE( x ) namespace x {
+#define END_NAMESPACE }
+
+BEGIN_NAMESPACE( strenc )
+
+constexpr auto time = __TIME__;
+constexpr auto seed = static_cast< int >( time[ 7 ] ) + static_cast< int >( time[ 6 ] ) * 10 + static_cast< int >( time[ 4 ] ) * 60 + static_cast< int >( time[ 3 ] ) * 600 + static_cast< int >( time[ 1 ] ) * 3600 + static_cast< int >( time[ 0 ] ) * 36000;
+
+// 1988, Stephen Park and Keith Miller
+// "Random Number Generators: Good Ones Are Hard To Find", considered as "minimal standard"
+// Park-Miller 31 bit pseudo-random number generator, implemented with G. Carta's optimisation:
+// with 32-bit math and without division
+
+template < int N >
+struct RandomGenerator {
+private:
+	static constexpr unsigned a = 16807; // 7^5
+	static constexpr unsigned m = 2147483647; // 2^31 - 1
+
+	static constexpr unsigned s = RandomGenerator< N - 1 >::value;
+	static constexpr unsigned lo = a * ( s & 0xFFFF ); // Multiply lower 16 bits by 16807
+	static constexpr unsigned hi = a * ( s >> 16 ); // Multiply higher 16 bits by 16807
+	static constexpr unsigned lo2 = lo + ( ( hi & 0x7FFF ) << 16 ); // Combine lower 15 bits of hi with lo's upper bits
+	static constexpr unsigned hi2 = hi >> 15; // Discard lower 15 bits of hi
+	static constexpr unsigned lo3 = lo2 + hi;
+
+public:
+	static constexpr unsigned max = m;
+	static constexpr unsigned value = lo3 > m ? lo3 - m : lo3;
+};
+
+template <>
+struct RandomGenerator< 0 > {
+	static constexpr unsigned value = seed;
+};
+
+template < int N, int M >
+struct RandomInt {
+	static constexpr auto value = RandomGenerator< N + 1 >::value % M;
+};
+
+template < int N >
+struct RandomChar {
+	static const char value = static_cast< char >( 1 + RandomInt< N, 0x7F - 1 >::value );
+};
+
+template < size_t N, int K >
+struct XorString {
+private:
+	const char _key;
+	std::array< char, N + 1 > _encrypted;
+	bool decrypted = false;
+
+	constexpr char enc( char c ) const {
+		return c ^ _key;
+	}
+
+	char dec( char c ) const {
+		return c ^ _key;
+	}
+
+public:
+	template < size_t... Is >
+	constexpr __forceinline XorString( const char* const str, std::index_sequence< Is... > ) : _key( RandomChar< K >::value ), _encrypted{ enc( str[ Is ] )... } {
+	}
+
+	__forceinline const char* decrypt( void ) {
+		if( !decrypted ) {
+			for( size_t i = 0; i < N; ++i ) {
+				_encrypted[ i ] = dec( _encrypted[ i ] );
+			}
+			_encrypted[ N ] = '\0';
+			decrypted = true;
+		}
+		printf( "N: %u K: %d str: %s address: %08x\n", N, K, _encrypted.data( ), _encrypted.data( ) );
+
+		return _encrypted.data( );
+	}
+};
+
+//--------------------------------------------------------------------------------
+//-- Note: XorStr will __NOT__ work directly with functions like printf.
+//         To work with them you need a wrapper function that takes a const char*
+//         as parameter and passes it to printf and alike.
+//
+//         The Microsoft Compiler/Linker is not working correctly with variadic 
+//         templates!
+//  
+//         Use the functions below or use std::cout (and similar)!
+//--------------------------------------------------------------------------------
+
+static auto w_printf = [ ]( const char* fmt, ... ) {
+	va_list args;
+	va_start( args, fmt );
+	vprintf_s( fmt, args );
+	va_end( args );
+};
+
+static auto w_printf_s = [ ]( const char* fmt, ... ) {
+	va_list args;
+	va_start( args, fmt );
+	vprintf_s( fmt, args );
+	va_end( args );
+};
+
+static auto w_sprintf = [ ]( char* buf, const char* fmt, ... ) {
+	va_list args;
+	va_start( args, fmt );
+	vsprintf( buf, fmt, args );
+	va_end( args );
+};
+
+static auto w_sprintf_s = [ ]( char* buf, size_t buf_size, const char* fmt, ... ) {
+	va_list args;
+	va_start( args, fmt );
+	vsprintf_s( buf, buf_size, fmt, args );
+	va_end( args );
+};
+
+//for compatibility with debug mode
+struct debug_ret {
+private:
+	const char* ret;
+
+public:
+	debug_ret( const char* str ) : ret( str ) { };
+
+	auto decrypt( ) {
+		return ret;
+	}
+};
+
+constexpr size_t strlen_ct( const char* const str ) {
+	size_t out = 1;
+
+	for( ; str[ out ] != '\0'; ++out );
+
+	return out;
+}
+
+#if 0
+#define xors_raw( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ) )
+#define xors( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() )
+#else
+#define xors_raw( s ) ( [ ]{ strenc::debug_ret ret{ s }; return ret; }( ) )
+#define xors( s ) ( s )
+#endif
+
+END_NAMESPACE
+\ No newline at end of file
diff --git a/tf2/test_cso2.vcxproj b/tf2/test_cso2.vcxproj
new file mode 100644
index 0000000..56df171
--- /dev/null
+++ b/tf2/test_cso2.vcxproj
@@ -0,0 +1,302 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{DD486C1B-C911-42B8-AB24-A9102A23DC02}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>test_cso2</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <ProjectName>tf2_base</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)\bin\</OutDir>
+    <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)\bin\$(Configuration)\</OutDir>
+    <IncludePath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level2</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;TEST_CSO2_EXPORTS;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <MinimalRebuild>false</MinimalRebuild>
+      <AdditionalOptions>/Zc:threadSafeInit- %(AdditionalOptions) /std:c++latest</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;TEST_CSO2_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>/Zc:threadSafeInit- /std:c++latest %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;TEST_CSO2_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>C:\HL-SDK\mp\game\shared;C:\HL-SDK\mp\game\client;C:\HL-SDK\mp\common;C:\HL-SDK\mp\common\xbox;C:\HL-SDK\mp\public\tier3;C:\HL-SDK\mp\public\tier2;C:\HL-SDK\mp\public\tier1;C:\HL-SDK\mp\public\tier0;C:\HL-SDK\mp\public;C:\HL-SDK\mp\tier1</AdditionalIncludeDirectories>
+      <AdditionalOptions>/Zc:threadSafeInit- %(AdditionalOptions) /std:c++latest</AdditionalOptions>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;TEST_CSO2_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>C:\HL-SDK\mp\game\shared;C:\HL-SDK\mp\game\client;C:\HL-SDK\mp\common;C:\HL-SDK\mp\common\xbox;C:\HL-SDK\mp\public\tier3;C:\HL-SDK\mp\public\tier2;C:\HL-SDK\mp\public\tier1;C:\HL-SDK\mp\public\tier0;C:\HL-SDK\mp\public;C:\HL-SDK\mp\tier1</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="aim_lagcomp.cpp" />
+    <ClCompile Include="CBasePlayer.cpp" />
+    <ClCompile Include="CBaseWeapon.cpp" />
+    <ClCompile Include="chams.cpp" />
+    <ClCompile Include="checksum_crc.cpp" />
+    <ClCompile Include="chl_createmove.cpp" />
+    <ClCompile Include="clientmode_createmove.cpp" />
+    <ClCompile Include="console.cpp" />
+    <ClCompile Include="ctx.cpp" />
+    <ClCompile Include="d3d.cpp" />
+    <ClCompile Include="d3d_sprite.cpp" />
+    <ClCompile Include="directx.cpp" />
+    <ClCompile Include="do_post_screen_space_effects.cpp" />
+    <ClCompile Include="draw_model_execute.cpp" />
+    <ClCompile Include="emit_sound.cpp" />
+    <ClCompile Include="extra.cpp" />
+    <ClCompile Include="factory.cpp" />
+    <ClCompile Include="framestagenotify.cpp" />
+    <ClCompile Include="get_viewmodel_fov.cpp" />
+    <ClCompile Include="graphics.cpp" />
+    <ClCompile Include="hooks.cpp" />
+    <ClCompile Include="input_system.cpp" />
+    <ClCompile Include="interfaces.cpp" />
+    <ClCompile Include="KeyValues.cpp" />
+    <ClCompile Include="listener.cpp" />
+    <ClCompile Include="math.cpp" />
+    <ClCompile Include="movement.cpp" />
+    <ClCompile Include="netvars.cpp" />
+    <ClCompile Include="on_screen_size_changed.cpp" />
+    <ClCompile Include="override_mouse_input.cpp" />
+    <ClCompile Include="override_view.cpp" />
+    <ClCompile Include="paint.cpp" />
+    <ClCompile Include="prediction.cpp" />
+    <ClCompile Include="process_movement.cpp" />
+    <ClCompile Include="projectile_pred.cpp" />
+    <ClCompile Include="renderer.cpp" />
+    <ClCompile Include="scene_end.cpp" />
+    <ClCompile Include="shut_down.cpp" />
+    <ClCompile Include="simple_settings.cpp" />
+    <ClCompile Include="Source.cpp" />
+    <ClCompile Include="aim.cpp" />
+    <ClCompile Include="util.cpp" />
+    <ClCompile Include="visuals_draw.cpp" />
+    <ClCompile Include="visuals_local.cpp" />
+    <ClCompile Include="visuals_players.cpp" />
+    <ClCompile Include="visuals_world.cpp" />
+    <ClCompile Include="window_procedure.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="base_cheat.h" />
+    <ClInclude Include="ButtonCode_t.h" />
+    <ClInclude Include="CAttribute.h" />
+    <ClInclude Include="CBaseWeapon.h" />
+    <ClInclude Include="chams.h" />
+    <ClInclude Include="checksum_crc.h" />
+    <ClInclude Include="CHLClient.h" />
+    <ClInclude Include="CInput.hpp" />
+    <ClInclude Include="ClientClass.h" />
+    <ClInclude Include="color.hpp" />
+    <ClInclude Include="conditions.h" />
+    <ClInclude Include="console.hpp" />
+    <ClInclude Include="con_alias.hpp" />
+    <ClInclude Include="con_fn.hpp" />
+    <ClInclude Include="ctx.hpp" />
+    <ClInclude Include="CBasePlayer.h" />
+    <ClInclude Include="d3d.hpp" />
+    <ClInclude Include="d3d_sprite.hpp" />
+    <ClInclude Include="dt_common.h" />
+    <ClInclude Include="dt_recv.h" />
+    <ClInclude Include="extra.h" />
+    <ClInclude Include="factory.h" />
+    <ClInclude Include="factory.hpp" />
+    <ClInclude Include="fnv.hpp" />
+    <ClInclude Include="GlowObject.h" />
+    <ClInclude Include="graphics.h" />
+    <ClInclude Include="icons.hpp" />
+    <ClInclude Include="identity.h" />
+    <ClInclude Include="IGameEventManager.h" />
+    <ClInclude Include="IGameMovement.h" />
+    <ClInclude Include="IMaterialSystem.hpp" />
+    <ClInclude Include="input_system.hpp" />
+    <ClInclude Include="KeyValues.h" />
+    <ClInclude Include="IAppSystem.h" />
+    <ClInclude Include="IClientEntity.h" />
+    <ClInclude Include="ICvar.h" />
+    <ClInclude Include="IInputSystem.h" />
+    <ClInclude Include="IPlayerInfoManager.h" />
+    <ClInclude Include="IVRenderView.h" />
+    <ClInclude Include="listener.hpp" />
+    <ClInclude Include="math.h" />
+    <ClInclude Include="mem.hpp" />
+    <ClInclude Include="movement.h" />
+    <ClInclude Include="netvars.h" />
+    <ClInclude Include="netvar_proxy.hpp" />
+    <ClInclude Include="aim.h" />
+    <ClInclude Include="prediction.h" />
+    <ClInclude Include="projectile_pred.h" />
+    <ClInclude Include="renderer.hpp" />
+    <ClInclude Include="ScreenSpaceEffects.h" />
+    <ClInclude Include="settings.h" />
+    <ClInclude Include="simple_settings.h" />
+    <ClInclude Include="strings.hpp" />
+    <ClInclude Include="ui.h" />
+    <ClInclude Include="ui_base_item.h" />
+    <ClInclude Include="ui_button.h" />
+    <ClInclude Include="ui_checkbox.h" />
+    <ClInclude Include="ui_color_picker.h" />
+    <ClInclude Include="ui_draw.h" />
+    <ClInclude Include="ui_dropdown.h" />
+    <ClInclude Include="ui_dropdown_item.h" />
+    <ClInclude Include="ui_form.h" />
+    <ClInclude Include="ui_key_picker.h" />
+    <ClInclude Include="ui_label.h" />
+    <ClInclude Include="ui_menu.h" />
+    <ClInclude Include="ui_render.h" />
+    <ClInclude Include="ui_slider.h" />
+    <ClInclude Include="ui_tab_manager.h" />
+    <ClInclude Include="ui_text_input.h" />
+    <ClInclude Include="util.hpp" />
+    <ClInclude Include="UtlMem.h" />
+    <ClInclude Include="VFunc.h" />
+    <ClInclude Include="hooks.h" />
+    <ClInclude Include="IClientEntityList.h" />
+    <ClInclude Include="IClientMode.h" />
+    <ClInclude Include="IEngineTrace.h" />
+    <ClInclude Include="IEngineVGui.h" />
+    <ClInclude Include="interfaces.h" />
+    <ClInclude Include="CGlobalVarsBase.h" />
+    <ClInclude Include="IPanel.h" />
+    <ClInclude Include="ISurface.h" />
+    <ClInclude Include="IVDebugOverlay.h" />
+    <ClInclude Include="IVEngineClient.h" />
+    <ClInclude Include="sdk.h" />
+    <ClInclude Include="pattern.hpp" />
+    <ClInclude Include="vector.hpp" />
+    <ClInclude Include="visuals.hpp" />
+    <ClInclude Include="vmt.h" />
+    <ClInclude Include="x86.hpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
+\ No newline at end of file
diff --git a/tf2/test_cso2.vcxproj.filters b/tf2/test_cso2.vcxproj.filters
new file mode 100644
index 0000000..d9d322d
--- /dev/null
+++ b/tf2/test_cso2.vcxproj.filters
@@ -0,0 +1,428 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="interfaces.cpp" />
+    <ClCompile Include="Source.cpp" />
+    <ClCompile Include="aim.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="CBasePlayer.cpp">
+      <Filter>sdk</Filter>
+    </ClCompile>
+    <ClCompile Include="simple_settings.cpp">
+      <Filter>data</Filter>
+    </ClCompile>
+    <ClCompile Include="math.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="movement.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="ctx.cpp">
+      <Filter>context</Filter>
+    </ClCompile>
+    <ClCompile Include="framestagenotify.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="paint.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="graphics.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="CBaseWeapon.cpp">
+      <Filter>sdk</Filter>
+    </ClCompile>
+    <ClCompile Include="chl_createmove.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="clientmode_createmove.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="projectile_pred.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="KeyValues.cpp">
+      <Filter>sdk</Filter>
+    </ClCompile>
+    <ClCompile Include="prediction.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="process_movement.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="input_system.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="d3d.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="d3d_sprite.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="directx.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="factory.cpp" />
+    <ClCompile Include="util.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="renderer.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="netvars.cpp">
+      <Filter>data</Filter>
+    </ClCompile>
+    <ClCompile Include="hooks.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="checksum_crc.cpp">
+      <Filter>sdk</Filter>
+    </ClCompile>
+    <ClCompile Include="visuals_draw.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="visuals_world.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="visuals_players.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="visuals_local.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="override_mouse_input.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="get_viewmodel_fov.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="do_post_screen_space_effects.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="override_view.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="shut_down.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="draw_model_execute.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="scene_end.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="on_screen_size_changed.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="emit_sound.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="window_procedure.cpp">
+      <Filter>hooks</Filter>
+    </ClCompile>
+    <ClCompile Include="chams.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="extra.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+    <ClCompile Include="console.cpp">
+      <Filter>util</Filter>
+    </ClCompile>
+    <ClCompile Include="listener.cpp">
+      <Filter>hooks\hookers</Filter>
+    </ClCompile>
+    <ClCompile Include="aim_lagcomp.cpp">
+      <Filter>features</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="interfaces.h" />
+    <ClInclude Include="sdk.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IClientMode.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="CHLClient.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IEngineVGui.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IClientEntityList.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IEngineTrace.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="CGlobalVarsBase.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IVDebugOverlay.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IVEngineClient.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="CBasePlayer.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IPanel.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="ISurface.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="VFunc.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IClientEntity.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="netvars.h">
+      <Filter>data</Filter>
+    </ClInclude>
+    <ClInclude Include="dt_common.h">
+      <Filter>data</Filter>
+    </ClInclude>
+    <ClInclude Include="dt_recv.h">
+      <Filter>data</Filter>
+    </ClInclude>
+    <ClInclude Include="aim.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="simple_settings.h">
+      <Filter>data</Filter>
+    </ClInclude>
+    <ClInclude Include="settings.h">
+      <Filter>data</Filter>
+    </ClInclude>
+    <ClInclude Include="math.h">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="base_cheat.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="conditions.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IPlayerInfoManager.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="ClientClass.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="movement.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="ICvar.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="GlowObject.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="UtlMem.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IInputSystem.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IAppSystem.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="ButtonCode_t.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="fnv.hpp">
+      <Filter>protection</Filter>
+    </ClInclude>
+    <ClInclude Include="ctx.hpp">
+      <Filter>context</Filter>
+    </ClInclude>
+    <ClInclude Include="vmt.h">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="hooks.h">
+      <Filter>hooks</Filter>
+    </ClInclude>
+    <ClInclude Include="graphics.h">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="factory.hpp">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IVRenderView.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="CBaseWeapon.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="projectile_pred.h">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="CAttribute.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="ScreenSpaceEffects.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="KeyValues.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="prediction.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="IGameMovement.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="ui.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_base_item.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_button.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_checkbox.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_color_picker.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_draw.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_dropdown.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_dropdown_item.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_form.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_key_picker.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_label.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_menu.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_render.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_slider.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_tab_manager.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="ui_text_input.h">
+      <Filter>menu</Filter>
+    </ClInclude>
+    <ClInclude Include="input_system.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="util.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="icons.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="d3d.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="d3d_sprite.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="factory.h" />
+    <ClInclude Include="console.hpp" />
+    <ClInclude Include="strings.hpp">
+      <Filter>protection</Filter>
+    </ClInclude>
+    <ClInclude Include="x86.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="con_fn.hpp" />
+    <ClInclude Include="con_alias.hpp" />
+    <ClInclude Include="pattern.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="vector.hpp">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="color.hpp">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="renderer.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="netvar_proxy.hpp">
+      <Filter>hooks\hookers</Filter>
+    </ClInclude>
+    <ClInclude Include="IMaterialSystem.hpp">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="checksum_crc.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="IGameEventManager.h">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="mem.hpp">
+      <Filter>util</Filter>
+    </ClInclude>
+    <ClInclude Include="CInput.hpp">
+      <Filter>sdk</Filter>
+    </ClInclude>
+    <ClInclude Include="visuals.hpp">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="chams.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="identity.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="extra.h">
+      <Filter>features</Filter>
+    </ClInclude>
+    <ClInclude Include="listener.hpp">
+      <Filter>hooks\hookers</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="sdk">
+      <UniqueIdentifier>{3662005c-363b-4165-98d1-4cd08efa5aec}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="data">
+      <UniqueIdentifier>{9b96d956-b922-4bc1-a7fd-448a79007f56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="features">
+      <UniqueIdentifier>{971e8665-630e-40f6-a426-a9c59476dd28}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="util">
+      <UniqueIdentifier>{7abe95b2-6694-4252-9044-b0a3b6ca500d}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="menu">
+      <UniqueIdentifier>{280b6489-8704-41f7-98d1-76e4510e59b1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="context">
+      <UniqueIdentifier>{45735c33-3420-447c-9257-46d489466c79}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="hooks">
+      <UniqueIdentifier>{8f34dc36-01d7-4458-a53a-f3698e843b94}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="protection">
+      <UniqueIdentifier>{bf4d8bec-9f02-4e3b-99bd-a328befb5cd3}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="hooks\hookers">
+      <UniqueIdentifier>{2c764ae7-bdc8-4a36-b752-8ac395c2c006}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>
+\ No newline at end of file
diff --git a/tf2/ui.h b/tf2/ui.h
new file mode 100644
index 0000000..bafb2ce
--- /dev/null
+++ b/tf2/ui.h
@@ -0,0 +1,374 @@
+#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.h"
+#include "base_cheat.h"
+
+namespace ui
+{
+	int current_category = 0;
+
+	static std::string date_str = __DATE__;
+	auto menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "quebot" ),
+		__DATE__ );
+
+	static void render( ) {
+		static bool was_setup = false;
+		if( !was_setup ) {
+			std::transform( date_str.begin( ), date_str.end( ), date_str.begin( ),
+				[ ]( char c ) { return ::tolower( c ); }
+			);
+
+			menu.reset( );
+			menu = std::make_shared< ui::c_menu >( 10, 10, 580, 470, xors( "moneybot - tf2" ),
+				date_str.c_str( ) );
+			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_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.primary.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.primary.m_speed ) );
+						general_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "bone - dropdown" ), &g_settings.legit.primary.m_bone, &ui::dropdowns::aimbot_bone ) );
+						general_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.primary.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.melee.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.melee.m_speed ) );
+						snipers_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "bone - dropdown" ), &g_settings.legit.melee.m_bone, &ui::dropdowns::aimbot_bone ) );
+						snipers_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.melee.m_assist_strength ) );
+					}
+
+					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.secondary.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.secondary.m_speed ) );
+						rifles_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "bone - dropdown" ), &g_settings.legit.secondary.m_bone, &ui::dropdowns::aimbot_bone ) );
+						rifles_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 140, 0.f, 1.f, xors( "assist strength" ), &g_settings.legit.secondary.m_assist_strength ) );
+					}
+
+
+
+					left_column->add_item( general_form );
+					left_column->add_item( snipers_form );
+					right_column->add_item( rifles_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 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 - test" ), &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 ) );
+						player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "name" ), &g_settings.visuals.name ) );
+						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 ) );
+						player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "conditions - close" ), &g_settings.visuals.conditions ) );
+						player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "class" ), &g_settings.visuals.player_class ) );
+						//player_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "resolver indicator - when i add hvh" ), &g_settings.visuals.resolver_indicator ) ); 
+						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 - weird angles" ), &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 - not done" ), &g_settings.visuals.hitmarkers ) ); no need
+						hud_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "spectator list" ), &g_settings.visuals.spec_list ) );
+					}
+
+					auto other_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "other" ) ); {
+						//other_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "bullet tracers - not done" ), &g_settings.visuals.bullet_tracers, &dropdowns::tracer_type ) ); no bullet_impact event or any equivalent
+						other_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "floating ragdolls - hopefully" ), &g_settings.visuals.floating_ragdolls ) );
+					}
+
+					auto chams_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "chams - crash" ), 170 ); {
+						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( "friendlies" ), &g_settings.visuals.chams.friendlies( ) ) );
+						chams_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "flat" ), &g_settings.visuals.chams.flat( ) ) )->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs( ); } );
+						chams_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "reflectivity" ), &g_settings.visuals.chams.reflectivity )
+						)->set_cond( [ ]( ) { return !g_settings.visuals.chams.flat && !g_settings.misc.hide_from_obs; } );
+
+						chams_form->add_item( std::make_shared< ui::c_slider< float > >( 0, 0, 120, 0.f, 1.f, xors( "shine" ), &g_settings.visuals.chams.shine )
+						)->set_cond( [ ]( ) { return !g_settings.visuals.chams.flat && !g_settings.misc.hide_from_obs; } );
+
+						chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "friendlies visible" ), &g_settings.visuals.chams.color_visible_friendly( ) ) )->set_cond(
+							[ ]( ) { return g_settings.visuals.chams.friendlies( ); } );
+						chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "friendlies hidden" ), &g_settings.visuals.chams.color_hidden_friendly( ) ) )->set_cond(
+							[ ]( ) { return g_settings.visuals.chams.friendlies( ) && g_settings.visuals.chams.ignore_z( ); } );
+						chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "enemies visible" ), &g_settings.visuals.chams.color_visible_enemy( ) ) );
+						chams_form->add_item( std::make_shared< ui::c_color_picker >( 0, 0, 120, xors( "enemies hidden" ), &g_settings.visuals.chams.color_hidden_enemy( ) ) )->set_cond(
+							[ ]( ) { return g_settings.visuals.chams.ignore_z( ); } );
+					}
+
+					chams_form->set_cond( [ ]( ) { return !g_settings.misc.hide_from_obs( ); } );
+
+					left_column->add_item( main_form );
+					left_column->add_item( player_form );
+
+					right_column->add_item( hud_form );
+					right_column->add_item( other_form );
+					right_column->add_item( chams_form );
+
+					subtab_players->add_item( left_column );
+					subtab_players->add_item( right_column );
+				}
+
+				auto subtab_other = std::make_shared< ui::c_tab_sheet >( xors( "other" ) ); {
+					auto left_column = std::make_shared< ui::base_item >( 0, 0, 0, 0 );
+					auto right_column = std::make_shared< ui::base_item >( 220, -5, 0, 0 );
+
+					auto world_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "world" ) ); {
+						world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "world modulate - not done" ), &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 - not done" ), &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 - maybe" ), &g_settings.visuals.transparent_props ) //maybe?
+						)->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 - not done" ), &g_settings.visuals.fullbright ) );
+						world_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "projectiles" ), &g_settings.visuals.projectile_esp, &dropdowns::world_esp_type )
+						)->add_item( std::make_shared< ui::c_color_picker >( 180, 4, 15, &g_settings.visuals.building_esp_clr( ) ) );
+
+						world_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 120, xors( "buildings" ), &g_settings.visuals.building_esp, &dropdowns::world_esp_type )
+						)->add_item( std::make_shared< ui::c_color_picker >( 180, 4, 15, &g_settings.visuals.building_esp_clr( ) ) );
+
+						world_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "building owner - not done" ), &g_settings.visuals.building_owner )
+						)->set_cond( [ ]( ) { return g_settings.visuals.building_esp == 1 || g_settings.visuals.building_esp == 3; } );
+					}
+
+					//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( "projectile prediction - hopefully" ), &g_settings.visuals.grenade_prediction( ) ) );
+					//}
+
+					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 - crash" ), &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 - broken" ), &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 - not done" ), &g_settings.misc.no_scope ) );
+						removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "transparent viewmodel - hopefully" ), &g_settings.misc.transparent_vm ) );
+						removals_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "no post processing - not done" ), &g_settings.misc.disable_post_process ) );
+					}
+
+					left_column->add_item( world_form );
+					//left_column->add_item( local_form );
+
+					right_column->add_item( view_form );
+					right_column->add_item( removals_form );
+
+					subtab_other->add_item( left_column );
+					subtab_other->add_item( right_column );
+				}
+
+				subtab_sheet->add_item( subtab_other );
+				subtab_sheet->add_item( subtab_players );
+
+				tab_visuals->add_item( subtab_sheet );
+			}
+
+
+			auto tab_misc = std::make_shared< ui::c_tab_sheet >( xors( "miscellaneous" ), &icons::sprite_misc ); {
+				auto subtab_sheet = std::make_shared< ui::c_subtab_manager >( );
+
+				auto subtab_general = std::make_shared< ui::c_tab_sheet >( xors( "general" ) ); {
+					auto column_left = subtab_general->add_item( std::make_shared< ui::base_item >( 0, 0, 0, 0 ) );
+					auto column_right = subtab_general->add_item( std::make_shared< ui::base_item >( 220, -5, 0, 0 ) );
+
+					auto movement_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "movement" ) ); {
+						movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "auto strafe" ), &g_settings.misc.auto_strafe ) );
+						movement_form->add_item( std::make_shared< ui::c_checkbox >( 0, 0, xors( "bhop" ), &g_settings.misc.bunny_hop( ) ) );
+					}
+
+					auto identity_form = std::make_shared< ui::c_form >( 0, 1, 215, 0, xors( "timeshift - not done" ) ); {
+						//enabled (key)
+						//on attack
+						//value
+					}
+
+
+					auto helpers_form = std::make_shared< ui::c_form >( 0, 0, 215, 0, xors( "helpers - not done" ) ); {
+						//no push
+						//auto backstab
+						//
+					}
+
+					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.extra.unlock_hidden_cvars( ); } ) );
+					}
+
+					column_left->add_item( movement_form );
+					column_right->add_item( identity_form );
+					column_right->add_item( helpers_form );
+					column_left->add_item( other_form );
+
+				}
+				subtab_sheet->add_item( subtab_general );
+
+				tab_misc->add_item( subtab_sheet );
+			}
+
+
+			auto tab_config = std::make_shared< ui::c_tab_sheet >( xors( "config" ), &icons::sprite_config ); {
+				auto cfg_form = std::make_shared< ui::c_form >( 0, 10, 200, 93, xors( "config" ) );
+				cfg_form->add_item( std::make_shared< ui::c_dropdown< > >( 0, 0, 180, xors( "setting" ), &g_settings.menu.cur_setting, &dropdowns::configs ) );
+				cfg_form->add_item( std::make_shared< ui::c_button >( 0, 0, 85, 20, xors( "save" ), [ ]( ) { g_settings.save( ); } ) );
+				cfg_form->add_item( std::make_shared< ui::c_button >( 95, -25, 85, 20, xors( "load" ), [ ]( ) { g_settings.load( ); } ) );
+				//cfg_form->add_item( std::make_shared< ui::c_button >( 0, -25, 85, 20, xors( "to clipboard" ), [ ]( ) { g_settings.copy_to_clipboard( ); } ) );
+				//cfg_form->add_item( std::make_shared< ui::c_button >( 95, -50, 85, 20, xors( "from clipboard" ), [ ]( ) { g_settings.load_from_clipboard( ); } ) );
+				cfg_form->add_item( std::make_shared< ui::c_checkbox >( 0, -25, xors( "anti-untrusted" ), &g_settings.menu.anti_untrusted ) );
+
+				tab_config->add_item( cfg_form );
+			}
+
+			tab_sheet->add_item( tab_config );
+			tab_sheet->add_item( tab_misc );
+			tab_sheet->add_item( tab_visuals );
+			tab_sheet->add_item( tab_rage );
+			tab_sheet->add_item( tab_legit );
+
+			menu->add_item( tab_sheet );
+
+			was_setup = true;
+		}
+
+			render_item( menu.get( ) );
+
+			//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;
+			}
+		
+	}
+}
+\ No newline at end of file
diff --git a/tf2/ui_base_item.h b/tf2/ui_base_item.h
new file mode 100644
index 0000000..68c2198
--- /dev/null
+++ b/tf2/ui_base_item.h
@@ -0,0 +1,164 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include <functional>
+
+#include "ui_draw.h"
+
+namespace ui
+{
+	//the offset between each item
+	constexpr int ITEM_OFFSET = 5;
+
+	class base_item : public std::enable_shared_from_this< base_item > {
+	public:
+		base_item( ) { }
+		base_item( int x, int y, int w, int h, const char* name = nullptr ) :
+			m_x( x ), m_y( y ), m_width( w ), m_height( h ) {
+			if( name ) {
+				strcpy( m_text, name );
+			}
+		}
+
+		virtual void render( ) { };
+		virtual bool is_hovered( ) { return false; }
+		virtual bool is_form( ) const { return false; }
+
+		virtual void reset( ) {
+			m_y_offset = 0;
+		}
+
+		virtual int get_total_height( ) const {
+			return m_height;
+		}
+
+		void set_y_offset( int offset ) {
+			m_y_offset = offset;
+		}
+
+		int get_y_offset( ) const {
+			return m_y_offset;
+		}
+
+		auto add_item( std::shared_ptr< base_item > item ) {
+			item.get( )->m_parent = shared_from_this( );
+			m_items.emplace( m_items.begin( ), item );
+
+			return item;
+		}
+
+		auto& get_items( ) { return m_items; }
+		auto  get_parent( ) { return m_parent; }
+
+		virtual int x( ) const { return m_x; }
+		virtual int y( ) const { return m_y; }
+		virtual int w( ) const { return m_width; }
+		virtual int h( ) const { return m_height; }
+
+		void set_x( int x ) { m_x = x; }
+		void set_y( int y ) { m_y = y; }
+
+		void set_width( int w ) { m_width = w; }
+		void set_height( int h ) { m_height = h; }
+
+		bool get_visible( ) const {
+			if( m_cond && !m_cond( ) ) {
+				return false;
+			}
+
+			return m_visible;
+		}
+
+		void set_cond( std::function< bool( ) > func ) {
+			m_cond = func;
+		}
+
+		void set_visible( bool vis ) { m_visible = vis; }
+		void set_text( const char* text ) {
+			strcpy( m_text, text );
+		}
+		auto get_text( ) const {
+			return m_text;
+		}
+
+		std::shared_ptr< base_item > find_item( const char* name ) {
+			if( !m_items.empty( ) ) {
+				for( auto& it : m_items ) {
+					if( it->get_text( ) && !strcmp( it->get_text( ), name ) ) {
+						return it;
+					}
+
+					auto it_find = it->find_item( name );
+					if( it_find != it ) return it_find;
+				}
+			}
+
+			return shared_from_this( );
+		}
+
+		auto get_top_parent( ) {
+			for( auto parent = m_parent; ;
+				parent = parent->get_parent( ) ) {
+				if( !parent->get_parent( ) ) {
+					return parent;
+				}
+			}
+
+			return shared_from_this( );
+		}
+
+		int get_relative_x( ) {
+			int x = m_x;
+			for( auto parent = get_parent( ); !!parent;
+				parent = parent->get_parent( ) ) {
+				x += parent->x( );
+			}
+
+			return x;
+		}
+
+		int get_relative_y( ) {
+			int y = m_y + get_y_offset( );
+			for( auto parent = get_parent( ); !!parent;
+				parent = parent->get_parent( ) ) {
+				y += parent->y( ) + parent->get_y_offset( );
+			}
+
+			return y;
+		}
+
+		void set_disabled( bool disabled ) {
+			m_disabled = disabled;
+
+			for( auto& it : m_items ) {
+				it->set_disabled( disabled );
+			}
+		}
+
+		void set_disabled_callbacks( bool disabled ) {
+			auto top = get_top_parent( );
+
+			top->set_disabled( disabled );
+
+			m_disabled = false;
+		}
+
+	protected:
+		int m_x{ };
+		int m_y{ };
+
+		int m_width{ };
+		int m_height{ };
+
+		//current y position for rendering
+		int m_y_offset{ };
+
+		bool m_visible = true;
+		bool m_disabled = false;
+		char m_text[ 256 ]{ };
+
+		std::shared_ptr< base_item > m_parent;
+		std::vector< std::shared_ptr< base_item > > m_items;
+		std::function< bool( ) > m_cond;
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_button.h b/tf2/ui_button.h
new file mode 100644
index 0000000..022fc67
--- /dev/null
+++ b/tf2/ui_button.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <functional>
+
+#include "ui_base_item.h"
+
+namespace ui
+{
+	class c_button : public base_item {
+	public:
+		c_button( int x, int y, int w, int h, const char* name, std::function< void( ) > fn ) :
+			base_item( x, y, w, h, name ), m_fn( fn ) { }
+
+		virtual bool is_hovered( ) override {
+			if ( m_disabled ) return false;
+
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+			int h = m_height;
+
+			int mouse_x, mouse_y;
+			ui_get_cursor_pos( mouse_x, mouse_y );
+
+
+			return mouse_x >= x && mouse_x <= x + m_width
+				&& mouse_y >= y && mouse_y <= y + h;
+		}
+
+
+		virtual void render( ) override {
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+
+			ui_draw_rect( x, y, m_width, m_height, ui_get_disabled_col( ) );
+			ui_draw_outlined_rect( x - 1, y - 1, m_width + 1, m_height + 1,
+				is_hovered( ) ? ui_get_text_col( ) : ui_get_accent_col( ) );
+
+			if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) {
+				ui_draw_rect( x, y, m_width, m_height, ui_get_bg_col( ) );
+				if ( !m_mouse_held ) {
+					m_fn( );
+				}
+				m_mouse_held = true;
+			}
+			else {
+				m_mouse_held = false;
+			}
+
+			ui_draw_string( x + m_width / 2, y + 2, true, ui_get_text_col( ), m_text );
+		}
+
+	protected:
+		std::function< void( ) > m_fn;
+		bool m_mouse_held{ };
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_checkbox.h b/tf2/ui_checkbox.h
new file mode 100644
index 0000000..50cad1c
--- /dev/null
+++ b/tf2/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/tf2/ui_color_picker.h b/tf2/ui_color_picker.h
new file mode 100644
index 0000000..2711d29
--- /dev/null
+++ b/tf2/ui_color_picker.h
@@ -0,0 +1,201 @@
+#pragma once
+
+#include "ui_base_item.h"
+#include "d3d.hpp"
+
+namespace ui
+{
+	class c_color_picker : public base_item {
+		static constexpr int BOX_WIDTH = 106;
+		static constexpr int BOX_HEIGHT = 125;
+	public:
+		c_color_picker( int x, int y, int w, const char* name, clr_t* setting ) :
+			base_item( x, y, w, 4, name ), m_setting( setting ),
+			m_has_text( true ) { }
+
+		c_color_picker( int x, int y, int w, clr_t* setting ) :
+			base_item( x, y, w, 8, xors( "COLOR_PICKER" ) ), m_setting( setting ),
+			m_has_text( false ) { }
+
+		virtual bool is_hovered( ) override {
+			if ( m_disabled ) return false;
+
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+
+			int cursor_x, cursor_y;
+			ui_get_cursor_pos( cursor_x, cursor_y );
+
+			if ( m_has_text ) y += 12;
+
+			if ( !m_active ) {
+				return cursor_x >= x && cursor_x <= x + m_width
+					&& cursor_y >= y && cursor_y <= y + m_height;
+			}
+
+			return cursor_x >= x && cursor_x <= x + BOX_WIDTH + 23
+				&& cursor_y >= y && cursor_y <= y + BOX_HEIGHT + 2;
+		}
+
+		virtual int get_total_height( ) const override {
+			return m_has_text ? ( m_height + 12 ) : m_height;
+		}
+
+		void input( ) {
+			bool active_backup = m_active;
+			bool active_changed = false;
+
+			if ( is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) {
+				if ( !m_active ) {
+					m_mouse_held = true;
+				}
+
+				m_active = true;
+			}
+			else if ( m_active && !is_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) {
+				m_active = false;
+			}
+			else {
+				m_mouse_held = false;
+			}
+
+			active_changed = active_backup != m_active;
+			if ( active_changed ) {
+				set_disabled_callbacks( m_active );
+			}
+
+			m_hue = m_setting->hue( );
+			if ( m_hue > 1.0f ) {
+				m_hue -= 359.f;
+			}
+
+			m_saturation = m_setting->saturation( );
+			m_brightness = m_setting->brightness( ) / 255.f;
+			m_alpha = m_setting->a( );
+		}
+
+		void output( ) {
+			*m_setting = clr_t::from_hsb( m_hue, m_saturation, m_brightness );
+			m_setting->a( ) = m_alpha;
+		}
+
+		virtual void render( ) override {
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+
+			if ( m_has_text ) {
+				ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text );
+				y += 12;
+			}
+
+			input( );
+			
+			if ( m_active ) {
+				RECT old_rect;
+				g_d3d.get_device( )->GetScissorRect( &old_rect );
+				
+				RECT new_rect{
+					x - 1, y - 1, 
+					x + BOX_WIDTH + 22,
+					y + BOX_HEIGHT + 2
+				};
+
+				g_d3d.get_device( )->SetScissorRect( &new_rect );
+
+				int mouse_x, mouse_y;
+				ui_get_cursor_pos( mouse_x, mouse_y );
+
+				clr_t bg_col( 0, 0, 0, 90 );
+				ui_draw_rect( x, y, BOX_WIDTH + 20, BOX_HEIGHT, bg_col );
+				ui_draw_outlined_rect( x - 1, y - 1, BOX_WIDTH + 22, BOX_HEIGHT + 2, ui_get_accent_col( ) );
+
+				for ( int i{ }; i < 100; i += 3 ) {
+					for ( int i2{ }; i2 < 100; i2 += 3 ) {
+						ui_draw_rect( x + i + 1, y + i2 + 1, 3, 3,
+							clr_t::from_hsb( m_hue, float( i2 ) * 0.01f, float( i ) * 0.01f ) );
+					}
+				}
+
+				if ( g_input.is_key_pressed( KEYS_MOUSE1 ) && !m_mouse_held
+					&& mouse_x > x && mouse_x <= x + 100
+					&& mouse_y > y && mouse_y <= y + 100 ) {
+
+					int mouse_x_c = std::clamp( mouse_x, x, x + 100 );
+					int mouse_y_c = std::clamp( mouse_y, y, y + 100 );
+
+					int delta_y = std::clamp( mouse_y_c - y, 0, 100 );
+					int delta_x = std::clamp( mouse_x_c - x, 0, 100 );
+
+					m_saturation = float( delta_y ) * 0.01f;
+					m_brightness = float( delta_x ) * 0.01f;
+				}
+
+				auto is_hue_slider_hovered = [&]( ) -> bool {
+					return mouse_x > x + 110 && mouse_x < x + 122
+						&& mouse_y > y && mouse_y < y + 100;
+				};
+
+				auto draw_slider_hue = [&]( ) {
+					for ( int i{ }; i < 100; ++i ) {
+						auto cur_col = clr_t::from_hsb( float( i ) * 0.01f, m_saturation, m_brightness );
+
+						ui_draw_rect( x + 110, y + i + 1, 12, 2, cur_col );
+					}
+
+					ui_draw_outlined_rect( x + 109, y + int( m_hue * 100.f ) + 1, 14, 3,
+						is_hue_slider_hovered( ) ? ui_get_text_col( ) : ui_get_disabled_col( ) );
+				};
+
+				auto is_alpha_slider_hovered = [&]( ) -> bool {
+					return mouse_x > x + 1 && mouse_x < x + 122
+						&& mouse_y > y + 110 && mouse_y < y + 124;
+				};
+
+				auto draw_slider_alpha = [&]( ) {
+					for ( int i{ 121 }; i >= 0; --i ) {
+						auto col = *m_setting;
+						col.a( ) = ( int )( float( i ) * 255.f / 121.f );
+
+						ui_draw_rect( x + i + 1, y + 110, 1, 12, col );
+					}
+
+					int a_pos = ( int )( float( m_alpha ) * 121.f / 255.f );
+					ui_draw_outlined_rect( x + 1 + a_pos, y + 109, 3, 14,
+						is_alpha_slider_hovered( ) ? ui_get_text_col( ) : ui_get_disabled_col( ) );
+				};
+
+				draw_slider_hue( );
+				if ( is_hue_slider_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) {
+					int delta = std::clamp( mouse_y - y, 0, 100 );
+					m_hue = float( delta ) * 0.01f;
+				}
+
+				draw_slider_alpha( );
+				if ( is_alpha_slider_hovered( ) && g_input.is_key_pressed( KEYS_MOUSE1 ) ) {
+					int delta = std::clamp( mouse_x - x, 0, 121 );
+					m_alpha = ( int )( float( delta ) * 255.f / 121.f );
+				}
+
+				output( );
+
+				g_d3d.get_device( )->SetScissorRect( &old_rect );
+			}
+			else {
+				if ( is_hovered( ) ) {
+					ui_draw_rect( x - 1, y - 1, m_width + 2, m_height + 2, ui_get_text_col( ) );
+				}
+				ui_draw_rect( x, y, m_width, m_height, *m_setting );
+			}
+		}
+
+	protected:
+		clr_t* m_setting	= nullptr;
+		bool m_active		= false;
+		bool m_mouse_held	= false;
+		float m_saturation	= 1.0f;
+		float m_brightness	= 1.0f;
+		float m_hue			= 0.f;
+		uint8_t m_alpha		= 255;
+		bool m_has_text		= false;
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_draw.h b/tf2/ui_draw.h
new file mode 100644
index 0000000..4686bf0
--- /dev/null
+++ b/tf2/ui_draw.h
@@ -0,0 +1,163 @@
+#pragma once
+#include "color.hpp"
+#include "d3d.hpp"
+#include "icons.hpp"
+#include "d3d_sprite.hpp"
+#include "input_system.hpp"
+
+namespace ui
+{
+	extern float get_tf2_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;
+	}*/
+
+	static 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_raw, icons::visuals_size, 66, 66 );
+		icons::sprite_misc.init( device, icons::misc_icon, icons::misc_size, 66, 66 );
+		icons::sprite_config.init( device, icons::config_icon, icons::config_size, 66, 66 );
+	}
+
+	__forceinline clr_t ui_get_accent_col( ) {
+		clr_t col_start = {
+			g_settings.menu.menu_color_1r,
+			g_settings.menu.menu_color_1g,
+			g_settings.menu.menu_color_1b
+		};
+
+		clr_t col_end = {
+			g_settings.menu.menu_color_2r,
+			g_settings.menu.menu_color_2g,
+			g_settings.menu.menu_color_2b
+		};
+
+		clr_t col = clr_t::blend( col_start, col_end, anim_time );
+
+		return col;
+	}
+
+	__forceinline clr_t& ui_get_disabled_col( ) {
+		static clr_t col = clr_t( 61, 61, 61, 255 );
+		return col;
+	}
+
+	__forceinline clr_t& ui_get_bg_col( ) {
+		static clr_t col = clr_t( 24, 25, 27, 255 );
+		return col;
+	}
+
+	__forceinline clr_t& ui_get_text_col( ) {
+		static clr_t col = clr_t( 221, 221, 221, 255 );
+		return col;
+	}
+
+	__forceinline void ui_draw_gradient( int x, int y, int w, int h, clr_t start,
+		clr_t end, GradientType_t type = GRADIENT_HORIZONTAL ) {
+
+		g_d3d.draw_gradient( start, end, x, y, w, h, type );
+	}
+
+	__forceinline void ui_draw_line( int x, int y, int x1, int y1, clr_t color ) {
+		g_d3d.draw_line( color, x, y, x1, y1 );
+	}
+
+	__forceinline void ui_draw_rect( int x, int y, int w, int h, clr_t color ) {
+		g_d3d.draw_filled_rect( color, x, y, w, h );
+	}
+
+	__forceinline void ui_draw_outlined_rect( int x, int y, int w, int h, clr_t color ) {
+		g_d3d.draw_rect( color, x, y, w, h );
+	}
+
+	__forceinline void ui_draw_circle( int x, int y, int r, clr_t color, int res = 48 ) {
+		g_d3d.draw_circle( color, x, y, r, res );
+	}
+
+	__forceinline void ui_draw_filled_circle( int x, int y, int r, clr_t color, int res = 48 ) {
+		g_d3d.draw_filled_circle( color, x, y, r, res );
+	}
+
+	__forceinline void ui_draw_string( int x, int y, bool center, clr_t color, const char* str, ... ) {
+		char buf[ 2048 ]{ };
+		va_list list{ };
+
+		__crt_va_start( list, str );
+		vsprintf_s( buf, 2048, str, list );
+		__crt_va_end( list );
+
+		g_d3d.draw_text( d3d::fonts.f_menu, color, x, y,
+			center ? ALIGN_CENTER : ALIGN_LEFT, D3DFONTFLAG_DROPSHADOW, buf );
+	}
+
+	__forceinline void ui_get_text_size( int& w, int& h, const char* text, ... ) {
+		char*	buf = ( char* )_alloca( 2048 );
+		va_list list{ };
+
+		__crt_va_start( list, text );
+		vsprintf_s( buf, 2048, text, list );
+		__crt_va_end( list );
+
+		w = g_d3d.get_text_width( d3d::fonts.f_menu, 0, buf );
+		h = g_d3d.get_text_height( d3d::fonts.f_menu, 0, buf );
+	}
+
+	__forceinline void ui_get_cursor_pos( int& x, int& y ) {
+		g_input.get_cursor_pos( x, y );
+	}
+
+	__forceinline float ui_get_frametime( ) {
+		return get_tf2_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/tf2/ui_dropdown.h b/tf2/ui_dropdown.h
new file mode 100644
index 0000000..0c4e990
--- /dev/null
+++ b/tf2/ui_dropdown.h
@@ -0,0 +1,217 @@
+#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 = &it;
+				}
+			}
+		}
+
+		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_enable_time = GetTickCount( ) * 0.001f + 0.220f;
+						m_enable_next_frame = true;
+					}
+				}
+			}
+
+			if ( hovered ) {
+				ui_draw_outlined_rect( x - 1, y - 1 + hovered, 
+					m_width + 1, m_height + 1, ui_get_text_col( ) );
+			}
+		}
+
+		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 = !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 > m_enable_time && m_enable_next_frame ) {
+				set_disabled_callbacks( false );
+				m_enable_next_frame = false;
+			}
+
+
+			active_changed = m_active != active_backup;
+			//disable input on all items
+			if ( active_changed ) {
+				if ( !m_active ) {
+					m_enable_time = GetTickCount( ) * 0.001f + 0.220f;
+					m_enable_next_frame = true;
+				}
+				else {
+					set_disabled_callbacks( true );
+				}
+			}
+
+			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;
+		t* m_setting{ };
+		size_t m_max_items{ };
+		size_t m_curr_scroll{ };
+		float m_enable_time{ };
+		int m_enable_next_frame{ };
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_dropdown_item.h b/tf2/ui_dropdown_item.h
new file mode 100644
index 0000000..f77a732
--- /dev/null
+++ b/tf2/ui_dropdown_item.h
@@ -0,0 +1,83 @@
+#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 = {
+			{ "head", 0 },
+			{ "neck", 1 },
+			{ "pelvis", 3 },
+			{ "chest", 6 },
+			{ "thorax", 5 },
+		};
+
+		static std::vector< dropdown_item_t< > > tracer_type = {
+			{ xors( "none" ), 0 },
+			{ xors( "line" ), 1 },
+			{ xors( "beam" ), 2 }
+		};
+
+		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< > > weapon_esp_types = {
+			{ xors( "none" ), 0 },
+			{ xors( "icon" ), 1 },
+			{ xors( "name" ), 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< > > aimbot_bone = {
+			{ "head", 0 },
+			{ "neck", 1 },
+			{ "pelvis", 3 },
+			{ "chest", 6 },
+			{ "thorax", 5 },
+		};
+
+		static std::vector< dropdown_item_t< > > configs = {
+			{ xors( "scout" ), 0 },
+			{ xors( "soldier" ), 1 },
+			{ xors( "pyro" ), 2 },
+			{ xors( "demo" ), 3 },
+			{ xors( "heavy" ), 4 },
+			{ xors( "engineer" ), 5 },
+			{ xors( "medic" ), 6 },
+			{ xors( "sniper" ), 7 },
+			{ xors( "spy" ), 8 },
+			{ xors( "rage 1" ), 9 },
+			{ xors( "rage 2" ), 10 },
+		};
+
+	}
+}
+\ No newline at end of file
diff --git a/tf2/ui_form.h b/tf2/ui_form.h
new file mode 100644
index 0000000..0791528
--- /dev/null
+++ b/tf2/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 ) :
+			base_item( x, y, w, h, name ), m_dynamic( !h ), m_max_height( max_h ), m_collapse( collapse ) { };
+
+		virtual int x( ) const override {
+			return m_x + 10;
+		}
+
+		virtual int y( ) const override {
+			return m_y + m_scroll_offset + 9;
+		}
+
+		virtual bool is_form( ) const override {
+			return true;
+		}
+
+		virtual bool is_hovered( ) override {
+			int mouse_x, mouse_y;
+			ui_get_cursor_pos( mouse_x, mouse_y );
+
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+
+			return mouse_x > x && mouse_x < x + w( )
+				&& mouse_y > y && mouse_y < y + h( );
+		}
+
+		bool is_collapse_hovered( ) {
+			if( !m_collapse ) return false;
+
+			int mouse_x, mouse_y;
+			ui_get_cursor_pos( mouse_x, mouse_y );
+
+			int x = get_relative_x( ) + m_width - 8;
+			int y = get_relative_y( ) + 2;
+
+			return mouse_x >= x && mouse_x <= x + 5
+				&& mouse_y >= y && mouse_y <= y + 7;
+		}
+
+		bool is_collapsed( ) {
+			return ( m_collapse && !m_open );
+		}
+
+		inline void update_size( ) {
+			if ( !m_dynamic ) return;
+
+			int total_height{ ITEM_OFFSET * 2 };
+			for ( auto& it : m_items ) {
+				if ( it->get_visible( ) ) {
+					auto item_height = it->get_total_height( ) + ITEM_OFFSET;
+					if( m_max_height && total_height + item_height > m_max_height ) {
+						total_height = m_max_height;
+						break;
+					}
+					total_height += it->get_total_height( ) + ITEM_OFFSET;
+				}
+			}
+
+			m_height = total_height;
+		}
+
+		virtual int get_total_height( ) const override {
+			if( !m_open && m_collapse ) return 18;
+			return m_height + 5;
+		}
+
+		int get_total_item_height( ) {
+			int total_height{ ITEM_OFFSET * 2 };
+			for( auto& it : m_items ) {
+				if( it->get_visible( ) ) {
+					auto item_height = it->get_total_height( ) + ITEM_OFFSET;
+					total_height += it->get_total_height( ) + ITEM_OFFSET;
+				}
+			}
+
+			return total_height;
+		}
+
+		void input( ) {
+			if( m_collapse ) {
+				bool hovered = is_collapse_hovered( );
+				bool clicked = g_input.is_key_pressed( KEYS_MOUSE1 );
+				if( hovered && clicked ) {
+					if( !m_was_pressed ) {
+						m_open ^= 1;
+					}
+					m_was_pressed = true;
+				}
+				else {
+					m_was_pressed = false;
+				}
+			}
+
+			if( m_max_height && get_total_item_height( ) > m_max_height ) {
+				if( !m_disabled && is_hovered( ) ) {
+					auto scroll_state = g_input.get_scroll_state( );
+					if( !!scroll_state && m_was_hovered ) {
+						scroll_state > 0 ? m_scroll_offset += 13 : m_scroll_offset -= 13;
+					}
+					m_scroll_offset = std::clamp( m_scroll_offset, -( get_total_item_height( ) - m_height + 3 ), 0 );
+				}
+			}
+			else {
+				m_scroll_offset = 0;
+			}
+		}
+
+		virtual void render( ) override {
+			update_size( );
+			input( );
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+
+			int text_w, text_h;
+			ui_get_text_size( text_w, text_h, m_text );
+
+			if( m_collapse ) {
+				if( !m_open && m_collapse ) {
+					ui_draw_outlined_rect( x, y, m_width, 14, ui_get_accent_col( ) );
+					ui_draw_line( x + 3, y, x + text_w + 1, y, ui_get_bg_col( ) );
+					ui_draw_string( x + 3, y - 7, false, ui_get_text_col( ), m_text );
+
+					int button_x = x + m_width - 6;
+					int button_y = y + 2;
+
+					ui_draw_string( button_x, button_y, true,
+						is_collapse_hovered( ) ? ui_get_accent_col( ) : ui_get_text_col( ), "+" );
+					return;
+				}
+			}
+
+			for( int i{ }; i < 8; ++i ) {
+				clr_t col = ui_get_bg_col( ) * ( 0.72f + i * 0.04f );
+				ui_draw_rect( x, y + i, m_width, m_height - i * 2, col );
+			}
+
+			ui_draw_outlined_rect( x, y, m_width, m_height, ui_get_accent_col( ) );
+
+			if( m_max_height && get_total_item_height( ) > m_height ) {
+				const size_t height = get_total_height( ) - 20;
+				const float delta = ( float )( get_total_item_height( ) - height + 1 );
+				const float slider_step = ( ( float )( height ) / delta );
+				const float slider_height = slider_step * 13.f;
+
+				size_t slider_pos = static_cast< size_t >( slider_step * m_scroll_offset );
+				ui_draw_rect( x + m_width - 7, y + 8, 4, height, ui_get_disabled_col( ) );
+				ui_draw_rect( x + m_width - 7, y - slider_pos + 8, 4, ( int )slider_height + 1, ui_get_accent_col( ) );
+			}
+
+			if( is_hovered( ) != m_was_hovered ) {
+				bool backup = m_disabled;
+				if( !backup ) {
+					set_disabled( !is_hovered( ) );
+				}
+				m_disabled = backup;
+			}
+
+			ui_draw_line( x + 3, y, x + text_w + 1, y, ui_get_bg_col( ) );
+			ui_draw_string( x + 3, y - 7, false, ui_get_text_col( ), m_text );
+			if( m_collapse ) {
+				int button_x = x + m_width - 6;
+				int button_y = y + 2;
+
+				ui_draw_string( button_x, button_y, true,
+					is_collapse_hovered( ) ? ui_get_accent_col( ) : ui_get_text_col( ), "-" );
+			}
+
+			m_was_hovered = is_hovered( );
+		}
+
+	protected:
+		bool m_dynamic{ };
+		bool m_was_hovered{ };
+		int m_max_height{ };
+		int m_scroll_offset{ };
+		bool m_was_pressed{ };
+		bool m_collapse{ };
+		bool m_open{ true };
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_key_picker.h b/tf2/ui_key_picker.h
new file mode 100644
index 0000000..03aed84
--- /dev/null
+++ b/tf2/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/tf2/ui_label.h b/tf2/ui_label.h
new file mode 100644
index 0000000..9df46b5
--- /dev/null
+++ b/tf2/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/tf2/ui_menu.h b/tf2/ui_menu.h
new file mode 100644
index 0000000..aae68a9
--- /dev/null
+++ b/tf2/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/tf2/ui_render.h b/tf2/ui_render.h
new file mode 100644
index 0000000..f67f16b
--- /dev/null
+++ b/tf2/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/tf2/ui_slider.h b/tf2/ui_slider.h
new file mode 100644
index 0000000..0e55a73
--- /dev/null
+++ b/tf2/ui_slider.h
@@ -0,0 +1,165 @@
+#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 );
+
+			ui_draw_string( x + ( int )( ( m_width - 8 ) * progress ) + 3, y + 2, true, ui_get_text_col( ), val_str );
+		}
+
+		virtual int get_total_height( ) const override {
+			return m_height + ( m_has_text ? 12 : 6 );
+		}
+
+		virtual void render( ) override {
+			int x = get_relative_x( );
+			int y = get_relative_y( );
+			int text_w, text_h;
+			char val[ 12 ];
+
+			input( );
+
+			//weird hacky fix for floating point vars
+			if ( m_suffix )
+				sprintf_s( val, 12, t( 0.1f ) == t( 0 ) ? "%d %s" : "%0.2f %s", *m_setting, m_suffix );
+			else 
+				sprintf_s( val, 12, t( 0.1f ) == t( 0 ) ? "%d" : "%0.2f", *m_setting );
+
+			if( m_has_text ) {
+				ui_draw_string( x + 2, y, false, ui_get_text_col( ), m_text );
+				ui_get_text_size( text_w, text_h, val );
+				ui_draw_string( x + m_width - text_w - 1, y, false, ui_get_text_col( ), val );
+				draw_slider( x, y + 12 );
+			}
+			else {
+				draw_slider_small( x, y + 2 );
+			}
+		}
+
+
+	protected:
+		t*			m_setting;
+		t			m_full;
+		float		m_min;
+		float		m_max;
+		bool		m_has_text = true;
+		const char* m_suffix;
+		bool		m_mouse_held = false;
+	};
+}
+\ No newline at end of file
diff --git a/tf2/ui_tab_manager.h b/tf2/ui_tab_manager.h
new file mode 100644
index 0000000..76258c8
--- /dev/null
+++ b/tf2/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/tf2/ui_text_input.h b/tf2/ui_text_input.h
new file mode 100644
index 0000000..f486106
--- /dev/null
+++ b/tf2/ui_text_input.h
@@ -0,0 +1,47 @@
+#pragma once
+#include "ui_base_item.h"
+
+namespace ui
+{
+	class c_text_input : public base_item {
+		c_text_input( int x, int y, int w, const char* name, size_t max_chars, char* str ) :
+			base_item( x, y, w, 16, name ), m_length( max_chars ), m_str( str ) { }
+
+		virtual bool is_hovered( ) override {
+
+		}
+
+		void input( ) {
+			static float last_press[ KEYS_MAX ]{ };
+
+			int key = g_input.is_any_key_pressed( );
+			if ( key == KEYS_BACK ) {
+				if ( strlen( m_str ) ) {
+					m_str[ strlen( m_str ) - 1 ] = 0;
+				}
+			}
+			if ( key != KEYS_NONE ) {
+				float cur_time = GetTickCount( ) * 0.001f;
+				if ( std::abs( cur_time - last_press[ key ] ) > 0.1f ) {
+
+					auto scan_code = MapVirtualKeyA( key, MAPVK_VK_TO_VSC );
+					uword_t ascii;
+					ToAscii( key, scan_code, 0, &ascii, 0 );
+					char str[ 2 ] = { ( char )ascii, 0 };
+					strcat_s( m_str, m_length, str );
+
+					last_press[ key ] = cur_time;
+				}
+			}
+		}
+
+		virtual void render( ) override {
+
+		}
+
+	protected:
+		size_t	m_length{ };
+		char*	m_str{ };
+
+	};
+}
+\ No newline at end of file
diff --git a/tf2/util.cpp b/tf2/util.cpp
new file mode 100644
index 0000000..424df71
--- /dev/null
+++ b/tf2/util.cpp
@@ -0,0 +1,223 @@
+#include "util.hpp"
+
+#include "interfaces.h"
+#include "CBasePlayer.h"
+#include "pattern.hpp"
+#include "ctx.hpp"
+#include "settings.h"
+#include "math.h"
+#include "base_cheat.h"
+
+float TICK_INTERVAL( ) {
+	return cl.m_globals->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 cl.m_globals->frametime > cl.m_globals->interval_per_tick;
+}
+
+int util::get_closest_player( ) {
+	float	cur_fov{ 360.f };
+	int		ret{ -1 };
+	vec3_t	viewangles{ };
+	vec3_t	local_pos{ };
+
+	bool friendlies = g_settings.legit.friendlies;
+
+	local_pos = g_ctx.m_local->get_eye_pos( );
+	cl.m_engine( )->GetViewAngles( viewangles );
+
+	for( int i{ 1 }; i < cl.m_globals->maxclients; ++i ) {
+		auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+
+		if( !ent ) continue;
+		if( ent == g_ctx.m_local ) continue;
+		if( !ent->is_valid( ) ) continue;
+		int team = ent->get_team( );
+		if( team == g_ctx.m_local->get_team( ) && !friendlies ) {
+			continue;
+		}
+
+		auto ang = math::vector_angles( local_pos, ent->get_hitbox_position( 0 ) );
+		ang.clamp( );
+
+		float fov = ( viewangles - ang ).clamp( ).length2d( );
+		if( fov < cur_fov ) {
+			ret = i;
+			cur_fov = fov;
+		}
+	}
+
+	return ret;
+}
+
+void util::clip_trace_to_player( IClientEntity* player, vec3_t& src, 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;
+	}
+
+	cl.m_trace( )->clip_ray_to_ent( ray, mask | CONTENTS_HITBOX, player, &player_trace );
+
+	if( player_trace.fraction < smallest_fraction ) {
+		*tr = player_trace;
+		smallest_fraction = player_trace.fraction;
+	}
+}
+
+
+bool util::trace_ray( vec3_t& start, vec3_t& end, IClientEntity* a, IClientEntity* b ) {
+	CGameTrace tr;
+	Ray_t ray;
+	CTraceFilter filter;
+
+	filter.pSkip = a;
+
+	ray.Init( start, end );
+
+	cl.m_trace( )->trace_ray( 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 );
+}
+
+vec3_t util::get_spread_dir( float inaccuracy, float spread, vec3_t angles, int seed ) {
+	set_random_seed( ( seed & 0xff ) + 1 );
+
+	float rand_a = get_random_float( 0.0f, 1.0f );
+	float pi_rand_a = get_random_float( 0.f, 2.f * M_PI );
+	float rand_b = get_random_float( 0.f, 1.0f );
+	float pi_rand_b = 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( );
+
+	return spread_dir;
+}
+
+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 );
+}
+
+float util::get_total_latency( ) {
+	auto nci = cl.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 = cl.m_cvar( )->FindVar( xors( "cl_interpolate" ) );
+	static cvar_t* cl_interp = cl.m_cvar( )->FindVar( xors( "cl_interp" ) );
+	static cvar_t* cl_updaterate = cl.m_cvar( )->FindVar( xors( "cl_updaterate" ) );
+	static cvar_t* cl_interp_ratio = cl.m_cvar( )->FindVar( xors( "cl_interp_ratio" ) );
+
+	if( cl_interp && cl_interpolate && cl_updaterate && cl_interp_ratio ) {
+		bool interpolate = cl_interpolate->get_int( );
+		if( interpolate ) {
+			float interp = cl_interp->get_float( );
+			float interp_ratio = cl_interp_ratio->get_float( );
+			float updaterate = cl_updaterate->get_float( );
+
+			return std::max< float >( interp, interp_ratio / updaterate );
+		}
+	}
+
+	return 0.f;
+}
+
+bool util::is_tick_valid( int tickcount ) {
+	float latency = get_total_latency( );
+	float correct = std::clamp( latency + get_lerptime( ), 0.f, 1.f );
+	float delta = correct - ( g_ctx.pred_time( ) - TICKS_TO_TIME( tickcount ) );
+
+
+	return std::abs( delta ) < 0.2f;
+}
+
+void util::disable_pvs( ) {
+	for( int i{ 1 }; i < 65; ++i ) {
+		auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+
+		if( !ent || !ent->is_valid( ) )
+			continue;
+
+		if( ent == g_ctx.m_local )
+			continue;
+
+		*( int* )( uintptr_t( ent ) + 0xa30 ) = cl.m_globals->framecount;
+		*( int* )( uintptr_t( ent ) + 0xa28 ) = 0;
+	}
+}
+
+vec2_t util::screen_transform( vec3_t world ) {
+	vec3_t tmp; cl.m_overlay( )->ScreenPosition( world, tmp );
+	const matrix3x4& w2s_matrix = cl.m_engine( )->GetWorldToScreenMatrix( );
+	float w = w2s_matrix[ 3 ][ 3 ];
+	for( int i{ }; i < 3; i++ ) {
+		w += w2s_matrix[ 3 ][ i ] * world[ i ];
+	}
+	if( w < 0.001f ) return{ 10000.f, 10000.f };
+
+	return{ tmp.x, tmp.y };
+}
+
+const char* util::object_index_to_name( int index ) {
+	index = std::clamp( index, 0, 65 );
+
+	switch( index ) {
+	case 89:
+		return xors( "teleporter" );
+	case 86:
+		return xors( "dispenser" );
+	case 88:
+		return xors( "sentry" );
+	default:
+		return xors( "none" );
+	}
+}
+
diff --git a/tf2/util.hpp b/tf2/util.hpp
new file mode 100644
index 0000000..7aaa007
--- /dev/null
+++ b/tf2/util.hpp
@@ -0,0 +1,100 @@
+#pragma once
+#include <inttypes.h>
+#include <string>
+#include "strings.hpp"
+
+#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 );
+	}
+};
+
+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, vec3_t& src, vec3_t& end,
+	unsigned mask, CTraceFilter* filter, CGameTrace* trace );
+
+extern bool trace_ray( vec3_t& start, 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( float inaccuracy, float spread, vec3_t angles, int seed );
+extern float get_random_float( float min, float max );
+extern bool __vectorcall intersects_hitbox( vec3_t eye_pos, vec3_t end_pos, vec3_t min, vec3_t max, float radius );
+extern bool hitchance( int target, const vec3_t& angles, int percentage );
+extern bool hitchance( int target, const vec3_t& angle, int percentage, int hi );
+extern float get_total_latency( );
+extern float get_lerptime( );
+extern int get_closest_player( );
+extern vec2_t screen_transform( vec3_t world );
+extern const char* object_index_to_name( int index );
+extern void disable_pvs( );
+
+END_REGION
+\ No newline at end of file
diff --git a/tf2/vector.hpp b/tf2/vector.hpp
new file mode 100644
index 0000000..af24136
--- /dev/null
+++ b/tf2/vector.hpp
@@ -0,0 +1,334 @@
+#pragma once
+#include <cmath>
+#include <algorithm>
+
+
+class vec2_t {
+public:
+	vec2_t( ) {
+		x = y = 0.0f;
+	}
+
+	vec2_t( float X, float Y ) {
+		x = X; y = Y;
+	}
+
+	vec2_t( float* v ) {
+		x = v[ 0 ]; y = v[ 1 ];
+	}
+
+	vec2_t( const float* v ) {
+		x = v[ 0 ]; y = v[ 1 ];
+	}
+
+	vec2_t( const vec2_t& v ) {
+		x = v.x; y = v.y;
+	}
+
+	vec2_t& operator=( const vec2_t& v ) {
+		x = v.x; y = v.y; return *this;
+	}
+
+	float& operator[]( int i ) {
+		return ( ( float* )this )[ i ];
+	}
+
+	float operator[]( int i ) const {
+		return ( ( float* )this )[ i ];
+	}
+
+	vec2_t& operator+=( const vec2_t& v ) {
+		x += v.x; y += v.y; return *this;
+	}
+
+	vec2_t& operator-=( const vec2_t& v ) {
+		x -= v.x; y -= v.y; return *this;
+	}
+
+	vec2_t& operator*=( const vec2_t& v ) {
+		x *= v.x; y *= v.y; return *this;
+	}
+
+	vec2_t& operator/=( const vec2_t& v ) {
+		x /= v.x; y /= v.y; return *this;
+	}
+
+	vec2_t& operator+=( float v ) {
+		x += v; y += v; return *this;
+	}
+
+	vec2_t& operator-=( float v ) {
+		x -= v; y -= v; return *this;
+	}
+
+	vec2_t& operator*=( float v ) {
+		x *= v; y *= v; return *this;
+	}
+
+	vec2_t& operator/=( float v ) {
+		x /= v; y /= v; return *this;
+	}
+
+	vec2_t operator+( const vec2_t& v ) const {
+		return vec2_t( x + v.x, y + v.y );
+	}
+
+	vec2_t operator-( const vec2_t& v ) const {
+		return vec2_t( x - v.x, y - v.y );
+	}
+
+	vec2_t operator*( const vec2_t& v ) const {
+		return vec2_t( x * v.x, y * v.y );
+	}
+
+	vec2_t operator/( const vec2_t& v ) const {
+		return vec2_t( x / v.x, y / v.y );
+	}
+
+	vec2_t operator+( float v ) const {
+		return vec2_t( x + v, y + v );
+	}
+
+	vec2_t operator-( float v ) const {
+		return vec2_t( x - v, y - v );
+	}
+
+	vec2_t operator*( float v ) const {
+		return vec2_t( x * v, y * v );
+	}
+
+	vec2_t operator/( float v ) const {
+		return vec2_t( x / v, y / v );
+	}
+
+	void set( float X = 0.0f, float Y = 0.0f ) {
+		x = X; y = Y;
+	}
+
+	float length( void ) const {
+		return sqrtf( x * x + y * y );
+	}
+
+	float lengthsqr( void ) const {
+		return ( x * x + y * y );
+	}
+
+	float dist_to( const vec2_t& v ) const {
+		return ( *this - v ).length( );
+	}
+
+	float dist_to_sqr( const vec2_t& v ) const {
+		return ( *this - v ).lengthsqr( );
+	}
+
+	float dot( const vec2_t& v ) const {
+		return ( x * v.x + y * v.y );
+	}
+
+	bool is_zero( void ) const {
+		return ( x > -FLT_EPSILON && x < FLT_EPSILON &&
+			y > -FLT_EPSILON && y < FLT_EPSILON );
+	}
+
+	operator bool( ) const noexcept {
+		return !is_zero( );
+	}
+
+public:
+	float x, y;
+};
+
+class vec3_t {
+public:
+	vec3_t( ) {
+		x = y = z = 0.0f;
+	}
+
+	vec3_t( float X, float Y, float Z ) {
+		x = X; y = Y; z = Z;
+	}
+
+	vec3_t( float* v ) {
+		x = v[ 0 ]; y = v[ 1 ]; z = v[ 2 ];
+	}
+
+	vec3_t( const float* v ) {
+		x = v[ 0 ]; y = v[ 1 ]; z = v[ 2 ];
+	}
+
+	vec3_t( const vec3_t& v ) {
+		x = v.x; y = v.y; z = v.z;
+	}
+
+	vec3_t( const vec2_t& v ) {
+		x = v.x; y = v.y; z = 0.0f;
+	}
+
+	__forceinline vec3_t& operator=( const vec3_t& v ) {
+		x = v.x; y = v.y; z = v.z; return *this;
+	}
+
+	__forceinline vec3_t& operator=( const vec2_t& v ) {
+		x = v.x; y = v.y; z = 0.0f; return *this;
+	}
+
+	float& operator[]( int i ) {
+		return ( ( float* )this )[ i ];
+	}
+
+	__forceinline float operator[]( int i ) const {
+		return ( ( float* )this )[ i ];
+	}
+
+	vec3_t& operator+=( const vec3_t& v ) {
+		x += v.x; y += v.y; z += v.z; return *this;
+	}
+
+	vec3_t& operator-=( const vec3_t& v ) {
+		x -= v.x; y -= v.y; z -= v.z; return *this;
+	}
+
+	vec3_t& operator*=( const vec3_t& v ) {
+		x *= v.x; y *= v.y; z *= v.z; return *this;
+	}
+
+	vec3_t& operator/=( const vec3_t& v ) {
+		x /= v.x; y /= v.y; z /= v.z; return *this;
+	}
+
+	vec3_t& operator+=( float v ) {
+		x += v; y += v; z += v; return *this;
+	}
+
+	vec3_t& operator-=( float v ) {
+		x -= v; y -= v; z -= v; return *this;
+	}
+
+	vec3_t& operator*=( float v ) {
+		x *= v; y *= v; z *= v; return *this;
+	}
+
+	vec3_t& operator/=( float v ) {
+		x /= v; y /= v; z /= v; return *this;
+	}
+
+	__forceinline vec3_t operator+( const vec3_t& v ) const {
+		return vec3_t( x + v.x, y + v.y, z + v.z );
+	}
+
+	__forceinline vec3_t operator-( const vec3_t& v ) const {
+		return vec3_t( x - v.x, y - v.y, z - v.z );
+	}
+
+	__forceinline vec3_t operator*( const vec3_t& v ) const {
+		return vec3_t( x * v.x, y * v.y, z * v.z );
+	}
+
+	__forceinline vec3_t operator/( const vec3_t& v ) const {
+		return vec3_t( x / v.x, y / v.y, z / v.z );
+	}
+
+	__forceinline vec3_t operator+( float v ) const {
+		return vec3_t( x + v, y + v, z + v );
+	}
+
+	__forceinline vec3_t operator-( float v ) const {
+		return vec3_t( x - v, y - v, z - v );
+	}
+
+	__forceinline vec3_t operator*( float v ) const {
+		return vec3_t( x * v, y * v, z * v );
+	}
+
+	__forceinline vec3_t operator/( float v ) const {
+		return vec3_t( x / v, y / v, z / v );
+	}
+
+	__forceinline float length( ) const {
+		return sqrtf( x * x + y * y + z * z );
+	}
+
+	__forceinline float lengthsqr( ) const {
+		return ( x * x + y * y + z * z );
+	}
+
+	__forceinline float length2d( ) const {
+		return sqrtf( x * x + y * y );
+	}
+
+	__forceinline float length2dsqr( ) const {
+		return ( x * x + y * y );
+	}
+
+	__forceinline float dist_to( const vec3_t& v ) const {
+		return ( *this - v ).length( );
+	}
+
+	__forceinline float dist_to_sqr( const vec3_t& v ) const {
+		return ( *this - v ).lengthsqr( );
+	}
+
+	__forceinline float dot( const vec3_t& v ) const {
+		return ( x * v.x + y * v.y + z * v.z );
+	}
+
+	__forceinline float fov_to( 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/tf2/visuals.hpp b/tf2/visuals.hpp
new file mode 100644
index 0000000..2f8e9f3
--- /dev/null
+++ b/tf2/visuals.hpp
@@ -0,0 +1,56 @@
+#pragma once
+#include <vector>
+#include "vector.hpp"
+#include "color.hpp"
+#include <unordered_map>
+#include "strings.hpp"
+#include "IVRenderView.h"
+class c_base_player;
+
+namespace features
+{
+	class c_visuals {
+	private:
+		static const clr_t esp_green( uint8_t alpha = 255 ) {
+			return clr_t( 1, 216, 62, alpha );
+		}
+		static const clr_t esp_red( uint8_t alpha = 255 ) {
+			return clr_t( 240, 0, 0, alpha );
+		}
+		static const clr_t esp_blue( uint8_t alpha = 255 ) {
+			return clr_t( 84, 173, 247, alpha );
+		}
+
+		void draw_line( const vec2_t& a, const vec2_t& b, const clr_t& clr );
+		void draw_line( int x, int y, int x1, int y1, const clr_t& clr );
+		void draw_rect( int x, int y, int w, int h, const clr_t& clr );
+		void draw_filled_rect( int x, int y, int w, int h, const clr_t& clr );
+		void draw_circle( int x, int y, int r, const clr_t& clr, int res = 48 );
+
+		void draw_really_big_string( int x, int y, const clr_t& clr, const char* msg, ... );
+		void draw_string( int x, int y, int align, bool big, const clr_t& clr, const char* msg, ... );
+
+
+		void draw_local( );
+		void draw_players( );
+		void draw_world( );
+
+		void draw_hits( );
+		void spectator_list( );
+		//void throwable_prediction( );
+
+		void invalidate_glow( );
+
+		vec3_t m_stored_pos[ 65 ]{ };
+		float  m_anim_progress[ 65 ]{ };
+		float  m_last_hit{ };
+		int    m_ent_dmg[ 65 ]{ };
+	public:
+		void update_glow( );
+		void world_modulate( );
+		void update_position( int index, const vec3_t& pos );
+		void out_of_fov( c_base_player* ent, const vec3_t& pos, clr_t col );
+		void store_hit( );
+		void operator()( );
+	};
+}
+\ No newline at end of file
diff --git a/tf2/visuals_draw.cpp b/tf2/visuals_draw.cpp
new file mode 100644
index 0000000..87c476b
--- /dev/null
+++ b/tf2/visuals_draw.cpp
@@ -0,0 +1,94 @@
+#include "d3d.hpp"
+#include "interfaces.h"
+#include "renderer.hpp"
+#include "visuals.hpp"
+#include "settings.h"
+
+namespace features
+{
+	void c_visuals::draw_line( const vec2_t& a, const vec2_t& b, const clr_t& clr ) {
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_line( clr, a.x, a.y, b.x, b.y );
+		else
+			g_renderer.draw_line( a, b, clr );
+	}
+
+	void c_visuals::draw_line( int x, int y, int x1, int y1, const clr_t& clr ) {
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_line( clr, x, y, x1, y1 );
+		else
+			g_renderer.draw_line( x, y, x1, y1, clr );
+	}
+
+	void c_visuals::draw_rect( int x, int y, int w, int h, const clr_t& clr ) {
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_rect( clr, x, y, w, h );
+		else
+			g_renderer.draw_box( x, y, w, h, clr );
+	}
+
+	void c_visuals::draw_filled_rect( int x, int y, int w, int h, const clr_t& col ) {
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_filled_rect( col, x, y, w, h );
+		else
+			g_renderer.draw_rect( x, y, w, h, col );
+	}
+
+	void c_visuals::draw_circle( int x, int y, int r, const clr_t& col, int res ) {
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_circle( col, x, y, r, res );
+		else
+			g_renderer.draw_circle( x, y, r, col, res );
+	}
+
+	void c_visuals::draw_string( int x, int y, int align, bool big, const clr_t& col, const char* msg, ... ) {
+		char* buffer = ( char* )_alloca( 1024 );
+		va_list list{ };
+
+		memset( buffer, 0, 1024 );
+
+		__crt_va_start( list, msg );
+		vsprintf_s( buffer, 1024, msg, list );
+		__crt_va_end( list );
+
+		switch( align ) {
+		case ALIGN_CENTER:
+			if( g_settings.misc.hide_from_obs )
+				g_d3d.draw_text< ALIGN_CENTER >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer );
+			else
+				g_renderer.draw_string< ALIGN_CENTER >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer );
+
+			break;
+		case ALIGN_LEFT:
+			if( g_settings.misc.hide_from_obs )
+				g_d3d.draw_text< ALIGN_LEFT >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer );
+			else
+				g_renderer.draw_string< ALIGN_LEFT >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer );
+
+			break;
+		case ALIGN_RIGHT:
+			if( g_settings.misc.hide_from_obs )
+				g_d3d.draw_text< ALIGN_RIGHT >( big ? ::d3d::fonts.f_12 : ::d3d::fonts.f_esp_small, col, x, y, big ? D3DFONTFLAG_DROPSHADOW : D3DFONTFLAG_OUTLINE, buffer );
+			else
+				g_renderer.draw_string< ALIGN_RIGHT >( big ? g_fonts.f_12 : g_fonts.f_esp_small, x, y, col, buffer );
+
+			break;
+		}
+	}
+
+	void c_visuals::draw_really_big_string( int x, int y, const clr_t& col, const char* msg, ... ) {
+		char* buffer = ( char* )_alloca( 1024 );
+		va_list list{ };
+
+		memset( buffer, 0, 1024 );
+
+		__crt_va_start( list, msg );
+		vsprintf_s( buffer, 1024, msg, list );
+		__crt_va_end( list );
+
+		if( g_settings.misc.hide_from_obs )
+			g_d3d.draw_text< ALIGN_LEFT >( ::d3d::fonts.f_18, col, x, y, D3DFONTFLAG_OUTLINE, buffer );
+		else
+			g_renderer.draw_string< ALIGN_LEFT >( g_fonts.f_bold, x, y, col, msg );
+	}
+}
+\ No newline at end of file
diff --git a/tf2/visuals_local.cpp b/tf2/visuals_local.cpp
new file mode 100644
index 0000000..7f549d9
--- /dev/null
+++ b/tf2/visuals_local.cpp
@@ -0,0 +1,207 @@
+#include <algorithm>
+
+#include "visuals.hpp"
+#include "ctx.hpp"
+#include "base_cheat.h"
+#include "renderer.hpp"
+#include "input_system.hpp"
+#include "math.h"
+#include "settings.h"
+#include "interfaces.h"
+namespace features
+{
+	void c_visuals::draw_local( ) {
+		int screen_w, screen_h;
+		cl.m_engine( )->GetScreenSize( screen_w, screen_h );
+
+		int cur_pos{ };
+
+
+		if( g_settings.misc.no_scope( ) &&
+			g_ctx.m_local->m_bIsScoped( ) ) {
+			int w, h;
+			cl.m_engine( )->GetScreenSize( w, h );
+
+			draw_line( 0, h / 2, w, h / 2, clr_t( 0, 0, 0 ) );
+			draw_line( w / 2, 0, w / 2, h, clr_t( 0, 0, 0 ) );
+		}
+		spectator_list( );
+		//throwable_prediction( ); -- sometime when i can be fucked
+	}
+
+	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 = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+			if( ent && ent->is_player( ) && !ent->ce( )->is_dormant( ) ) {
+				auto spec_handle = ent->m_hObserverTarget( );
+				auto spec_ent = cl.m_entlist( )->get_entity_from_handle< c_base_player >( 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;
+		cl.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;
+		}
+	}
+	//i wanna do this
+	/*
+	void c_visuals::throwable_prediction( ) {
+		static auto sv_gravity = cl.m_cvar( )->FindVar( xors( "sv_gravity" ) );
+
+		if( !g_settings.visuals.grenade_prediction )
+			return;
+
+		
+		/*
+		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_active_weapon( );
+		if( !weapon ) return;
+
+		int def_index = weapon->m_iItemDefinitionIndex( );
+		if( weapon->has_trajectory( ) )
+			return;
+
+		auto wpn_info = weapon->get_wpn_info( );
+
+		vec3_t throw_ang, forward;
+		cl.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 ) );
+
+		cl.m_trace( )->trace_ray( 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 ) );
+
+			cl.m_trace( )->trace_ray( ray, CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_MONSTER | CONTENTS_CURRENT_90, &filter, &trace );
+			if( trace.allsolid )
+				throw_pos = vec3_t( );
+
+			end_pos = trace.endpos;
+			draw_3d_line( src, end_pos, clr_t( 66, 143, 244 ) );
+
+			if( trace.fraction != 1.f ) {
+				float surf_elasticity = 1.f;
+				vec3_t throw_pos2{ };
+				clip_velocity( throw_pos, trace.plane.normal, throw_pos2, 2.f );
+
+				if( trace.m_pEnt && cl.m_engine( )->GetPlayerInfo( trace.m_pEnt->index( ), &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 ) );
+				cl.m_trace( )->trace_ray( ray, CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_MONSTER | CONTENTS_CURRENT_90, &filter, &trace );
+
+				draw_3d_line( end_pos, end, clr_t( 66, 143, 244 ), true );
+				end_pos = trace.endpos;
+				throw_pos = throw_pos2;
+			}
+		}
+	}*/
+
+}
+\ No newline at end of file
diff --git a/tf2/visuals_objects.cpp b/tf2/visuals_objects.cpp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tf2/visuals_objects.cpp
diff --git a/tf2/visuals_players.cpp b/tf2/visuals_players.cpp
new file mode 100644
index 0000000..8b9aaf9
--- /dev/null
+++ b/tf2/visuals_players.cpp
@@ -0,0 +1,551 @@
+#include <algorithm>
+
+#include "visuals.hpp"
+#include "ctx.hpp"
+#include "base_cheat.h"
+#include "renderer.hpp"
+#include "input_system.hpp"
+#include "math.h"
+#include "settings.h"
+#include "interfaces.h"
+//2k lines of code here
+int screen_w, screen_h;
+
+namespace features
+{
+	void c_visuals::update_position( int index, const vec3_t& pos ) {
+		m_stored_pos[ index ] = pos;
+		if( m_anim_progress[ index ] <= 0.3f && g_settings.visuals.dormant ) {
+			m_anim_progress[ index ] = 0.3f;
+		}
+	}
+
+	void c_visuals::store_hit( ) {
+		if( !g_settings.visuals.hitmarkers )
+			return;
+
+		cl.m_surface( )->play_sound( xors( "buttons\\arena_switch_press_02.wav" ) );
+		m_last_hit = cl.m_globals->curtime;
+	}
+
+
+	void c_visuals::draw_hits( ) {
+		if( !g_settings.visuals.hitmarkers || !g_ctx.run_frame( ) )
+			return;
+
+		static const clr_t col_start = clr_t( 231, 75, 75, 255 );
+		static const clr_t col_end = clr_t( 0xf4, 0x7c, 0xa8, 255 );
+
+		float delta = ( cl.m_globals->curtime - m_last_hit ) * 1.5f;
+		if( std::abs( delta ) > 1.0f ) return;
+
+		clr_t blend = clr_t::blend( col_start, col_end, delta );
+		if( delta > 0.75f ) {
+			blend.a( ) = 255 * ( 1.0f - delta ) * 4.f;
+		}
+
+		auto get_rotated_point = [ ]( vec2_t point, float rotation, float distance ) {
+			float rad = DEG2RAD( rotation );
+
+			point.x += sin( rad ) * distance;
+			point.y += cos( rad ) * distance;
+
+			return point;
+		};
+
+
+		for( size_t i{ }; i < 2; ++i ) {
+			float rotation = 135.f + i * 90.f;
+
+			vec2_t center = { screen_w * 0.5f, screen_h * 0.5f };
+			vec2_t start = get_rotated_point( center, rotation, 8.f );
+			vec2_t end = get_rotated_point( center, rotation, 17.f );
+
+			vec2_t rot_start = get_rotated_point( center, rotation - 180.f, 8.f );
+			vec2_t rot_end = get_rotated_point( center, rotation - 180.f, 17.f );
+
+			draw_line( start, end, blend );
+			draw_line( rot_start, rot_end, blend );
+		}
+	}
+
+	struct box_t {
+		int x, y, w, h;
+	};
+
+	box_t get_box( c_base_player* ent ) {
+		const matrix3x4& matrix = ent->m_CollisionGroup( );
+
+		vec3_t min = ent->m_vecMins( );
+		vec3_t max = ent->m_vecMaxs( );
+
+		std::array< vec3_t, 8 > point_list = {
+			vec3_t{ min.x, min.y, min.z },
+			vec3_t{ min.x, max.y, min.z },
+			vec3_t{ max.x, max.y, min.z },
+			vec3_t{ max.x, min.y, min.z },
+			vec3_t{ max.x, max.y, max.z },
+			vec3_t{ min.x, max.y, max.z },
+			vec3_t{ min.x, min.y, max.z },
+			vec3_t{ max.x, min.y, max.z }
+		};
+
+		std::array< float, 8 > x_points;
+		std::array< float, 8 > y_points;
+
+		vec2_t origin = util::screen_transform( ent->m_vecOrigin( ) );
+
+		for( auto& it : point_list ) {
+			vec3_t backup = it;
+			for( int i{ }; i < 3; ++i ) {
+				it[ i ] = backup.dot( ( const vec3_t& )( matrix[ i ] ) ) + matrix[ i ][ 3 ];
+			}
+		}
+
+		for( size_t i{ }; i < 8; ++i ) {
+			vec2_t w2s = util::screen_transform( point_list[ i ] );
+			x_points[ i ] = w2s.x;
+			y_points[ i ] = w2s.y;
+		}
+
+		std::sort( x_points.begin( ), x_points.end( ) );
+		std::sort( y_points.begin( ), y_points.end( ) );
+
+		int x = ( int )x_points.front( );
+		int w = ( int )x_points.back( ) - x;
+
+		int y = ( int )y_points.front( );
+		int h = ( int )y_points.back( ) - y;
+
+		return { x - ( int )origin.x, y - ( int )origin.y, w, h };
+	}
+
+	void c_visuals::out_of_fov( c_base_player* ent, const vec3_t& pos, clr_t col ) {
+		vec2_t	screen;
+		vec2_t	circle;
+
+		auto find_point = [ ]( vec2_t& point, float deg_x, float deg_y ) {
+			float x2 = screen_w / 2.f;
+			float y2 = screen_h / 2.f;
+
+			float d = sqrt( pow( point.x - x2, 2 ) + pow( point.y - y2, 2 ) );
+			float r_x = deg_x / d;
+			float r_y = deg_y / d;
+
+			point.x = r_x * point.x + ( 1.f - r_x ) * x2;
+			point.y = r_y * point.y + ( 1.f - r_y ) * y2;
+		};
+
+		auto get_screen_point = [ ]( vec2_t& screen, const vec3_t& delta ) {
+			decltype( auto ) w2s_matrix = cl.m_engine( )->GetWorldToScreenMatrix( );
+			float x;
+			float w;
+			float y;
+
+			screen.x = w2s_matrix[ 0 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 0 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 0 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 0 ][ 3 ];
+			screen.y = w2s_matrix[ 1 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 1 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 1 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 1 ][ 3 ];
+			w = w2s_matrix[ 3 ][ 0 ] * delta[ 0 ] + w2s_matrix[ 3 ][ 1 ] * delta[ 1 ] + w2s_matrix[ 3 ][ 2 ] * delta[ 2 ] + w2s_matrix[ 3 ][ 3 ];
+
+			if( w < 0.001f ) {
+				float invw = -1.0f / w;
+				screen.x *= invw;
+				screen.y *= invw;
+			}
+			else {
+				float invw = 1.0f / w;
+				screen.x *= invw;
+				screen.y *= invw;
+			}
+
+			x = float( screen_w ) / 2.f;
+			y = float( screen_h ) / 2.f;
+			x += 0.5f * screen.x * screen_w + 0.5f;
+			y -= 0.5f * screen.y * screen_h + 0.5f;
+			screen.x = x;
+			screen.y = y;
+		};
+
+		screen = util::screen_transform( pos );//get_screen_point( screen, pos );
+		circle = util::screen_transform( pos );// get_screen_point( circle, pos );
+
+		float radius = g_settings.visuals.out_of_pov_radius * 0.49f;
+
+		float ratio = g_settings.visuals.out_of_pov_radius;
+
+		float w = screen_w * ratio + screen_h * ( 1.0f - ratio );
+
+		find_point( screen, w * radius,
+			float( screen_h ) * radius );
+
+		auto min = std::min< int >( screen_w, screen_h ) * radius;
+		find_point( circle, float( min ), float( min ) );
+
+		auto rot_around_center = [ ]( vec2_t start, float rot ) {
+			float rad = rot * ( M_PI / 180.f );
+
+			start.x += sin( rad ) * float( g_settings.visuals.out_of_pov_size );
+			start.y += cos( rad ) * float( g_settings.visuals.out_of_pov_size );
+
+			return start;
+		};
+
+		float delta_x = ( float( screen_w / 2 ) - circle.x );
+		float delta_y = ( float( screen_h / 2 ) - circle.y );
+
+		auto hyp = sqrt( delta_x * delta_x + delta_y * delta_y );
+
+		float cos_ = delta_x / hyp;
+
+		float deg = RAD2DEG( acos( cos_ ) );
+
+		if( screen.y < screen_h / 2 ) {
+			deg *= -1.f;
+		}
+
+		auto rotated_pos_1 = rot_around_center( screen, deg + 115 );
+		auto rotated_pos_2 = rot_around_center( screen, deg + 65 );
+
+		col.a( ) *= 0.8f;
+
+		vertex_t v[ ] = {
+			{ screen },
+		{ rotated_pos_1 },
+		{ rotated_pos_2 }
+		};
+
+		if( !g_settings.misc.hide_from_obs )
+			g_renderer.draw_polygon( 3, v, col );
+		else {
+			draw_line( screen, rotated_pos_1, col );
+			draw_line( screen, rotated_pos_2, col );
+			draw_line( rotated_pos_1, rotated_pos_2, col );
+		}
+	}
+
+	void c_visuals::update_glow( ) {
+		if( !g_settings.visuals.active || g_settings.misc.hide_from_obs )
+			return;
+
+		static auto glow_object_manager = *pattern::first_code_match< GlowObjectManager_t** >( cl.m_chl.dll( ), xors ( "8B 0D ? ? ? ? A1 ? ? ? ? 56 8B 37" ) ) + 0x2;
+		if( !glow_object_manager ) return;
+
+		static bool invalidated;
+		if( !g_settings.visuals.glow ) {
+			if( !invalidated ) {
+				invalidate_glow( );
+				invalidated = true;
+			}
+			return;
+		}
+
+		invalidated = false;
+		for( int i{ }; i < 64; ++i ) {
+			auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+			if( !ent ) continue;
+
+
+			if( !ent->is_valid( ) ) {
+				continue;
+			}
+
+			if( ent->is_enemy( ) || g_settings.visuals.friendlies ) {
+				ent->m_bGlowEnabled( ) = true;
+				ent->update_glow_effect( );
+			}
+		}
+
+		if( !glow_object_manager->data.Count( ) ) return; //data count crashed yea lazy cool cool? cool
+		for( int i{ }; i < glow_object_manager->data.Count( ); ++i ) {
+			auto ent = ( c_base_player* )cl.m_entlist( )->get_entity_from_handle( glow_object_manager->data[ i ].ent_ptr );
+			if( ent && ent->is_valid( ) && ( ent->is_enemy( ) || g_settings.visuals.friendlies( ) ) ) {
+				clr_t clr = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ? g_settings.visuals.glow_friendly : g_settings.visuals.glow_enemy;
+				clr.a( ) = 200;
+				glow_object_manager->data[ i ].glow_color = clr.to_fclr( );
+			}
+		}
+
+	}
+
+	void c_visuals::invalidate_glow( ) {
+		for( int i{ }; i < 64; i++ ) {
+			auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+			if( !ent ) continue;
+			if( ent->get_client_class( )->m_class_id == CTFPlayer ) {
+				ent->m_bGlowEnabled( ) = false;
+				ent->destroy_glow_effect( );
+			}
+		}
+	}
+
+	inline clr_t blend_clr( clr_t in, float progress ) {
+		static const clr_t clr_gray = { 160, 160, 160, 255 };
+		int a = in.a( );
+
+		clr_t ret = clr_t::blend( clr_gray, in, 0.1f + progress * 0.9f );
+		ret.a( ) = a;
+		return ret;
+	}
+
+	void c_visuals::draw_players( ) {
+		static constexpr float anim_rate = 1.0f / 0.3f;
+		static float pov_progress[ 65 ]{ };
+
+		auto resource = c_base_player::get_player_resource( );
+
+		for( int i{ }; i < 65; ++i ) {
+			auto ent = cl.m_entlist( )->get_client_entity< c_base_player >( i );
+
+			if( !ent || !ent->is_player( ) || !ent->is_alive( ) || ent == g_ctx.m_local )
+				continue;
+
+			if( i == ( g_ctx.m_local->m_hObserverTarget( ) & 0xfff ) )
+				continue;
+
+			if( ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) &&
+				!g_settings.visuals.friendlies( ) )
+				continue;
+
+			float   rate = cl.m_globals->frametime * anim_rate;
+			float&	anim = m_anim_progress[ i ];
+			float	alpha = anim;
+			bool	dormant = ent->ce( )->is_dormant( );
+			int		health = ent->m_iHealth( );
+			auto	origin = ent->m_vecOrigin( );
+			auto	box = get_box( ent );
+			int		right_pos = 0;
+			int		bottom_pos = 0;
+			bool	too_distant = true;
+			if( g_ctx.m_local )
+				too_distant = ent->m_vecOrigin( ).dist_to( g_ctx.m_local->m_vecOrigin( ) ) > 2500.f;
+
+			if( !dormant ) {
+				update_position( i, origin );
+				anim = 1.0f;
+			}
+			else {
+				if( anim < 0.3f && g_settings.visuals.dormant && !too_distant ) {
+					rate *= 0.01f;
+				}
+				anim = std::clamp( anim -= rate, 0.f, 1.0f );
+				if( m_anim_progress[ i ] <= 0.f )
+					continue;
+			}
+
+			clr_t col = ent->m_iTeamNum( ) == g_ctx.m_local->m_iTeamNum( ) ?
+				g_settings.visuals.box_friendly : g_settings.visuals.box_enemy;
+
+			if( dormant ) {
+				col = blend_clr( col, anim );
+				col.a( ) *= anim;
+			}
+
+			auto w2s_cur_origin = util::screen_transform( m_stored_pos[ i ] );
+
+			box.x += w2s_cur_origin.x;
+			box.y += w2s_cur_origin.y;
+
+			if( box.x > screen_w || box.x + box.w < 0 ||
+				box.y > screen_h || box.y + box.h < 0 ) {
+				if( g_settings.visuals.out_of_pov ) {
+					auto& anim = pov_progress[ i ];
+					anim = std::clamp( anim += cl.m_globals->frametime * anim_rate, 0.f, 1.0f );
+					if( dormant )
+						anim = std::clamp( anim -= cl.m_globals->frametime * anim_rate, 0.f, 1.0f );
+					else
+						anim = std::clamp( anim += cl.m_globals->frametime * anim_rate, 0.f, 1.0f );
+
+					col.a( ) *= anim;
+					out_of_fov( ent, origin, 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 = cl.m_modelinfo( )->GetStudioModel( ent->ce( )->get_model( ) );
+				if( hdr ) {
+					matrix3x4 matrix[ 128 ];
+					ent->ce( )->setup_bones( matrix, 128, 0x100, 0.f );
+
+					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( ) ) {
+				draw_string( box.x + box.w / 2, box.y - 12, ALIGN_CENTER, true,
+					blend_clr( clr_t( 255, 255, 255, alpha * 255 ), anim ), ent->get_info( ).name );
+			}
+
+			if( g_settings.visuals.player_class( ) ) {
+				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 ), ent->get_class_name( ) );
+
+				right_pos += 9;
+			}
+
+			if( g_settings.visuals.weapon( ) ) {
+				auto weapon = ent->get_active_weapon( );
+				if( weapon ) { //magic font
+					int max = weapon->get_max_clip_1( );
+
+					if( g_settings.visuals.ammo && max > 1 && g_settings.visuals.weapon == 1 && !g_settings.misc.hide_from_obs ) {
+						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 ) );
+
+						draw_filled_rect( box.x + 1, box.y + box.h + 4 + bottom_pos,
+							percent, 1, blend_clr( clr_t( 66, 143, 244, 255 * alpha ), anim ) );
+
+						if( progress < 0.25f ) {
+							draw_string(
+								box.x + percent, box.y + box.h + 2 + bottom_pos, ALIGN_LEFT, false,
+								clr_t( 255, 255, 255, 180 * alpha ), "%d", weapon->m_iClip1( ) );
+						}
+
+						bottom_pos += 4;
+					}
+
+					/*if( g_settings.visuals.weapon == 1 && !g_settings.misc.hide_from_obs ) {
+						g_renderer.draw_string< ALIGN_CENTER >( 0xa1, box.x + box.w / 2, box.y + box.h + bottom_pos + 3,
+							clr_t( 255, 255, 255, alpha * 255 ), "%c", weapon->get_hud_icon( ) );
+					}*/
+					else {
+						char wep_str[ 64 ];
+						if( g_settings.visuals.ammo( ) && weapon->m_iClip1( ) > -1 )
+							sprintf_s< 64 >( wep_str, "%s [%d]", weapon->get_print_name( ), weapon->m_iClip1( ) );
+						else
+							sprintf_s< 64 >( wep_str, "%s", weapon->get_print_name( ) );
+
+						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.conditions( ) ) {
+				int x_pos = box.x + box.w + 3;
+				int y_pos = box.y - 1;
+
+				switch( ent->m_nPlayerCond( ) ) {
+				case TFCond_Slowed:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "slow" ) );
+					right_pos += 9;
+					break;
+				case TFCond_Zoomed: //dont work too lazy
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "scoped" ) );
+					right_pos += 9;
+					break;
+				case TFCond_Bonked:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "bonk" ) );
+					right_pos += 9;
+					break;
+				case TFCond_Disguised:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "disg" ) );
+					right_pos += 9;
+					break;
+				case TFCond_Cloaked:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "cloak" ) );
+					right_pos += 9;
+					break;
+				case TFCond_Ubercharged:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "uber" ) );
+					right_pos += 9;
+					break;
+				case TFCond_UberchargeFading:
+					draw_string( x_pos, y_pos + right_pos, ALIGN_LEFT, false, clr_t( 255, 255, 255, 255 * alpha ), xors( "uber" ) );
+					right_pos += 9;
+					break;
+				}
+
+			}
+
+		}
+	}
+
+	void c_visuals::operator()( ) {
+		cl.m_engine( )->GetScreenSize( screen_w, screen_h );
+		if( g_ctx.run_frame( ) ) {
+			draw_local( );
+		}
+
+		if( !g_ctx.m_local )
+			return;
+
+		switch( g_settings.visuals.activation_type( ) ) {
+		case 0:
+			g_settings.visuals.active = false;
+			break;
+		case 1:
+			g_settings.visuals.active = true;
+			break;
+		case 2:
+			g_settings.visuals.active = g_input.is_key_pressed( g_settings.visuals.key );
+			break;
+		case 3: {
+			static bool held = false;
+			bool pressed = g_input.is_key_pressed( g_settings.visuals.key );
+			if( pressed ) {
+				if( !held )
+					g_settings.visuals.active ^= 1;
+				held = true;
+			}
+			else held = false;
+		}
+				break;
+		default:
+			g_settings.visuals.active = false;
+			break;
+		}
+
+		if( g_settings.visuals.active ) {
+			draw_players( );
+		}
+
+		draw_world( );
+		draw_hits( );
+	}
+}
+\ No newline at end of file
diff --git a/tf2/visuals_world.cpp b/tf2/visuals_world.cpp
new file mode 100644
index 0000000..b727798
--- /dev/null
+++ b/tf2/visuals_world.cpp
@@ -0,0 +1,344 @@
+#include <unordered_map>
+#include <cmath>
+#include "ctx.hpp"
+#include "visuals.hpp"
+#include "interfaces.h"
+#include "renderer.hpp"
+#include "base_cheat.h"
+#include "settings.h"
+namespace features
+{
+	void fix_static_props( ) {
+		static auto cvar = cl.m_cvar( )->FindVar( xors( "r_drawspecificstaticprop" ) );
+		static bool fixed{ };
+		if( !fixed ) {
+			cvar->m_flags |= 0;
+			cvar->set_value( 1 );
+
+			fixed = true;
+		}
+	}
+
+
+	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" ) );
+
+
+		for( int i{ }; i < cl.m_entlist( )->get_highest_entity_index( ); ++i ) {
+			auto ent = cl.m_entlist( )->get_client_entity< IClientEntity >( i );
+			if( !ent ) continue;
+
+			auto client_class = ent->get_client_class( );
+			if( !client_class ) continue;
+
+			int class_id = client_class->m_class_id;
+			std::string name = "";
+
+			auto is_object = [ &name ]( int class_id ) -> bool {
+				switch( class_id ) {
+				case CObjectSentrygun:
+					name = xors( "sentry" );
+					return true;
+				case CObjectDispenser:
+					name = xors( "dispenser" );
+					return true;
+				case CObjectTeleporter:
+					name = xors( "teleporter" );
+					return true;
+				default:
+					return false;
+				}
+
+				return false;
+			};
+
+			auto is_projectile = [ &name ]( int class_id ) -> bool {
+				switch( class_id ) {
+				case CTFProjectile_Arrow:
+					name = xors( "arrow" );
+					return true;
+				case CTFProjectile_Cleaver:
+					name = xors( "cleaver" );
+					return true;
+				case CTFProjectile_EnergyBall:
+					name = xors( "energy ball" );
+					return true;
+				case CTFProjectile_EnergyRing:
+					name = xors( "energy ring" );
+					return true;
+				case CTFProjectile_Flare:
+					name = xors( "flare" );
+					return true;
+				case CTFProjectile_HealingBolt:
+					name = xors( "healing bolt" );
+					return true;
+				case CTFProjectile_Jar:
+					name = xors( "jar" );
+					return true;
+				case CTFProjectile_JarMilk:
+					name = xors( "jar milk" );
+					return true;
+				case CTFGrenadePipebombProjectile:
+					name = xors( "pipe bomb" );
+					return true;
+				case CTFProjectile_Rocket:
+					name = xors( "rocket" );
+					return true;
+				case CTFProjectile_Throwable:
+					name = xors( "throwable" );
+					return true;
+				case CTFProjectile_ThrowableBreadMonster:
+					name = xors( "bread monster" );
+					return true;
+				case CTFProjectile_ThrowableBrick:
+					name = xors( "brick" );
+					return true;
+				case CTFProjectile_ThrowableRepel:
+					name = xors( "repel" );
+					return true;
+				case CTFProjectile_SentryRocket:
+					name = xors( "rocket" );
+					return true;
+				default:
+					return false;
+				}
+				return false;
+			};
+
+				//objects
+			if( is_object( class_id ) ) {
+				
+				//wont work
+				if( ( g_settings.visuals.building_esp == 2 || g_settings.visuals.building_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+					//*( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+				}
+
+				if( g_settings.visuals.building_esp == 1 || g_settings.visuals.building_esp == 3 ) {
+					auto pos = ent->get_abs_origin( );
+					auto w2s = util::screen_transform( pos );
+					//currently they are not cute
+					//auto cutie = cl.m_entlist( )->get_entity_from_handle< c_base_player >( ent->as< c_base_weapon >( )->m_hOwnerEntity( ) );
+					draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+						g_settings.visuals.building_esp_clr, name.c_str( ) );
+
+					//later
+
+					//if( g_settings.visuals.building_owner( ) )
+					//	draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, g_settings.visuals.building_esp_clr, cutie->get_info( ).name );
+				}
+			}
+
+
+
+
+				//projectiles
+			if( is_projectile( class_id ) ) {
+				//wont work
+				if( ( g_settings.visuals.projectile_esp == 2 || g_settings.visuals.projectile_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+					//*( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+				}
+
+				if( g_settings.visuals.projectile_esp == 1 || g_settings.visuals.projectile_esp == 3 ) {
+					auto pos = ent->get_abs_origin( );
+					auto w2s = util::screen_transform( pos );
+					//again not cute
+					//auto cutie = cl.m_entlist( )->get_entity_from_handle< c_base_player >( ent->as< c_base_weapon >( )->m_hOwnerEntity( ) );
+					draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+						g_settings.visuals.projectile_esp_clr, name.c_str( ) );
+
+					//later when i can be fucked
+
+					//if( g_settings.visuals.building_owner( ) )
+					//	draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, g_settings.visuals.projectile_esp_clr, cutie->get_info( ).name );
+				}
+			}
+
+
+
+
+
+				/*if( class_id == CObjectTeleporter || class_id == CObjectDispenser || class_id == CObjectSentrygun ) {
+					auto owner = ( int )ent->as< c_base_weapon >( )->m_hBuilder( ) & 0xfff;
+					if( owner <= 0 || owner > 64 ) {
+						auto origin = ent->get_render_origin( );
+						if( origin ) {
+							bool draw = g_settings.visuals.grenade_esp( ) == 1;
+							bool glow = g_settings.visuals.grenade_esp( ) == 2;
+
+							if( draw || g_settings.visuals.grenade_esp == 3 ) {
+								if( !glow && !g_settings.misc.hide_from_obs ) {
+									*( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = false;
+								}
+
+								auto w2s = util::screen_transform( origin );
+								auto name = util::object_index_to_name( class_id );
+
+								draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+									g_settings.visuals.grenade_esp_clr( ), name );
+							}
+							if( ( glow || g_settings.visuals.grenade_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+								*( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+							}
+						}
+					}
+				}*/
+				/*else {
+					if( g_settings.visuals.weapon_esp && strstr( client_class->m_name, xors( "Projectile" ) ) ) {
+						auto model = ent->get_model( );
+						if( !model ) continue;
+
+						std::string name = xors( "Rocket" );
+
+						auto hdr = cl.m_modelinfo( )->GetStudioModel( model );
+						if( !hdr )
+							continue;
+
+						if( !strstr( hdr->name, xors( "thrown" ) ) && !strstr( hdr->name, xors( "dropped" ) ) )
+							continue;
+
+
+
+
+						if( strstr( hdr->name, xors( "JarGas" ) ) ) {
+							name = xors( "jargas" );
+						}
+						else if( strstr( hdr->name, xors( "Cleaver" ) ) ) {
+							name = xors( "Cleaver" );
+						}
+						else if( strstr( hdr->name, xors( "JarMilk" ) ) ) {
+							name = xors( "Milk" );
+						}
+						else if( strstr( hdr->name, xors( "incendiary" ) ) || strstr( hdr->name, xors( "molotov" ) ) ) {
+							name = xors( "molotov" );
+						}
+
+						if( ( g_settings.visuals.weapon_esp == 2 || g_settings.visuals.weapon_esp == 3 ) && !g_settings.misc.hide_from_obs ) {
+							*( bool* )( uintptr_t( ent ) + m_bShouldGlow ) = true;
+						}
+
+						if( g_settings.visuals.weapon_esp == 1 || g_settings.visuals.weapon_esp == 3 ) {
+							auto pos = ent->get_render_origin( );
+							auto w2s = util::screen_transform( pos );
+							auto cutie = cl.m_entlist( )->get_entity_from_handle< c_base_player >( ent->as< c_base_weapon >( )->m_hOwnerEntity( ) );
+							draw_string( w2s.x, w2s.y, ALIGN_CENTER, false,
+								g_settings.visuals.grenade_esp_clr, name.c_str( ) );
+
+							if( g_settings.visuals.grenade_owner( ) )
+								draw_string( w2s.x, w2s.y + 10, ALIGN_CENTER, false, g_settings.visuals.grenade_esp_clr, cutie->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 || !cl.m_engine( )->IsInGame( ) || g_settings.misc.hide_from_obs ) {
+			modulated = false;
+			if( !world_materials2.empty( ) ) {
+				for( auto& it : world_materials2 ) {
+					auto mat = cl.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 = cl.m_mat_system( )->FirstMaterial( );
+				i != cl.m_mat_system( )->InvalidMaterial( );
+				i = cl.m_mat_system( )->NextMaterial( i ) ) {
+
+				auto mat = cl.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/tf2/vmt.h b/tf2/vmt.h
new file mode 100644
index 0000000..f2a39ac
--- /dev/null
+++ b/tf2/vmt.h
@@ -0,0 +1,79 @@
+#pragma once
+#include <vector>
+#include "util.hpp"
+
+// todo - dex; rewrite this, VirtualQuery (except for custom codeptr / readptr) and VirtualProtect shouldnt be used 
+//             and we need to copy rtti over too or stuff will break later on
+
+//             correct me if im wrong, but the vtable isnt replaced, instead the original is edited during hooking, rtti should be intact and accessable by game
+//             class could definetly do with a rewrite tho!
+
+//             ^ you're corrct, but changing page rights and replacing ptrs direclty in rdata (or usually the heap, since thats where vmts go) is not a safe solution
+//             copying table + aligning it to compensate for rtti is safer
+//             vac loves scanning memory regions but it doesnt really do much outside of game servers (only loads some shit for checking DEP and stuff)
+
+// trash
+
+//llama is a fucking nigger
+//true
+
+namespace hooks
+{
+	class c_vmt {
+		uintptr_t* m_table;
+		uintptr_t* m_original;
+		std::vector< uintptr_t > m_new;
+	public:
+		int count( ) {
+			int vfunc_count{ };
+
+			while( m_original[ vfunc_count ] ) {
+				vfunc_count++;
+			};
+
+			return vfunc_count;
+		}
+
+		c_vmt( void* table ) {
+			if( !table ) {
+				return;
+			}
+
+			this->m_table = reinterpret_cast< uintptr_t* >( table );
+			this->m_original = *reinterpret_cast< uintptr_t** >( this->m_table );
+
+			for( int i = -1; i < this->count( ); ++i ) {
+				this->m_new.push_back( this->m_original[ i ] );
+			}
+
+			auto data = this->m_new.data( );
+			*this->m_table = uintptr_t( &data[ 1 ] );
+		}
+
+		~c_vmt( ) { }
+
+		template< typename T = uintptr_t > T get_function( int index ) {
+			return( ( T )( this->m_new.at( index + 1 ) ) );
+		}
+
+		template< typename T = uintptr_t > T get_old_function( int index ) {
+			return( ( T )( this->m_original[ index ] ) );
+		}
+
+		void hook( int index, uintptr_t new_func ) {
+			this->m_new.at( index + 1 ) = new_func;
+		}
+
+		void unhook( int index ) {
+			this->m_new.at( index + 1 ) = this->m_original[ index ];
+		}
+
+		void hook( int index, void* new_func ) {
+			hook( index, reinterpret_cast< uintptr_t >( new_func ) );
+		}
+
+		void restore( ) const {
+			*this->m_table = uintptr_t( m_original );
+		}
+	};
+}
+\ No newline at end of file
diff --git a/tf2/window_procedure.cpp b/tf2/window_procedure.cpp
new file mode 100644
index 0000000..b67f9bb
--- /dev/null
+++ b/tf2/window_procedure.cpp
@@ -0,0 +1,59 @@
+#include "hooks.h"
+#include "input_system.hpp"
+#include "settings.h"
+
+//im pretty sure half this shit is redundant rn but idrc
+
+
+decltype( &hooks::window_procedure ) hooks::window_procedure_o;
+long __stdcall hooks::window_procedure( HWND hwnd, uint32_t msg, uint32_t wparam, long lparam ) {
+	if( cl.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/tf2/x86.hpp b/tf2/x86.hpp
new file mode 100644
index 0000000..e96c469
--- /dev/null
+++ b/tf2/x86.hpp
@@ -0,0 +1,47 @@
+#pragma once
+#include <inttypes.h>
+
+namespace x86
+{
+	enum class reg : size_t {
+		eax = 0,
+		ecx,
+		edx,
+		ebx,
+		esp,
+		ebp,
+		esi,
+		edi,
+
+		/*
+		x64:
+		r8,
+		r9,
+		r10,
+		r11,
+		r12,
+		r13,
+		r14,
+		r15,*/
+	};
+
+	enum instruction : uint8_t {
+		retn_imm16 = 0xc2,
+		retn = 0xc3,
+		fs = 0x64,
+		//its big nigga season
+		call = 0xff
+	};
+
+	__forceinline static uint32_t encode_mov_imm32( x86::reg dreg ) {
+		return ( 0xb8 + ( size_t( dreg ) ) );
+	}
+
+	__forceinline static uint32_t encode_push_reg( x86::reg dreg ) {
+		return ( 0x50 | ( ( size_t( dreg ) ) & 7 ) );
+	}
+
+	__forceinline static uint32_t encode_pop_reg( x86::reg dreg ) {
+		return ( 0x58 | ( ( size_t( dreg ) ) & 7 ) );
+	}
+};
+\ No newline at end of file
author	JustSomePwner <crotchyalt@gmail.com>	2018-08-30 14:01:54 +0200
committer	JustSomePwner <crotchyalt@gmail.com>	2018-08-30 14:01:54 +0200
commit	7ccb819f867493f8ec202ea3b39c94c198c64584 (patch)
tree	94622e61af0ff359e3d6689cf274d74f60b2492a /tf2
parent	564d979b79e8a5aaa5014eba0ecd36c61575934f (diff)