Help with polyloader

main.cpp(479): error C3409: empty attribute block is not allowed
main.cpp(479): error C2143: syntax error: missing ']' before '/'
main.cpp(479): error C2059: syntax error: '/'
main.cpp(483): error C2143: syntax error: missing ';' before '{'
main.cpp(483): error C2447: '{': missing function header (old-style formal list?)
main.cpp(540): error C3409: empty attribute block is not allowed
main.cpp(540): error C2143: syntax error: missing ']' before '/'
main.cpp(540): error C2059: syntax error: '/'
main.cpp(544): error C2143: syntax error: missing ';' before '{'
main.cpp(544): error C2447: '{': missing function header (old-style formal list?)
main.cpp(577): error C3409: empty attribute block is not allowed
main.cpp(577): error C2143: syntax error: missing ']' before '/'
main.cpp(577): error C2059: syntax error: '/'
main.cpp(581): error C2143: syntax error: missing ';' before '{'
main.cpp(581): error C2447: '{': missing function header (old-style formal list?)
main.cpp(615): error C3409: empty attribute block is not allowed
main.cpp(615): error C2143: syntax error: missing ']' before '/'
main.cpp(615): error C2059: syntax error: '/'
main.cpp(619): error C2143: syntax error: missing ';' before '{'
main.cpp(619): error C2447: '{': missing function header (old-style formal list?)
main.cpp(670): error C3409: empty attribute block is not allowed
main.cpp(670): error C2143: syntax error: missing ']' before '/'
main.cpp(670): error C2059: syntax error: '/'
main.cpp(674): error C2143: syntax error: missing ';' before '{'
main.cpp(674): error C2447: '{': missing function header (old-style formal list?)
main.cpp(695): error C3409: empty attribute block is not allowed
main.cpp(695): error C2143: syntax error: missing ']' before '/'
main.cpp(695): error C2059: syntax error: '/'
main.cpp(699): error C2143: syntax error: missing ';' before '{'
main.cpp(699): error C2447: '{': missing function header (old-style formal list?)
main.cpp(727): error C3409: empty attribute block is not allowed
main.cpp(727): error C2143: syntax error: missing ']' before '/'
main.cpp(727): error C2059: syntax error: '/'
main.cpp(731): error C2143: syntax error: missing ';' before '{'
main.cpp(731): error C2447: '{': missing function header (old-style formal list?)
main.cpp(839): error C3409: empty attribute block is not allowed
main.cpp(839): error C2143: syntax error: missing ']' before '/'
main.cpp(839): error C2059: syntax error: '/'
main.cpp(843): error C2143: syntax error: missing ';' before '{'
main.cpp(843): error C2447: '{': missing function header (old-style formal list?)
main.cpp(901): error C3409: empty attribute block is not allowed
main.cpp(901): error C2143: syntax error: missing ']' before '/'
main.cpp(901): error C2059: syntax error: '/'

#include <iostream>
#include <Windows.h>
#include <string>
#include <thread>
#include <math.h>
#include <random>
#include <stdint.h>
#include "Decrypt.h"

using namespace std;
int ConsolePos_x = 5;
int ConsolePos_y = 5;

#include "MManager.h"

[junk_enable 5 10 /]

[swap_lines]
bool GLOW_status = false;
bool RADAR_status = false;
bool SLOWAIM_status = false;
bool RCS_status = false;
bool BHOP_status = false;
[/swap_lines]

Memory MManager;
Module Client;
Module Engine;

[swap_lines]
DWORD LocalPlayer = 0x00A6D444;
DWORD EnginePointer = 0x006B432C;
DWORD EntityList = 0x04A5B8F4;
DWORD ViewAngle = 0x00004D0C;
DWORD VectorPunch = 0x00004C28;
DWORD GlowObject = 0x04B70B9C;
DWORD Sensitivity = 0x00A72C4C;
DWORD ForceJump = 0x04AF0464;
[/swap_lines]

