You need to be compile project.

#include <windows.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <winsvc.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <io.h>
#include <fcntl.h>
#include <conio.h>
#include <cmath>
#include <ctime>
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <thread>
#include <chrono>
#include <tchar.h>
#include <windows.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <winsvc.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <io.h>
#include <fcntl.h>
#include <conio.h>
#include <cmath>
#include <ctime>
 
using namespace std;
void Center(const std::string& text) {
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
 
    int consoleWidth = csbi.srWindow.Right - csbi.srWindow.Left + 1;
    int padding = (consoleWidth - text.size()) / 2;
 
    if (padding < 0) padding = 0;
 
    cout << string(padding, ' ') << text << endl;
}
bool IsElevated() {
    BOOL isAdmin = FALSE;
    HANDLE token = NULL;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) {
        TOKEN_ELEVATION elevation;
        DWORD size = sizeof(TOKEN_ELEVATION);
        if (GetTokenInformation(token, TokenElevation, &elevation, sizeof(elevation), &size)) {
            isAdmin = elevation.TokenIsElevated;
        }
        CloseHandle(token);
    }
    return isAdmin != FALSE;
}
 
void CHECK_ADMIN() {
    if (IsElevated()) {
        // Already admin → do nothing
        return;
    }
 
    // Not admin → relaunch self as admin
    wchar_t szPath[MAX_PATH];
    GetModuleFileNameW(NULL, szPath, MAX_PATH);
 
    SHELLEXECUTEINFOW sei = { sizeof(sei) };
    sei.lpVerb = L"runas";
    sei.lpFile = szPath;
    sei.hwnd = NULL;
    sei.nShow = SW_NORMAL;
 
    if (ShellExecuteExW(&sei)) {
        // Success → child process started with admin rights
        exit(0); // kill the non-elevated instance
    }
    else {
        // User clicked "No" on UAC or error
 
        Center("[!] Failed to elevate to administrator.");
        Center("[!] Run the program as administrator manually.");
        Sleep(4000);
        exit(1);
    }
 
 
 
 
 
 
 
 
 
 
 
}
bool IsVgcRunning() {
    SC_HANDLE scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (scManager == NULL) {
        std::cerr << "OpenSCManager failed: " << GetLastError() << std::endl;
        return false;
    }
 
    SC_HANDLE service = OpenService(scManager, L"vgc", SERVICE_QUERY_STATUS);
    if (service == NULL) {
        std::cerr << "OpenService failed: " << GetLastError() << std::endl;
        CloseServiceHandle(scManager);
        return false;
    }
 
    SERVICE_STATUS_PROCESS ssStatus;
    DWORD bytesNeeded;
    if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssStatus, sizeof(SERVICE_STATUS_PROCESS), &bytesNeeded)) {
        std::cerr << "QueryServiceStatusEx failed: " << GetLastError() << std::endl;
        CloseServiceHandle(service);
        CloseServiceHandle(scManager);
        return false;
    }
 
    CloseServiceHandle(service);
    CloseServiceHandle(scManager);
 
    return ssStatus.dwCurrentState == SERVICE_RUNNING;
}
bool StartVgc() {
    SC_HANDLE scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (scManager == NULL) {
        std::cerr << "OpenSCManager failed: " << GetLastError() << std::endl;
        return false;
    }
 
    SC_HANDLE service = OpenService(scManager, L"vgc", SERVICE_START);
    if (service == NULL) {
        std::cerr << "OpenService failed: " << GetLastError() << std::endl;
        CloseServiceHandle(scManager);
        return false;
    }
 
    if (!StartService(service, 0, NULL)) {
        std::cerr << "StartService failed: " << GetLastError() << std::endl;
        CloseServiceHandle(service);
        CloseServiceHandle(scManager);
        return false;
    }
 
 
    CloseServiceHandle(service);
    CloseServiceHandle(scManager);
    return true;
}
bool IsProcessRunning(const TCHAR* executableName) {
    PROCESSENTRY32 entry;
    entry.dwSize = sizeof(PROCESSENTRY32);
 
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE) return false;
 
    if (!Process32First(snapshot, &entry)) {
        CloseHandle(snapshot);
        return false;
    }
 
    do {
        if (!_tcsicmp(entry.szExeFile, executableName)) {
            CloseHandle(snapshot);
            return true;
        }
    } while (Process32Next(snapshot, &entry));
 
    CloseHandle(snapshot);
    return false;
}
 
