text: #pragma once
  #include <Windows.h>
  #include <locale>
  
  #define M_PI 3.14159265358979323846264338327950288419716939937510
  
  template<class T>
  struct TArray
  {
  	friend struct FString;
  
  public:
  	inline TArray()
  	{
  		Data = nullptr;
  		Count = Max = 0;
  	};
  
  	inline int Num() const
  	{
  		return Count;
  	};
  
  	inline T& operator[](int i)
  	{
  		return Data[i];
  	};
  
  	inline const T& operator[](int i) const
  	{
  		return Data[i];
  	};
  
  	inline bool IsValidIndex(int i) const
  	{
  		return i < Num();
  	}
  
  private:
  	T* Data;
  	int32_t Count;
  	int32_t Max;
  };
  
  class UClass {
  public:
  	BYTE _padding_0[0x40];
  	UClass* SuperClass;
  };
  
  class UObject {
  public:
  	PVOID VTableObject;
  	DWORD ObjectFlags;
  	DWORD InternalIndex;
  	UClass* Class;
  	BYTE _padding_0[0x8];
  	UObject* Outer;
  
  	inline BOOLEAN IsA(PVOID parentClass) {
  		for (auto super = this->Class; super; super = super->SuperClass) {
  			if (super == parentClass) {
  				return TRUE;
  			}
  		}
  
  		return FALSE;
  	}
  };
  
  class FUObjectItem {
  public:
  	UObject* Object;
  	DWORD Flags;
  	DWORD ClusterIndex;
  	DWORD SerialNumber;
  	DWORD SerialNumber2;
  };
  
  class TUObjectArray {
  public:
  	FUObjectItem* Objects[9];
  };
  
  class GObjects {
  public:
  	TUObjectArray* ObjectArray;
  	BYTE _padding_0[0xC];
  	DWORD ObjectCount;
  };
  
  struct FString : private TArray<wchar_t>
  {
  	inline FString()
  	{
  	};
  
  	FString(const wchar_t* other)
  	{
  		Max = Count = *other ? std::wcslen(other) + 1 : 0;
  
  		if (Count)
  		{
  			Data = const_cast<wchar_t*>(other);
  		}
  	};
  
  	inline bool IsValid() const
  	{
  		return Data != nullptr;
  	}
  
  	inline const wchar_t* c_str() const
  	{
  		return Data;
  	}
  
  	std::string ToString() const
  	{
  		auto length = std::wcslen(Data);
  
  		std::string str(length, '\0');
  
  		std::use_facet<std::ctype<wchar_t>>(std::locale()).narrow(Data, Data + length, '?', &str[0]);
  
  		return str;
  	}
  };
  typedef struct {
  	float X, Y, Z;
  } FVector;
  
  class FRotator
  {
  public:
  	FRotator() : Pitch(0.f), Yaw(0.f), Roll(0.f)
  	{
  
  	}
  
  	FRotator(float _Pitch, float _Yaw, float _Roll) : Pitch(_Pitch), Yaw(_Yaw), Roll(_Roll)
  	{
  
  	}
  	~FRotator()
  	{
  
  	}
  
  	float Pitch;
  	float Yaw;
  	float Roll;
  	inline FRotator get() {
  		return FRotator(Pitch, Yaw, Roll);
  	}
  	inline void set(float _Pitch, float _Yaw, float _Roll) {
  		Pitch = _Pitch;
  		Yaw = _Yaw;
  		Roll = _Roll;
  	}
  
  	inline FRotator Clamp() {
  		FRotator result = get();
  		if (result.Pitch > 180)
  			result.Pitch -= 360;
  		else if (result.Pitch < -180)
  			result.Pitch += 360;
  		if (result.Yaw > 180)
  			result.Yaw -= 360;
  		else if (result.Yaw < -180)
  			result.Yaw += 360;
  		if (result.Pitch < -89)
  			result.Pitch = -89;
  		if (result.Pitch > 89)
  			result.Pitch = 89;
  		while (result.Yaw < -180.0f)
  			result.Yaw += 360.0f;
  		while (result.Yaw > 180.0f)
  			result.Yaw -= 360.0f;
  
  		result.Roll = 0;
  		return result;
  
  	}
  	double Length() {
  		return sqrt(Pitch * Pitch + Yaw * Yaw + Roll * Roll);
  	}
  
  	FRotator operator+(FRotator angB) { return FRotator(Pitch + angB.Pitch, Yaw + angB.Yaw, Roll + angB.Roll); }
  	FRotator operator-(FRotator angB) { return FRotator(Pitch - angB.Pitch, Yaw - angB.Yaw, Roll - angB.Roll); }
  	FRotator operator/(float flNum) { return FRotator(Pitch / flNum, Yaw / flNum, Roll / flNum); }
  	FRotator operator*(float flNum) { return FRotator(Pitch * flNum, Yaw * flNum, Roll * flNum); }
  	bool operator==(FRotator angB) { return Pitch == angB.Pitch && Yaw == angB.Yaw && Yaw == angB.Yaw; }
  	bool operator!=(FRotator angB) { return Pitch != angB.Pitch || Yaw != angB.Yaw || Yaw != angB.Yaw; }
  
  };
  
  class Vector3
  {
  public:
  	Vector3() : x(0.f), y(0.f), z(0.f)
  	{
  
  	}
  
  	Vector3(float _x, float _y, float _z) : x(_x), y(_y), z(_z)
  	{
  
  	}
  	~Vector3()
  	{
  
  	}
  
  	float x;
  	float y;
  	float z;
  
  	inline float Dot(Vector3 v)
  	{
  		return x * v.x + y * v.y + z * v.z;
  	}
  
  	inline float Distance(Vector3 v)
  	{
  		return float(sqrtf(powf(v.x - x, 2.0) + powf(v.y - y, 2.0) + powf(v.z - z, 2.0)));
  	}
  
  	inline double Length() {
  		return sqrt(x * x + y * y + z * z);
  	}
  
  	inline FRotator ToFRotator() {
  		FRotator rot = FRotator();
  		float RADPI = (float)(180 / M_PI);
  		rot.Yaw = (float)atan2(y, x) * RADPI;
  		rot.Pitch = (float)atan2(z, sqrt((x * x) + (y * y))) * RADPI;
  		rot.Roll = 0;
  		return rot;
  	}
  	Vector3 operator+(Vector3 v)
  	{
  		return Vector3(x + v.x, y + v.y, z + v.z);
  	}
  
  	Vector3 operator-(Vector3 v)
  	{
  		return Vector3(x - v.x, y - v.y, z - v.z);
  	}
  
  	Vector3 operator*(float flNum) { return Vector3(x * flNum, y * flNum, z * flNum); }
  };
  
  struct FMatrix
  {
  	float M[4][4];
  };
  
  struct FMinimalViewInfo
  {
  	Vector3 Loc;
  	Vector3 Rot;
  	float Fov;
  };
  
  struct {
  	FMinimalViewInfo Info;
  	float ProjectionMatrix[4][4];
  } view;
  
  typedef struct {
  	FVector ViewOrigin;
  	char _padding_0[4];
  	FMatrix ViewRotationMatrix;
  	FMatrix ProjectionMatrix;
  } FSceneViewProjectionData;
  
  static FMatrix* myMatrix = new FMatrix();
  
  GObjects* UObjectArrayA = nullptr;
  PVOID GNameA;
  PVOID freeA;
  PVOID Uworld;
  PVOID BoneMatrixA;
  
  PVOID ClientSetRotation;
  
  #define read(base, offs) (*(PVOID *)(((PBYTE)base + offs)))