[swap_blocks]
[block]
void ActivationByHotkeys()
{
    for (;;)
    {
        [swap_blocks]
        [block]
        if (GetAsyncKeyState(VK_F5) & 0x8000)
        {
            while (GetAsyncKeyState(VK_F5) & 0x8000)
            {
                Sleep(50);
            }
            BHOP_status = !BHOP_status;
            if (BHOP_status)
            {
                cout << "| BHOP is now ON            |" << endl;
            }
            else
            {
                cout << "| BHOP is now OFF           |" << endl;
            }
        }
        [/block]
        [block]
        if (GetAsyncKeyState(VK_F6) & 0x8000)
        {
            while (GetAsyncKeyState(VK_F6) & 0x8000)
            {
                Sleep(50);
            }
            RCS_status = !RCS_status;
            if (RCS_status)
            {
                cout << "| RCS is now ON             |" << endl;
            }
            else
            {
                cout << "| RCS is now OFF            |" << endl;
            }
        }
        [/block]
        [block]
        if (GetAsyncKeyState(VK_F7) & 0x8000)
        {
            while (GetAsyncKeyState(VK_F7) & 0x8000)
            {
                Sleep(50);
            }
            RADAR_status = !RADAR_status;
            if (RADAR_status)
            {
                cout << "| RADAR is now ON           |" << endl;
            }
            else
            {
                cout << "| RADAR is now OFF          |" << endl;
            }
        }
        [/block]
        [block]
        if (GetAsyncKeyState(VK_F8) & 0x8000)
        {
            while (GetAsyncKeyState(VK_F8) & 0x8000)
            {
                Sleep(50);
            }
            SLOWAIM_status = !SLOWAIM_status;
            if (SLOWAIM_status)
            {
                cout << "| SLOWAIM is now ON         |" << endl;
            }
            else
            {
                cout << "| SLOWAIM is now OFF        |" << endl;
            }
        }
        [/block]
        [block]
        if (GetAsyncKeyState(VK_F9) & 0x8000)
        {
            while (GetAsyncKeyState(VK_F9) & 0x8000)
            {
                Sleep(50);
            }
            GLOW_status = !GLOW_status;
            if (GLOW_status)
            {
                cout << "| GLOW is now ON            |" << endl;
            }
            else
            {
                cout << "| GLOW is now OFF           |" << endl;
            }
        }
        [/block]
        [block]
        if (GetAsyncKeyState(VK_F4) & 0x8000)
        {
            cout << "|                           |" << endl;
            cout << "|   Press ANY key to EXIT   |" << endl;
            cout << "-----------------------------" << endl;
            Sleep(100);
            exit(0);
        }
        [/block]
        [/swap_blocks]
        Sleep(1);
    }
}
[/block]

[block]
void GLOW()
{
    for (;;)
    {
        if (GLOW_status)
        {
            DWORD Engine_dwBase = MManager.Read<DWORD>(Engine.dwBase + EnginePointer);
            DWORD LocalPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + LocalPlayer);
            int LocalPlayer_isConnected = MManager.Read<int>(Engine_dwBase + 0x100);

            if (LocalPlayer_isConnected == 6)
            {
                DWORD Client_glowPointer = MManager.Read<DWORD>(Client.dwBase + GlowObject);
                int Client_objectCount = MManager.Read<int>(Client.dwBase + GlowObject + 0x4);

                for (int i = 0; i < Client_objectCount; i++)
                {
                    GlowObjectPlayer glowObj = MManager.Read<GlowObjectPlayer>(Client_glowPointer + (i * sizeof(GlowObjectPlayer)));

                    if (Client_glowPointer != NULL && glowObj.pEntity != NULL)
                    {
                        bool EntityPlayer_isDormant = MManager.Read<bool>(glowObj.pEntity + 0xE9);
                        int EntityPlayer_teamNum = MManager.Read<int>(glowObj.pEntity + 0xF0);
                        int ClassID = MManager.Read<int>(MManager.Read<int>(MManager.Read<int>(MManager.Read<int>(glowObj.pEntity + 0x8) + 2 * 0x4) + 0x1) + 20);
                        int LocalPlayer_teamNum = MManager.Read<int>(LocalPlayer_dwBase + 0xF0);

                        if (ClassID == 35)
                        {
                            if (!EntityPlayer_isDormant)
                            {
                                if (LocalPlayer_teamNum != EntityPlayer_teamNum)
                                {
                                    glowObj.r = 1.0f;
                                    glowObj.g = 0.0f;
                                    glowObj.b = 0.0f;
                                    glowObj.a = 1.0f;
                                }
                                else
                                {
                                    glowObj.r = 0.0f;
                                    glowObj.g = 0.0f;
                                    glowObj.b = 1.0f;
                                    glowObj.a = 1.0f;
                                }
                                glowObj.RenderWhenOccluded = true;
                                glowObj.RenderWhenUnoccluded = false;
                                glowObj.FullBloom = false;

                                MManager.Write<GlowObjectPlayer>(Client_glowPointer + (i * sizeof(GlowObjectPlayer)), glowObj);
                            }
                        }
                    }
                }
            }
        }
        Sleep(25);
    }
}
[/block]

