struct GlowStruct
    {
        float r;
        float g;
        float b;
        float a;
        bool rwo;
        bool rwuo;
    };
    void wallhack(MemoryManagment *mem)
    {
        while (true)
        {
            if (t4==true)
            {
                GlowStruct Team =
                {
                    0,
                    0,
                    1,
                    1,
                    true,
                    false
                };

                int adress;
                int i = 1;

                do
                {
                    adress = mem->clientModuleBase + Offsets::LocalPlayer;
                    int Player = mem->Read<int>(adress);

                    adress = Player + Offsets::team;
                    int MyTeam = mem->Read<int>(adress);

                    adress = mem->clientModuleBase + Offsets::entitylist + (i-1) * 0x10;
                    int EntityList = mem->Read<int>(adress);

                    adress = EntityList + Offsets::health;
                    int Health = mem->Read<int>(adress);

                    float x, y, z;

                    if (Health<=100 && Health > 75)
                    {
                        x = 0; //green
                        y = 255;
                        z = 0;
                    }
                    else if (Health <= 75 && Health > 50)
                    {
                        x = 255;   //yellow
                        y = 255;
                        z = 0;
                    }
                    else if (Health <= 50 && Health > 25)
                    {
                        x = 255 / 255;   //orange 255,127,80
                        y = 128 / 255;
                        z = 0; // 255;
                    }
                    else if (Health <= 25 && Health > 0)
                    {
                        x = 255; //red 255 , 0 ,0
                        y = 0;
                        z = 0;
                    }

                    GlowStruct Enemy =
                    {
                        x,
                        y,
                        z,
                        1,
                        true,
                        false
                    };

                    adress = EntityList + Offsets::team;
                    int HisTeam = mem->Read<int>(adress);

                    adress = EntityList + Offsets::dormant;

                    if (!mem->Read<bool>(adress))
                    {
                        adress = EntityList + Offsets::glowindex;
                        int GlowIndex = mem->Read<int>(adress);

                        if (MyTeam == HisTeam)
                        {
                            adress = mem->clientModuleBase + Offsets::glowobject;
                            int GlowObject = mem->Read<int>(adress);

                            int calculation = GlowIndex * 0x38 + 0x4;
                            int current = GlowObject + calculation;
                            mem->Write<float>((current), Team.r);

                            calculation = GlowIndex * 0x38 + 0x8;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Team.g);

                            calculation = GlowIndex * 0x38 + 0xC;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Team.b);

                            calculation = GlowIndex * 0x38 + 0x10;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Team.a);

                            calculation = GlowIndex * 0x38 + 0x24;
                            current = GlowObject + calculation;
                            mem->Write<bool>((current), Team.rwo);

                            calculation = GlowIndex * 0x38 + 0x25;
                            current = GlowObject + calculation;
                            mem->Write<bool>((current), Team.rwuo);
                        }
                        else
                        {
                            adress = mem->clientModuleBase + Offsets::glowobject;
                            int GlowObject = mem->Read<int>(adress);

                            int calculation = GlowIndex * 0x38 + 0x4;
                            int current = GlowObject + calculation;
                            mem->Write<float>((current), Enemy.r);

                            calculation = GlowIndex * 0x38 + 0x8;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Enemy.g);

                            calculation = GlowIndex * 0x38 + 0xC;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Enemy.b);

                            calculation = GlowIndex * 0x38 + 0x10;
                            current = GlowObject + calculation;
                            mem->Write<float>((current), Enemy.a);

                            calculation = GlowIndex * 0x38 + 0x24;
                            current = GlowObject + calculation;
                            mem->Write<bool>((current), Enemy.rwo);

                            calculation = GlowIndex * 0x38 + 0x25;
                            current = GlowObject + calculation;
                            mem->Write<bool>((current), Enemy.rwuo);
                        }
                    }
                    i++;
                } while (i < 65);

                Sleep(5);
            }
        }
    }