function spam(times = 1,log = true){
	for(let i = 0; i < times; i++){
	$.get("backend-search.php", {term: (" "+Date.now())}).done(function(data){
	if(log) console.log(data);
	});
	}
}
spam(100000);

class LinkedList {
  constructor() {
    this.nodes = [];
  }

  get size() {
    return this.nodes.length;
  }

  get head() {
    return this.size ? this.nodes[0] : null;
  }

  get tail() {
    return this.size ? this.nodes[this.size - 1] : null;
  }

  insertAt(index, value) {
    const previousNode = this.nodes[index - 1] || null;
    const nextNode = this.nodes[index] || null;
    const node = { value, next: nextNode };

    if (previousNode) previousNode.next = node;
    this.nodes.splice(index, 0, node);
  }

  insertFirst(value) {
    this.insertAt(0, value);
  }

  insertLast(value) {
    this.insertAt(this.size, value);
  }

  getAt(index) {
    return this.nodes[index];
  }

  removeAt(index) {
    const previousNode = this.nodes[index - 1];
    const nextNode = this.nodes[index + 1] || null;

    if (previousNode) previousNode.next = nextNode;

    return this.nodes.splice(index, 1);
  }

  clear() {
    this.nodes = [];
  }

  reverse() {
    this.nodes = this.nodes.reduce(
      (acc, { value }) => [{ value, next: acc[0] || null }, ...acc],
      []
    );
  }

  *[Symbol.iterator]() {
    yield* this.nodes;
  }
}

const list = new LinkedList();

list.insertFirst(1);
list.insertFirst(2);
list.insertFirst(3);
list.insertLast(4);
list.insertAt(3, 5);

list.size;                      // 5
list.head.value;                // 3
list.head.next.value;           // 2
list.tail.value;                // 4
[...list.map(e => e.value)];    // [3, 2, 1, 5, 4]

list.removeAt(1);               // 2
list.getAt(1).value;            // 1
list.head.next.value;           // 1
[...list.map(e => e.value)];    // [3, 1, 5, 4]

list.reverse();
[...list.map(e => e.value)];    // [4, 5, 1, 3]

list.clear();
list.size;                      // 0

const arithmeticProgression  = (n, lim) =>
  Array.from({ length: Math.ceil(lim / n) }, (_, i) => (i + 1) * n );
  
arithmeticProgression(5, 25); // [5, 10, 15, 20, 25]

const primes = num => {
  let arr = Array.from({ length: num - 1 }).map((x, i) => i + 2),
    sqroot = Math.floor(Math.sqrt(num)),
    numsTillSqroot = Array.from({ length: sqroot - 1 }).map((x, i) => i + 2);
  numsTillSqroot.forEach(x => (arr = arr.filter(y => y % x !== 0 || y === x)));
  return arr;
};

primes(10); // [2, 3, 5, 7]

//Upvotes comments according to a regex pattern. I tried it out on https://www.reddit.com/r/VALORANT/comments/ne74n4/please_admire_this_clip_precise_gunplay_btw/
//Known bugs:
	//If a comment was already upvoted, it gets downvoted
	//For some reason, it has around a 50-70% success rate. The case insensitive bit works, but I think some of the query selector stuff gets changed. Still, 50% is good

let comments = document.getElementsByClassName("_3tw__eCCe7j-epNCKGXUKk"); //Comment class
let commentsToUpvote = [];
const regexToMatch = /wtf/gi;
for(let comment of comments){
	let text = comment.querySelector("._1qeIAgB0cPwnLhDF9XSiJM"); //Comment content class
	if(text == undefined){
	continue;
	}
	text = text.textContent;
	if(regexToMatch.test(text)){
	console.log(text);
	commentsToUpvote.push(comment);
	}
}
function upvote(comment){
	console.log(comment.querySelector(".icon-upvote")); //Just showing you what it's doing
	comment.querySelector(".icon-upvote").click();
}
function slowRecurse(){
	let comment = commentsToUpvote.pop(); //It's gonna go bottom to top but whatever
	if(comment != undefined){
	upvote(comment);
	setTimeout(slowRecurse,500);
	}
}
slowRecurse();

class Timer{
	start(){
		this.startTime = Date.now();
	}
	stop(){
		const dt = Date.now() - this.startTime;
		console.log(dt);
		return dt;
	}
	getExecTime(fun, asynchronous){
		return asynchronous ? this.getAsyncExecTime(fun) : this.getSyncExecTime(fun);
	}
	getSyncExecTime(fun){
		this.start();
		fun();
		return this.stop();
	}
	async getAsyncExecTime(fun){
		this.start();
		await fun();
		return this.stop();
	}
	static average(fun, numTimes, asynchronous = false){
		const times = [];
		const promises = [];
		let timer = new Timer();
		if(asynchronous){
			for(let i = 0; i < numTimes; i++){
				timer.getAsyncExecTime(fun);
			}
		}else{
			for(let i = 0; i < numTimes; i++){
				timer.getSyncExecTime(fun);
			}
		}
		return (times => times.reduce(((sum, acc) => sume + acc), 0) / times.length);
	}
	static async timeAsync(fun, numTimes){
		if(numTimes <= 1) return new Timer().getAsyncExecTime(fun);
		const promises = [];
		let timer = new Timer(true);
		for(let i = 0; i < numTimes; i++){
			promises.push(fun().catch((e)=>{}));
		}
		try{
			await Promise.all(promises).catch((e)=>{});
		}catch(e){
			//do absolutely nothing
		}
		return timer.stop();
	}
	constructor(start = false){
		if(start) this.start();
	}
}