#define PURPLE 13
#define GREEN  10
#define RED    12
#define YELLOW 14
 
void SetColor(int c) {
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c);
}
 
void LOGO() {
    SetColor(PURPLE);
    cout << R"(
                               ____________________________________________________________                                                               
                             |        ___      ___  __      ___       _______  ___  ___    |
                             |       |"  \    /"  |/""\    |"  |     /"     "||"  \/"  |    |
                             |        \   \  //  //    \   ||  |    (: ______) \   \  /     |
                             |         \\  \/. .//' /\  \  |:  |     \/    |    \\  \/      |
                             |          \.    ////  __'  \  \  |___  // ___)_   /\.  \      |
                             |           \\   //   /  \\  \( \_|:  \(:      "| /  \   \     |
                             |            \__/(___/    \___)\_______)\_______)|___/\___|    |
                             |                                                              |
                               ____________________________________________________________                              
)" << endl;
}
 
 
 
 
void WaitForProcessToOpen(const TCHAR* processName) {
    SetColor(YELLOW);
 
    Center("===================================================================");
    Center("[+] Waiting for VALORANT to start...");
    Center("===================================================================");
 
    // Get console width
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    GetConsoleScreenBufferInfo(hConsole, &csbi);
 
    int consoleWidth = csbi.srWindow.Right - csbi.srWindow.Left + 1;
 
    string base = "[+] Waiting";
    int dots = 0;
 
    // Print a blank centered line where animation will be
    int animPad = (consoleWidth - (int)base.size() - 3) / 2;
    cout << endl;
    cout << string(animPad, ' ') << base << "   " << endl;
 
    // Save cursor position (this is where animation will update)
    CONSOLE_SCREEN_BUFFER_INFO posInfo;
    GetConsoleScreenBufferInfo(hConsole, &posInfo);
 
    int animX = animPad;
    int animY = posInfo.dwCursorPosition.Y - 1;  // line we just printed
 
    while (!IsProcessRunning(processName)) {
 
        // Move cursor to animation position
        COORD pos;
        pos.X = animX;
        pos.Y = animY;
        SetConsoleCursorPosition(hConsole, pos);
 
        // Print animation
        cout << base << string(dots, '.') << "   ";
 
        dots = (dots + 1) % 4;
        cout.flush();
 
        std::this_thread::sleep_for(std::chrono::milliseconds(400));
    }
 
    // When found, move cursor down and print message
    COORD endPos;
    endPos.X = 0;
    endPos.Y = animY + 2;
    SetConsoleCursorPosition(hConsole, endPos);
 
    SetColor(GREEN);
    Center("[+] VALORANT FOUND!");
    cout << endl;
}
 
 
 
void PrintASCIIArt();
void PrintColoredText(const std::wstring& text, bool animated);
 
class PopupBypass {
private:
    std::vector<DWORD> dnsCacheThreadler;
    std::vector<DWORD> svchostThreadler;
    std::vector<DWORD> askiyaAlinanThreadler;
    HANDLE hDnsCacheProcess;
    DWORD vgcPID;
    DWORD svchostPID;
    bool bypassAktif;
    bool dnsFreezeYapildi;
 
    struct ProcessCpuInfo {
        DWORD pid;
        ULONGLONG lastKernelTime;
        ULONGLONG lastUserTime;
    };
    ProcessCpuInfo vgcCpuInfo;
 
