#include "RageBot.h"
#include "RenderManager.h"
#include "Resolver.h"
#include "Autowall.h"
#include <iostream>
#include "UTIL Functions.h"


/* AntiAim-List

YAW-Backward
YAW-Static
YAW-Jitter
YAW-Spinbot
YAW-FakeJitter
YAW-FakeSpin
YAW-FakeBackward//
YAW-FakeForward
YAW-FakeStatic
*/

void IJhsiujayu2t67arstyafshjzghkdhauis()
{
	float uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 562414;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 58345124314;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 3453464574)
		uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 4545572;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 3457796;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 567325;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 957362);
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 434535758;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 6835235;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 234346457)
		uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 679345245;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 323436547;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 674536234;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 457678769);
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 45894234;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 2343468;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 56745234)
		uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 4534345567;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 1234545675;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 3445779;
	if (uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 6734123);
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 3455758;
	uatgs76ard5632rtysdgtyfatydfghgs7ydtazjlkajwq89af = 4537383235;
}

void AngleVectors3(const Vector &angles, Vector *forward)
{
	Assert(s_bMathlibInitialized);
	Assert(forward);

	float	sp, sy, cp, cy;

	sy = sin(DEG2RAD(angles[1]));
	cy = cos(DEG2RAD(angles[1]));

	sp = sin(DEG2RAD(angles[0]));
	cp = cos(DEG2RAD(angles[0]));

	forward->x = cp*cy;
	forward->y = cp*sy;
	forward->z = -sp;
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

template<class T, class U>
T clamp(T in, U low, U high)
{
	if (in <= low)
		return low;

	if (in >= high)
		return high;

	return in;
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

float RandomNumber(float Min, float Max)
{
	return ((float(rand()) / float(RAND_MAX)) * (Max - Min)) + Min;
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

float GetLatency()
{
	INetChannelInfo *nci = Interfaces::Engine->GetNetChannelInfo();
	if (nci)
	{
		float Latency = nci->GetAvgLatency(FLOW_OUTGOING) + nci->GetAvgLatency(FLOW_INCOMING);
		return Latency;
	}
	else
	{
		return 0.0f;
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}
float GetOutgoingLatency()
{
	INetChannelInfo *nci = Interfaces::Engine->GetNetChannelInfo();
	if (nci)
	{
		float OutgoingLatency = nci->GetAvgLatency(FLOW_OUTGOING);
		return OutgoingLatency;
	}
	else
	{
		return 0.0f;
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}
float GetIncomingLatency()
{
	INetChannelInfo *nci = Interfaces::Engine->GetNetChannelInfo();
	if (nci)
	{
		float IncomingLatency = nci->GetAvgLatency(FLOW_INCOMING);
		return IncomingLatency;
	}
	else
	{
		return 0.0f;
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}


float OldLBY;
float LBYBreakerTimer;
float LastLBYUpdateTime;
bool bSwitch;
float CurrentVelocity(IClientEntity* LocalPlayer)
{
	int vel = LocalPlayer->GetVelocity().Length2D();
	return vel;
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

/*bool NextLBYUpdate()
{
	IClientEntity* LocalPlayer = hackManager.pLocal();

	float flServerTime = (float)(LocalPlayer->GetTickBase()  * Interfaces::Globals->interval_per_tick);


	if (OldLBY != LocalPlayer->GetLowerBodyYaw())
	{
		LBYBreakerTimer++;
		OldLBY = LocalPlayer->GetLowerBodyYaw();
		bSwitch = !bSwitch;
		LastLBYUpdateTime = flServerTime;
	}

	if (CurrentVelocity(LocalPlayer) > 0.1)
	{
		LastLBYUpdateTime = flServerTime;
		return false;
	}

	if ((LastLBYUpdateTime + 1.0725 - GetOutgoingLatency() < flServerTime) && (LocalPlayer->GetFlags() & FL_ONGROUND))
	{
		if (LastLBYUpdateTime + 1.1 - GetOutgoingLatency() < flServerTime)
		{
			LastLBYUpdateTime = flServerTime;
		}
		return true;
	}
	return false;
}*/

bool NextLBYUpdate()
{
	IClientEntity* LocalPlayer = hackManager.pLocal();

	float flServerTime = (float)(LocalPlayer->GetTickBase()  * Interfaces::Globals->interval_per_tick);
	IJhsiujayu2t67arstyafshjzghkdhauis();
	if (OldLBY != LocalPlayer->GetLowerBodyYaw())
	{
		LBYBreakerTimer++;
		OldLBY = LocalPlayer->GetLowerBodyYaw();
		bSwitch = !bSwitch;
		LastLBYUpdateTime = flServerTime;
	}

	if (CurrentVelocity(LocalPlayer) > 0.1)
	{
		LastLBYUpdateTime = flServerTime;
		return false;
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();

	if ((LastLBYUpdateTime + 1.1 - GetOutgoingLatency() < flServerTime) && (LocalPlayer->GetFlags() & FL_ONGROUND))
	{
		if (LastLBYUpdateTime + 0.9 - GetOutgoingLatency() < flServerTime)
		{
			LastLBYUpdateTime = flServerTime;
		}
		return true;
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
	return false;
}

namespace AAYaw /*AA-Yaw*/
{

	void Backward(CUserCmd* pCmd)
	{
		pCmd->viewangles.y -= 180.00f;
	}

	void FakeBackward(CUserCmd* pCmd, bool& bSendPacket)
	{
		if (bSendPacket)
		{
			pCmd->viewangles.y += 180;
		}
		else
		{
			pCmd->viewangles.y -= 90;
		}
	}

	void FakeSideways(CUserCmd* pCmd, bool& bSendPacket)
	{

		static bool flip;
		static bool flip2;
		flip = !flip;
		flip2 = !flip2;

		if (pCmd->command_number % 2)
		{
			bSendPacket = false;

			if (flip2)
				pCmd->viewangles.y += 90.5f;

			else
				pCmd->viewangles.y -= 90.5f;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.0f;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FakeSidewaysALT(CUserCmd* pCmd, bool& bSendPacket)
	{

		static bool flip;
		static bool flip2;
		flip = !flip;
		flip2 = !flip2;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (pCmd->command_number % 2)
		{
			bSendPacket = false;

			if (flip2)
				pCmd->viewangles.y -= 90.5f;

			else
				pCmd->viewangles.y += 90.5f;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.0f;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void FakeJitterSideways(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool Fast = false;
		if (Fast)
		{
			bSendPacket = false; //true angle
			pCmd->viewangles.y -= 90.0;
		}
		else
		{
			bSendPacket = true; //fake angle
			static bool Fast2 = false;
			if (Fast2)
			{
				pCmd->viewangles.y += 75;
			}
			else
			{
				pCmd->viewangles.y += 105;
			}
			Fast2 = !Fast2;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}
	void FakeJitterSidewaysALT(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool Fast = false;
		if (Fast)
		{
			bSendPacket = false; //true angle
			pCmd->viewangles.y += 90.0;
		}
		else
		{
			bSendPacket = true; //fake angle
			static bool Fast2 = false;
			if (Fast2)
			{
				pCmd->viewangles.y -= 75;
			}
			else
			{
				pCmd->viewangles.y -= 105;
			}
			Fast2 = !Fast2;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}
	void PAA(CUserCmd *pCmd, bool &bSendPacket)
	{

		int random = rand() % 100;
		int maxJitter = rand() % (85 - 70 + 1) + 70;
		hackManager.pLocal()->GetLowerBodyYaw() - (rand() % maxJitter);
		if (random < 35 + (rand() % 15))
		{
			bSendPacket = false;
			pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() - (rand() % maxJitter);;
		}

		else if (random < 85 + (rand() % 15))
		{
			bSendPacket = true;
			pCmd->viewangles.y += hackManager.pLocal()->GetLowerBodyYaw() - (rand() % maxJitter);;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FakeSwitch(CUserCmd *pCmd, bool &bSendPacket)
	{
		IClientEntity *pLocal = hackManager.pLocal();

		static bool f_flip = true;
		f_flip = !f_flip;

		if (f_flip)
		{
			bSendPacket = false;
			if (NextLBYUpdate())
			{

				pCmd->viewangles.y -= 87.554f;;
			}
			else
			{

				pCmd->viewangles.y += 93.946f;
			}
		}
		else if (!f_flip)
		{
			bSendPacket = true;
			pCmd->viewangles.y += (rand() % 50 + 145);
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FakeSwitchALT(CUserCmd *pCmd, bool &bSendPacket)
	{
		IClientEntity *pLocal = hackManager.pLocal();
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static bool f_flip = true;
		f_flip = !f_flip;

		if (f_flip)
		{
			bSendPacket = false;
			if (NextLBYUpdate())
			{

				pCmd->viewangles.y += 87.554f;;
			}
			else
			{

				pCmd->viewangles.y -= 93.946f;
			}
		}
		else if (!f_flip)
		{
			bSendPacket = true;
			pCmd->viewangles.y += (rand() % 50 + 145);
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void TestLBYBreak(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool Fast = false;
		bool flip = true;
		QAngle angle_for_yaw;
		static int counter = 0;
		static int motion = 0;
		int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
		int oldlowerbodyyaw = 0;
		if (Fast)
		{
			static bool f_flip = true;
			f_flip = !f_flip;

			if (f_flip)
			{
				pCmd->viewangles.y -= 170.00f;
				bSendPacket = false;
			}
			else if (!f_flip)
			{
				pCmd->viewangles.y -= 190.00f;
				bSendPacket = false;
			}
		}
		else
		{


			if (flip)
			{
				if (counter % 48 == 0)
					motion++;
				int value = ServerTime % 2;
				switch (value) {

				case 0:pCmd->viewangles.y += 180;
					bSendPacket = true;
				case 1:pCmd->viewangles.y += 90;
					bSendPacket = true;
				}
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}

/*	void BolbiBreak(CUserCmd *pCmd, bool &bSendPacket)
	{
		IClientEntity *pLocal = hackManager.pLocal();

		static bool f_flip = true;
		f_flip = !f_flip;

		if (f_flip)
		{
			bSendPacket = false;
			if (NextLBYUpdate())
			{
				pCmd->viewangles.y -= 155;
			}
			else
			{

				pCmd->viewangles.y += 90;
			}
		}
		else if (!f_flip)
		{
			bSendPacket = true;
			if (NextLBYUpdate())
			{
				pCmd->viewangles.y += 90;
			}
			else
			{
				pCmd->viewangles.y -= 155;
			}
		}
	}*/

/*	void BolbiBreakALT(CUserCmd *pCmd)
	{
		IClientEntity *pLocal = hackManager.pLocal();

		if (NextLBYUpdate())
		{
			pCmd->viewangles.y += 155;
		}
		else
		{
			pCmd->viewangles.y -= 90;
		}
	}

	void BolbiBreak(CUserCmd *pCmd)
	{
		IClientEntity *pLocal = hackManager.pLocal();

		if (NextLBYUpdate())
		{
			pCmd->viewangles.y -= 155;
		}
		else
		{
			pCmd->viewangles.y += 90;
		}
	}*/


	void BolbiBreakALT(CUserCmd *pCmd, bool& bSendPacket)
	{
		float randfloat = rand() % -180 + 360;
		IClientEntity *pLocal = hackManager.pLocal();
		static int ChokedPackets = -1;
		ChokedPackets++;

		if (NextLBYUpdate())
		{
			pCmd->viewangles.y -= randfloat;
		}
		else
		{
			pCmd->viewangles.y += 90;
		}
		if (ChokedPackets < 1)
		{
			bSendPacket = false;
			pCmd->viewangles.y -= randfloat;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 90;
			ChokedPackets = -1;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void AntiCorrection(CUserCmd* pCmd)
	{
		Vector newAngle = pCmd->viewangles;

		static int ChokedPackets = -1;
		ChokedPackets++;

		float yaw;
		static int state = 0;
		static bool LBYUpdated = false;

		float flCurTime = Interfaces::Globals->curtime;
		static float flTimeUpdate = 1.09f;
		static float flNextTimeUpdate = flCurTime + flTimeUpdate;
		if (flCurTime >= flNextTimeUpdate) {
			LBYUpdated = !LBYUpdated;
			state = 0;
		}

		if (flNextTimeUpdate < flCurTime || flNextTimeUpdate - flCurTime > 10.f)
			flNextTimeUpdate = flCurTime + flTimeUpdate;

		if (LBYUpdated)
			yaw = 90;
		else
			yaw = -90;

		if (yaw)
			newAngle.y += yaw;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		pCmd->viewangles = newAngle;
	}

	void AntiCorrectionALT(CUserCmd* pCmd)
	{
		Vector newAngle = pCmd->viewangles;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static int ChokedPackets = -1;
		ChokedPackets++;

		float yaw;
		static int state = 0;
		static bool LBYUpdated = false;

		float flCurTime = Interfaces::Globals->curtime;
		static float flTimeUpdate = 1.09f;
		static float flNextTimeUpdate = flCurTime + flTimeUpdate;
		if (flCurTime >= flNextTimeUpdate) {
			LBYUpdated = !LBYUpdated;
			state = 0;
		}

		if (flNextTimeUpdate < flCurTime || flNextTimeUpdate - flCurTime > 10.f)
			flNextTimeUpdate = flCurTime + flTimeUpdate;

		if (LBYUpdated)
			yaw = -90;
		else
			yaw = 90;

		if (yaw)
			newAngle.y += yaw;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		pCmd->viewangles = newAngle;
	}

	void anti_aim1(CUserCmd* command, bool& send_packet)
	{
		float outgoing_latency = 0.f; //inetchannel
		float current_lby = hackManager.pLocal()->GetLowerBodyYaw();
		float last_lby = 0.f;
		float last_lby_time = 0.f;
		float spin = rand() % 100;
		static bool jitter_switch = false;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (current_lby != last_lby || fabs(hackManager.pLocal()->GetVelocity().Length2D()) > 0.1f) {
			last_lby_time = Interfaces::Globals->curtime;
			last_lby = current_lby;
		}
		else {
			if (!send_packet) {
				if (fabs(last_lby < 1.1 - Interfaces::Globals->curtime)) { /* instead of this check u can also do last_lby < 1.1 - curtime*/
					command->viewangles.y += 90.f;
				}
				else {
					command->viewangles.y += 180.f;
				}
			}
			else {
				command->viewangles.y -= 90.f;
			}
			if (send_packet) { /* when faking throw a random spin in*/
				if (current_lby != last_lby) {
					command->viewangles.y += spin;
				}
				else {
					command->viewangles.y += 60.0f;
				}
			}
			else {
				command->viewangles.y += 180.0f;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void TestBreak(CUserCmd *pCmd, bool& bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		IClientEntity *pLocal = hackManager.pLocal();
		if (!bSendPacket)
		{
			if (NextLBYUpdate())
				pCmd->viewangles.y += 160;
			else
				pCmd->viewangles.y -= 160;
		}
		else
		{
			if (NextLBYUpdate())
			{
				switch (pCmd->tick_count % 4)
				{
				case 0:
					pCmd->viewangles.y = pLocal->GetLowerBodyYaw() - 90;
				case 1:
					pCmd->viewangles.y += 90;
				case 2:
					pCmd->viewangles.y = pLocal->GetLowerBodyYaw() - 90;
				case 3:
					pCmd->viewangles.y += 90;
				}
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void BolbiBreak(CUserCmd *pCmd, bool& bSendPacket)
	{
		float randfloat = rand() % -180 + 360;
		IClientEntity *pLocal = hackManager.pLocal();
		static int ChokedPackets = -1;
		ChokedPackets++;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (NextLBYUpdate())
		{
			pCmd->viewangles.y += randfloat;
		}
		else
		{
			pCmd->viewangles.y -= 90;
		}
		if (ChokedPackets < 1)
		{
			bSendPacket = false;
			pCmd->viewangles.y -= randfloat;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 90;
			ChokedPackets = -1;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void Arizona1(CUserCmd *pCmd, bool &bSendPacket) //Jitter Movement mit static bool Fast :)
	{
		static bool Fast = false;
		if (Fast)
		{
			bSendPacket = false; //true angle
			pCmd->viewangles.y = pCmd->viewangles.y - 134.0;
		}
		else
		{
			bSendPacket = true; //fake angle
			pCmd->viewangles.y = pCmd->viewangles.y - 226.0;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}


	void LBY90switch(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool f_flip = true;
		f_flip = !f_flip;

		if (f_flip)
		{
			pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + 90.00f;
			bSendPacket = false;
		}
		else if (!f_flip)
		{
			pCmd->viewangles.y += hackManager.pLocal()->GetLowerBodyYaw() - 0.00f;
			bSendPacket = true;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void TestPLBY(CUserCmd *pCmd, bool &bSendPacket)


	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static bool Fast = false;
		bool flip = true;
		QAngle angle_for_yaw;
		static int counter = 0;
		static int motion = 0;
		int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
		int oldlowerbodyyaw = 0;
		if (Fast)
		{
			static bool f_flip = true;
			f_flip = !f_flip;

			if (f_flip)
			{
				pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() - 87.554f;
				bSendPacket = false;
			}
			else if (!f_flip)
			{
				pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + 93.946f;
				bSendPacket = false;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else
		{


			if (flip)
			{
				if (counter % 48 == 0)
					motion++;
				int value = ServerTime % 2;
				switch (value) {

				case 0:pCmd->viewangles.y += hackManager.pLocal()->GetLowerBodyYaw() - 126.446f;
					bSendPacket = true;
				case 1:pCmd->viewangles.y += hackManager.pLocal()->GetLowerBodyYaw() + 124.874f;
					bSendPacket = true;
				}
			}
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}

	void lbyfake(CUserCmd* pCmd, bool& bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (hackManager.pLocal()->GetVelocity().Length() > 0)
		{
			int var1;
			int var2;
			float var3;

			pCmd->viewangles.y += 180;
			var1 = rand() % 100;
			var2 = rand() % (10 - 6 + 1) + 10;
			var3 = var2 - (rand() % var2);
			if (var1 < 60 + (rand() % 15))
				pCmd->viewangles.y -= var3;
			else if (var1 < 100 + (rand() % 15))
				pCmd->viewangles.y += var3;
		}
		else {
			static bool lby;
			lby = !lby;

			if (lby)
			{
				bSendPacket = false;
				pCmd->viewangles.y += 195.f;
			}
			else {
				bSendPacket = true;
				int meme = Menu::Window.AntiAimTab.AntiAimSpinspeed.GetValue() * 1000.0;
				float CalculatedCurTime_1 = (Interfaces::Globals->curtime * meme);
				pCmd->viewangles.y = CalculatedCurTime_1;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void testbindedlby(CUserCmd* pCmd, bool& bSendPacket)
	{
		{
			static bool Fast = false;
			bool flip = true;
			QAngle angle_for_yaw;
			static int counter = 0;
			static int motion = 0;
			int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
			int oldlowerbodyyaw = 0;
			if (Fast)
			{
				static bool f_flip = true;
				f_flip = !f_flip;

				if (f_flip)
				{
					pCmd->viewangles.y -= 170.00f;
					bSendPacket = false;
				}
				else if (!f_flip)
				{
					pCmd->viewangles.y -= 190.00f;
					bSendPacket = false;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			else
			{


				if (flip)
				{

					if (counter % 48 == 0)
						motion++;
					int value = ServerTime % 2;
					switch (value) {
						int bindkey3 = Menu::Window.MiscTab.bindkey3.GetKey();
						if (bindkey3 > 0 && GUI.GetKeyState(bindkey3))
							pCmd->viewangles.y += 180;
						bSendPacket = true;
					}
					{
						pCmd->viewangles.y += 90;
						bSendPacket = true;
					}
					IJhsiujayu2t67arstyafshjzghkdhauis();
				}

			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
			Fast = !Fast;
		}
	}
	void FakeSlowSpinBackwards(CUserCmd* pCmd, bool& bSendPacket)
	{
		{

			int random = rand() % 100;
			int random2 = rand() % 1000;
			static bool dir;
			static float current_y = pCmd->viewangles.y;
			IClientEntity* pLocal = hackManager.pLocal();
			float server_time = pLocal->GetTickBase() * Interfaces::Globals->interval_per_tick;

			if (bSendPacket) {
				pCmd->viewangles.y = (float)(fmod(server_time / 0.39f * 360.0f, 360.0f));
			}
			else
			{
				if (random == 1) dir = !dir;
				if (dir)
					current_y -= 100.9;
				else
					current_y += 100.9;
				pCmd->viewangles.y = current_y;
				if (random == random2)
					pCmd->viewangles.y -= random;
			}
		}
		pCmd->viewangles.y -= 180;
		bSendPacket = false;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}




	void RotateYaw(CUserCmd *pCmd, bool& bSendPacket)
	{
		{
			bSendPacket = false;
			int RotateCurrent = rand() % 1 + 2;
			if (RotateCurrent == 1)
			{
				pCmd->viewangles.y = 271.f;
			}
			else if (RotateCurrent == 2)
			{
				pCmd->viewangles.y = -271.f;
			}
		}
		pCmd->viewangles.y -= 180;
		bSendPacket = false;
		IJhsiujayu2t67arstyafshjzghkdhauis();

	}
	void FakeHeadPeja(CUserCmd *pCmd, bool &bSendPacket)
	{
		int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i;
		IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
		IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

		static bool isMoving;
		float PlayerIsMoving = abs(pLocal->GetVelocity().Length());
		if (PlayerIsMoving > 0.1) isMoving = true;
		else if (PlayerIsMoving <= 0.1) isMoving = false;

		int flip = (int)floorf(Interfaces::Globals->curtime / 1.1) % 2;
		static bool bFlipYaw;
		float flInterval = Interfaces::Globals->interval_per_tick;
		float flTickcount = pCmd->tick_count;
		float flTime = flInterval * flTickcount;
		if (std::fmod(flTime, 1) == 0.f)
			bFlipYaw = !bFlipYaw;

		if (PlayerIsMoving <= 0.1)
		{
			if (bSendPacket)
			{
				pCmd->viewangles.y += 180.f;
			}
			else
			{
				if (flip)
				{
					pCmd->viewangles.y += bFlipYaw ? 90.f : -90.f;

				}
				else
				{
					pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + bFlipYaw ? 90.f : -90.f;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else if (PlayerIsMoving > 0.1)
		{
			if (bSendPacket)
			{
				pCmd->viewangles.y += 180.f;
			}
			else
			{
				pCmd->viewangles.y += 90.f;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void BackwardsJitter(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool choke = false;
		static bool s = false;
		if (choke)
		{
			bSendPacket = false; //true angle
			pCmd->viewangles.y += (rand() % 50 + 145);
		}
		else
		{
			bSendPacket = true;
			if (s) {
				pCmd->viewangles.y += 90.f;
			}
			else {
				pCmd->viewangles.y -= 90.f;
			}
			s = !s; //fake angle
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		choke = !choke;
	}

	void FakeBackwards(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool choke = false;
		static bool s = false;
		if (choke)
		{
			bSendPacket = false; //true angle
			if (s) {
				pCmd->viewangles.y += 90.f;
			}
			else {
				pCmd->viewangles.y -= 90.f;
			}
			s = !s;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.f; //fake angle
		}
		choke = !choke;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FakeSidewaysJitter(CUserCmd *pCmd, bool &bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static int ChokedPackets = -1;
		ChokedPackets++;
		if (ChokedPackets < 1)
		{
			bSendPacket = false;
			pCmd->viewangles.y -= 90;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y -= 45;
			pCmd->viewangles.y -= 40;
			pCmd->viewangles.y -= 35;
			ChokedPackets = -1;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FakeSidewaysJitterALT(CUserCmd *pCmd, bool &bSendPacket)
	{
		static int ChokedPackets = -1;
		ChokedPackets++;
		if (ChokedPackets < 1)
		{
			bSendPacket = false;
			pCmd->viewangles.y += 90;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 45;
			pCmd->viewangles.y += 40;
			pCmd->viewangles.y += 35;
			ChokedPackets = -1;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}



	void try1(CUserCmd *pCmd, bool& bSendPacket)
	{
		static bool SwitchY;
		static bool SwitchY2;
		static bool SwitchY4;

		SwitchY4 = !SwitchY4;
		if (SwitchY4)
		{
			static bool RandX1;
			static bool RandX2;
			if (RandX2)
			{
				pCmd->viewangles.y = -36000264.00000000;
			}
			else if (RandX1)
			{
				pCmd->viewangles.y = 36000264.00000000;
			}
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		SwitchY = !SwitchY;
		if (SwitchY)
		{
			pCmd->viewangles.y = 36000264.00000000f;
		}
		SwitchY2 = !SwitchY2;
		if (SwitchY2)
		{
			pCmd->viewangles.y = 36000264.00000000f;
		}
		else if (!SwitchY && !SwitchY2)
		{
			static bool JoelSwitchY;

			JoelSwitchY = !JoelSwitchY;
			if (JoelSwitchY)
			{
				pCmd->viewangles.y = -36000264.00000000;
			}
			else
			{
				pCmd->viewangles.y = 36000264.00000000f;
			}
		}
		else
		{
			static bool SwitchY3;
			SwitchY3 = !SwitchY3;
			if (SwitchY3)
			{
				pCmd->viewangles.y = 36000264.00000000f;
			}
			else
			{
				pCmd->viewangles.y = -36000264.00000000f;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	/*
	{
	static bool Fast = false;
	if (Fast)
	{
	bSendPacket = false; //true angle
	pCmd->viewangles.y += 175.0;
	}
	else
	{
	bSendPacket = true; //fake angle
	static bool Fast2 = false;
	if (Fast2)
	{
	pCmd->viewangles.y += 75;
	}
	else
	{
	pCmd->viewangles.y += 105;
	}
	Fast2 = !Fast2;
	}
	Fast = !Fast;
	}
	*/
	void sidejittermemes(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool Fast = false;
		bool flip = true;
		QAngle angle_for_yaw;
		static int counter = 0;
		static int motion = 0;
		int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
		int oldlowerbodyyaw = 0;
		if (Fast)
		{
			IJhsiujayu2t67arstyafshjzghkdhauis();
			static bool f_flip = true;
			f_flip = !f_flip;

			if (f_flip)
			{
				pCmd->viewangles.y -= 180;
				bSendPacket = false;
			}
			else if (!f_flip)
			{
				{
					int random = rand() % 100;

					// Small chance of starting fowards
					if (random < 98)
						// Look backwards
						pCmd->viewangles.y -= 180;

					// Some gitter
					if (random < 15)
					{
						float change = -70 + (rand() % (int)(140 + 1));
						pCmd->viewangles.y += change;
					}
					if (random == 69)
					{
						float change = -90 + (rand() % (int)(180 + 1));
						pCmd->viewangles.y += change;
					}
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
				bSendPacket = false;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else
		{
			if (flip)
			{
				if (counter % 48 == 0)
					motion++;
				int value = ServerTime % 2;
				switch (value) {

				case 0:pCmd->viewangles.y += 75;
					bSendPacket = true;
				case 1:pCmd->viewangles.y += 105;
					bSendPacket = true;
				}
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}





	/*
	{
	int bindkey2 = Menu::Window.MiscTab.bindkey2.GetKey();
	int bindkey3 = Menu::Window.MiscTab.bindkey3.GetKey();
	{
	static bool wilupdate;
	static float LastLBYUpdateTime = 0;
	float server_time = hackManager.pLocal()->GetTickBase() * Interfaces::Globals->interval_per_tick;
	if (server_time >= LastLBYUpdateTime)
	{
	LastLBYUpdateTime = server_time + 1.1f;
	wilupdate = true;

	}
	else
	{
	wilupdate = false;
	}
	// LZ Do edgeScan
	if (bSendPacket = false)
	{
	if (bindkey2 > 0 && GUI.GetKeyState(bindkey2)) //b
	pCmd->viewangles.y -= 90.f;
	else if (bindkey3 > 0 && GUI.GetKeyState(bindkey3)) //N
	pCmd->viewangles.y += 90.f;
	}
	else {
	if (bindkey3 > 0 && GUI.GetKeyState(bindkey3)) //b
	pCmd->viewangles.y += 90.f;
	else if (bindkey3 > 0 && GUI.GetKeyState(bindkey3)) //N
	pCmd->viewangles.y -= 90.f;
	}
	if (wilupdate)
	{
	if (bSendPacket = true)
	if (bindkey2 > 0 && GUI.GetKeyState(bindkey2)) //b
	pCmd->viewangles.y -= 180.f;
	else if (bindkey3 > 0 && GUI.GetKeyState(bindkey3)) //N
	pCmd->viewangles.y += 180.f;
	}
	}
	}
	*/
	void fakeanglespin(CUserCmd* pCmd)
	{
		if (pCmd->command_number % 2) {
			pCmd->viewangles.y = pCmd->viewangles.y + 36000180.0;
		}
		float CalculatedCurTime_2 = (Interfaces::Globals->curtime * 5000.0);
		pCmd->viewangles.y = CalculatedCurTime_2 + 36000000.0;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	/*

	void FakeEdge(CUserCmd *pCmd, bool &bSendPacket)
	{
	IClientEntity* pLocal = hackManager.pLocal();

	Vector vEyePos = pLocal->GetOrigin() + pLocal->GetViewOffset();

	CTraceFilter filter;
	filter.pSkip = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

	for (int y = 0; y < 360; y++)
	{
	Vector qTmp(10.0f, pCmd->viewangles.y, 0.0f);
	qTmp.y += y;

	if (qTmp.y > 180.0)
	qTmp.y -= 360.0;
	else if (qTmp.y < -180.0)
	qTmp.y += 360.0;

	GameUtils::NormaliseViewAngle(qTmp);

	Vector vForward;

	VectorAngles(qTmp, vForward);

	float fLength = (19.0f + (19.0f * sinf(DEG2RAD(10.0f)))) + 7.0f;
	vForward *= fLength;

	trace_t tr;

	Vector vTraceEnd = vEyePos + vForward;

	Ray_t ray;

	ray.Init(vEyePos, vTraceEnd);
	Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &tr);

	if (tr.fraction != 1.0f)
	{
	Vector angles;

	Vector vNegative = Vector(tr.plane.normal.x * -1.0f, tr.plane.normal.y * -1.0f, tr.plane.normal.z * -1.0f);

	VectorAngles(vNegative, angles);

	GameUtils::NormaliseViewAngle(angles);

	qTmp.y = angles.y;

	GameUtils::NormaliseViewAngle(qTmp);

	trace_t trLeft, trRight;

	Vector vLeft, vRight;
	VectorAngles(qTmp + Vector(0.0f, 30.0f, 0.0f), vLeft);
	VectorAngles(qTmp + Vector(0.0f, 30.0f, 0.0f), vRight);

	vLeft *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));
	vRight *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));

	vTraceEnd = vEyePos + vLeft;

	ray.Init(vEyePos, vTraceEnd);
	Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &trLeft);

	vTraceEnd = vEyePos + vRight;

	ray.Init(vEyePos, vTraceEnd);
	Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &trRight);

	if ((trLeft.fraction == 1.0f) && (trRight.fraction != 1.0f))
	qTmp.y -= 90.f;
	else if ((trLeft.fraction != 1.0f) && (trRight.fraction == 1.0f))
	qTmp.y += 90.f;

	if (qTmp.y > 180.0)
	qTmp.y -= 360.0;
	else if (qTmp.y < -180.0)
	qTmp.y += 360.0;

	pCmd->viewangles.y = qTmp.y;

	int offset = Menu::Window.AntiAimTab.AntiAimOffset.GetValue();

	static int ChokedPackets = -1;
	ChokedPackets++;
	if (ChokedPackets < 1)
	{
	bSendPacket = false; // +=180?
	}
	else
	{
	bSendPacket = true;
	pCmd->viewangles.y -= offset;
	ChokedPackets = -1;
	}
	return;
	}
	}
	pCmd->viewangles.y += 360.0f;
	}
	*/

	void comeback(CUserCmd *pCmd, bool &bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static bool first;
		static bool lowerbody;
		lowerbody = !lowerbody;
		if (lowerbody)
		{
			if (first)
			{
				first = false;
				pCmd->viewangles.y += 180.0f;
				bSendPacket = true;
			}
			else
			{
				{
					bSendPacket = true; //fake angle
					static bool Fast2 = false;
					if (Fast2)
					{
						pCmd->viewangles.y += 75;
					}
					else
					{
						pCmd->viewangles.y += 105;
					}
					Fast2 = !Fast2;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else
		{
			if (lowerbody)
			{
				first = false;
				pCmd->viewangles.y -= 180.0f;
				bSendPacket = true;
			}
			else
			{
				bSendPacket = true; //fake angle
				static bool Fast2 = false;
				if (Fast2)
				{
					pCmd->viewangles.y -= 75;
				}
				else
				{
					pCmd->viewangles.y -= 105;
				}
				Fast2 = !Fast2;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	enum ADAPTIVE_SIDE {
		ADAPTIVE_UNKNOWN,
		ADAPTIVE_LEFT,
		ADAPTIVE_RIGHT
	};

	enum ADAPTIVE_SIDE2 {
		ADAPTIVE_UNKNOWN2,
		ADAPTIVE_LEFT2,
		ADAPTIVE_RIGHT2
	};

	void adaptive2(CUserCmd * pCmd, bool& bSendPacket) {
		auto fov_to_player = [](Vector view_offset, Vector view, IClientEntity* m_entity, int hitbox)
		{
			CONST FLOAT MaxDegrees = 180.0f;
			Vector Angles = view;
			Vector Origin = view_offset;
			Vector Delta(0, 0, 0);
			Vector Forward(0, 0, 0);
			AngleVectors3(Angles, &Forward);
			Vector AimPos = GetHitboxPosition(m_entity, hitbox);
			VectorSubtract(AimPos, Origin, Delta);
			Normalize(Delta, Delta);
			FLOAT DotProduct = Forward.Dot(Delta);
			return (acos(DotProduct) * (MaxDegrees / PI));
			IJhsiujayu2t67arstyafshjzghkdhauis();
		};

		auto m_local = hackManager.pLocal();

		int target = -1;
		float mfov = 20;

		Vector viewoffset = m_local->GetOrigin() + m_local->GetViewOffset();
		Vector view; Interfaces::Engine->GetViewAngles(view);

		for (int i = 0; i < Interfaces::Engine->GetMaxClients(); i++) {
			IClientEntity* m_entity = Interfaces::EntList->GetClientEntity(i);

			if (m_entity && m_entity->IsDormant() == false && m_entity->IsAlive() && m_entity->GetIndex() != hackManager.pLocal()->GetIndex()) {

				float fov = fov_to_player(viewoffset, view, m_entity, 0);
				if (fov < mfov) {
					mfov = fov;
					target = i;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}

		ADAPTIVE_SIDE2 side = ADAPTIVE_UNKNOWN2;

		Vector at_target_angle;

		if (target) {
			auto m_entity = Interfaces::EntList->GetClientEntity(target);

			if (m_entity && m_entity->IsDormant() == false && m_entity->IsAlive() && m_entity->GetIndex() != hackManager.pLocal()->GetIndex()) {
				Vector pos_enemy;
				if (Render::WorldToScreen(m_entity->GetOrigin(), pos_enemy)) {
					CalcAngle(m_local->GetOrigin(), m_entity->GetOrigin(), at_target_angle);

					POINT mouse = GUI.GetMouse();

					if (mouse.x > pos_enemy.x) side = ADAPTIVE_RIGHT2;
					else if (mouse.x < pos_enemy.x) side = ADAPTIVE_LEFT2;
					else side = ADAPTIVE_UNKNOWN2;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}

			if (side == ADAPTIVE_RIGHT) {
				pCmd->viewangles.y = at_target_angle.y + 90;
			}
			else if (side == ADAPTIVE_LEFT) {
				pCmd->viewangles.y = at_target_angle.y - 90;
			}

		if (side == ADAPTIVE_UNKNOWN) {
			pCmd->viewangles.y -= 180;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}


	void adaptive(CUserCmd * pCmd, bool& bSendPacket) {
		auto fov_to_player = [](Vector view_offset, Vector view, IClientEntity* m_entity, int hitbox)
		{
			CONST FLOAT MaxDegrees = 180.0f;
			Vector Angles = view;
			Vector Origin = view_offset;
			Vector Delta(0, 0, 0);
			Vector Forward(0, 0, 0);
			AngleVectors3(Angles, &Forward);
			Vector AimPos = GetHitboxPosition(m_entity, hitbox);
			VectorSubtract(AimPos, Origin, Delta);
			Normalize(Delta, Delta);
			FLOAT DotProduct = Forward.Dot(Delta);
			return (acos(DotProduct) * (MaxDegrees / PI));
			IJhsiujayu2t67arstyafshjzghkdhauis();
		};

		auto m_local = hackManager.pLocal();

		int target = -1;
		float mfov = 20;

		Vector viewoffset = m_local->GetOrigin() + m_local->GetViewOffset();
		Vector view; Interfaces::Engine->GetViewAngles(view);

		for (int i = 0; i < Interfaces::Engine->GetMaxClients(); i++) {
			IClientEntity* m_entity = Interfaces::EntList->GetClientEntity(i);

			if (m_entity && m_entity->IsDormant() == false && m_entity->IsAlive() && m_entity->GetIndex() != hackManager.pLocal()->GetIndex()) {

				float fov = fov_to_player(viewoffset, view, m_entity, 0);
				if (fov < mfov) {
					mfov = fov;
					target = i;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}

		ADAPTIVE_SIDE side = ADAPTIVE_UNKNOWN;

		Vector at_target_angle;

		if (target) {
			auto m_entity = Interfaces::EntList->GetClientEntity(target);

			if (m_entity && m_entity->IsDormant() == false && m_entity->IsAlive() && m_entity->GetIndex() != hackManager.pLocal()->GetIndex()) {
				Vector pos_enemy;
				if (Render::WorldToScreen(m_entity->GetOrigin(), pos_enemy)) {
					CalcAngle(m_local->GetOrigin(), m_entity->GetOrigin(), at_target_angle);

					POINT mouse = GUI.GetMouse();

					if (mouse.x > pos_enemy.x) side = ADAPTIVE_RIGHT;
					else if (mouse.x < pos_enemy.x) side = ADAPTIVE_LEFT;
					else side = ADAPTIVE_UNKNOWN;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}

			if (side == ADAPTIVE_RIGHT) {
				pCmd->viewangles.y = at_target_angle.y - 90;
			}
			else if (side == ADAPTIVE_LEFT) {
				pCmd->viewangles.y = at_target_angle.y + 90;
			}


		if (side == ADAPTIVE_UNKNOWN) {
			pCmd->viewangles.y -= 180;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void lbynibybraekr(CUserCmd* pCmd, bool &bSendPacket)
	{
		static float StartLbyBreaker;
		static float LastLBYUpdateTime;
		static float lbyDelta;
		static int LBYBreakerTimer1 = 1;
		float realAngle = pCmd->viewangles.y += 180.0f;;
		float fakeAngle;
		float lby;
		static int random;
		random = rand() % 2;

		IJhsiujayu2t67arstyafshjzghkdhauis();
		// FAKE ANGLE ROFL ROFL ROFL
		if (random == 1) {
			fakeAngle = pCmd->viewangles.y -= 90.0f;
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else {
			fakeAngle = pCmd->viewangles.y += 90.0f;
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}


		// ROFL ROFL I KNOW
		while (realAngle < -180.0f)
			realAngle += 360.0f;

		while (realAngle > 180.0f)
			realAngle -= 360.0f;

		while (fakeAngle < -180.0f)
			fakeAngle += 360.0f;

		while (fakeAngle > 180.0f)
			fakeAngle -= 360.0f;


		// Real Angle should always be more then 35° FAKE Angle & LBY ; 45 because most bruteforce ur lby + 40°
		if (fabsf(realAngle - lby) > 45 && fabsf(realAngle - fakeAngle) > 45) {
			realAngle += realAngle;
		}

		if (fabsf(realAngle - lby) < 45 || fabsf(realAngle - fakeAngle) < 45) {
			realAngle += 45;
		}

		// IF LBY Update from Proxy then fake Angle "Peek"... like a fagg

		if (StartLbyBreaker != LBYBreakerTimer1)
		{
			bSendPacket = true;
			StartLbyBreaker = LBYBreakerTimer1;
			pCmd->viewangles.y += fakeAngle;
		}
		else
		{
			pCmd->viewangles.y += realAngle;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void fake2(CUserCmd* pCmd, bool& bSendPacket)
	{
#define RandomInt(min, max) (rand() % (max - min + 1) + min)
		int flip = (int)floorf(Interfaces::Globals->curtime / 3) % 2;
		static bool lowerbody;
		lowerbody = !lowerbody;
		if (lowerbody)
		{
			IJhsiujayu2t67arstyafshjzghkdhauis();
			bSendPacket = true;
			int rand2;
			static bool flipit;
			rand2 = RandomInt(1, 100);
			if (flipit) {
				if (rand2 < 2) {
					pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() - 260.27 + flip * hackManager.pLocal()->GetLowerBodyYaw() - 184.86;
				}
				else
				{
					pCmd->viewangles.y += flip * hackManager.pLocal()->GetLowerBodyYaw() - 260.27;
				}
				flipit = false;
			}
			else {
				if (rand2 < 2) {
					pCmd->viewangles.y += -260.27 + flip * 184.86;
				}
				else
				{
					pCmd->viewangles.y += flip * 260.27;
				}
				flipit = true;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
			lowerbody = false;
		}
		else {
			bSendPacket = false;
			pCmd->viewangles.y += 180;
			lowerbody = true;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void pLBY(CUserCmd* pCmd, bool& bSendPacket)
	{
		static bool ySwitch;
		static bool jbool;
		static bool jboolt;
		ySwitch = !ySwitch;
		jbool = !jbool;
		jboolt = !jbool;
		if (ySwitch)
		{
			if (jbool)
			{
				if (jboolt)
				{
					pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() - 87.554f;
					bSendPacket = false;
				}
				else
				{
					pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() + 93.946f;
					bSendPacket = false;
				}
			}
			else
			{
				if (jboolt)
				{
					pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() - 126.446f;
					bSendPacket = false;
				}
				else
				{
					pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() + 124.874f;
					bSendPacket = false;
				}
			}
		}
		else
		{
			pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw();
			bSendPacket = true;
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	/*
	int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i;
	IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
	IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

	static bool isMoving;
	float PlayerIsMoving = abs(pLocal->GetVelocity().Length());
	if (PlayerIsMoving > 0.1) isMoving = true;
	else if (PlayerIsMoving <= 0.1) isMoving = false;
	*/

	void Paatest(CUserCmd *pCmd, bool &bSendPacket)
	{
		int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i;
		IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
		IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

		static bool isMoving;
		float PlayerIsMoving = abs(pLocal->GetVelocity().Length());
		if (PlayerIsMoving > 0.1) isMoving = true;
		else if (PlayerIsMoving <= 0.1) isMoving = false;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (PlayerIsMoving <= 0.1)
		{
			static bool Fast = false;
			bool flip = true;
			QAngle angle_for_yaw;
			static int counter = 0;
			static int motion = 0;
			int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
			int oldlowerbodyyaw = 0;
			if (Fast)
			{
				static bool f_flip = true;
				f_flip = !f_flip;

				if (f_flip)
				{
					pCmd->viewangles.y -= 170.00f;
					bSendPacket = false;
				}
				else if (!f_flip)
				{
					pCmd->viewangles.y -= 190.00f;
					bSendPacket = false;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			else
			{


				if (flip)
				{
					if (counter % 48 == 0)
						motion++;
					int value = ServerTime % 2;
					switch (value) {

					case 0:pCmd->viewangles.y += 180;
						bSendPacket = true;
					case 1:pCmd->viewangles.y += 90;
						bSendPacket = true;
					}
					IJhsiujayu2t67arstyafshjzghkdhauis();
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
			Fast = !Fast;
		}
		if (PlayerIsMoving > 0.1)
		{
			static bool Fast = false;
			if (Fast)
			{
				bSendPacket = false; //true angle
				pCmd->viewangles.y += 175.0;
			}
			else
			{
				bSendPacket = true; //fake angle
				static bool Fast2 = false;
				if (Fast2)
				{
					pCmd->viewangles.y += 75;
				}
				else
				{
					pCmd->viewangles.y += 105;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
				Fast2 = !Fast2;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
			Fast = !Fast;
		}
	}
	void skeet(CUserCmd* pCmd, bool& bSendPacket)
	{
		static bool pJitter;
		if (pJitter <= 1)
		{
			pCmd->viewangles.x = 88.000000;
			pCmd->viewangles.y += 135.000000;
		}
		else if (pJitter > 1 && pJitter <= 3)
		{
			pCmd->viewangles.x = 88.000000;
			pCmd->viewangles.y += 22.000000;
		}
		if (pCmd->tick_count % 3)
		{
			bSendPacket = false;
			if (pJitter <= 1)
			{
				pCmd->viewangles.y += 60.000000;
				pJitter += 1;
			}
			else if (pJitter > 1 && pJitter <= 3)
			{
				pCmd->viewangles.y -= 55.000000;
				pJitter += 1;
			}
			else
			{
				pJitter = 0;
			}
		}
		else
		{
			bSendPacket = true;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void aagud(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool f_flip = true;
		f_flip = !f_flip;
		static int fakeaa = pCmd->viewangles.y = -90 + bSendPacket;


		if (f_flip)
		{
			pCmd->viewangles.y += 90;
			bSendPacket = false;
		}
		else if (!f_flip)
		{
			pCmd->viewangles.y -= 50;
			bSendPacket = true;
		}
		else if (fakeaa)
		{
			pCmd->viewangles.y = fakeaa;
			bSendPacket = false;
		}
		else if (fakeaa = bSendPacket)
		{
			fakeaa;
		}
		else if (fakeaa = false)
		{
			pCmd->viewangles.z = 50.f;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void fake90p100yaw(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool f_flip = true;
		f_flip = !f_flip;

		if (f_flip)
		{
			QAngle v37 = pCmd->viewangles;
			pCmd->viewangles.y = v37.y + 90.0;
			bSendPacket = true;
		}
		else if (!f_flip)
		{
			QAngle v37 = pCmd->viewangles;
			pCmd->viewangles.y = v37.y - 90.0;
			bSendPacket = false;
		}
		else if (f_flip)
		{
			pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + 90;
			bSendPacket = true;
		}
		else if (!f_flip)
		{
			pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() - 90;
			bSendPacket = false;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void SideFake2(CUserCmd *pCmd, bool& bSendPacket)
	{
		bool faked123;
		if (faked123 = true)
		{
			bSendPacket = true; //fake aa = obviously some aa with some + shit xddd
			pCmd->viewangles.y += 90 + rand() % 10; //pAntiAWaa :33 + non ut <3333333333333333333333333333333333333333333333333333333
			faked123 = false;
		}
		else if (Menu::Window.MiscTab.FakeLagEnable.GetState())
		{
			//if fakelag is on then dont care about anything else just put on backwards with some -
			pCmd->viewangles.y = 180 - rand() % 7, 5;
		}
		else
		{ //but when fakelag is off then put on real angle jitter
			bSendPacket = false;
			bool pJitter;
			if (pJitter = true)
			{
				pCmd->viewangles.y = -70 + 60;
				pJitter = false;
			}
			else
			{
				pCmd->viewangles.y = 69 - rand() % 15;
				pJitter = true;
			}
			faked123 = true;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
/*	void fakehead(CUserCmd *pCmd, bool& bSendPacket)
	{
		IClientEntity* pLocal = hackManager.pLocal();

		Vector vEyePos = pLocal->GetOrigin() + pLocal->GetViewOffset();

		CTraceFilter filter;
		filter.pSkip = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

		for (int y = 0; y < 360; y++)
		{
			Vector qTmp(10.0f, pCmd->viewangles.y, 0.0f);
			qTmp.y += y;

			if (qTmp.y > 180.0)
				qTmp.y -= 360.0;
			else if (qTmp.y < -180.0)
				qTmp.y += 360.0;

			GameUtils::NormaliseViewAngle(qTmp);

			Vector vForward;

			VectorAngles(qTmp, vForward);

			float fLength = (19.0f + (19.0f * sinf(DEG2RAD(10.0f)))) + 7.0f;
			vForward *= fLength;

			trace_t tr;

			Vector vTraceEnd = vEyePos + vForward;

			Ray_t ray;

			ray.Init(vEyePos, vTraceEnd);
			Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &tr);

			if (tr.fraction != 1.0f)
			{
				Vector angles;

				Vector vNegative = Vector(tr.plane.normal.x * -1.0f, tr.plane.normal.y * -1.0f, tr.plane.normal.z * -1.0f);

				VectorAngles(vNegative, angles);

				GameUtils::NormaliseViewAngle(angles);

				qTmp.y = angles.y;

				GameUtils::NormaliseViewAngle(qTmp);

				trace_t trLeft, trRight;

				Vector vLeft, vRight;
				VectorAngles(qTmp + Vector(0.0f, 30.0f, 0.0f), vLeft);
				VectorAngles(qTmp + Vector(0.0f, 30.0f, 0.0f), vRight);

				vLeft *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));
				vRight *= (fLength + (fLength * sinf(DEG2RAD(30.0f))));

				vTraceEnd = vEyePos + vLeft;

				ray.Init(vEyePos, vTraceEnd);
				Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &trLeft);

				vTraceEnd = vEyePos + vRight;

				ray.Init(vEyePos, vTraceEnd);
				Interfaces::Trace->TraceRay(ray, MASK_PLAYERSOLID_BRUSHONLY, &filter, &trRight);


				int offset = Menu::Window.AntiAimTab.AntiAimOffset.GetValue();

				{
					static bool Fast = false;
					bool flip = true;
					QAngle angle_for_yaw;
					static int counter = 0;
					static int motion = 0;
					int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
					int oldlowerbodyyaw = 0;
					if (Fast)
					{
						static bool f_flip = true;
						f_flip = !f_flip;

						if (f_flip)
						{
							pCmd->viewangles.y -= 170.00f;
							bSendPacket = false;
						}
						else if (!f_flip)
						{
							pCmd->viewangles.y -= 190.00f;
							bSendPacket = false;
						}
					}
					else
					{


						if (flip)
						{
							if (counter % 48 == 0)
								motion++;
							int value = ServerTime % 2;
							switch (value) {

							case 0:pCmd->viewangles.y += 180;
								bSendPacket = true;
							case 1:pCmd->viewangles.y += 90;
								bSendPacket = true;
							}
						}
					}
					Fast = !Fast;
				}
			}
		}
		pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() * hackManager.pLocal()->GetLowerBodyYaw() ? -90.f : 90.f;
	}*/

	void FakeBackJitterxD(CUserCmd* pCmd, bool& bSendPacket)
	{
		IClientEntity* pLocal = hackManager.pLocal();

		if (bSendPacket)
		{
			pCmd->viewangles.y += pLocal->GetLowerBodyYaw() + 35;
		}
		else
		{
				float change = 0;
				int random = rand() % 100;

				if (random < 98)

					pCmd->viewangles.y -= 179;

				if (random < 15)
				{
					float change = -40 + (rand() % (int)(140 + 1));
					pCmd->viewangles.y += change;
				}
				if (random == 69)
				{
					float change = -89 + (rand() % (int)(180 + 1));
					pCmd->viewangles.y += change;
				}
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void FakeTwoStep(CUserCmd* pCmd, bool& bSendPacket) {

		IClientEntity* pLocal = hackManager.pLocal();
		static bool bFlipYaw;
		float flInterval = Interfaces::Globals->interval_per_tick;
		float flTickcount = pCmd->tick_count;
		float flTime = flInterval * flTickcount;
		float server_time = pLocal->GetTickBase() * Interfaces::Globals->interval_per_tick;
		if (std::fmod(flTime, 10) == 4.f)
			bFlipYaw = !bFlipYaw;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (bSendPacket)
			pCmd->viewangles.y -= (float)(fmod(server_time / 10.45f * 39.0f, 180.0f));
		else
			pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + bFlipYaw ? -90.f : 90.f;
	}

	void testing(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool Fast = false;
		bool flip = true;
		QAngle angle_for_yaw;
		static int counter = 0;
		static int motion = 0;
		int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
		int oldlowerbodyyaw = 0;
		if (Fast)
		{
			static bool f_flip = true;
			f_flip = !f_flip;

			if (f_flip)
			{
				pCmd->viewangles.y -= pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() + 30;
				bSendPacket = false;
			}
			else if (!f_flip)
			{
				pCmd->viewangles.y -= pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() - 30;
				bSendPacket = false;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else
		{


			if (flip)
			{
				if (counter % 48 == 0)
					motion++;
				int value = ServerTime % 2;
				switch (value) {

				case 0:pCmd->viewangles.y += pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() * 60;
					bSendPacket = true;
				case 1:pCmd->viewangles.y += pCmd->viewangles.y -= hackManager.pLocal()->GetLowerBodyYaw() * 30;
					bSendPacket = true;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		Fast = !Fast;
	}


	void Jitter(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool ySwitch = false;
		int veloc = hackManager.pLocal()->GetVelocity().Length();
		if (ySwitch)
			pCmd->viewangles.y -= 90 * veloc;
		else
			pCmd->viewangles.y += 90 * veloc;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		ySwitch = !ySwitch;
	}

	void FadedJitter(CUserCmd *pCmd, bool &bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static bool ySwitch = false;
		int veloc = hackManager.pLocal()->GetVelocity().Length();
		if (bSendPacket)
		{
			if (ySwitch)
				pCmd->viewangles.y -= 70 * (veloc / 3);
			else
				pCmd->viewangles.y -= 110 * (veloc / 3);

			ySwitch = !ySwitch;
		}
		else
		{
			if (ySwitch)
				pCmd->viewangles.y += 70 * (veloc / 3);
			else
				pCmd->viewangles.y += 110 * (veloc / 3);

			ySwitch = !ySwitch;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void FadedJitterAlt(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool ySwitch = false;
		int veloc = hackManager.pLocal()->GetVelocity().Length();
		if (bSendPacket)
		{
			if (ySwitch)
				pCmd->viewangles.y += 70 * (veloc / 3);
			else
				pCmd->viewangles.y += 110 * (veloc / 3);

			ySwitch = !ySwitch;
		}
		else
		{
			if (ySwitch)
				pCmd->viewangles.y -= 70 * (veloc / 3);
			else
				pCmd->viewangles.y -= 110 * (veloc / 3);

			ySwitch = !ySwitch;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	/*
	{
	static bool Fast = false;
	bool flip = true;
	QAngle angle_for_yaw;
	static int counter = 0;
	static int motion = 0;
	int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
	int oldlowerbodyyaw = 0;
	if (Fast)
	{
	static bool f_flip = true;
	f_flip = !f_flip;

	if (f_flip)
	{
	pCmd->viewangles.y -= 170.00f;
	bSendPacket = false;
	}
	else if (!f_flip)
	{
	pCmd->viewangles.y -= 190.00f;
	bSendPacket = false;
	}
	}
	else
	{


	if (flip)
	{
	if (counter % 48 == 0)
	motion++;
	int value = ServerTime % 2;
	switch (value) {

	case 0:pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() + 90.00f;
	bSendPacket = true;
	case 1:pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() - 100.00f;
	bSendPacket = true;
	}

	}
	}
	Fast = !Fast;
	}
	*/
	void Jitter1(CUserCmd *pCmd, bool &bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		static bool Fast = false;
		bool flip = true;
		QAngle angle_for_yaw;
		static int counter = 0;
		static int motion = 0;
		int ServerTime = (float)Interfaces::Globals->interval_per_tick * hackManager.pLocal()->GetTickBase() * 1;
		int oldlowerbodyyaw = 0;
		if (Fast)
		{
			static bool f_flip = true;
			f_flip = !f_flip;

			if (f_flip)
			{
				pCmd->viewangles.y -= 170.00f;
				bSendPacket = false;
			}
			else if (!f_flip)
			{
				pCmd->viewangles.y -= 190.00f;
				bSendPacket = false;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else
		{


			if (flip)
			{
				if (counter % 48 == 0)
					motion++;
				int value = ServerTime % 2;
				switch (value) {

				case 0:pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() + 90.00f;
					bSendPacket = true;
				case 1:pCmd->viewangles.y = hackManager.pLocal()->GetLowerBodyYaw() - 180.00f;
					bSendPacket = true;
				}
				IJhsiujayu2t67arstyafshjzghkdhauis();
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast = !Fast;
	}

	void Autistic(CUserCmd *pCmd, bool &bSendPacket)
	{
		static bool f_flip = true;
		f_flip = !f_flip;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (f_flip)
		{
			bSendPacket = true; //fake angle
			int r1 = 90 - rand() % 10;
			static float current_y = pCmd->viewangles.y;
			current_y += r1;
			pCmd->viewangles.y = current_y;

		}
		else if (!f_flip)
		{
			bSendPacket = true;
			int r1 = 179 - rand() % 10;
			static float current_y = pCmd->viewangles.y;
			current_y += r1;
			pCmd->viewangles.y = current_y;

		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	void TickOverRide(CUserCmd *pCmd, bool &bSendPacket)
	{
		IJhsiujayu2t67arstyafshjzghkdhauis();
		bool jitter = false;
		int Add = 0;

		if (bSendPacket)
		{
			if (jitter)
				Add = -90;
			else
				Add = 90;
		}
		else
		{
			float flRandom = rand() % 5 + 1.f;
			switch (pCmd->tick_count % 4)
			{
			case 0:
				Add = -170.f - flRandom;
				break;
			case 3:
			case 1:
				Add = 180.f;
				break;
			case 2:
				Add = 170.f + flRandom;
				break;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void SideJitterALT(CUserCmd *pCmd)
	{
		static bool Fast2 = false;
		if (Fast2)
		{
			pCmd->viewangles.y -= 75;
		}
		else
		{
			pCmd->viewangles.y -= 105;

		}
		Fast2 = !Fast2;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void SideJitter(CUserCmd *pCmd)
	{
		static bool Fast2 = false;
		if (Fast2)
		{
			pCmd->viewangles.y += 75;
		}
		else
		{
			pCmd->viewangles.y += 105;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
		Fast2 = !Fast2;
	}

	void NewBackJitter(CUserCmd *pCmd)
	{
		static bool Fast2 = false;
		if (Fast2)
		{
			pCmd->viewangles.y += 165;
		}
		else
		{
			pCmd->viewangles.y -= 165;
		}
		Fast2 = !Fast2;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void SlowSpin(CUserCmd *pCmd)
	{
		static int y2 = -179;
		int spinBotSpeedFast = Menu::Window.AntiAimTab.SpinSpeed.GetValue() / 1.618033988749895f;

		y2 += spinBotSpeedFast;

		if (y2 >= 179)
			y2 = -179;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		pCmd->viewangles.y = y2;
	}

	void LowerbodyNew(CUserCmd *pCmd)
	{
		float randfloat = rand() % -180 + 360;
		IClientEntity *pLocal = hackManager.pLocal();

		if (NextLBYUpdate())
		{
			pCmd->viewangles.y += 90;
		}
		else
		{
			pCmd->viewangles.y -= 90;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void Spinbot(CUserCmd* pCmd) {

		int random = rand() % 100;
		int random2 = rand() % 1000;

		static bool dir;
		static float current_y = pCmd->viewangles.y;

		if (random == 1) dir = !dir;

		if (dir)
			current_y += 100.9;
		else
			current_y -= 100.9;

		pCmd->viewangles.y = current_y;
		IJhsiujayu2t67arstyafshjzghkdhauis();
		if (random == random2)
			pCmd->viewangles.y += random;
	}

	void LowerbodyNewALT(CUserCmd *pCmd)
	{
		float randfloat = rand() % -180 + 360;
		IClientEntity *pLocal = hackManager.pLocal();

		if (NextLBYUpdate())
		{
			pCmd->viewangles.y -= 90;
		}
		else
		{
			pCmd->viewangles.y += 90;
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	void tolong(CUserCmd *pCmd, bool &bSendPacket)
	{
		static float StoredYaw = 0;
		IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());
		static bool flip = false;
		static bool flip2 = false;
		float flip2angle = 0.f;
		if (pLocal->GetLowerBodyYaw() != StoredYaw) //If lowerbody updates and is different than previous change the antiaim
			flip2 = !flip2;
		if (flip2)
			flip2angle = 180.f;
		else
			flip2angle = 0.f;
		IJhsiujayu2t67arstyafshjzghkdhauis();

		if (flip)
		{
			pCmd->viewangles.y += 90.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -90.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 100.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -100.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 110.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -110.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 120.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -120.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 130.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -130.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 310.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -310.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 300.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -300.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 290.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -290.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 280.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -280.0 + flip2angle;
			bSendPacket = true;
		}
		if (flip)
		{
			pCmd->viewangles.y += 270.0 + flip2angle;
			bSendPacket = false;
		}
		else
		{
			pCmd->viewangles.y += -270.0 + flip2angle;
			bSendPacket = true;
		}
		StoredYaw = pLocal->GetLowerBodyYaw();
		flip = !flip;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}


}
bool CanFire()
{
	IClientEntity* pLocalEntity = (IClientEntity*)Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());
	if (!pLocalEntity)
		return false;

	CBaseCombatWeapon* entwep = (CBaseCombatWeapon*)Interfaces::EntList->GetClientEntityFromHandle(pLocalEntity->GetActiveWeaponHandle());

	float flServerTime = (float)pLocalEntity->GetTickBase() * Interfaces::Globals->interval_per_tick;
	float flNextPrimaryAttack = entwep->GetNextPrimaryAttack();

	std::cout << flServerTime << " " << flNextPrimaryAttack << std::endl;

	return !(flNextPrimaryAttack > flServerTime);
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

void edruiythyusdfgshdfasgydr::aimAtPlayer(CUserCmd *pCmd)
{
	IClientEntity* pLocal = hackManager.pLocal();

	CBaseCombatWeapon* pWeapon = (CBaseCombatWeapon*)Interfaces::EntList->GetClientEntityFromHandle(hackManager.pLocal()->GetActiveWeaponHandle());

	if (!pLocal || !pWeapon)
		return;

	Vector eye_position = pLocal->GetEyePosition();

	float best_dist = pWeapon->GetCSWpnData()->flRange;
	IJhsiujayu2t67arstyafshjzghkdhauis();
	IClientEntity* target = nullptr;

	for (int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); i++)
	{
		IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
		if (TargetMeetsRequirements(pEntity))
		{
			if (Globals::TargetID != -1)
				target = Interfaces::EntList->GetClientEntity(Globals::TargetID);
			else
				target = pEntity;

			Vector target_position = target->GetEyePosition();

			float temp_dist = eye_position.DistTo(target_position);

			if (best_dist > temp_dist)
			{
				best_dist = temp_dist;
				CalcAngle(eye_position, target_position, pCmd->viewangles);
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}


/*void CRageBot::DoAntiAim(CUserCmd *pCmd, bool &bSendPacket)
{
	IClientEntity* pLocal = hackManager.pLocal();
	int FlipKey = Menu::Window.AntiAimTab.FlipKey.GetKey();


	if ((pCmd->buttons & IN_USE) || pLocal->GetMoveType() == MOVETYPE_LADDER)
		return;

	if ((IsAimStepping || pCmd->buttons & IN_ATTACK) && !Menu::Window.RageBotTab.AimbotSilentAim.GetIndex())
		return;

	if (Menu::Window.AntiAimTab.AntiAimTarget.GetState())
		aimAtPlayer(pCmd);

	CBaseCombatWeapon* CSWeapon = (CBaseCombatWeapon*)Interfaces::EntList->GetClientEntityFromHandle(hackManager.pLocal()->GetActiveWeaponHandle());
	if (CSWeapon)
	{
		CSWeaponInfo* pWeaponInfo = CSWeapon->GetCSWpnData();
		if (!GameUtils::IsBallisticWeapon(CSWeapon))
		{
			if (Menu::Window.AntiAimTab.AntiAimKnife.GetState())
			{
				if (!CanFire() || pCmd->buttons & IN_ATTACK2)
					return;
			}
			else
			{
				return;
			}
		}

	}

	switch (Menu::Window.AntiAimTab.AntiAimPitch.GetIndex())
	{
	case 0:
		break;
	case 1:
		pCmd->viewangles.x = 89.0000;
		break;

	case 2:
		pCmd->viewangles.x = -180;
		break;

	case 3:
		pCmd->viewangles.x = 991;
		break;

	case 4:
		pCmd->viewangles.x = 1080;
		break;

	case 5:
		pCmd->viewangles.x = -1080;
		break;

	case 6:
	{
		static bool flip = true;
		if (flip)
		{
			pCmd->viewangles.x = 89;
			flip = !flip;
		}
		else
		{
			pCmd->viewangles.x = 174;
			flip = !flip;
		}
		break;
	}

	case 7:
	{
		static bool flip = true;
		if (flip)
		{
			pCmd->viewangles.x = 45;
			flip = !flip;
		}
		else
		{
			pCmd->viewangles.x = 89;
			flip = !flip;
		}
		break;
	}
	}
	int i = 0; i < Interfaces::EntList->GetHighestEntityIndex(); ++i;
	IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);
	if (FlipKey > 0 && GUI.GetKeyPress(FlipKey))
	{
		flipBool = !flipBool;
	}

	static bool isMoving;
	float PlayerIsMoving = abs(pLocal->GetVelocity().Length());
	if (PlayerIsMoving > 0.1) isMoving = true;
	else if (PlayerIsMoving <= 0.1) isMoving = false;

	if (PlayerIsMoving <= 40)
		switch (Menu::Window.AntiAimTab.staticyaw.GetIndex())
		{
		case 0:
			break;
		case 1:
			AAYaw::Backward(pCmd);
			break;
		case 2:
			if (flipBool)
			{
				AAYaw::FakeSideways(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FakeSidewaysALT(pCmd, bSendPacket);
			}
			break;
		case 3:
			if (flipBool)
			{
				AAYaw::FakeJitterSidewaysALT(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FakeJitterSideways(pCmd, bSendPacket);
			}
			break;
		case 4:
			AAYaw::TestLBYBreak(pCmd, bSendPacket);
			break;
		case 5:
			if (flipBool)
			{
				AAYaw::BolbiBreakALT(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::BolbiBreak(pCmd, bSendPacket);
			}
			break;
		case 6:
			AAYaw::FakeSwitch(pCmd, bSendPacket);
			break;
		case 7:
				if (flipBool)
				{
					AAYaw::FakeSidewaysJitterALT(pCmd, bSendPacket);
				}
				else if (!flipBool)
				{
					AAYaw::FakeSidewaysJitter(pCmd, bSendPacket);
				}
			break;
		case 8:
			if (flipBool)
			{
				AAYaw::FadedJitter(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FadedJitter(pCmd, bSendPacket);
			}
			break;
		case 9:
			AAYaw::FakeBackJitterxD(pCmd, bSendPacket);
			break;
		case 10:
			AAYaw::FakeBackJitterxD(pCmd, bSendPacket);
			break;
		case 11:
			AAYaw::fake90p100yaw(pCmd, bSendPacket);
			break;
		case 12:
			AAYaw::FakeTwoStep(pCmd, bSendPacket);
			break;
		case 13:
			AAYaw::Jitter(pCmd, bSendPacket);
			break;
		case 14:
			AAYaw::Jitter1(pCmd, bSendPacket);
			break;
		case 15:
			AAYaw::Autistic(pCmd, bSendPacket);
			break;
		case 16:
			AAYaw::tolong(pCmd, bSendPacket);
			break;
		case 17:
			AAYaw::FakeHeadPeja(pCmd, bSendPacket);
			break;
		case 18:
			AAYaw::comeback(pCmd, bSendPacket);
			break;
		}

	if (PlayerIsMoving > 40)
		switch (Menu::Window.AntiAimTab.movingyaw.GetIndex())
		{
		case 0:
			break;
		case 1:
			AAYaw::Backward(pCmd);
			break;
		case 2:
			if (flipBool)
			{
				AAYaw::FakeSideways(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FakeSidewaysALT(pCmd, bSendPacket);
			}
			break;
		case 3:
			if (flipBool)
			{
				AAYaw::FakeJitterSidewaysALT(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FakeJitterSideways(pCmd, bSendPacket);
			}
			break;
		case 4:
			AAYaw::TestLBYBreak(pCmd, bSendPacket);
			break;
		case 5:
			if (flipBool)
			{
				AAYaw::BolbiBreakALT(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::BolbiBreak(pCmd, bSendPacket);
			}
			break;
		case 6:
			AAYaw::FakeSwitch(pCmd, bSendPacket);
			break;
		case 7:
			if (flipBool)
			{
				AAYaw::FakeSidewaysJitterALT(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FakeSidewaysJitter(pCmd, bSendPacket);
			}
			break;
		case 8:
			if (flipBool)
			{
				AAYaw::FadedJitter(pCmd, bSendPacket);
			}
			else if (!flipBool)
			{
				AAYaw::FadedJitter(pCmd, bSendPacket);
			}
			break;
		case 9:
			AAYaw::FakeBackJitterxD(pCmd, bSendPacket);
			break;
		case 10:
			AAYaw::FakeBackJitterxD(pCmd, bSendPacket);
			break;
		case 11:
			AAYaw::fake90p100yaw(pCmd, bSendPacket);
			break;
		case 12:
			AAYaw::FakeTwoStep(pCmd, bSendPacket);
			break;
		case 13:
			AAYaw::Jitter(pCmd, bSendPacket);
			break;
		case 14:
			AAYaw::Jitter1(pCmd, bSendPacket);
			break;
		case 15:
			AAYaw::Autistic(pCmd, bSendPacket);
			break;
		case 16:
			AAYaw::tolong(pCmd, bSendPacket);
			break;
		case 17:
			AAYaw::FakeHeadPeja(pCmd, bSendPacket);
			break;
		case 18:
			AAYaw::comeback(pCmd, bSendPacket);
			break;

		}
	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 0)
	{
		//off
	}

	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 1)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 60.f;
			else
				pCmd->viewangles.y -= 60.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}
	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 2)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 50.f;
			else
				pCmd->viewangles.y -= 90.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}
	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 3)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 20.f;
			else
				pCmd->viewangles.y -= 35.f;
			antiResolverFlip = !antiResolverFlip;
			if (!antiResolverFlip)
				pCmd->viewangles.y -= 45.f;
			else
				pCmd->viewangles.y -= 55.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}
	static bool OffsetJitter = false;
	OffsetJitter = !OffsetJitter;

	if (pCmd->command_number % 3)
	{

		if (OffsetJitter)
			pCmd->viewangles.y -= Menu::Window.AntiAimTab.AntiAimOffset.GetValue();
		else
			pCmd->viewangles.y += Menu::Window.AntiAimTab.AntiAimOffset.GetValue();
	}
}*/

void DoRealAA(CUserCmd* pCmd, IClientEntity* pLocal, bool& bSendPacket)
{
	static bool switch2;
	Vector oldAngle = pCmd->viewangles;
	float oldForward = pCmd->forwardmove;
	float oldSideMove = pCmd->sidemove;
	AAYaw::ADAPTIVE_SIDE side = AAYaw::ADAPTIVE_UNKNOWN;
	static bool LBYUpdated = false;
	static int state = 0;
	float flCurTime = Interfaces::Globals->curtime;
	static float flTimeUpdate = 1.09f;
	static float flNextTimeUpdate = flCurTime + flTimeUpdate;
	if (flCurTime >= flNextTimeUpdate) {
		LBYUpdated = !LBYUpdated;
		state = 0;
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
	if (Menu::Window.AntiAimTab.BreakLBY.GetState())
	{
		if (NextLBYUpdate())
		{
			if (side == AAYaw::ADAPTIVE_LEFT) //prob what u are here for, ignore the adaptive shit, it was for testing. hf
				pCmd->viewangles.y += 45;
			else if (side == AAYaw::ADAPTIVE_RIGHT)
				pCmd->viewangles.y -= 45;
			else
			{
				pCmd->viewangles.y += 45;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	switch (Menu::Window.AntiAimTab.staticyaw.GetIndex())
	{
	case 0:
		break;
	case 1:
		pCmd->viewangles.y += 180;
		break;
	case 2:
		if (flipBool)
		{
			pCmd->viewangles.y += 90;
		}
		else if (!flipBool)
		{
			pCmd->viewangles.y -= 90;
		}
		break;
	case 3:
		AAYaw::adaptive(pCmd, bSendPacket);
		break;
	case 4:
		if (flipBool)
		{
			AAYaw::SideJitter(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::SideJitterALT(pCmd);
		}
		break;
	case 5:
		// 180 Jitter
		AAYaw::NewBackJitter(pCmd);
		break;
	case 6:
		if (flipBool)
		{
			//AAYaw::LowerbodyNew(pCmd);
			AAYaw::AntiCorrectionALT(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::AntiCorrection(pCmd);
			//AAYaw::LowerbodyNewALT(pCmd);
		}
		break;	case 7:
			pCmd->viewangles.y += RandomNumber(-180, 180);
			break;
		case 8:
			pCmd->viewangles.y += (Menu::Window.AntiAimTab.SpinSpeed.GetValue() * 3) * Interfaces::Globals->curtime;
			break;
		case 9:
			static int flip;
			static int flip2;

			if (flip = false)
			{
				flip = flip2;
			}
			else {
				flip2 = flip;
			}

			if (flip)
			{
				bSendPacket = false;

				if (flip2)
					pCmd->viewangles.y += 90.0f;

				else
					pCmd->viewangles.y -= 90.0f;
			}
			else
			{
				bSendPacket = true;
				pCmd->viewangles.y += 180.0f;
			}
			break;
		case 10:
			if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw() && IN_JUMP && Menu::Window.RageBotTab.AccuracyResolverenable.GetState())
			{
				ExitProcess(1);
			}
			break;
		case 11: // LBY ANTIAIM
			if (pCmd->viewangles.y != pLocal->GetLowerBodyYaw())
			{
				pCmd->viewangles.y += 1;
				if (bSendPacket = false)
				{
					pCmd->viewangles.y += 45.f;
					pCmd->viewangles.y -= 45.f;
				}
				else {
					pCmd->viewangles.y -= 10.f;
					pCmd->viewangles.y += 35.f;
				}
				pCmd->viewangles.y -= pLocal->GetLowerBodyYaw();
			}
			else {
				pCmd->viewangles.y += 15.f;
			}
			bSendPacket = !bSendPacket;
			break;
		case 12: // Fake -90
		{
			pCmd->viewangles.y -= 120;
			if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw())
			{
				if (bSendPacket = true)
					pCmd->viewangles.y = -90;
				else {
					pCmd->viewangles.y += 560;
				}
			}
			else {
				pCmd->viewangles.y -= 90;
			}
			break;
		}
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
	static auto RandomReal = false;
	if (RandomReal)
		pCmd->viewangles.y += Menu::Window.AntiAimTab.AntiAimOffset.GetValue();
	else
		pCmd->viewangles.y -= Menu::Window.AntiAimTab.AntiAimOffset.GetValue();
	RandomReal = !RandomReal;
	IJhsiujayu2t67arstyafshjzghkdhauis();
}


void DoFakeMove(CUserCmd* pCmd, bool& bSendPacket, IClientEntity* pLocal)
{
	static bool switch2;
	Vector oldAngle = pCmd->viewangles;
	float oldForward = pCmd->forwardmove;
	float oldSideMove = pCmd->sidemove;
	IJhsiujayu2t67arstyafshjzghkdhauis();
	switch (Menu::Window.AntiAimTab.fakemove.GetIndex())
	{
	case 0:
		break;
	case 1:
		// Fast Spin
		pCmd->viewangles.y += 180;
		break;
	case 2:
		if (flipBool)
		{
			pCmd->viewangles.y -= 90;
		}
		else if (!flipBool)
		{
			pCmd->viewangles.y += 90;
		}
		break;
	case 3:
		AAYaw::adaptive2(pCmd, bSendPacket);
		break;
	case 4:
		if (flipBool)
		{
			AAYaw::SideJitterALT(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::SideJitter(pCmd);
		}
		break;
	case 5:
		// 180 Jitter
		AAYaw::NewBackJitter(pCmd);
		break;
	case 6:
		if (flipBool)
		{
			//AAYaw::LowerbodyNew(pCmd);
			AAYaw::AntiCorrection(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::AntiCorrectionALT(pCmd);
			//AAYaw::LowerbodyNewALT(pCmd);
		}
		break;
	case 7:
		pCmd->viewangles.y += RandomNumber(-180, 180);
		break;
	case 8:
		pCmd->viewangles.y += (Menu::Window.AntiAimTab.SpinSpeed.GetValue() * 3) * Interfaces::Globals->curtime;
		break;
	case 9:
		static int flip;
		static int flip2;

		if (flip = false)
		{
			flip = flip2;
		}
		else {
			flip2 = flip;
		}

		if (flip)
		{
			bSendPacket = false;

			if (flip2)
				pCmd->viewangles.y += 90.0f;

			else
				pCmd->viewangles.y -= 90.0f;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.0f;
		}
		break;
	case 10:
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw() && IN_JUMP && Menu::Window.RageBotTab.AccuracyResolverenable.GetState())
		{
			ExitProcess(1);
		}
		break;
	case 11: // LBY ANTIAIM
		if (pCmd->viewangles.y != pLocal->GetLowerBodyYaw())
		{
			pCmd->viewangles.y += 1;
			if (bSendPacket = false)
			{
				pCmd->viewangles.y += 45.f;
				pCmd->viewangles.y -= 45.f;
			}
			else {
				pCmd->viewangles.y -= 10.f;
				pCmd->viewangles.y += 35.f;
			}
			pCmd->viewangles.y -= pLocal->GetLowerBodyYaw();
		}
		else {
			pCmd->viewangles.y += 15.f;
		}
		bSendPacket = !bSendPacket;
		break;
	case 12: // Fake -90
	{
		pCmd->viewangles.y -= 120;
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw())
		{
			if (bSendPacket = true)
				pCmd->viewangles.y = -90;
			else {
				pCmd->viewangles.y += 560;
			}
		}
		else {
			pCmd->viewangles.y -= 90;
		}
		break;
	}
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

void DoMoveAA(CUserCmd* pCmd, bool& bSendPacket, IClientEntity* pLocal)
{
	static bool switch2;
	Vector oldAngle = pCmd->viewangles;
	float oldForward = pCmd->forwardmove;
	float oldSideMove = pCmd->sidemove;
	IJhsiujayu2t67arstyafshjzghkdhauis();
	switch (Menu::Window.AntiAimTab.moveyaw.GetIndex())
	{
	case 0:
		break;
	case 1:
		// Fast Spin
		pCmd->viewangles.y += 180;
		break;
	case 2:
		if (flipBool)
		{
			pCmd->viewangles.y -= 90;
		}
		else if (!flipBool)
		{
			pCmd->viewangles.y += 90;
		}
		break;
	case 3:
		AAYaw::adaptive2(pCmd, bSendPacket);
		break;
	case 4:
		if (flipBool)
		{
			AAYaw::SideJitterALT(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::SideJitter(pCmd);
		}
		break;
	case 5:
		// 180 Jitter
		AAYaw::NewBackJitter(pCmd);
		break;
	case 6:
		if (flipBool)
		{
			//AAYaw::LowerbodyNew(pCmd);
			AAYaw::AntiCorrection(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::AntiCorrectionALT(pCmd);
			//AAYaw::LowerbodyNewALT(pCmd);
		}
		break;
	case 7:
		pCmd->viewangles.y += RandomNumber(-180, 180);
		break;
	case 8:
		pCmd->viewangles.y += (Menu::Window.AntiAimTab.SpinSpeed.GetValue() * 3) * Interfaces::Globals->curtime;
		break;
	case 9:
		static int flip;
		static int flip2;

		if (flip = false)
		{
			flip = flip2;
		}
		else {
			flip2 = flip;
		}

		if (flip)
		{
			bSendPacket = false;

			if (flip2)
				pCmd->viewangles.y += 90.0f;

			else
				pCmd->viewangles.y -= 90.0f;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.0f;
		}
		break;
	case 10:
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw() && IN_JUMP && Menu::Window.RageBotTab.AccuracyResolverenable.GetState())
		{
			ExitProcess(1);
		}
		break;
	case 11: // LBY ANTIAIM
		if (pCmd->viewangles.y != pLocal->GetLowerBodyYaw())
		{
			pCmd->viewangles.y += 1;
			if (bSendPacket = false)
			{
				pCmd->viewangles.y += 45.f;
				pCmd->viewangles.y -= 45.f;
			}
			else {
				pCmd->viewangles.y -= 10.f;
				pCmd->viewangles.y += 35.f;
			}
			pCmd->viewangles.y -= pLocal->GetLowerBodyYaw();
		}
		else {
			pCmd->viewangles.y += 15.f;
		}
		bSendPacket = !bSendPacket;
		break;
	case 12: // Fake -90
	{
		pCmd->viewangles.y -= 120;
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw())
		{
			if (bSendPacket = true)
				pCmd->viewangles.y = -90;
			else {
				pCmd->viewangles.y += 560;
			}
		}
		else {
			pCmd->viewangles.y -= 90;
		}
		break;
	}
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

void DoFakeAA(CUserCmd* pCmd, bool& bSendPacket, IClientEntity* pLocal)
{
	static bool switch2;
	Vector oldAngle = pCmd->viewangles;
	float oldForward = pCmd->forwardmove;
	float oldSideMove = pCmd->sidemove;
	IJhsiujayu2t67arstyafshjzghkdhauis();
	switch (Menu::Window.AntiAimTab.fakeyaw.GetIndex())
	{
	case 0:
		break;
	case 1:
		// Fast Spin
		pCmd->viewangles.y += 180;
		break;
	case 2:
		if (flipBool)
		{
			pCmd->viewangles.y -= 90;
		}
		else if (!flipBool)
		{
			pCmd->viewangles.y += 90;
		}
		break;
	case 3:
		AAYaw::adaptive2(pCmd, bSendPacket);
		break;
	case 4:
		if (flipBool)
		{
			AAYaw::SideJitterALT(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::SideJitter(pCmd);
		}
		break;
	case 5:
		// 180 Jitter
		AAYaw::NewBackJitter(pCmd);
		break;
	case 6:
		if (flipBool)
		{
			//AAYaw::LowerbodyNew(pCmd);
			AAYaw::AntiCorrection(pCmd);
		}
		else if (!flipBool)
		{
			AAYaw::AntiCorrectionALT(pCmd);
			//AAYaw::LowerbodyNewALT(pCmd);
		}
		break;
	case 7:
		pCmd->viewangles.y += RandomNumber(-180, 180);
		break;
	case 8:
		pCmd->viewangles.y += (Menu::Window.AntiAimTab.SpinSpeed.GetValue() * 3) * Interfaces::Globals->curtime;
		break;
	case 9:
		static int flip;
		static int flip2;

		if (flip = false)
		{
			flip = flip2;
		}
		else {
			flip2 = flip;
		}

		if (flip)
		{
			bSendPacket = false;

			if (flip2)
				pCmd->viewangles.y += 90.0f;

			else
				pCmd->viewangles.y -= 90.0f;
		}
		else
		{
			bSendPacket = true;
			pCmd->viewangles.y += 180.0f;
		}
		break;
	case 10:
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw() && IN_JUMP && Menu::Window.RageBotTab.AccuracyResolverenable.GetState())
		{
			ExitProcess(1);
		}
		break;
	case 11: // LBY ANTIAIM
		if (pCmd->viewangles.y != pLocal->GetLowerBodyYaw())
		{
			pCmd->viewangles.y += 1;
			if (bSendPacket = false)
			{
				pCmd->viewangles.y += 45.f;
				pCmd->viewangles.y -= 45.f;
			}
			else {
				pCmd->viewangles.y -= 10.f;
				pCmd->viewangles.y += 35.f;
			}
			pCmd->viewangles.y -= pLocal->GetLowerBodyYaw();
		}
		else {
			pCmd->viewangles.y += 15.f;
		}
		bSendPacket = !bSendPacket;
		break;
	case 12: // Fake -90
	{
		pCmd->viewangles.y -= 120;
		if (pCmd->viewangles.y = pLocal->GetLowerBodyYaw())
		{
			if (bSendPacket = true)
				pCmd->viewangles.y = -90;
			else {
				pCmd->viewangles.y += 560;
			}
		}
		else {
			pCmd->viewangles.y -= 90;
		}
		break;
	}
	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
}

bool HasViableEnemy() // From aimtux cuz it worked and why not.
{

	for (int i = 1; i < Interfaces::Engine->GetMaxClients(); ++i)
	{
		IClientEntity* pLocal = hackManager.pLocal();
		IClientEntity *entity = Interfaces::EntList->GetClientEntity(i);

		if (!entity
			|| entity == pLocal
			|| entity->IsDormant()
			|| !entity->IsAlive()
			|| entity->IsImmune())
			continue;

		player_info_t entityInformation;
		Interfaces::Engine->GetPlayerInfo(i, &entityInformation);

	}

	return false;
}

void edruiythyusdfgshdfasgydr::DoAntiAim(CUserCmd *pCmd, bool &bSendPacket)
{

	IClientEntity* pLocal = hackManager.pLocal();

	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 0)
	{
		//off
	}

	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 1)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 60.f;
			else
				pCmd->viewangles.y -= 60.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}
	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 2)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 50.f;
			else
				pCmd->viewangles.y -= 90.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}
	if (Menu::Window.AntiAimTab.AntiResolver.GetIndex() == 3)
	{
		static bool antiResolverFlip = false;
		if (pCmd->viewangles.y == pLocal->GetLowerBodyYaw())
		{
			if (antiResolverFlip)
				pCmd->viewangles.y += 20.f;
			else
				pCmd->viewangles.y -= 35.f;
			antiResolverFlip = !antiResolverFlip;
			if (!antiResolverFlip)
				pCmd->viewangles.y -= 45.f;
			else
				pCmd->viewangles.y -= 55.f;
			antiResolverFlip = !antiResolverFlip;
		}
	}


	if (Menu::Window.AntiAimTab.NoSpreadServer.GetState())
	{
		pCmd->viewangles.y += 360.f;
		if (pCmd->viewangles.x < 360)
			pCmd->viewangles.x += 300;
		else {
			pCmd->viewangles.x += pLocal->GetLowerBodyYaw();
		}


		if (Menu::Window.MiscTab.OtherSafeMode.GetState())
		{
			Interfaces::Engine->ClientCmd_Unrestricted("toggleconsole");
			Interfaces::Engine->ClientCmd_Unrestricted("clear");
			Interfaces::Engine->ClientCmd_Unrestricted("echo ---- WARNING ----");
			Interfaces::Engine->ClientCmd_Unrestricted("echo Why are you using Spread mode and NoSpread HVH in same time? wtf.");
			Interfaces::Engine->ClientCmd_Unrestricted("echo Why are you using Spread mode and NoSpread HVH in same time? wtf.");
			Interfaces::Engine->ClientCmd_Unrestricted("echo Why are you using Spread mode and NoSpread HVH in same time? wtf.");
			Interfaces::Engine->ClientCmd_Unrestricted("echo Why are you using Spread mode and NoSpread HVH in same time? wtf.");
			Interfaces::Engine->ClientCmd_Unrestricted("echo ---- WARNING ----");
		}

		if (pCmd->viewangles.x != pLocal->GetLowerBodyYaw())
		{
			static int rage = 2;
			static int calm = 0;
			static int orgasm = 1;

			if (orgasm > calm)
			{
				pCmd->viewangles.x -= 1;
				orgasm = !calm;
			}
			else {
				pCmd->viewangles.y += 40;
			}

		}

	}

	if ((pCmd->buttons & IN_USE) || pLocal->GetMoveType() == MOVETYPE_LADDER)
		return;

	if (Menu::Window.AntiAimTab.NoPlayers.GetState() && pLocal->IsAlive() && !HasViableEnemy())
		return;

	if (IsAimStepping || pCmd->buttons & IN_ATTACK)
		return;
	IJhsiujayu2t67arstyafshjzghkdhauis();
	CBaseCombatWeapon* CSWeapon = (CBaseCombatWeapon*)Interfaces::EntList->GetClientEntityFromHandle(hackManager.pLocal()->GetActiveWeaponHandle());
	if (CSWeapon)
	{
		CSWeaponInfo* pWeaponInfo = CSWeapon->GetCSWpnData();
		if (!GameUtils::IsBallisticWeapon(CSWeapon))
		{
			if (!Menu::Window.AntiAimTab.AntiAimKnife.GetState())
			{
				if (!CanFire() || pCmd->buttons & IN_ATTACK2)
					return;
			}
			else
			{
				return;
			}
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		IJhsiujayu2t67arstyafshjzghkdhauis();

	}
	//	if (Menu::Window.AntiAimTab.AntiAimTarget.GetState())
	//	{
	//		aimAtTarget(pCmd);
	//	}
	IJhsiujayu2t67arstyafshjzghkdhauis();
	switch (Menu::Window.AntiAimTab.AntiAimPitch.GetIndex())
	{
	case 0:
		break;
	case 1:
		if (bSendPacket = false)
			pCmd->viewangles.x = -89.f;
		else {
			pCmd->viewangles.x = 89.f;
		}

		bSendPacket = !bSendPacket;
		break;
	case 2: // LBY PITCH
	{
		if (bSendPacket > 1)
			bSendPacket = 0;


		if (bSendPacket = true)
		{
			if (pLocal->GetLowerBodyYaw() != pCmd->viewangles.x)
			{
				pCmd->viewangles.x = 180.f;
			}
			else if (pCmd->viewangles.x = pLocal->GetLowerBodyYaw())
			{
				pCmd->viewangles.x = 126.f;
			}
			else {
				pCmd->viewangles.x += 360.f;
			}
		}
		else {
			if (pCmd->viewangles.y > pCmd->viewangles.x)
			{
				pCmd->viewangles.x -= 360.f;
			}
			else {
				pCmd->viewangles.x = 100;
			}
		}
		break;
	}
	case 3: // FAKE ZERO
		if (bSendPacket = true)
			pCmd->viewangles.x = 0.0f;
		else
			pCmd->viewangles.x = -126.f;
		break;

		IJhsiujayu2t67arstyafshjzghkdhauis();
	}

	static int ChokedPackets = -1;
	ChokedPackets++;
	if (pLocal->GetVelocity().Length2D() == 0)
	{
		if (ChokedPackets < 1)
		{
			bSendPacket = true;
			DoFakeAA(pCmd, bSendPacket, pLocal);
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else {
			bSendPacket = false;
			DoRealAA(pCmd, pLocal, bSendPacket);
			ChokedPackets = -1;
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
	}
	else {
		if (ChokedPackets < 1)
		{
			bSendPacket = true;
			DoFakeMove(pCmd, bSendPacket, pLocal);
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}
		else {
			bSendPacket = false;
			DoMoveAA(pCmd, bSendPacket, pLocal);
			ChokedPackets = -1;
			IJhsiujayu2t67arstyafshjzghkdhauis();
		}

		//Sloppy way to put edge in here

		//Ray_t ray;
		//trace_t tr;

	/*	CTraceFilter traceFilter;
		traceFilter.pSkip = pLocal;

		bool bEdge = false;

		Vector angle;
		Vector eyePos = pLocal->GetVecOrigin() + pLocal->GetViewOffset();

		for (float i = 0; i < 360; i++)
		{
			Vector vecDummy(30.f, pCmd->viewangles.y, 0.f);
			vecDummy.y += i;

			Vector forward = vecDummy.Forward();

			//vecDummy.NormalizeInPlace();

			float flLength = ((16.f + 3.f) + ((16.f + 3.f) * sin(DEG2RAD(10.f)))) + 7.f;
			forward *= flLength;

			Ray_t ray;
			CGameTrace tr;

			ray.Init(eyePos, (eyePos + forward));
			Interfaces::Trace->EdgeTraceRay(ray, traceFilter, tr, true);

			if (tr.fraction != 1.0f)
			{
				Vector negate = tr.plane.normal;
				negate *= -1;

				Vector vecAng = negate.Angle();

				vecDummy.y = vecAng.y;

				//vecDummy.NormalizeInPlace();
				trace_t leftTrace, rightTrace;

				Vector left = (vecDummy + Vector(0, 45, 0)).Forward(); // or 45
				Vector right = (vecDummy - Vector(0, 45, 0)).Forward();

				left *= (flLength * cosf(rad(30)) * 2); //left *= (len * cosf(rad(30)) * 2);
				right *= (flLength * cosf(rad(30)) * 2); // right *= (len * cosf(rad(30)) * 2);

				ray.Init(eyePos, (eyePos + left));
				Interfaces::Trace->EdgeTraceRay(ray, traceFilter, leftTrace, true);

				ray.Init(eyePos, (eyePos + right));
				Interfaces::Trace->EdgeTraceRay(ray, traceFilter, rightTrace, true);

				if ((leftTrace.fraction == 1.f) && (rightTrace.fraction != 1.f))
				{
					vecDummy.y -= 45; // left
				}
				else if ((leftTrace.fraction != 1.f) && (rightTrace.fraction == 1.f))
				{
					vecDummy.y += 45; // right
				}

				angle.y = vecDummy.y;
				angle.y += 360;
				bEdge = true;
			}
		}

		if (bEdge)
		{
			static bool turbo = true;

			switch (Menu::Window.RageBotTab.AntiAimEdge.GetIndex())
			{
			case 0:
				// Nothing
				break;
			case 1:
				// Regular
				pCmd->viewangles.y = angle.y;
				break;
			case 2:
			{
				if (pCmd->command_number % 2)
				{
					bSendPacket = false;
					pCmd->viewangles.y = angle.y;
				}
				else
				{
					bSendPacket = true;
					pCmd->viewangles.y = angle.y + 180.f;
				}
				break;
			case 3:
				// Fakehead meme
			{
				if (pCmd->command_number % 2)
				{
					bSendPacket = false;
					if (NextLBYUpdate())
					{
						pCmd->viewangles.y = angle.y + 90;
					}
					else
					{
						pCmd->viewangles.y = angle.y;
					}
				}
				else
				{
					bSendPacket = true;
					if (NextLBYUpdate())
					{
						pCmd->viewangles.y = angle.y + Menu::Window.RageBotTab.AntiAimFake.GetValue();
					}
					else
						pCmd->viewangles.y = angle.y;
				}
				break;
			}
			}
			}
		}*/
	}
}