[block]
void RADAR()
{
    for (;;)
    {
        if (RADAR_status)
        {
            DWORD Engine_dwBase = MManager.Read<DWORD>(Engine.dwBase + EnginePointer);
            DWORD LocalPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + LocalPlayer);
            int LocalPlayer_isConnected = MManager.Read<int>(Engine_dwBase + 0x100);

            if (LocalPlayer_isConnected == 6)
            {
                for (int i = 0; i < 64; i++)
                {
                    DWORD EntityPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + EntityList + (0x10 * i));
                    int EntityPlayer_teamNum = MManager.Read<int>(EntityPlayer_dwBase + 0xF0);
                    int LocalPlayer_teamNum = MManager.Read<int>(LocalPlayer_dwBase + 0xF0);

                    if (LocalPlayer_teamNum != EntityPlayer_teamNum)
                    {
                        bool EntityPlayer_isDormant = MManager.Read<bool>(EntityPlayer_dwBase + 0xE9);
                        bool EntityPlayer_isSpotted = MManager.Read<bool>(EntityPlayer_dwBase + 0x935);

                        if (!EntityPlayer_isDormant && !EntityPlayer_isSpotted)
                        {
                            MManager.Write<bool>(EntityPlayer_dwBase + 0x935, 1);
                        }
                    }
                }
            }
        }
        Sleep(1);
    }
}
[/block]

[block]
void SLOWAIM()
{

    float LocalPlayer_sensitivity = MManager.Read<float>(Client.dwBase + Sensitivity);
    for (;;)
    {
        if (SLOWAIM_status)
        {
            DWORD Engine_dwBase = MManager.Read<DWORD>(Engine.dwBase + EnginePointer);
            DWORD LocalPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + LocalPlayer);
            int LocalPlayer_isConnected = MManager.Read<int>(Engine_dwBase + 0x100);

            if (LocalPlayer_isConnected == 6)
            {
                int LocalPlayer_crosshairID = MManager.Read<int>(LocalPlayer_dwBase + CrosshairID) - 1;
                int LocalPlayer_teamNum = MManager.Read<int>(LocalPlayer_dwBase + 0xF0);
                DWORD EntityPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + EntityList + (0x10 * LocalPlayer_crosshairID));
                int EntityPlayer_teamNum = MManager.Read<int>(EntityPlayer_dwBase + 0xF0);
                bool EntityPlayer_lifeState = MManager.Read<bool>(EntityPlayer_dwBase + 0x25B);
                bool EntityPlayer_isDormant = MManager.Read<bool>(EntityPlayer_dwBase + 0xE9);

                if (LocalPlayer_crosshairID > 0 && LocalPlayer_crosshairID < 64 && LocalPlayer_teamNum != EntityPlayer_teamNum && !EntityPlayer_isDormant && !EntityPlayer_lifeState)
                {
                    MManager.Write<float>(Client.dwBase + Sensitivity, 1.0f);

                }
                else
                {
                    MManager.Write<float>(Client.dwBase + Sensitivity, LocalPlayer_sensitivity);
                }
            }
        }
        Sleep(1);
    }
}
[/block]