    bool HataAyiklamaHaklariniEtkinlestir() {
        HANDLE hToken;
        TOKEN_PRIVILEGES tp;
        LUID luid;
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
            return false;
        if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) {
            CloseHandle(hToken);
            return false;
        }
        tp.PrivilegeCount = 1;
        tp.Privileges[0].Luid = luid;
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
        CloseHandle(hToken);
        return true;
    }
 
    DWORD ProsesBul(const std::wstring& prosesIsmi) {
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
 
        PROCESSENTRY32W pe;
        pe.dwSize = sizeof(pe);
        if (!Process32FirstW(hSnapshot, &pe)) {
            CloseHandle(hSnapshot);
            return 0;
        }
        do {
            std::wstring mevcutProses(pe.szExeFile);
            std::transform(mevcutProses.begin(), mevcutProses.end(), mevcutProses.begin(), ::towlower);
            std::wstring hedefProses(prosesIsmi);
            std::transform(hedefProses.begin(), hedefProses.end(), hedefProses.begin(), ::towlower);
 
            if (mevcutProses == hedefProses) {
                CloseHandle(hSnapshot);
                return pe.th32ProcessID;
            }
        } while (Process32NextW(hSnapshot, &pe));
        CloseHandle(hSnapshot);
        return 0;
    }
 
    void ValorantKapat() {
        DWORD valorantPID = ProsesBul(L"VALORANT-Win64-Shipping.exe");
        if (valorantPID != 0) {
            HANDLE hValorant = OpenProcess(PROCESS_TERMINATE, FALSE, valorantPID);
            if (hValorant) {
                TerminateProcess(hValorant, 0);
                CloseHandle(hValorant);
            }
        }
    }
 
    void KillProcessByName(const wchar_t* processName) {
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return;
 
        PROCESSENTRY32W pe;
        pe.dwSize = sizeof(pe);
        if (Process32FirstW(hSnapshot, &pe)) {
            do {
                std::wstring currentProcess(pe.szExeFile);
                std::transform(currentProcess.begin(), currentProcess.end(), currentProcess.begin(), ::towlower);
                std::wstring targetProcess(processName);
                std::transform(targetProcess.begin(), targetProcess.end(), targetProcess.begin(), ::towlower);
 
                if (currentProcess == targetProcess) {
                    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
                    if (hProcess) {
                        TerminateProcess(hProcess, 0);
                        CloseHandle(hProcess);
                    }
                }
            } while (Process32NextW(hSnapshot, &pe));
        }
        CloseHandle(hSnapshot);
    }
 
    bool ServisDurdur(const wchar_t* serviceName) {
        SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
        if (!hSCManager) return false;
 
        SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_STOP | SERVICE_QUERY_STATUS);
        if (!hService) {
            CloseServiceHandle(hSCManager);
            return false;
        }
 
        SERVICE_STATUS_PROCESS ssp;
        DWORD dwBytesNeeded;
        if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) {
            if (ssp.dwCurrentState != SERVICE_STOPPED) {
                ControlService(hService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&ssp);
                for (int i = 0; i < 50; i++) {
                    Sleep(100);
                    if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) {
                        if (ssp.dwCurrentState == SERVICE_STOPPED) break;
                    }
                }
            }
        }
 
        CloseServiceHandle(hService);
        CloseServiceHandle(hSCManager);
        return true;
    }
 
    bool ServisBaslat(const wchar_t* serviceName) {
        SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
        if (!hSCManager) return false;
 
        SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_START | SERVICE_QUERY_STATUS);
        if (!hService) {
            CloseServiceHandle(hSCManager);
            return false;
        }
 
        SERVICE_STATUS_PROCESS ssp;
        DWORD dwBytesNeeded;
        if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) {
            if (ssp.dwCurrentState == SERVICE_STOPPED) {
                StartServiceW(hService, 0, NULL);
                for (int i = 0; i < 50; i++) {
                    Sleep(100);
                    if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) {
                        if (ssp.dwCurrentState == SERVICE_RUNNING) break;
                    }
                }
            }
        }
 
        CloseServiceHandle(hService);
        CloseServiceHandle(hSCManager);
        return true;
    }
 
    void NetshKomutu(const std::wstring& komut) {
        STARTUPINFOW si = { sizeof(STARTUPINFOW) };
        PROCESS_INFORMATION pi = {};
        si.dwFlags = STARTF_USESHOWWINDOW;
        si.wShowWindow = SW_HIDE;
 
        std::wstring cmdLine = L"netsh.exe " + komut;
        std::vector<wchar_t> cmdBuffer(cmdLine.begin(), cmdLine.end());
        cmdBuffer.push_back(L'\0');
 
        CreateProcessW(nullptr, cmdBuffer.data(), nullptr, nullptr, FALSE,
            CREATE_NO_WINDOW | CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi);
 
        if (pi.hProcess) {
            WaitForSingleObject(pi.hProcess, 2000);
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
        }
    }
 
    void GuvenlikDuvariKuraliEkle(const std::wstring& kuralIsmi, const std::wstring& programYolu, bool giden) {
        std::wstringstream ss;
        ss << L"advfirewall firewall add rule name=\"" << kuralIsmi
            << L"\" dir=" << (giden ? L"out" : L"in")
            << L" action=block program=\"" << programYolu
            << L"\" enable=yes profile=any";
        NetshKomutu(ss.str());
    }
 
    void GuvenlikDuvariKuraliSil(const std::wstring& kuralIsmi) {
        std::wstringstream ss;
        ss << L"advfirewall firewall delete rule name=\"" << kuralIsmi << L"\"";
        NetshKomutu(ss.str());
    }
 
    void GuvenlikDuvariEngellemeleri() {
        std::wstring vgcYolu = L"C:\\Program Files\\Riot Vanguard\\vgc.exe";
        std::wstring vgmYolu = L"C:\\Program Files\\Riot Vanguard\\vgm.exe";
        GuvenlikDuvariKuraliEkle(L"Block vgc.exe Outbound", vgcYolu, true);
        GuvenlikDuvariKuraliEkle(L"Block vgm.exe Outbound", vgmYolu, true);
    }
 
    void GuvenlikDuvariKurallariniTemizle() {
        GuvenlikDuvariKuraliSil(L"Block vgc.exe Outbound");
        GuvenlikDuvariKuraliSil(L"Block vgc.exe Inbound");
        GuvenlikDuvariKuraliSil(L"Block vgm.exe Outbound");
    }
 
    DWORD GetServicePID(const wchar_t* serviceName) {
        SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
        if (!hSCManager) return 0;
 
        SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_QUERY_STATUS);
        if (!hService) {
            CloseServiceHandle(hSCManager);
            return 0;
        }
 
        SERVICE_STATUS_PROCESS ssp;
        DWORD dwBytesNeeded;
        if (!QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) {
            CloseServiceHandle(hService);
            CloseServiceHandle(hSCManager);
            return 0;
        }
 
        DWORD pid = ssp.dwProcessId;
        CloseServiceHandle(hService);
        CloseServiceHandle(hSCManager);
        return pid;
    }
 
    bool DnsCacheFreeze() {
        ServisDurdur(L"Dnscache");
        Sleep(300);
        ServisBaslat(L"Dnscache");
        Sleep(500);
 
        DWORD dnsPid = GetServicePID(L"Dnscache");
        if (dnsPid == 0) return false;
 
        hDnsCacheProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dnsPid);
        if (!hDnsCacheProcess) return false;
 
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return false;
 
        THREADENTRY32 te;
        te.dwSize = sizeof(THREADENTRY32);
        dnsCacheThreadler.clear();
 
        if (Thread32First(hSnapshot, &te)) {
            do {
                if (te.th32OwnerProcessID == dnsPid) {
                    HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID);
                    if (hThread) {
                        SuspendThread(hThread);
                        dnsCacheThreadler.push_back(te.th32ThreadID);
                        CloseHandle(hThread);
                    }
                }
            } while (Thread32Next(hSnapshot, &te));
        }
        CloseHandle(hSnapshot);
 
        dnsFreezeYapildi = !dnsCacheThreadler.empty();
        return dnsFreezeYapildi;
    }
 
    void DnsCacheUnfreeze() {
        for (DWORD threadID : dnsCacheThreadler) {
            HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, threadID);
            if (hThread) {
                ResumeThread(hThread);
                CloseHandle(hThread);
            }
        }
        dnsCacheThreadler.clear();
 
        if (hDnsCacheProcess) {
            CloseHandle(hDnsCacheProcess);
            hDnsCacheProcess = NULL;
        }
        dnsFreezeYapildi = false;
    }
 
    bool SvchostSuspend() {
        DWORD dnsServicePID = GetServicePID(L"Dnscache");
        if (dnsServicePID == 0) return false;
 
        svchostThreadler.clear();
        bool basarili = false;
 
        HANDLE hSnapshotThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (hSnapshotThread != INVALID_HANDLE_VALUE) {
            THREADENTRY32 te;
            te.dwSize = sizeof(THREADENTRY32);
 
            if (Thread32First(hSnapshotThread, &te)) {
                do {
                    if (te.th32OwnerProcessID == dnsServicePID) {
                        HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID);
                        if (hThread) {
                            SuspendThread(hThread);
                            svchostThreadler.push_back(te.th32ThreadID);
                            basarili = true;
                            CloseHandle(hThread);
                        }
                    }
                } while (Thread32Next(hSnapshotThread, &te));
            }
            CloseHandle(hSnapshotThread);
        }
 
        if (basarili) {
            svchostPID = dnsServicePID;
        }
        return basarili;
    }
 
    void SvchostResume() {
        for (DWORD threadID : svchostThreadler) {
            HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, threadID);
            if (hThread) {
                ResumeThread(hThread);
                CloseHandle(hThread);
            }
        }
        svchostThreadler.clear();
        svchostPID = 0;
    }
 
    double GetVgcCpuUsage() {
        if (vgcPID == 0) return 0.0;
 
        HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, vgcPID);
        if (!hProcess) return 0.0;
 
        FILETIME ftCreation, ftExit, ftKernel, ftUser;
        if (!GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser)) {
            CloseHandle(hProcess);
            return 0.0;
        }
 
        ULARGE_INTEGER kernel, user;
        kernel.LowPart = ftKernel.dwLowDateTime;
        kernel.HighPart = ftKernel.dwHighDateTime;
        user.LowPart = ftUser.dwLowDateTime;
        user.HighPart = ftUser.dwHighDateTime;
 
        ULONGLONG currentTime = kernel.QuadPart + user.QuadPart;
        double cpuUsage = 0.0;
 
        if (vgcCpuInfo.lastKernelTime != 0) {
            ULONGLONG timeDiff = currentTime - (vgcCpuInfo.lastKernelTime + vgcCpuInfo.lastUserTime);
            if (timeDiff > 0) {
                cpuUsage = (double)timeDiff / 100000.0;
            }
        }
 
        vgcCpuInfo.lastKernelTime = kernel.QuadPart;
        vgcCpuInfo.lastUserTime = user.QuadPart;
 
        CloseHandle(hProcess);
        return cpuUsage;
    }
 
    void VgcThreadleriniAskiyaAl() {
        if (vgcPID == 0) {
            vgcPID = ProsesBul(L"vgc.exe");
            if (vgcPID == 0) return;
        }
 
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return;
 
        THREADENTRY32 te;
        te.dwSize = sizeof(THREADENTRY32);
        std::vector<DWORD> yeniThreadler;
 
        if (Thread32First(hSnapshot, &te)) {
            do {
                if (te.th32OwnerProcessID == vgcPID) {
                    bool zatenVar = false;
                    for (DWORD tid : askiyaAlinanThreadler) {
                        if (tid == te.th32ThreadID) {
                            zatenVar = true;
                            break;
                        }
                    }
                    if (!zatenVar) {
                        HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID);
                        if (hThread) {
                            SuspendThread(hThread);
                            yeniThreadler.push_back(te.th32ThreadID);
                            CloseHandle(hThread);
                        }
                    }
                }
            } while (Thread32Next(hSnapshot, &te));
        }
        CloseHandle(hSnapshot);
 
        if (!yeniThreadler.empty()) {
            askiyaAlinanThreadler.insert(askiyaAlinanThreadler.end(), yeniThreadler.begin(), yeniThreadler.end());
        }
    }
 
    void VgcThreadleriniDevamEttir() {
        for (DWORD threadID : askiyaAlinanThreadler) {
            HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_SET_INFORMATION, FALSE, threadID);
            if (hThread) {
                SetThreadPriority(hThread, THREAD_PRIORITY_NORMAL);
                ResumeThread(hThread);
                CloseHandle(hThread);
            }
        }
        askiyaAlinanThreadler.clear();
 
        if (vgcPID != 0) {
            HANDLE hVgc = OpenProcess(PROCESS_SET_INFORMATION | PROCESS_QUERY_INFORMATION, FALSE, vgcPID);
            if (hVgc) {
                SetPriorityClass(hVgc, NORMAL_PRIORITY_CLASS);
                DWORD_PTR processAffinityMask;
                DWORD_PTR systemAffinityMask;
                if (GetProcessAffinityMask(hVgc, &processAffinityMask, &systemAffinityMask)) {
                    SetProcessAffinityMask(hVgc, systemAffinityMask);
                }
                SIZE_T minWorkingSet = -1;
                SIZE_T maxWorkingSet = -1;
                SetProcessWorkingSetSize(hVgc, minWorkingSet, maxWorkingSet);
                CloseHandle(hVgc);
            }
        }
    }
 
    static DWORD WINAPI PopupBypassThread(LPVOID lpParam) {
        PopupBypass* self = (PopupBypass*)lpParam;
        self->PopupBypassRutini();
        return 0;
    }
 
    void PopupBypassRutini() {
        system("cls");
        PrintASCIIArt();
        std::wcout << L"\n";
        std::wcout << L"1. Popup Bypass\n";
        std::wcout << L"2. Safe Exit\n";
        std::wcout << L"3. STOP BYPASS\n\n";
        std::wcout << L"Enter your choice : \n\n";
 
        PrintColoredText(L"[*] Bypass started.\n", true);
        PrintColoredText(L"[*] Please open the game…\n", true);
 
        while (ProsesBul(L"VALORANT-Win64-Shipping.exe") == 0) {
            if (!bypassAktif) return;
            Sleep(500);
        }
        PrintColoredText(L"[+] Game detected!\n", true);
 
        PrintColoredText(L"[*] Waiting 8 seconds…\n", true);
        for (int i = 0; i < 80 && bypassAktif; i++) {
            Sleep(100);
        }
        if (!bypassAktif) return;
 
        vgcPID = ProsesBul(L"vgc.exe");
        if (vgcPID == 0) {
            PrintColoredText(L"[*] Waiting for VGC..\n", true);
            for (int i = 0; i < 10 && vgcPID == 0 && bypassAktif; i++) {
                Sleep(1000);
                vgcPID = ProsesBul(L"vgc.exe");
            }
        }
        if (!bypassAktif || vgcPID == 0) {
            PrintColoredText(L"[-] VGC not found!\n", true);
            return;
        }
 
        vgcCpuInfo.lastKernelTime = 0;
        vgcCpuInfo.lastUserTime = 0;
 
        PrintColoredText(L"[*] VGC CPU usage is being monitored…\n", true);
        bool cpuSpikeDetected = false;
        while (!cpuSpikeDetected && bypassAktif) {
            double cpu = GetVgcCpuUsage();
            if (cpu >= 0.1) {
                cpuSpikeDetected = true;
                PrintColoredText(L"[+] CPU spike detected! Applying DNS freeze…\n", true);
                break;
            }
            Sleep(10);
        }
        if (!bypassAktif) return;
 
        if (!cpuSpikeDetected) {
            PrintColoredText(L"[-] CPU spike tespit edilemedi!\n", true);
            return;
        }
 
        if (DnsCacheFreeze()) {
            PrintColoredText(L"[+]DNS freeze applied!\n", true);
        }
        else {
            PrintColoredText(L"[-] DNS freeze failed!\n", true);
            return;
        }
 
        PrintColoredText(L"[+] Bypass active! (press F8 to terminate)\n\n", true);
        std::wcout << L" Press any key to continue…\n\n";
    }
 
    void SafeExitIslemleri() {
        system("cls");
        PrintASCIIArt();
        std::wcout << L"\n";
        std::wcout << L"1. Popup Bypass\n";
        std::wcout << L"2. Safe Exit\n";
        std::wcout << L"3. Cikis\n\n";
        std::wcout << L"Seciminiz: 2\n\n";
 
        PrintColoredText(L"[*] Closing Valorant…\n", true);
        ValorantKapat();
        Sleep(2000);
 
        PrintColoredText(L"[*] Stopping bypass…\n", true);
        bypassAktif = false;
        Sleep(500);
 
        PrintColoredText(L"[*] Performing DNS unfreeze…\n", true);
        DnsCacheUnfreeze();
 
        ServisDurdur(L"Dnscache");
        Sleep(1000);
        ServisBaslat(L"Dnscache");
        Sleep(1000);
 
        dnsFreezeYapildi = false;
        vgcPID = 0;
        svchostPID = 0;
        dnsCacheThreadler.clear();
 
        PrintColoredText(L"[+] Safe exit completed!\n\n", true);
        std::wcout << L"[*] Safe exit completed! \n\n";
    }
 
    void F8Unfreeze() {
        PrintColoredText(L"\n[*] F8 pressed – Performing unfreeze…\n", true);
        DnsCacheUnfreeze();
        PrintColoredText(L"[+] Unfreeze completed!\n", true);
    }
 
public:
    PopupBypass() : hDnsCacheProcess(NULL), vgcPID(0), svchostPID(0),
        bypassAktif(false), dnsFreezeYapildi(false) {
        vgcCpuInfo.pid = 0;
        vgcCpuInfo.lastKernelTime = 0;
        vgcCpuInfo.lastUserTime = 0;
    }
 
    ~PopupBypass() {
        bypassAktif = false;
        if (hDnsCacheProcess) {
            CloseHandle(hDnsCacheProcess);
        }
    }
 
    void BypassBaslat() {
        if (bypassAktif) {
            PrintColoredText(L"[-] Bypass is already active!\n", true);
            return;
        }
 
        HataAyiklamaHaklariniEtkinlestir();
        bypassAktif = true;
        CreateThread(NULL, 0, PopupBypassThread, this, 0, NULL);
        Sleep(100);
    }
 
    void SafeExit() {
        SafeExitIslemleri();
    }
 
    void Unfreeze() {
        F8Unfreeze();
    }
 
    bool IsBypassActive() const {
        return bypassAktif;
    }
};
 
HANDLE g_hBypass = NULL;
PopupBypass* g_bypass = NULL;
 
void SetConsoleColor(int r, int g, int b) {
    std::wcout << L"\033[38;2;" << r << L";" << g << L";" << b << L"m";
}
 