[block]
void RCS()
{
    Vector LocalPlayer_oldVectorPunch;
    for (;;)
    {
        if (RCS_status)
        {
            DWORD Engine_dwBase = MManager.Read<DWORD>(Engine.dwBase + EnginePointer);
            DWORD LocalPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + LocalPlayer);
            bool LocalPlayer_lifeState = MManager.Read<bool>(LocalPlayer_dwBase + 0x25B);
            int LocalPlayer_isConnected = MManager.Read<int>(Engine_dwBase + 0x100);
            int LocalPlayer_shotsFired = MManager.Read<int>(LocalPlayer_dwBase + 0xBEB0);

            if (!LocalPlayer_lifeState && LocalPlayer_isConnected == 6)
            {
                Vector LocalPlayer_vectorPunch = MManager.Read<Vector>(LocalPlayer_dwBase + VectorPunch);

                random_device Random;
                mt19937 RandomGen(Random());
                uniform_real<float>RandomXdistrib(1.6f, 1.8f);
                uniform_real<float>RandomYdistrib(1.6f, 1.8f);
                LocalPlayer_vectorPunch.x *= RandomXdistrib(RandomGen);
                LocalPlayer_vectorPunch.y *= RandomYdistrib(RandomGen);
                LocalPlayer_vectorPunch.z = 0.0f;

                LocalPlayer_vectorPunch = MManager.NormalizeAngles(LocalPlayer_vectorPunch);

                if (LocalPlayer_shotsFired > 2)
                {
                    Vector LocalPlayer_viewAngle = MManager.Read<Vector>(Engine_dwBase + ViewAngle);
                    Vector LocalPlayer_modifiedAngle = LocalPlayer_vectorPunch;

                    LocalPlayer_modifiedAngle.x -= LocalPlayer_oldVectorPunch.x;
                    LocalPlayer_modifiedAngle.y -= LocalPlayer_oldVectorPunch.y;
                    LocalPlayer_modifiedAngle.z = 0.0f;

                    LocalPlayer_modifiedAngle = MManager.NormalizeAngles(LocalPlayer_modifiedAngle);                    

                    LocalPlayer_viewAngle.x -= LocalPlayer_modifiedAngle.x;
                    LocalPlayer_viewAngle.y -= LocalPlayer_modifiedAngle.y;
                    LocalPlayer_viewAngle.z = 0.0f;

                    LocalPlayer_viewAngle = MManager.NormalizeAngles(LocalPlayer_viewAngle);

                    MManager.Write<Vector>(Engine_dwBase + ViewAngle, LocalPlayer_viewAngle);
                }
                LocalPlayer_oldVectorPunch = LocalPlayer_vectorPunch;
            }
        }
        Sleep(1);
    }
}
[/block]

[block]
void BHOP()
{
    for (;;)
    {
        if (BHOP_status)
        {
            DWORD LocalPlayer_dwBase = MManager.Read<DWORD>(Client.dwBase + LocalPlayer);
            int LocalPlayer_fFlag = MManager.Read<int>(LocalPlayer_dwBase + 0x100);

            if (GetAsyncKeyState(VK_SPACE) & 0x8000)
            {
                if (LocalPlayer_fFlag & (1 << 0))
                {
                    MManager.Write<int>(Client.dwBase + ForceJump, 5);
                    Sleep(20);
                    MManager.Write<int>(Client.dwBase + ForceJump, 4);
                }
            }
        }
        Sleep(1);
    }
}
[/block]

[block]
void SetWindow(int Width, int Height, int x, int y)
{
    [swap_lines]
    _COORD coord;
    coord.X = Width;
    coord.Y = Height;
    [/swap_lines]

    _SMALL_RECT Rect;
    Rect.Top = 0;
    Rect.Left = 0;
    Rect.Bottom = Height - 1;
    Rect.Right = Width - 1;

    HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleScreenBufferSize(Handle, coord);
    SetConsoleWindowInfo(Handle, TRUE, &Rect);          
    HWND hWnd = GetConsoleWindow();
    RECT rcScr, rcWnd, rcClient;

    GetWindowRect(hWnd, &rcWnd);
    GetWindowRect(GetDesktopWindow(), &rcScr);
    GetClientRect(hWnd, &rcClient);

    MoveWindow(hWnd, x, y, rcWnd.right - rcWnd.left, rcWnd.bottom - rcWnd.top, 1);
    SetWindowLong(hWnd, GWL_STYLE, WS_POPUP);
    SetWindowRgn(hWnd, CreateRectRgn(rcClient.left + 2, rcClient.top + 2, rcClient.right + 2, rcClient.bottom + 2), TRUE);
    ShowWindow(hWnd, 1);
}
[/block]