void ResetConsoleColor() {
    std::wcout << L"\033[0m";
}
 
void PrintColoredText(const std::wstring& text, bool animated = false) {
    if (animated) {
        static int hue = 0;
        hue = (hue + 30) % 360;
 
        double h = hue;
        double s = 1.0;
        double v = 1.0;
 
        double c = v * s;
        double x = c * (1 - abs(fmod(h / 60.0, 2) - 1));
        double m = v - c;
 
        int r, g, b;
        if (h < 60) { r = (int)((c + m) * 255); g = (int)((x + m) * 255); b = (int)(m * 255); }
        else if (h < 120) { r = (int)((x + m) * 255); g = (int)((c + m) * 255); b = (int)(m * 255); }
        else if (h < 180) { r = (int)(m * 255); g = (int)((c + m) * 255); b = (int)((x + m) * 255); }
        else if (h < 240) { r = (int)(m * 255); g = (int)((x + m) * 255); b = (int)((c + m) * 255); }
        else if (h < 300) { r = (int)((x + m) * 255); g = (int)(m * 255); b = (int)((c + m) * 255); }
        else { r = (int)((c + m) * 255); g = (int)(m * 255); b = (int)((x + m) * 255); }
 
        SetConsoleColor(r, g, b);
        std::wcout << text;
        ResetConsoleColor();
    }
    else {
        std::wcout << text;
    }
}
 