[block]
void MoveConsole()
{
    bool re_size = false;

    for (;;)
    {

        if (GetAsyncKeyState(VK_RIGHT) & 0x8000 && GetAsyncKeyState(VK_LSHIFT) & 0x8000)
        {
            ConsolePos_x += 1;
            SetWindow(30, 30, ConsolePos_x, ConsolePos_y);
            re_size = true;
        }
        [swap_blocks]
        [block]
        else if (GetAsyncKeyState(VK_LEFT) & 0x8000 && GetAsyncKeyState(VK_LSHIFT) & 0x8000)
        {
            ConsolePos_x -= 1;
            SetWindow(30, 30, ConsolePos_x, ConsolePos_y);
            re_size = true;
        }
        [/block]
        [block]
        else if (GetAsyncKeyState(VK_UP) & 0x8000 && GetAsyncKeyState(VK_LSHIFT) & 0x8000)
        {
            ConsolePos_y -= 1;
            SetWindow(30, 30, ConsolePos_x, ConsolePos_y);
            re_size = true;
        }
        [/block]
        [block]
        else if (GetAsyncKeyState(VK_DOWN) & 0x8000 && GetAsyncKeyState(VK_LSHIFT) & 0x8000)
        {
            ConsolePos_y += 1;
            SetWindow(30, 30, ConsolePos_x, ConsolePos_y);
            re_size = true;
        }
        [/block]
        [block]
        else if (re_size)
        {
            SetWindow(29, 30, ConsolePos_x, ConsolePos_y);
            re_size = false;
        }
        [/block]
        [/swap_blocks]
        Sleep(1);
    }
}
[/block]

[block]
void main()
{
    SetConsoleTitle(" L3aRn T0 C0d3z -=- Made By PhY'z ");
    SetWindow(29, 30, ConsolePos_x, ConsolePos_y);

    cout << "-----------------------------" << endl;
    cout << "| L3aRn T0 C0d3z            |" << endl;
    cout << "|             Made By PhY'z |" << endl;
    cout << "|                           |" << endl;
    cout << "| Hotkeys:                  |" << endl;
    cout << "|        -> BunnyHop: F9    |" << endl;
    cout << "|        ->      RCS: F8    |" << endl;
    cout << "|        ->    Radar: F7    |" << endl;
    cout << "|        ->  SlowAIM: F6    |" << endl;
    cout << "|        ->  GlowESP: F5    |" << endl;
    cout << "|        ->     EXIT: F4    |" << endl;
    cout << "-----------------------------" << endl;

    if (!MManager.Attach("csgo.exe"))
    {
        cout << "-----------------------------" << endl;
        cout << "|         :WARNING:         |" << endl;
        cout << "|     CS:GO NOT FOUND!      |" << endl;
        cout << "|     CLOSING IN 3 SEC      |" << endl;
        cout << "-----------------------------" << endl;
        Sleep(1000 * 3);
        exit(0);
    }
    cout << "-----------------------------" << endl;
    cout << "|       :ACTIVATION:        |" << endl;
    cout << "|                           |" << endl;

    [swap_lines]
    Client = MManager.GetModule("client.dll");
    Engine = MManager.GetModule("engine.dll");
    [/swap_lines]

    PatternScan();

    [swap_lines]
    thread ACTIVATION_thread = thread(ActivationByHotkeys);
    thread CONSOLEMOVE_thread = thread(MoveConsole);
    thread GLOW_thread = thread(GLOW);
    thread RADAR_thread = thread(RADAR);
    thread SLOWAIM_thread = thread(SLOWAIM);
    thread BHOP_thread = thread(BHOP);
    thread RCS_thread = thread(RCS);
    [/swap_lines]

    [swap_lines]
    ACTIVATION_thread.join();
    CONSOLEMOVE_thread.join();
    GLOW_thread.join();
    RADAR_thread.join();
    SLOWAIM_thread.join();
    BHOP_thread.join();
    RCS_thread.join();
    [/swap_lines]
}
[/block]
[/swap_blocks]