void PrintASCIIArt() {
    SetConsoleColor(255, 0, 0);
    std::wcout << L"\n";
    std::wcout << L"                                      ░██    ░██    ░███    ░██         ░██████████ ░██    ░██  \n";
    std::wcout << L"                                      ░██    ░██   ░██░██   ░██         ░██          ░██  ░██   \n";
    std::wcout << L"                                      ░██    ░██  ░██  ░██  ░██         ░██           ░██░██    \n";
    std::wcout << L"                                      ░██    ░██ ░█████████ ░██         ░█████████     ░███    \n";
    std::wcout << L"                                       ░██  ░██  ░██    ░██ ░██         ░██           ░██░██   \n";
    std::wcout << L"                                        ░██░██   ░██    ░██ ░██         ░██          ░██  ░██  \n";
    std::wcout << L"                                         ░███    ░██    ░██ ░██████████ ░██████████ ░██    ░██ \n";
 
    '\n';
    '\n';
    wcout << L"===============================================================================================================================\n";
 
 
 
    std::wcout << L"\n";
    ResetConsoleColor();
}
 
DWORD WINAPI HotkeyThread(LPVOID lpParam) {
    bool f8Pressed = false;
    while (true) {
        if (GetAsyncKeyState(VK_F8) & 0x8000) {
            if (!f8Pressed) {
                f8Pressed = true;
                if (g_bypass) {
                    g_bypass->Unfreeze();
                }
            }
        }
        else {
            f8Pressed = false;
        }
        Sleep(100);
    }
    return 0;
}
 
DWORD WINAPI WindowSizeMonitor(LPVOID lpParam) {
    HWND hwnd = GetConsoleWindow();
    if (!hwnd) return 0;
 
    RECT targetRect;
    GetWindowRect(hwnd, &targetRect);
    int targetWidth = targetRect.right - targetRect.left;
    int targetHeight = targetRect.bottom - targetRect.top;
 
    while (true) {
        RECT currentRect;
        GetWindowRect(hwnd, &currentRect);
        int currentWidth = currentRect.right - currentRect.left;
        int currentHeight = currentRect.bottom - currentRect.top;
 
        if (currentWidth != targetWidth || currentHeight != targetHeight) {
            MoveWindow(hwnd, currentRect.left, currentRect.top, targetWidth, targetHeight, TRUE);
        }
 
        Sleep(100);
    }
    return 0;
}
 
int main() {
    HWND hwnd = GetConsoleWindow();
    if (hwnd) {
        LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE);
        style &= ~WS_THICKFRAME;
        style &= ~WS_MAXIMIZEBOX;
        SetWindowLongPtr(hwnd, GWL_STYLE, style);
 
        RECT rect;
        GetWindowRect(hwnd, &rect);
        int width = 1250;
        int height = 300;
        MoveWindow(hwnd, rect.left, rect.top, width, height, TRUE);
 
        HMENU hMenu = GetSystemMenu(hwnd, FALSE);
        if (hMenu) {
            EnableMenuItem(hMenu, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
            EnableMenuItem(hMenu, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
        }
    }
 
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(hOut, &csbi);
 
    COORD bufferSize;
    bufferSize.X = 100;
    bufferSize.Y = 50;
    SetConsoleScreenBufferSize(hOut, bufferSize);
 
    SMALL_RECT windowSize;
    windowSize.Left = 0;
    windowSize.Top = 0;
    windowSize.Right = 125;
    windowSize.Bottom = 30;
    SetConsoleWindowInfo(hOut, TRUE, &windowSize);
 
    DWORD dwMode = 0;
    GetConsoleMode(hOut, &dwMode);
    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    SetConsoleMode(hOut, dwMode);
 
    _setmode(_fileno(stdout), _O_U16TEXT);
    _setmode(_fileno(stdin), _O_U16TEXT);
 
    PopupBypass bypass;
    g_bypass = &bypass;
 
    CreateThread(NULL, 0, HotkeyThread, NULL, 0, NULL);
 
    CreateThread(NULL, 0, WindowSizeMonitor, NULL, 0, NULL);
 
    int secim = 0;
    CHECK_ADMIN();
 
    while (true) {
        system("cls");
        PrintASCIIArt();
        std::wcout << L"\n";
        std::wcout << L"1. Popup Bypass\n";
        std::wcout << L"2. Safe Exit\n";
        std::wcout << L"3. STOP BYPASS\n\n";
        std::wcout << L"Enter your choice : ";
 
        std::wcin >> secim;
 
        if (secim == 1) {
            bypass.BypassBaslat();
            _getch();
        }
        else if (secim == 2) {
            bypass.SafeExit();
            std::wcout << L"Press any key to continue..." << std::endl;
            _getch();
        }
        else if (secim == 3) {
            bypass.SafeExit();
            break;
        }
        else {
            std::wcout << L"\n[-] Invalid choice!" << std::endl;
            Sleep(1000);
        }
    }
 
    return 0;
}

thx

nice

perfekt

TEŞEKKÜRLER PAYLAŞIM İÇİN.